framework2

1
#include "ofEvents.h"
2
#include "ofAppRunner.h"
3
#include "ofAppBaseWindow.h"
4
#include "ofLog.h"
5

6
static ofEventArgs voidEventArgs;
7

8

9
//--------------------------------------
10
void ofSetFrameRate(int targetRate){
11
	auto window = ofGetMainLoop()->getCurrentWindow();
12
	if(window){
13
		window->events().setFrameRate(targetRate);
14
	}else{
15
		ofLogWarning("ofEvents") << "Trying to set framerate before mainloop is ready";
16
	}
17
}
18

19
//--------------------------------------
20
float ofGetFrameRate(){
21
	auto window = ofGetMainLoop()->getCurrentWindow();
22
	if(window){
23
		return window->events().getFrameRate();
24
	}else{
25
		return 0.f;
26
	}
27
}
28

29
//--------------------------------------
30
float ofGetTargetFrameRate(){
31
	auto window = ofGetMainLoop()->getCurrentWindow();
32
	if(window){
33
		return window->events().getTargetFrameRate();
34
	}else{
35
		return 0.f;
36
	}
37
}
38

39
//--------------------------------------
40
double ofGetLastFrameTime(){
41
	auto window = ofGetMainLoop()->getCurrentWindow();
42
	if(window){
43
		return window->events().getLastFrameTime();
44
	}else{
45
		return 0.f;
46
	}
47
}
48

49
//--------------------------------------
50
uint64_t ofGetFrameNum(){
51
	auto window = ofGetMainLoop()->getCurrentWindow();
52
	if(window){
53
		return window->events().getFrameNum();
54
	}else{
55
		return 0;
56
	}
57
}
58

59
//--------------------------------------
60
bool ofGetMousePressed(int button){ //by default any button
61
	auto window = ofGetMainLoop()->getCurrentWindow();
62
	if(window){
63
		return window->events().getMousePressed(button);
64
	}else{
65
		return false;
66
	}
67
}
68

69
//--------------------------------------
70
bool ofGetKeyPressed(int key){
71
	auto window = ofGetMainLoop()->getCurrentWindow();
72
	if(window){
73
		return window->events().getKeyPressed(key);
74
	}else{
75
		return false;
76
	}
77
}
78

79
//--------------------------------------
80
int ofGetMouseX(){
81
	auto window = ofGetMainLoop()->getCurrentWindow();
82
	if(window){
83
		return window->events().getMouseX();
84
	}else{
85
		return 0;
86
	}
87
}
88

89
//--------------------------------------
90
int ofGetMouseY(){
91
	auto window = ofGetMainLoop()->getCurrentWindow();
92
	if(window){
93
		return window->events().getMouseY();
94
	}else{
95
		return 0;
96
	}
97
}
98

99
//--------------------------------------
100
int ofGetPreviousMouseX(){
101
	auto window = ofGetMainLoop()->getCurrentWindow();
102
	if(window){
103
		return window->events().getPreviousMouseX();
104
	}else{
105
		return 0;
106
	}
107
}
108

109
//--------------------------------------
110
int ofGetPreviousMouseY(){
111
	auto window = ofGetMainLoop()->getCurrentWindow();
112
	if(window){
113
		return window->events().getPreviousMouseY();
114
	}else{
115
		return 0;
116
	}
117
}
118

119
ofCoreEvents::ofCoreEvents()
120
:targetRate(0)
121
,bFrameRateSet(false)
122
,fps(60)
123
,currentMouseX(0)
124
,currentMouseY(0)
125
,previousMouseX(0)
126
,previousMouseY(0)
127
,bPreMouseNotSet(false){
128

129
}
130

131
//------------------------------------------
132
void ofCoreEvents::disable(){
133
	setup.disable();
134
	draw.disable();
135
	update.disable();
136
	exit.disable();
137
	keyPressed.disable();
138
	keyReleased.disable();
139
	mouseDragged.disable();
140
	mouseReleased.disable();
141
	mousePressed.disable();
142
	mouseMoved.disable();
143
	mouseScrolled.disable();
144
	mouseEntered.disable();
145
	mouseExited.disable();
146
	touchDown.disable();
147
	touchUp.disable();
148
	touchMoved.disable();
149
	touchDoubleTap.disable();
150
	touchCancelled.disable();
151
	messageEvent.disable();
152
	fileDragEvent.disable();
153
}
154

155
//------------------------------------------
156
void ofCoreEvents::enable(){
157
	setup.enable();
158
	draw.enable();
159
	update.enable();
160
	exit.enable();
161
	keyPressed.enable();
162
	keyReleased.enable();
163
	mouseDragged.enable();
164
	mouseReleased.enable();
165
	mousePressed.enable();
166
	mouseMoved.enable();
167
	mouseScrolled.enable();
168
	mouseEntered.enable();
169
	mouseExited.enable();
170
	touchDown.enable();
171
	touchUp.enable();
172
	touchMoved.enable();
173
	touchDoubleTap.enable();
174
	touchCancelled.enable();
175
	messageEvent.enable();
176
	fileDragEvent.enable();
177
}
178

179
void ofCoreEvents::setTimeModeSystem(){
180
	timeMode = System;
181
}
182

183
void ofCoreEvents::setTimeModeFixedRate(uint64_t nanosecsPerFrame){
184
	timeMode = FixedRate;
185
	fixedRateTimeNanos = std::chrono::nanoseconds(nanosecsPerFrame);
186
}
187

188
void ofCoreEvents::setTimeModeFiltered(float alpha){
189
	timeMode = Filtered;
190
	fps.setFilterAlpha(alpha);
191
}
192

193
//--------------------------------------
194
void ofCoreEvents::setFrameRate(int _targetRate){
195
	// given this FPS, what is the amount of millis per frame
196
	// that should elapse?
197

198
	// --- > f / s
199

200
	if (_targetRate <= 0){
201
		bFrameRateSet = false;
202
	}else{
203
		bFrameRateSet	= true;
204
		targetRate		= _targetRate;
205
		uint64_t nanosPerFrame = 1000000000.0 / (double)targetRate;
206
		timer.setPeriodicEvent(nanosPerFrame);
207
	}
208
}
209

210
//--------------------------------------
211
float ofCoreEvents::getFrameRate() const{
212
	return fps.getFps();
213
}
214

215
//--------------------------------------
216
float ofCoreEvents::getTargetFrameRate() const{
217
	return targetRate;
218
}
219

220
//--------------------------------------
221
double ofCoreEvents::getLastFrameTime() const{
222
	switch(timeMode){
223
		case Filtered:
224
			return fps.getLastFrameFilteredSecs();
225
		case FixedRate:
226
			return std::chrono::duration<double>(fixedRateTimeNanos).count();
227
		case System:
228
		default:
229
			return fps.getLastFrameSecs();
230
	}
231

232
}
233

234
//--------------------------------------
235
uint64_t ofCoreEvents::getFrameNum() const{
236
	return fps.getNumFrames();
237
}
238

239
//--------------------------------------
240
bool ofCoreEvents::getMousePressed(int button) const{ //by default any button
241
	if(button==-1) return pressedMouseButtons.size();
242
	return pressedMouseButtons.find(button)!=pressedMouseButtons.end();
243
}
244

245
//--------------------------------------
246
bool ofCoreEvents::getKeyPressed(int key) const{
247
	if(key==-1) return pressedKeys.size();
248
	return pressedKeys.find(key)!=pressedKeys.end();
249
}
250

251
//--------------------------------------
252
int ofCoreEvents::getMouseX() const{
253
	return currentMouseX;
254
}
255

256
//--------------------------------------
257
int ofCoreEvents::getMouseY() const{
258
	return currentMouseY;
259
}
260

261
//--------------------------------------
262
int ofCoreEvents::getPreviousMouseX() const{
263
	return previousMouseX;
264
}
265

266
//--------------------------------------
267
int ofCoreEvents::getPreviousMouseY() const{
268
	return previousMouseY;
269
}
270

271
//--------------------------------------
272
int ofCoreEvents::getModifiers() const{
273
	return modifiers;
274
}
275

276
//------------------------------------------
277
bool ofCoreEvents::notifySetup(){
278
	return ofNotifyEvent( setup, voidEventArgs );
279
}
280

281
#include "ofGraphics.h"
282
//------------------------------------------
283
bool ofCoreEvents::notifyUpdate(){
284
	return ofNotifyEvent( update, voidEventArgs );
285
}
286

287
//------------------------------------------
288
bool ofCoreEvents::notifyDraw(){
289
	auto attended = ofNotifyEvent( draw, voidEventArgs );
290

291
	if (bFrameRateSet){
292
		timer.waitNext();
293
	}
294
	
295
	if(fps.getNumFrames()==0){
296
		if(bFrameRateSet) fps = ofFpsCounter(targetRate);
297
	}else{
298
		/*if(ofIsVerticalSyncEnabled()){
299
			float rate = ofGetRefreshRate();
300
			int intervals = round(lastFrameTime*rate/1000000.);//+vsyncedIntervalsRemainder;
301
			//vsyncedIntervalsRemainder = lastFrameTime*rate/1000000.+vsyncedIntervalsRemainder - intervals;
302
			lastFrameTime = intervals*1000000/rate;
303
		}*/
304
	}
305
	fps.newFrame();
306
	return attended;
307
}
308

309
//------------------------------------------
310
bool ofCoreEvents::notifyKeyPressed(int key, int keycode, int scancode, uint32_t codepoint){
311
	ofKeyEventArgs keyEventArgs(ofKeyEventArgs::Pressed,key,keycode,scancode,codepoint,0);
312
	return notifyKeyEvent(keyEventArgs);
313
}
314

315
//------------------------------------------
316
bool ofCoreEvents::notifyKeyReleased(int key, int keycode, int scancode, uint32_t codepoint){
317
	ofKeyEventArgs keyEventArgs(ofKeyEventArgs::Released,key,keycode,scancode,codepoint,0);
318
	return notifyKeyEvent(keyEventArgs);
319
}
320

321

322
//------------------------------------------
323
bool ofCoreEvents::notifyKeyEvent(ofKeyEventArgs & e){
324
	bool attended = false;
325
	modifiers = e.modifiers;
326
	switch(e.type){
327
		case ofKeyEventArgs::Pressed:
328
			// FIXME: modifiers are being reported twice, for generic and for left/right
329
			// add operators to the arguments class so it can be checked for both
330
			if(e.key == OF_KEY_RIGHT_CONTROL || e.key == OF_KEY_LEFT_CONTROL){
331
				pressedKeys.insert(OF_KEY_CONTROL);
332
				ofKeyEventArgs keyEventArgs = e;
333
				keyEventArgs.key = OF_KEY_CONTROL;
334
				attended = ofNotifyEvent( keyPressed, keyEventArgs );
335
			}
336
			else if(e.key == OF_KEY_RIGHT_SHIFT || e.key == OF_KEY_LEFT_SHIFT){
337
				pressedKeys.insert(OF_KEY_SHIFT);
338
				ofKeyEventArgs keyEventArgs = e;
339
				keyEventArgs.key = OF_KEY_SHIFT;
340
				attended = ofNotifyEvent( keyPressed, keyEventArgs );
341
			}
342
			else if(e.key == OF_KEY_LEFT_ALT || e.key == OF_KEY_RIGHT_ALT){
343
				pressedKeys.insert(OF_KEY_ALT);
344
				ofKeyEventArgs keyEventArgs = e;
345
				keyEventArgs.key = OF_KEY_ALT;
346
				attended = ofNotifyEvent( keyPressed, keyEventArgs );
347
			}
348
			else if(e.key == OF_KEY_LEFT_SUPER || e.key == OF_KEY_RIGHT_SUPER){
349
				pressedKeys.insert(OF_KEY_SUPER);
350
				ofKeyEventArgs keyEventArgs = e;
351
				keyEventArgs.key = OF_KEY_SUPER;
352
				attended = ofNotifyEvent( keyPressed, keyEventArgs );
353
			}
354

355
			pressedKeys.insert(e.key);
356
			if(!attended){
357
				return ofNotifyEvent( keyPressed, e );
358
			}else{
359
				return attended;
360
			}
361
		case ofKeyEventArgs::Released:
362
			// FIXME: modifiers are being reported twice, for generic and for left/right
363
			// add operators to the arguments class so it can be checked for both
364
			if(e.key == OF_KEY_RIGHT_CONTROL || e.key == OF_KEY_LEFT_CONTROL){
365
				pressedKeys.erase(OF_KEY_CONTROL);
366
				ofKeyEventArgs keyEventArgs = e;
367
				keyEventArgs.key = OF_KEY_CONTROL;
368
				attended = ofNotifyEvent( keyReleased, keyEventArgs );
369
			}
370
			else if(e.key == OF_KEY_RIGHT_SHIFT || e.key == OF_KEY_LEFT_SHIFT){
371
				pressedKeys.erase(OF_KEY_SHIFT);
372
				ofKeyEventArgs keyEventArgs = e;
373
				keyEventArgs.key = OF_KEY_SHIFT;
374
				attended = ofNotifyEvent( keyReleased, keyEventArgs );
375
			}
376
			else if(e.key == OF_KEY_LEFT_ALT || e.key == OF_KEY_RIGHT_ALT){
377
				pressedKeys.erase(OF_KEY_ALT);
378
				ofKeyEventArgs keyEventArgs = e;
379
				keyEventArgs.key = OF_KEY_ALT;
380
				attended = ofNotifyEvent( keyReleased, keyEventArgs );
381
			}
382
			else if(e.key == OF_KEY_LEFT_SUPER || e.key == OF_KEY_RIGHT_SUPER){
383
				pressedKeys.erase(OF_KEY_SUPER);
384
				ofKeyEventArgs keyEventArgs = e;
385
				keyEventArgs.key = OF_KEY_SUPER;
386
				attended = ofNotifyEvent( keyReleased, keyEventArgs );
387
			}
388

389
			pressedKeys.erase(e.key);
390
			if(!attended){
391
				return ofNotifyEvent( keyReleased, e );
392
			}else{
393
				return attended;
394
			}
395
	}
396
	return false;
397
}
398

399
//------------------------------------------
400
void ofCoreEvents::notifyTouchDown(int x, int y, int touchID){
401
	ofTouchEventArgs touchArgs;
402
	touchArgs.id = touchID;
403
	touchArgs.x = x;
404
	touchArgs.y = y;
405
	touchArgs.type = ofTouchEventArgs::down;
406
	notifyTouchEvent(touchArgs);
407
}
408

409
//------------------------------------------
410
void ofCoreEvents::notifyTouchUp(int x, int y, int touchID){
411
	ofTouchEventArgs touchArgs;
412
	touchArgs.id = touchID;
413
	touchArgs.x = x;
414
	touchArgs.y = y;
415
	touchArgs.type = ofTouchEventArgs::up;
416
	notifyTouchEvent(touchArgs);
417
}
418

419
//------------------------------------------
420
void ofCoreEvents::notifyTouchMoved(int x, int y, int touchID){
421
	ofTouchEventArgs touchArgs;
422
	touchArgs.id = touchID;
423
	touchArgs.x = x;
424
	touchArgs.y = y;
425
	touchArgs.type = ofTouchEventArgs::move;
426
	notifyTouchEvent(touchArgs);
427
}
428

429
//------------------------------------------
430
void ofCoreEvents::notifyTouchCancelled(int x, int y, int touchID){
431
	ofTouchEventArgs touchArgs;
432
	touchArgs.id = touchID;
433
	touchArgs.x = x;
434
	touchArgs.y = y;
435
	touchArgs.type = ofTouchEventArgs::cancel;
436
	notifyTouchEvent(touchArgs);
437
}
438

439

440
//------------------------------------------
441
void ofCoreEvents::notifyTouchDoubleTap(int x, int y, int touchID){
442
	ofTouchEventArgs touchArgs;
443
	touchArgs.id = touchID;
444
	touchArgs.x = x;
445
	touchArgs.y = y;
446
	touchArgs.type = ofTouchEventArgs::doubleTap;
447
	notifyTouchEvent(touchArgs);
448
}
449

450

451
//------------------------------------------
452
void ofCoreEvents::notifyTouchEvent(ofTouchEventArgs & touchArgs){
453
	switch(touchArgs.type){
454
		case ofTouchEventArgs::move:
455
			ofNotifyEvent( touchMoved, touchArgs );
456
			break;
457
		case ofTouchEventArgs::down:
458
			ofNotifyEvent( touchDown, touchArgs );
459
			break;
460
		case ofTouchEventArgs::up:
461
			ofNotifyEvent( touchUp, touchArgs );
462
			break;
463
		case ofTouchEventArgs::cancel:
464
			ofNotifyEvent( touchCancelled, touchArgs );
465
			break;
466
		case ofTouchEventArgs::doubleTap:
467
			ofNotifyEvent( touchDoubleTap, touchArgs );
468
			break;
469
	}
470
}
471

472

473
//------------------------------------------
474
bool  ofCoreEvents::notifyMouseEvent(ofMouseEventArgs & e){
475
	modifiers = e.modifiers;
476
	switch(e.type){
477
		case ofMouseEventArgs::Moved:
478
			if( bPreMouseNotSet ){
479
				previousMouseX	= e.x;
480
				previousMouseY	= e.y;
481
				bPreMouseNotSet	= false;
482
			}else{
483
				previousMouseX = currentMouseX;
484
				previousMouseY = currentMouseY;
485
			}
486

487
			currentMouseX = e.x;
488
			currentMouseY = e.y;
489

490
			return ofNotifyEvent( mouseMoved, e );
491
		case ofMouseEventArgs::Dragged:
492
			if( bPreMouseNotSet ){
493
				previousMouseX	= e.x;
494
				previousMouseY	= e.y;
495
				bPreMouseNotSet	= false;
496
			}else{
497
				previousMouseX = currentMouseX;
498
				previousMouseY = currentMouseY;
499
			}
500

501
			currentMouseX = e.x;
502
			currentMouseY = e.y;
503

504
			return ofNotifyEvent( mouseDragged, e );
505
		case ofMouseEventArgs::Pressed:{
506
			if( bPreMouseNotSet ){
507
				previousMouseX	= e.x;
508
				previousMouseY	= e.y;
509
				bPreMouseNotSet	= false;
510
			}else{
511
				previousMouseX = currentMouseX;
512
				previousMouseY = currentMouseY;
513
			}
514

515
			currentMouseX = e.x;
516
			currentMouseY = e.y;
517
			pressedMouseButtons.insert(e.button);
518

519

520
			return ofNotifyEvent( mousePressed, e );
521
		}
522
		case ofMouseEventArgs::Released:
523
			if( bPreMouseNotSet ){
524
				previousMouseX	= e.x;
525
				previousMouseY	= e.y;
526
				bPreMouseNotSet	= false;
527
			}else{
528
				previousMouseX = currentMouseX;
529
				previousMouseY = currentMouseY;
530
			}
531

532
			currentMouseX = e.x;
533
			currentMouseY = e.y;
534
			pressedMouseButtons.erase(e.button);
535

536
			return ofNotifyEvent( mouseReleased, e );
537
		case ofMouseEventArgs::Scrolled:
538
			return ofNotifyEvent( mouseScrolled, e );
539
		case ofMouseEventArgs::Entered:
540
			return ofNotifyEvent( mouseEntered, e );
541
		case ofMouseEventArgs::Exited:
542
			return ofNotifyEvent( mouseExited, e );
543
	}
544
	return false;
545
}
546

547
//------------------------------------------
548
bool ofCoreEvents::notifyMousePressed(int x, int y, int button){
549
	ofMouseEventArgs mouseEventArgs(ofMouseEventArgs::Pressed,x,y,button);
550
	return notifyMouseEvent(mouseEventArgs);
551
}
552

553
//------------------------------------------
554
bool ofCoreEvents::notifyMouseReleased(int x, int y, int button){
555
	ofMouseEventArgs mouseEventArgs(ofMouseEventArgs::Released,x,y,button);
556
	return notifyMouseEvent(mouseEventArgs);
557
}
558

559
//------------------------------------------
560
bool ofCoreEvents::notifyMouseDragged(int x, int y, int button){
561
	ofMouseEventArgs mouseEventArgs(ofMouseEventArgs::Dragged,x,y,button);
562
	return notifyMouseEvent(mouseEventArgs);
563
}
564

565
//------------------------------------------
566
bool ofCoreEvents::notifyMouseMoved(int x, int y){
567
	ofMouseEventArgs mouseEventArgs(ofMouseEventArgs::Moved,x,y,0);
568
	return notifyMouseEvent(mouseEventArgs);
569
}
570

571
//------------------------------------------
572
bool ofCoreEvents::notifyMouseScrolled(int x, int y, float scrollX, float scrollY){
573
	ofMouseEventArgs mouseEventArgs(ofMouseEventArgs::Scrolled,x,y);
574
	mouseEventArgs.scrollX = scrollX;
575
	mouseEventArgs.scrollY = scrollY;
576
	return notifyMouseEvent(mouseEventArgs);
577
}
578

579
//------------------------------------------
580
bool ofCoreEvents::notifyMouseEntered(int x, int y){
581
	ofMouseEventArgs mouseEventArgs(ofMouseEventArgs::Entered,x,y);
582
	return notifyMouseEvent(mouseEventArgs);
583
}
584

585
//------------------------------------------
586
bool ofCoreEvents::notifyMouseExited(int x, int y){
587
	ofMouseEventArgs mouseEventArgs(ofMouseEventArgs::Exited,x,y);
588
	return notifyMouseEvent(mouseEventArgs);
589
}
590

591
//------------------------------------------
592
bool ofCoreEvents::notifyExit(){
593
	return ofNotifyEvent( exit, voidEventArgs );
594
}
595

596
//------------------------------------------
597
bool ofCoreEvents::notifyWindowResized(int width, int height){
598
	ofResizeEventArgs resizeEventArgs(width,height);
599
	return ofNotifyEvent( windowResized, resizeEventArgs );
600
}
601

602
//------------------------------------------
603
bool ofCoreEvents::notifyWindowMoved(int x, int y){
604
	ofWindowPosEventArgs windowPosEventArgs(x,y);
605
	return ofNotifyEvent( windowMoved, windowPosEventArgs );
606
}
607

608
//------------------------------------------
609
bool ofCoreEvents::notifyDragEvent(ofDragInfo info){
610
	return ofNotifyEvent(fileDragEvent, info);
611
}
612

613
//------------------------------------------
614
bool ofSendMessage(ofMessage msg){
615
	return ofNotifyEvent(ofEvents().messageEvent, msg);
616
}
617

618
//------------------------------------------
619
bool ofSendMessage(std::string messageString){
620
	ofMessage msg(messageString);
621
	return ofSendMessage(msg);
622
}
623

624
//------------------------------------------
625
namespace of{
626
	namespace priv{
627
		std::atomic<uint_fast64_t> StdFunctionId::nextId;
628

629
		AbstractEventToken::~AbstractEventToken(){}
630

631
		BaseFunctionId::~BaseFunctionId(){}
632

633
		StdFunctionId::~StdFunctionId(){}
634
	}
635
}
636