propane 3.3.1-java → 3.4.0-java
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/.mvn/wrapper/MavenWrapperDownloader.java +117 -0
- data/.mvn/wrapper/maven-wrapper.properties +2 -3
- data/.travis.yml +9 -0
- data/CHANGELOG.md +7 -5
- data/README.md +1 -1
- data/Rakefile +8 -21
- data/lib/propane/native_folder.rb +16 -11
- data/lib/propane/version.rb +1 -1
- data/mvnw +127 -51
- data/mvnw.cmd +182 -145
- data/pom.rb +50 -48
- data/pom.xml +15 -6
- data/propane.gemspec +3 -3
- data/src/main/java/monkstone/vecmath/vec2/Vec2.java +1 -1
- data/src/main/java/monkstone/vecmath/vec3/Vec3.java +2 -2
- data/src/main/java/processing/awt/PGraphicsJava2D.java +1616 -1609
- data/src/main/java/processing/awt/PShapeJava2D.java +273 -265
- data/src/main/java/processing/awt/PSurfaceAWT.java +830 -817
- data/src/main/java/processing/core/PApplet.java +3990 -3990
- data/src/main/java/processing/core/PGraphics.java +37 -37
- data/src/main/java/processing/core/PImage.java +9 -9
- data/src/main/java/processing/core/PMatrix2D.java +6 -0
- data/src/main/java/processing/core/PShape.java +2 -2
- data/src/main/java/processing/core/PShapeOBJ.java +425 -409
- data/src/main/java/processing/core/PShapeSVG.java +167 -159
- data/src/main/java/processing/core/PSurfaceNone.java +10 -0
- data/src/main/java/processing/core/ThinkDifferent.java +7 -14
- data/src/main/java/processing/event/Event.java +7 -6
- metadata +9 -7
@@ -58,41 +58,41 @@ import processing.event.MouseEvent;
|
|
58
58
|
|
59
59
|
public class PSurfaceAWT extends PSurfaceNone {
|
60
60
|
|
61
|
-
|
61
|
+
GraphicsDevice displayDevice;
|
62
62
|
|
63
|
-
|
63
|
+
// used for canvas to determine whether resizable or not
|
64
64
|
// boolean resizable; // default is false
|
65
|
-
|
65
|
+
// Internally, we know it's always a JFrame (not just a Frame)
|
66
66
|
// JFrame frame;
|
67
|
-
|
68
|
-
|
69
|
-
|
70
|
-
|
67
|
+
// Trying Frame again with a11 to see if this avoids some Swing nastiness.
|
68
|
+
// In the past, AWT Frames caused some problems on Windows and Linux,
|
69
|
+
// but those may not be a problem for our reworked PSurfaceAWT class.
|
70
|
+
Frame frame;
|
71
71
|
|
72
|
-
|
73
|
-
|
72
|
+
// Note that x and y may not be zero, depending on the display configuration
|
73
|
+
Rectangle screenRect;
|
74
74
|
|
75
|
-
|
76
|
-
|
77
|
-
|
78
|
-
|
75
|
+
// Used for resizing, at least on Windows insets size changes when
|
76
|
+
// frame.setResizable() is called, and in resize listener we need
|
77
|
+
// to know what size the window was before.
|
78
|
+
Insets currentInsets = new Insets(0, 0, 0, 0);
|
79
79
|
|
80
|
-
|
80
|
+
// 3.0a5 didn't use strategy, and active was shut off during init() w/ retina
|
81
81
|
// boolean useStrategy = true;
|
82
|
-
|
82
|
+
Canvas canvas;
|
83
83
|
// Component canvas;
|
84
84
|
|
85
85
|
// PGraphics graphics; // moved to PSurfaceNone
|
86
|
-
|
87
|
-
|
86
|
+
int sketchWidth;
|
87
|
+
int sketchHeight;
|
88
88
|
|
89
|
-
|
89
|
+
int windowScaleFactor;
|
90
90
|
|
91
|
-
|
92
|
-
|
93
|
-
|
91
|
+
public PSurfaceAWT(PGraphics graphics) {
|
92
|
+
//this.graphics = graphics;
|
93
|
+
super(graphics);
|
94
94
|
|
95
|
-
|
95
|
+
/*
|
96
96
|
if (checkRetina()) {
|
97
97
|
// System.out.println("retina in use");
|
98
98
|
|
@@ -113,31 +113,31 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
113
113
|
// flicker--pushing pixels out before the screen has finished rendering.
|
114
114
|
// useStrategy = false;
|
115
115
|
}
|
116
|
-
|
117
|
-
|
116
|
+
*/
|
117
|
+
canvas = new SmoothCanvas();
|
118
118
|
// if (useStrategy) {
|
119
|
-
|
119
|
+
//canvas.setIgnoreRepaint(true);
|
120
120
|
// }
|
121
121
|
|
122
|
-
|
123
|
-
|
124
|
-
|
125
|
-
|
126
|
-
|
127
|
-
|
128
|
-
|
129
|
-
|
130
|
-
|
131
|
-
|
132
|
-
|
133
|
-
|
134
|
-
|
135
|
-
|
136
|
-
|
137
|
-
|
138
|
-
|
139
|
-
|
140
|
-
|
122
|
+
// Pass tab key to the sketch, rather than moving between components
|
123
|
+
canvas.setFocusTraversalKeysEnabled(false);
|
124
|
+
|
125
|
+
canvas.addComponentListener(new ComponentAdapter() {
|
126
|
+
@Override
|
127
|
+
public void componentResized(ComponentEvent e) {
|
128
|
+
if (!sketch.isLooping()) {
|
129
|
+
// make sure this is a real resize event, not just initial setup
|
130
|
+
// https://github.com/processing/processing/issues/3310
|
131
|
+
Dimension canvasSize = canvas.getSize();
|
132
|
+
if (canvasSize.width != sketch.sketchWidth()
|
133
|
+
|| canvasSize.height != sketch.sketchHeight()) {
|
134
|
+
sketch.redraw();
|
135
|
+
}
|
136
|
+
}
|
137
|
+
}
|
138
|
+
});
|
139
|
+
addListeners();
|
140
|
+
}
|
141
141
|
|
142
142
|
// /**
|
143
143
|
// * Handle grabbing the focus on startup. Other renderers can override this
|
@@ -173,71 +173,71 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
173
173
|
// }
|
174
174
|
// });
|
175
175
|
// }
|
176
|
-
|
177
|
-
|
176
|
+
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
|
177
|
+
public class SmoothCanvas extends Canvas {
|
178
178
|
|
179
|
-
|
180
|
-
|
179
|
+
private Dimension oldSize = new Dimension(0, 0);
|
180
|
+
private Dimension newSize = new Dimension(0, 0);
|
181
181
|
|
182
|
-
|
183
|
-
|
184
|
-
|
185
|
-
|
182
|
+
// Turns out getParent() returns a JPanel on a JFrame. Yech.
|
183
|
+
public Frame getFrame() {
|
184
|
+
return frame;
|
185
|
+
}
|
186
186
|
|
187
|
-
|
188
|
-
|
189
|
-
|
190
|
-
|
187
|
+
@Override
|
188
|
+
public Dimension getPreferredSize() {
|
189
|
+
return new Dimension(sketchWidth, sketchHeight);
|
190
|
+
}
|
191
191
|
|
192
|
-
|
193
|
-
|
194
|
-
|
195
|
-
|
192
|
+
@Override
|
193
|
+
public Dimension getMinimumSize() {
|
194
|
+
return getPreferredSize();
|
195
|
+
}
|
196
196
|
|
197
|
-
|
198
|
-
|
199
|
-
|
200
|
-
|
201
|
-
|
197
|
+
@Override
|
198
|
+
public Dimension getMaximumSize() {
|
199
|
+
//return resizable ? super.getMaximumSize() : getPreferredSize();
|
200
|
+
return frame.isResizable() ? super.getMaximumSize() : getPreferredSize();
|
201
|
+
}
|
202
202
|
|
203
|
-
|
204
|
-
|
205
|
-
|
206
|
-
|
207
|
-
|
203
|
+
@Override
|
204
|
+
public void validate() {
|
205
|
+
super.validate();
|
206
|
+
newSize.width = getWidth();
|
207
|
+
newSize.height = getHeight();
|
208
208
|
// if (oldSize.equals(newSize)) {
|
209
209
|
//// System.out.println("validate() return " + oldSize);
|
210
210
|
// return;
|
211
211
|
// } else {
|
212
|
-
|
212
|
+
if (!oldSize.equals(newSize)) {
|
213
213
|
// System.out.println("validate() render old=" + oldSize + " -> new=" + newSize);
|
214
|
-
|
215
|
-
|
214
|
+
oldSize = newSize;
|
215
|
+
sketch.setSize(newSize.width / windowScaleFactor, newSize.height / windowScaleFactor);
|
216
216
|
// try {
|
217
|
-
|
217
|
+
render();
|
218
218
|
// } catch (IllegalStateException ise) {
|
219
219
|
// System.out.println(ise.getMessage());
|
220
220
|
// }
|
221
|
-
|
222
|
-
|
221
|
+
}
|
222
|
+
}
|
223
223
|
|
224
|
-
|
225
|
-
|
224
|
+
@Override
|
225
|
+
public void update(Graphics g) {
|
226
226
|
// System.out.println("updating");
|
227
|
-
|
228
|
-
|
227
|
+
paint(g);
|
228
|
+
}
|
229
229
|
|
230
|
-
|
231
|
-
|
230
|
+
@Override
|
231
|
+
public void paint(Graphics screen) {
|
232
232
|
// System.out.println("painting");
|
233
233
|
// if (useStrategy) {
|
234
|
-
|
235
|
-
|
234
|
+
render();
|
235
|
+
/*
|
236
236
|
if (graphics != null) {
|
237
237
|
System.out.println("drawing to screen " + canvas);
|
238
238
|
screen.drawImage(graphics.image, 0, 0, sketchWidth, sketchHeight, null);
|
239
239
|
}
|
240
|
-
|
240
|
+
*/
|
241
241
|
|
242
242
|
// } else {
|
243
243
|
//// new Exception("painting").printStackTrace(System.out);
|
@@ -251,10 +251,10 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
251
251
|
// }
|
252
252
|
// }
|
253
253
|
// }
|
254
|
-
}
|
255
254
|
}
|
255
|
+
}
|
256
256
|
|
257
|
-
|
257
|
+
/*
|
258
258
|
@Override
|
259
259
|
public void addNotify() {
|
260
260
|
// System.out.println("adding notify");
|
@@ -262,38 +262,38 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
262
262
|
// prior to Java 7 on OS X, this no longer works [121222]
|
263
263
|
// createBufferStrategy(2);
|
264
264
|
}
|
265
|
-
|
266
|
-
|
267
|
-
|
268
|
-
|
269
|
-
|
270
|
-
|
271
|
-
|
272
|
-
|
273
|
-
|
274
|
-
|
265
|
+
*/
|
266
|
+
synchronized protected void render() {
|
267
|
+
if (canvas.isDisplayable()
|
268
|
+
&& graphics.image != null) {
|
269
|
+
if (canvas.getBufferStrategy() == null) {
|
270
|
+
canvas.createBufferStrategy(2);
|
271
|
+
}
|
272
|
+
BufferStrategy strategy = canvas.getBufferStrategy();
|
273
|
+
if (strategy != null) {
|
274
|
+
// Render single frame
|
275
275
|
// try {
|
276
|
-
|
277
|
-
|
278
|
-
|
279
|
-
|
280
|
-
|
281
|
-
|
282
|
-
|
283
|
-
|
284
|
-
|
285
|
-
|
286
|
-
|
287
|
-
|
288
|
-
|
289
|
-
|
290
|
-
|
291
|
-
|
292
|
-
}
|
276
|
+
do {
|
277
|
+
// The following loop ensures that the contents of the drawing buffer
|
278
|
+
// are consistent in case the underlying surface was recreated
|
279
|
+
do {
|
280
|
+
Graphics2D draw = (Graphics2D) strategy.getDrawGraphics();
|
281
|
+
// draw to width/height, since this may be a 2x image
|
282
|
+
draw.drawImage(graphics.image, 0, 0, sketchWidth, sketchHeight, null);
|
283
|
+
draw.dispose();
|
284
|
+
} while (strategy.contentsRestored());
|
285
|
+
|
286
|
+
// Display the buffer
|
287
|
+
strategy.show();
|
288
|
+
|
289
|
+
// Repeat the rendering if the drawing buffer was lost
|
290
|
+
} while (strategy.contentsLost());
|
291
|
+
}
|
293
292
|
}
|
293
|
+
}
|
294
294
|
|
295
295
|
|
296
|
-
|
296
|
+
/*
|
297
297
|
protected void blit() {
|
298
298
|
// Other folks that call render() (i.e. paint()) are already on the EDT.
|
299
299
|
// We need to be using the EDT since we're messing with the Canvas
|
@@ -335,21 +335,21 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
335
335
|
}
|
336
336
|
}
|
337
337
|
}
|
338
|
-
|
339
|
-
|
340
|
-
|
341
|
-
|
342
|
-
|
343
|
-
|
338
|
+
*/
|
339
|
+
// what needs to happen here?
|
340
|
+
@Override
|
341
|
+
public void initOffscreen(PApplet sketch) {
|
342
|
+
this.sketch = sketch;
|
343
|
+
}
|
344
344
|
|
345
|
-
|
345
|
+
/*
|
346
346
|
public Frame initOffscreen() {
|
347
347
|
Frame dummy = new Frame();
|
348
348
|
dummy.pack(); // get legit AWT graphics
|
349
349
|
// but don't show it
|
350
350
|
return dummy;
|
351
351
|
}
|
352
|
-
|
352
|
+
*/
|
353
353
|
|
354
354
|
/*
|
355
355
|
@Override
|
@@ -362,59 +362,59 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
362
362
|
|
363
363
|
return canvas;
|
364
364
|
}
|
365
|
-
|
366
|
-
|
367
|
-
|
365
|
+
*/
|
366
|
+
@Override
|
367
|
+
public void initFrame(final PApplet sketch) {/*, int backgroundColor,
|
368
368
|
int deviceIndex, boolean fullScreen, boolean spanDisplays) {*/
|
369
|
-
|
369
|
+
this.sketch = sketch;
|
370
370
|
|
371
|
-
|
372
|
-
|
371
|
+
GraphicsEnvironment environment
|
372
|
+
= GraphicsEnvironment.getLocalGraphicsEnvironment();
|
373
373
|
|
374
|
-
|
374
|
+
int displayNum = sketch.sketchDisplay();
|
375
375
|
// System.out.println("display from sketch is " + displayNum);
|
376
|
-
|
377
|
-
|
378
|
-
|
379
|
-
|
380
|
-
|
381
|
-
|
382
|
-
|
383
|
-
|
384
|
-
|
385
|
-
}
|
386
|
-
}
|
387
|
-
}
|
388
|
-
if (displayDevice == null) {
|
389
|
-
displayDevice = environment.getDefaultScreenDevice();
|
376
|
+
if (displayNum > 0) { // if -1, use the default device
|
377
|
+
GraphicsDevice[] devices = environment.getScreenDevices();
|
378
|
+
if (displayNum <= devices.length) {
|
379
|
+
displayDevice = devices[displayNum - 1];
|
380
|
+
} else {
|
381
|
+
System.err.format("Display %d does not exist, "
|
382
|
+
+ "using the default display instead.%n", displayNum);
|
383
|
+
for (int i = 0; i < devices.length; i++) {
|
384
|
+
System.err.format("Display %d is %s%n", (i + 1), devices[i]);
|
390
385
|
}
|
386
|
+
}
|
387
|
+
}
|
388
|
+
if (displayDevice == null) {
|
389
|
+
displayDevice = environment.getDefaultScreenDevice();
|
390
|
+
}
|
391
391
|
|
392
|
-
|
393
|
-
|
394
|
-
|
395
|
-
|
396
|
-
|
397
|
-
|
398
|
-
|
399
|
-
|
400
|
-
|
401
|
-
|
402
|
-
|
403
|
-
|
404
|
-
|
405
|
-
|
406
|
-
|
407
|
-
|
408
|
-
|
409
|
-
|
410
|
-
|
411
|
-
|
412
|
-
|
413
|
-
|
414
|
-
|
415
|
-
|
416
|
-
|
417
|
-
|
392
|
+
// Need to save the window bounds at full screen,
|
393
|
+
// because pack() will cause the bounds to go to zero.
|
394
|
+
// http://dev.processing.org/bugs/show_bug.cgi?id=923
|
395
|
+
boolean spanDisplays = sketch.sketchDisplay() == PConstants.SPAN;
|
396
|
+
screenRect = spanDisplays ? getDisplaySpan()
|
397
|
+
: displayDevice.getDefaultConfiguration().getBounds();
|
398
|
+
// DisplayMode doesn't work here, because we can't get the upper-left
|
399
|
+
// corner of the display, which is important for multi-display setups.
|
400
|
+
|
401
|
+
// Set the displayWidth/Height variables inside PApplet, so that they're
|
402
|
+
// usable and can even be returned by the sketchWidth()/Height() methods.
|
403
|
+
sketch.displayWidth = screenRect.width;
|
404
|
+
sketch.displayHeight = screenRect.height;
|
405
|
+
|
406
|
+
windowScaleFactor = PApplet.platform == PConstants.MACOSX
|
407
|
+
? 1 : sketch.pixelDensity;
|
408
|
+
|
409
|
+
sketchWidth = sketch.sketchWidth() * windowScaleFactor;
|
410
|
+
sketchHeight = sketch.sketchHeight() * windowScaleFactor;
|
411
|
+
|
412
|
+
boolean fullScreen = sketch.sketchFullScreen();
|
413
|
+
// Removing the section below because sometimes people want to do the
|
414
|
+
// full screen size in a window, and it also breaks insideSettings().
|
415
|
+
// With 3.x, fullScreen() is so easy, that it's just better that way.
|
416
|
+
// https://github.com/processing/processing/issues/3545
|
417
|
+
/*
|
418
418
|
// Sketch has already requested to be the same as the screen's
|
419
419
|
// width and height, so let's roll with full screen mode.
|
420
420
|
if (screenRect.width == sketchWidth &&
|
@@ -422,18 +422,18 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
422
422
|
fullScreen = true;
|
423
423
|
sketch.fullScreen(); // won't change the renderer
|
424
424
|
}
|
425
|
-
|
425
|
+
*/
|
426
426
|
|
427
|
-
|
428
|
-
|
429
|
-
|
430
|
-
|
427
|
+
if (fullScreen || spanDisplays) {
|
428
|
+
sketchWidth = screenRect.width;
|
429
|
+
sketchHeight = screenRect.height;
|
430
|
+
}
|
431
431
|
|
432
|
-
|
433
|
-
|
434
|
-
|
435
|
-
|
436
|
-
|
432
|
+
// Using a JFrame fixes a Windows problem with Present mode. This might
|
433
|
+
// be our error, but usually this is the sort of crap we usually get from
|
434
|
+
// OS X. It's time for a turnaround: Redmond is thinking different too!
|
435
|
+
// https://github.com/processing/processing/issues/1955
|
436
|
+
frame = new JFrame(displayDevice.getDefaultConfiguration());
|
437
437
|
// frame = new Frame(displayDevice.getDefaultConfiguration());
|
438
438
|
// // Default Processing gray, which will be replaced below if another
|
439
439
|
// // color is specified on the command line (i.e. in the prefs).
|
@@ -445,27 +445,27 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
445
445
|
// if (backgroundColor == 0) {
|
446
446
|
// backgroundColor = WINDOW_BGCOLOR;
|
447
447
|
// }
|
448
|
-
|
449
|
-
|
450
|
-
|
451
|
-
|
452
|
-
|
453
|
-
|
448
|
+
final Color windowColor = new Color(sketch.sketchWindowColor(), false);
|
449
|
+
if (frame instanceof JFrame) {
|
450
|
+
((JFrame) frame).getContentPane().setBackground(windowColor);
|
451
|
+
} else {
|
452
|
+
frame.setBackground(windowColor);
|
453
|
+
}
|
454
454
|
|
455
|
-
|
456
|
-
|
455
|
+
// Put the p5 logo in the Frame's corner to override the Java coffee cup.
|
456
|
+
setProcessingIcon(frame);
|
457
457
|
|
458
|
-
|
459
|
-
|
460
|
-
|
461
|
-
|
462
|
-
|
463
|
-
|
464
|
-
|
465
|
-
|
466
|
-
|
458
|
+
// For 0149, moving this code (up to the pack() method) before init().
|
459
|
+
// For OpenGL (and perhaps other renderers in the future), a peer is
|
460
|
+
// needed before a GLDrawable can be created. So pack() needs to be
|
461
|
+
// called on the Frame before applet.init(), which itself calls size(),
|
462
|
+
// and launches the Thread that will kick off setup().
|
463
|
+
// http://dev.processing.org/bugs/show_bug.cgi?id=891
|
464
|
+
// http://dev.processing.org/bugs/show_bug.cgi?id=908
|
465
|
+
frame.add(canvas);
|
466
|
+
setSize(sketchWidth / windowScaleFactor, sketchHeight / windowScaleFactor);
|
467
467
|
|
468
|
-
|
468
|
+
/*
|
469
469
|
if (fullScreen) {
|
470
470
|
// Called here because the graphics device is needed before we can
|
471
471
|
// determine whether the sketch wants size(displayWidth, displayHeight),
|
@@ -488,162 +488,164 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
488
488
|
// will be set visible in placeWindow() [3.0a10]
|
489
489
|
//frame.setVisible(true); // re-add native resources
|
490
490
|
}
|
491
|
-
|
492
|
-
|
493
|
-
|
491
|
+
*/
|
492
|
+
frame.setLayout(null);
|
493
|
+
//frame.add(applet);
|
494
494
|
|
495
|
-
|
496
|
-
|
497
|
-
|
495
|
+
// Need to pass back our new sketchWidth/Height here, because it may have
|
496
|
+
// been overridden by numbers we calculated above if fullScreen and/or
|
497
|
+
// spanScreens was in use.
|
498
498
|
// pg = sketch.makePrimaryGraphics(sketchWidth, sketchHeight);
|
499
499
|
// pg = sketch.makePrimaryGraphics();
|
500
|
-
|
501
|
-
|
502
|
-
|
503
|
-
|
500
|
+
// resize sketch to sketchWidth/sketchHeight here
|
501
|
+
if (fullScreen) {
|
502
|
+
frame.invalidate();
|
503
|
+
} else {
|
504
504
|
// frame.pack();
|
505
|
-
|
505
|
+
}
|
506
506
|
|
507
|
-
|
508
|
-
|
509
|
-
|
510
|
-
|
511
|
-
|
507
|
+
// insufficient, places the 100x100 sketches offset strangely
|
508
|
+
//frame.validate();
|
509
|
+
// disabling resize has to happen after pack() to avoid apparent Apple bug
|
510
|
+
// http://code.google.com/p/processing/issues/detail?id=467
|
511
|
+
frame.setResizable(false);
|
512
512
|
|
513
|
-
|
514
|
-
|
515
|
-
|
516
|
-
|
517
|
-
|
518
|
-
|
513
|
+
frame.addWindowListener(new WindowAdapter() {
|
514
|
+
@Override
|
515
|
+
public void windowClosing(WindowEvent e) {
|
516
|
+
sketch.exit(); // don't quit, need to just shut everything down (0133)
|
517
|
+
}
|
518
|
+
});
|
519
519
|
|
520
520
|
// sketch.setFrame(frame);
|
521
|
-
|
521
|
+
}
|
522
522
|
|
523
|
-
|
524
|
-
|
525
|
-
|
526
|
-
|
523
|
+
@Override
|
524
|
+
public Object getNative() {
|
525
|
+
return canvas;
|
526
|
+
}
|
527
527
|
|
528
528
|
// public Toolkit getToolkit() {
|
529
529
|
// return canvas.getToolkit();
|
530
530
|
// }
|
531
|
-
|
532
|
-
|
533
|
-
|
534
|
-
|
535
|
-
|
536
|
-
|
537
|
-
|
538
|
-
|
539
|
-
|
540
|
-
|
541
|
-
|
542
|
-
|
543
|
-
|
544
|
-
|
545
|
-
|
546
|
-
}
|
531
|
+
/**
|
532
|
+
* Set the window (and dock, or whatever necessary) title.
|
533
|
+
*
|
534
|
+
* @param title
|
535
|
+
*/
|
536
|
+
@Override
|
537
|
+
public void setTitle(String title) {
|
538
|
+
frame.setTitle(title);
|
539
|
+
// Workaround for apparent Java bug on OS X?
|
540
|
+
// https://github.com/processing/processing/issues/3472
|
541
|
+
if (cursorVisible
|
542
|
+
&& (PApplet.platform == PConstants.MACOSX)
|
543
|
+
&& (cursorType != PConstants.ARROW)) {
|
544
|
+
hideCursor();
|
545
|
+
showCursor();
|
547
546
|
}
|
547
|
+
}
|
548
548
|
|
549
|
-
|
550
|
-
|
551
|
-
|
552
|
-
|
553
|
-
|
554
|
-
|
549
|
+
/**
|
550
|
+
* Set true if we want to resize things (default is not resizable)
|
551
|
+
*
|
552
|
+
* @param resizable
|
553
|
+
*/
|
554
|
+
@Override
|
555
|
+
public void setResizable(boolean resizable) {
|
556
|
+
//this.resizable = resizable; // really only used for canvas
|
555
557
|
|
556
|
-
|
557
|
-
|
558
|
-
}
|
558
|
+
if (frame != null) {
|
559
|
+
frame.setResizable(resizable);
|
559
560
|
}
|
561
|
+
}
|
560
562
|
|
561
|
-
|
562
|
-
|
563
|
-
|
564
|
-
|
565
|
-
|
566
|
-
|
563
|
+
@Override
|
564
|
+
public void setIcon(PImage image) {
|
565
|
+
Image awtImage = (Image) image.getNative();
|
566
|
+
ThinkDifferent.init(sketch);
|
567
|
+
ThinkDifferent.setIconImage(awtImage);
|
568
|
+
}
|
567
569
|
|
568
|
-
|
569
|
-
|
570
|
-
|
571
|
-
|
570
|
+
@Override
|
571
|
+
public void setAlwaysOnTop(boolean always) {
|
572
|
+
frame.setAlwaysOnTop(always);
|
573
|
+
}
|
572
574
|
|
573
|
-
|
574
|
-
|
575
|
-
|
576
|
-
|
575
|
+
@Override
|
576
|
+
public void setLocation(int x, int y) {
|
577
|
+
frame.setLocation(x, y);
|
578
|
+
}
|
577
579
|
|
578
|
-
|
579
|
-
|
580
|
-
|
581
|
-
|
582
|
-
|
583
|
-
|
584
|
-
|
585
|
-
|
586
|
-
|
587
|
-
|
588
|
-
|
589
|
-
|
590
|
-
|
591
|
-
|
592
|
-
|
593
|
-
|
594
|
-
|
595
|
-
|
596
|
-
|
597
|
-
|
598
|
-
|
599
|
-
|
580
|
+
List<Image> iconImages;
|
581
|
+
|
582
|
+
protected void setProcessingIcon(Frame frame) {
|
583
|
+
// On OS X, this only affects what shows up in the dock when minimized.
|
584
|
+
// So replacing it is actually a step backwards. Brilliant.
|
585
|
+
if (PApplet.platform != PConstants.MACOSX) {
|
586
|
+
//Image image = Toolkit.getDefaultToolkit().createImage(ICON_IMAGE);
|
587
|
+
//frame.setIconImage(image);
|
588
|
+
// try {
|
589
|
+
if (iconImages == null) {
|
590
|
+
iconImages = new ArrayList<>();
|
591
|
+
final int[] sizes = {16, 32, 48, 64, 128, 256, 512};
|
592
|
+
|
593
|
+
for (int sz : sizes) {
|
594
|
+
//URL url = getClass().getResource("/icon/icon-" + sz + ".png");
|
595
|
+
URL url = PApplet.class.getResource("/icon/icon-" + sz + ".png");
|
596
|
+
Image image = Toolkit.getDefaultToolkit().getImage(url);
|
597
|
+
iconImages.add(image);
|
598
|
+
//iconImages.add(Toolkit.getLibImage("icons/pde-" + sz + ".png", frame));
|
599
|
+
}
|
600
|
+
}
|
601
|
+
frame.setIconImages(iconImages);
|
600
602
|
|
601
603
|
// } catch (Exception e) {
|
602
604
|
// } // harmless; keep this to ourselves
|
603
|
-
|
604
|
-
|
605
|
-
|
606
|
-
|
607
|
-
|
608
|
-
|
609
|
-
|
610
|
-
|
611
|
-
|
612
|
-
|
613
|
-
|
614
|
-
|
615
|
-
|
616
|
-
|
617
|
-
|
618
|
-
|
619
|
-
}
|
620
|
-
}
|
605
|
+
} else { // handle OS X differently
|
606
|
+
if (!dockIconSpecified()) { // don't override existing -Xdock param
|
607
|
+
// On OS X, set this for AWT surfaces, which handles the dock image
|
608
|
+
// as well as the cmd-tab image that's shown. Just one size, I guess.
|
609
|
+
URL url = PApplet.class.getResource("/icon/icon-512.png");
|
610
|
+
// Seems dangerous to have this in code instead of using reflection, no?
|
611
|
+
// ThinkDifferent.setIconImage(Toolkit.getDefaultToolkit().getImage(url));
|
612
|
+
try {
|
613
|
+
final String td = "processing.core.ThinkDifferent";
|
614
|
+
Class<?> thinkDifferent
|
615
|
+
= Thread.currentThread().getContextClassLoader().loadClass(td);
|
616
|
+
Method method
|
617
|
+
= thinkDifferent.getMethod("setIconImage", new Class[]{java.awt.Image.class});
|
618
|
+
method.invoke(null, new Object[]{Toolkit.getDefaultToolkit().getImage(url)});
|
619
|
+
} catch (ClassNotFoundException | IllegalAccessException | IllegalArgumentException | NoSuchMethodException | SecurityException | InvocationTargetException e) {
|
620
|
+
// That's unfortunate
|
621
621
|
}
|
622
|
+
}
|
622
623
|
}
|
624
|
+
}
|
623
625
|
|
624
|
-
|
625
|
-
|
626
|
-
|
627
|
-
|
628
|
-
|
629
|
-
|
630
|
-
|
631
|
-
|
632
|
-
|
633
|
-
|
626
|
+
/**
|
627
|
+
* @return true if -Xdock:icon was specified on the command line
|
628
|
+
*/
|
629
|
+
private boolean dockIconSpecified() {
|
630
|
+
// TODO This is incomplete... Haven't yet found a way to figure out if
|
631
|
+
// the app has an icns file specified already. Help?
|
632
|
+
List<String> jvmArgs
|
633
|
+
= ManagementFactory.getRuntimeMXBean().getInputArguments();
|
634
|
+
return (jvmArgs.stream().anyMatch((arg) -> (arg.startsWith("-Xdock:icon"))));
|
635
|
+
}
|
634
636
|
|
635
|
-
|
636
|
-
|
637
|
-
|
637
|
+
@Override
|
638
|
+
public void setVisible(boolean visible) {
|
639
|
+
frame.setVisible(visible);
|
638
640
|
|
639
|
-
|
640
|
-
|
641
|
-
|
642
|
-
|
643
|
-
|
641
|
+
// Generally useful whenever setting the frame visible
|
642
|
+
if (canvas != null) {
|
643
|
+
//canvas.requestFocusInWindow();
|
644
|
+
canvas.requestFocus();
|
645
|
+
}
|
644
646
|
|
645
|
-
|
646
|
-
|
647
|
+
// removing per https://github.com/processing/processing/pull/3162
|
648
|
+
// can remove the code below once 3.0a6 is tested and behaving
|
647
649
|
/*
|
648
650
|
if (visible && PApplet.platform == PConstants.LINUX) {
|
649
651
|
// Linux doesn't deal with insets the same way. We get fake insets
|
@@ -657,50 +659,50 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
657
659
|
insets.top + insets.bottom);
|
658
660
|
}
|
659
661
|
}
|
660
|
-
|
661
|
-
|
662
|
+
*/
|
663
|
+
}
|
662
664
|
|
663
|
-
|
664
|
-
|
665
|
-
|
666
|
-
|
665
|
+
//public void placeFullScreen(boolean hideStop) {
|
666
|
+
@Override
|
667
|
+
public void placePresent(int stopColor) {
|
668
|
+
setFullFrame();
|
667
669
|
|
668
|
-
|
670
|
+
// After the pack(), the screen bounds are gonna be 0s
|
669
671
|
// frame.setBounds(screenRect); // already called in setFullFrame()
|
670
|
-
|
671
|
-
|
672
|
-
|
672
|
+
canvas.setBounds((screenRect.width - sketchWidth) / 2,
|
673
|
+
(screenRect.height - sketchHeight) / 2,
|
674
|
+
sketchWidth, sketchHeight);
|
673
675
|
|
674
676
|
// if (PApplet.platform == PConstants.MACOSX) {
|
675
677
|
// macosxFullScreenEnable(frame);
|
676
678
|
// macosxFullScreenToggle(frame);
|
677
679
|
// }
|
678
|
-
|
679
|
-
|
680
|
-
|
681
|
-
|
682
|
-
|
683
|
-
|
684
|
-
|
685
|
-
}
|
686
|
-
});
|
687
|
-
frame.add(label);
|
688
|
-
|
689
|
-
Dimension labelSize = label.getPreferredSize();
|
690
|
-
// sometimes shows up truncated on mac
|
691
|
-
//System.out.println("label width is " + labelSize.width);
|
692
|
-
labelSize = new Dimension(100, labelSize.height);
|
693
|
-
label.setSize(labelSize);
|
694
|
-
label.setLocation(20, screenRect.height - labelSize.height - 20);
|
680
|
+
if (stopColor != 0) {
|
681
|
+
Label label = new Label("stop");
|
682
|
+
label.setForeground(new Color(stopColor, false));
|
683
|
+
label.addMouseListener(new MouseAdapter() {
|
684
|
+
@Override
|
685
|
+
public void mousePressed(java.awt.event.MouseEvent e) {
|
686
|
+
sketch.exit();
|
695
687
|
}
|
688
|
+
});
|
689
|
+
frame.add(label);
|
690
|
+
|
691
|
+
Dimension labelSize = label.getPreferredSize();
|
692
|
+
// sometimes shows up truncated on mac
|
693
|
+
//System.out.println("label width is " + labelSize.width);
|
694
|
+
labelSize = new Dimension(100, labelSize.height);
|
695
|
+
label.setSize(labelSize);
|
696
|
+
label.setLocation(20, screenRect.height - labelSize.height - 20);
|
697
|
+
}
|
696
698
|
|
697
699
|
// if (sketch.getGraphics().displayable()) {
|
698
700
|
// setVisible(true);
|
699
701
|
// }
|
700
|
-
|
702
|
+
}
|
701
703
|
|
702
704
|
|
703
|
-
|
705
|
+
/*
|
704
706
|
@Override
|
705
707
|
public void placeWindow(int[] location) {
|
706
708
|
setFrameSize(); //sketchWidth, sketchHeight);
|
@@ -744,132 +746,132 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
744
746
|
frame.setVisible(true);
|
745
747
|
}
|
746
748
|
}
|
747
|
-
|
748
|
-
|
749
|
+
*/
|
750
|
+
private void setCanvasSize() {
|
749
751
|
// System.out.format("setting canvas size %d %d%n", sketchWidth, sketchHeight);
|
750
752
|
// new Exception().printStackTrace(System.out);
|
751
|
-
|
752
|
-
|
753
|
+
int contentW = Math.max(sketchWidth, MIN_WINDOW_WIDTH);
|
754
|
+
int contentH = Math.max(sketchHeight, MIN_WINDOW_HEIGHT);
|
753
755
|
|
754
|
-
|
755
|
-
|
756
|
-
|
757
|
-
|
756
|
+
canvas.setBounds((contentW - sketchWidth) / 2,
|
757
|
+
(contentH - sketchHeight) / 2,
|
758
|
+
sketchWidth, sketchHeight);
|
759
|
+
}
|
758
760
|
|
759
|
-
|
760
|
-
|
761
|
-
|
762
|
-
|
763
|
-
|
764
|
-
|
761
|
+
/**
|
762
|
+
* Resize frame for these sketch (canvas) dimensions.
|
763
|
+
*/
|
764
|
+
private Dimension setFrameSize() { //int sketchWidth, int sketchHeight) {
|
765
|
+
// https://github.com/processing/processing/pull/3162
|
766
|
+
frame.addNotify(); // using instead of show() to add the peer [fry]
|
765
767
|
|
766
768
|
// System.out.format("setting frame size %d %d %n", sketchWidth, sketchHeight);
|
767
769
|
// new Exception().printStackTrace(System.out);
|
768
|
-
|
769
|
-
|
770
|
-
|
771
|
-
|
772
|
-
|
773
|
-
|
774
|
-
|
775
|
-
|
776
|
-
|
777
|
-
private void setFrameCentered() {
|
778
|
-
// Can't use frame.setLocationRelativeTo(null) because it sends the
|
779
|
-
// frame to the main display, which undermines the --display setting.
|
780
|
-
frame.setLocation(screenRect.x + (screenRect.width - sketchWidth) / 2,
|
781
|
-
screenRect.y + (screenRect.height - sketchHeight) / 2);
|
782
|
-
}
|
770
|
+
currentInsets = frame.getInsets();
|
771
|
+
int windowW = Math.max(sketchWidth, MIN_WINDOW_WIDTH)
|
772
|
+
+ currentInsets.left + currentInsets.right;
|
773
|
+
int windowH = Math.max(sketchHeight, MIN_WINDOW_HEIGHT)
|
774
|
+
+ currentInsets.top + currentInsets.bottom;
|
775
|
+
frame.setSize(windowW, windowH);
|
776
|
+
return new Dimension(windowW, windowH);
|
777
|
+
}
|
783
778
|
|
784
|
-
|
785
|
-
|
786
|
-
|
787
|
-
|
788
|
-
|
789
|
-
|
790
|
-
// and getting the graphics device will be PSurface-specific.
|
791
|
-
PApplet.hideMenuBar();
|
792
|
-
|
793
|
-
// Tried to use this to fix the 'present' mode issue.
|
794
|
-
// Did not help, and the screenRect setup seems to work fine.
|
795
|
-
//frame.setExtendedState(Frame.MAXIMIZED_BOTH);
|
796
|
-
// https://github.com/processing/processing/pull/3162
|
797
|
-
//frame.dispose(); // release native resources, allows setUndecorated()
|
798
|
-
frame.removeNotify();
|
799
|
-
frame.setUndecorated(true);
|
800
|
-
frame.addNotify();
|
779
|
+
private void setFrameCentered() {
|
780
|
+
// Can't use frame.setLocationRelativeTo(null) because it sends the
|
781
|
+
// frame to the main display, which undermines the --display setting.
|
782
|
+
frame.setLocation(screenRect.x + (screenRect.width - sketchWidth) / 2,
|
783
|
+
screenRect.y + (screenRect.height - sketchHeight) / 2);
|
784
|
+
}
|
801
785
|
|
802
|
-
|
803
|
-
|
804
|
-
|
805
|
-
|
806
|
-
|
786
|
+
/**
|
787
|
+
* Hide the menu bar, make the Frame undecorated, set it to screenRect.
|
788
|
+
*/
|
789
|
+
private void setFullFrame() {
|
790
|
+
// Called here because the graphics device is needed before we can
|
791
|
+
// determine whether the sketch wants size(displayWidth, displayHeight),
|
792
|
+
// and getting the graphics device will be PSurface-specific.
|
793
|
+
PApplet.hideMenuBar();
|
794
|
+
|
795
|
+
// Tried to use this to fix the 'present' mode issue.
|
796
|
+
// Did not help, and the screenRect setup seems to work fine.
|
797
|
+
//frame.setExtendedState(Frame.MAXIMIZED_BOTH);
|
798
|
+
// https://github.com/processing/processing/pull/3162
|
799
|
+
//frame.dispose(); // release native resources, allows setUndecorated()
|
800
|
+
frame.removeNotify();
|
801
|
+
frame.setUndecorated(true);
|
802
|
+
frame.addNotify();
|
803
|
+
|
804
|
+
// this may be the bounds of all screens
|
805
|
+
frame.setBounds(screenRect);
|
806
|
+
// will be set visible in placeWindow() [3.0a10]
|
807
|
+
//frame.setVisible(true); // re-add native resources
|
808
|
+
}
|
807
809
|
|
808
|
-
|
809
|
-
|
810
|
-
|
811
|
-
|
810
|
+
@Override
|
811
|
+
public void placeWindow(int[] location, int[] editorLocation) {
|
812
|
+
//Dimension window = setFrameSize(sketchWidth, sketchHeight);
|
813
|
+
Dimension window = setFrameSize(); //sketchWidth, sketchHeight);
|
812
814
|
|
813
|
-
|
814
|
-
|
815
|
+
int contentW = Math.max(sketchWidth, MIN_WINDOW_WIDTH);
|
816
|
+
int contentH = Math.max(sketchHeight, MIN_WINDOW_HEIGHT);
|
815
817
|
|
816
|
-
|
817
|
-
|
818
|
-
|
818
|
+
if (sketch.sketchFullScreen()) {
|
819
|
+
setFullFrame();
|
820
|
+
}
|
819
821
|
|
820
|
-
|
821
|
-
|
822
|
-
|
823
|
-
|
824
|
-
|
825
|
-
|
826
|
-
|
827
|
-
|
828
|
-
|
829
|
-
|
830
|
-
|
831
|
-
|
832
|
-
|
833
|
-
|
834
|
-
|
835
|
-
|
836
|
-
|
837
|
-
|
838
|
-
|
839
|
-
|
840
|
-
|
841
|
-
|
842
|
-
|
843
|
-
|
844
|
-
|
822
|
+
// Ignore placement of previous window and editor when full screen
|
823
|
+
if (!sketch.sketchFullScreen()) {
|
824
|
+
if (location != null) {
|
825
|
+
// a specific location was received from the Runner
|
826
|
+
// (applet has been run more than once, user placed window)
|
827
|
+
frame.setLocation(location[0], location[1]);
|
828
|
+
|
829
|
+
} else if (editorLocation != null) {
|
830
|
+
int locationX = editorLocation[0] - 20;
|
831
|
+
int locationY = editorLocation[1];
|
832
|
+
|
833
|
+
if (locationX - window.width > 10) {
|
834
|
+
// if it fits to the left of the window
|
835
|
+
frame.setLocation(locationX - window.width, locationY);
|
836
|
+
|
837
|
+
} else { // doesn't fit
|
838
|
+
// if it fits inside the editor window,
|
839
|
+
// offset slightly from upper lefthand corner
|
840
|
+
// so that it's plunked inside the text area
|
841
|
+
//locationX = editorLocation[0] + 66;
|
842
|
+
//locationY = editorLocation[1] + 66;
|
843
|
+
locationX = (sketch.displayWidth - window.width) / 2;
|
844
|
+
locationY = (sketch.displayHeight - window.height) / 2;
|
845
|
+
|
846
|
+
/*
|
845
847
|
if ((locationX + window.width > sketch.displayWidth - 33) ||
|
846
848
|
(locationY + window.height > sketch.displayHeight - 33)) {
|
847
849
|
// otherwise center on screen
|
848
850
|
locationX = (sketch.displayWidth - window.width) / 2;
|
849
851
|
locationY = (sketch.displayHeight - window.height) / 2;
|
850
852
|
}
|
851
|
-
|
852
|
-
|
853
|
-
}
|
854
|
-
} else { // just center on screen
|
855
|
-
setFrameCentered();
|
856
|
-
}
|
857
|
-
Point frameLoc = frame.getLocation();
|
858
|
-
if (frameLoc.y < 0) {
|
859
|
-
// Windows actually allows you to place frames where they can't be
|
860
|
-
// closed. Awesome. http://dev.processing.org/bugs/show_bug.cgi?id=1508
|
861
|
-
frame.setLocation(frameLoc.x, 30);
|
862
|
-
}
|
853
|
+
*/
|
854
|
+
frame.setLocation(locationX, locationY);
|
863
855
|
}
|
856
|
+
} else { // just center on screen
|
857
|
+
setFrameCentered();
|
858
|
+
}
|
859
|
+
Point frameLoc = frame.getLocation();
|
860
|
+
if (frameLoc.y < 0) {
|
861
|
+
// Windows actually allows you to place frames where they can't be
|
862
|
+
// closed. Awesome. http://dev.processing.org/bugs/show_bug.cgi?id=1508
|
863
|
+
frame.setLocation(frameLoc.x, 30);
|
864
|
+
}
|
865
|
+
}
|
864
866
|
|
865
|
-
|
866
|
-
|
867
|
-
|
867
|
+
canvas.setBounds((contentW - sketchWidth) / 2,
|
868
|
+
(contentH - sketchHeight) / 2,
|
869
|
+
sketchWidth, sketchHeight);
|
868
870
|
|
869
|
-
|
870
|
-
|
871
|
+
// handle frame resizing events
|
872
|
+
setupFrameResizeListener();
|
871
873
|
|
872
|
-
|
874
|
+
/*
|
873
875
|
// If displayable() is false, then PSurfaceNone should be used, but...
|
874
876
|
if (sketch.getGraphics().displayable()) {
|
875
877
|
frame.setVisible(true);
|
@@ -880,64 +882,64 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
880
882
|
// canvas.requestFocus();
|
881
883
|
// }
|
882
884
|
}
|
883
|
-
|
885
|
+
*/
|
884
886
|
// if (sketch.getGraphics().displayable()) {
|
885
887
|
// setVisible(true);
|
886
888
|
// }
|
887
|
-
|
889
|
+
}
|
888
890
|
|
889
|
-
|
890
|
-
|
891
|
-
|
892
|
-
|
893
|
-
|
894
|
-
|
895
|
-
|
896
|
-
|
897
|
-
|
898
|
-
|
899
|
-
|
900
|
-
|
891
|
+
// needs to resize the frame, which will resize the canvas, and so on...
|
892
|
+
@Override
|
893
|
+
public void setSize(int wide, int high) {
|
894
|
+
// When the surface is set to resizable via surface.setResizable(true),
|
895
|
+
// a crash may occur if the user sets the window to size zero.
|
896
|
+
// https://github.com/processing/processing/issues/5052
|
897
|
+
if (high <= 0) {
|
898
|
+
high = 1;
|
899
|
+
}
|
900
|
+
if (wide <= 0) {
|
901
|
+
wide = 1;
|
902
|
+
}
|
901
903
|
|
902
904
|
// if (PApplet.DEBUG) {
|
903
905
|
// //System.out.format("frame visible %b, setSize(%d, %d) %n", frame.isVisible(), wide, high);
|
904
906
|
// new Exception(String.format("setSize(%d, %d)", wide, high)).printStackTrace(System.out);
|
905
907
|
// }
|
906
|
-
|
907
|
-
|
908
|
-
|
908
|
+
//if (wide == sketchWidth && high == sketchHeight) { // doesn't work on launch
|
909
|
+
if (wide == sketch.width && high == sketch.height
|
910
|
+
&& (frame == null || currentInsets.equals(frame.getInsets()))) {
|
909
911
|
// if (PApplet.DEBUG) {
|
910
912
|
// new Exception("w/h unchanged " + wide + " " + high).printStackTrace(System.out);
|
911
913
|
// }
|
912
|
-
|
913
|
-
|
914
|
+
return; // unchanged, don't rebuild everything
|
915
|
+
}
|
914
916
|
|
915
|
-
|
916
|
-
|
917
|
+
sketchWidth = wide * windowScaleFactor;
|
918
|
+
sketchHeight = high * windowScaleFactor;
|
917
919
|
|
918
920
|
// canvas.setSize(wide, high);
|
919
921
|
// frame.setSize(wide, high);
|
920
|
-
|
921
|
-
|
922
|
-
|
923
|
-
|
922
|
+
if (frame != null) { // skip if just a canvas
|
923
|
+
setFrameSize(); //wide, high);
|
924
|
+
}
|
925
|
+
setCanvasSize();
|
924
926
|
// if (frame != null) {
|
925
927
|
// frame.setLocationRelativeTo(null);
|
926
928
|
// }
|
927
929
|
|
928
|
-
|
929
|
-
|
930
|
-
|
930
|
+
//initImage(graphics, wide, high);
|
931
|
+
//throw new RuntimeException("implement me, see readme.md");
|
932
|
+
sketch.setSize(wide, high);
|
931
933
|
// sketch.width = wide;
|
932
934
|
// sketch.height = high;
|
933
935
|
|
934
|
-
|
935
|
-
|
936
|
+
// set PGraphics variables for width/height/pixelWidth/pixelHeight
|
937
|
+
graphics.setSize(wide, high);
|
936
938
|
// System.out.println("out of setSize()");
|
937
|
-
|
939
|
+
}
|
938
940
|
|
939
|
-
|
940
|
-
|
941
|
+
//public void initImage(PGraphics gr, int wide, int high) {
|
942
|
+
/*
|
941
943
|
@Override
|
942
944
|
public void initImage(PGraphics graphics) {
|
943
945
|
GraphicsConfiguration gc = canvas.getGraphicsConfiguration();
|
@@ -954,7 +956,7 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
954
956
|
int high = graphics.height * graphics.pixelFactor;
|
955
957
|
graphics.image = gc.createCompatibleImage(wide, high);
|
956
958
|
}
|
957
|
-
|
959
|
+
*/
|
958
960
|
// @Override
|
959
961
|
// public Component getComponent() {
|
960
962
|
// return canvas;
|
@@ -962,7 +964,7 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
962
964
|
// @Override
|
963
965
|
// public void setSmooth(int level) {
|
964
966
|
// }
|
965
|
-
|
967
|
+
/*
|
966
968
|
private boolean checkRetina() {
|
967
969
|
if (PApplet.platform == PConstants.MACOSX) {
|
968
970
|
// This should probably be reset each time there's a display change.
|
@@ -988,24 +990,24 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
988
990
|
}
|
989
991
|
return false;
|
990
992
|
}
|
991
|
-
|
992
|
-
|
993
|
-
|
994
|
-
|
995
|
-
|
996
|
-
|
997
|
-
|
998
|
-
|
999
|
-
|
1000
|
-
|
1001
|
-
|
1002
|
-
|
1003
|
-
}
|
1004
|
-
return bounds;
|
993
|
+
*/
|
994
|
+
/**
|
995
|
+
* Get the bounds rectangle for all displays.
|
996
|
+
*/
|
997
|
+
static Rectangle getDisplaySpan() {
|
998
|
+
Rectangle bounds = new Rectangle();
|
999
|
+
GraphicsEnvironment environment
|
1000
|
+
= GraphicsEnvironment.getLocalGraphicsEnvironment();
|
1001
|
+
for (GraphicsDevice device : environment.getScreenDevices()) {
|
1002
|
+
for (GraphicsConfiguration config : device.getConfigurations()) {
|
1003
|
+
Rectangle2D.union(bounds, config.getBounds(), bounds);
|
1004
|
+
}
|
1005
1005
|
}
|
1006
|
+
return bounds;
|
1007
|
+
}
|
1006
1008
|
|
1007
1009
|
|
1008
|
-
|
1010
|
+
/*
|
1009
1011
|
private void checkDisplaySize() {
|
1010
1012
|
if (canvas.getGraphicsConfiguration() != null) {
|
1011
1013
|
GraphicsDevice displayDevice = getGraphicsConfiguration().getDevice();
|
@@ -1019,81 +1021,81 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
1019
1021
|
}
|
1020
1022
|
}
|
1021
1023
|
}
|
1022
|
-
|
1023
|
-
|
1024
|
-
|
1025
|
-
|
1026
|
-
|
1027
|
-
|
1028
|
-
|
1029
|
-
|
1030
|
-
|
1031
|
-
|
1032
|
-
|
1033
|
-
|
1034
|
-
|
1035
|
-
|
1036
|
-
|
1037
|
-
|
1038
|
-
|
1039
|
-
|
1024
|
+
*/
|
1025
|
+
/**
|
1026
|
+
* Set this sketch to communicate its state back to the PDE.
|
1027
|
+
* <p/>
|
1028
|
+
* This uses the stderr stream to write positions of the window (so that it
|
1029
|
+
* will be saved by the PDE for the next run) and notify on quit. See more
|
1030
|
+
* notes in the Worker class.
|
1031
|
+
*/
|
1032
|
+
@Override
|
1033
|
+
public void setupExternalMessages() {
|
1034
|
+
frame.addComponentListener(new ComponentAdapter() {
|
1035
|
+
@Override
|
1036
|
+
public void componentMoved(ComponentEvent e) {
|
1037
|
+
Point where = ((Frame) e.getSource()).getLocation();
|
1038
|
+
sketch.frameMoved(where.x, where.y);
|
1039
|
+
}
|
1040
|
+
});
|
1041
|
+
}
|
1040
1042
|
|
1041
|
-
|
1042
|
-
|
1043
|
-
|
1044
|
-
|
1045
|
-
|
1046
|
-
|
1047
|
-
|
1048
|
-
|
1049
|
-
|
1050
|
-
|
1051
|
-
|
1052
|
-
|
1053
|
-
|
1054
|
-
|
1055
|
-
|
1056
|
-
|
1057
|
-
|
1058
|
-
|
1059
|
-
|
1060
|
-
|
1061
|
-
|
1062
|
-
|
1063
|
-
|
1064
|
-
|
1065
|
-
|
1066
|
-
|
1067
|
-
|
1068
|
-
|
1069
|
-
|
1070
|
-
|
1071
|
-
|
1072
|
-
|
1073
|
-
|
1074
|
-
|
1075
|
-
|
1076
|
-
|
1077
|
-
|
1078
|
-
|
1079
|
-
|
1080
|
-
|
1081
|
-
|
1082
|
-
|
1083
|
-
|
1084
|
-
|
1085
|
-
|
1086
|
-
|
1087
|
-
|
1088
|
-
|
1089
|
-
|
1090
|
-
|
1091
|
-
|
1092
|
-
|
1093
|
-
|
1094
|
-
|
1095
|
-
|
1096
|
-
|
1043
|
+
/**
|
1044
|
+
* Set up a listener that will fire proper component resize events in cases
|
1045
|
+
* where frame.setResizable(true) is called.
|
1046
|
+
*/
|
1047
|
+
private void setupFrameResizeListener() {
|
1048
|
+
frame.addWindowStateListener((WindowEvent e) -> {
|
1049
|
+
// This seems to be firing when dragging the window on OS X
|
1050
|
+
// https://github.com/processing/processing/issues/3092
|
1051
|
+
if (Frame.MAXIMIZED_BOTH == e.getNewState()) {
|
1052
|
+
// Supposedly, sending the frame to back and then front is a
|
1053
|
+
// workaround for this bug:
|
1054
|
+
// http://stackoverflow.com/a/23897602
|
1055
|
+
// but is not working for me...
|
1056
|
+
//frame.toBack();
|
1057
|
+
//frame.toFront();
|
1058
|
+
// Packing the frame works, but that causes the window to collapse
|
1059
|
+
// on OS X when the window is dragged. Changing to addNotify() for
|
1060
|
+
// https://github.com/processing/processing/issues/3092
|
1061
|
+
//frame.pack();
|
1062
|
+
frame.addNotify();
|
1063
|
+
}
|
1064
|
+
});
|
1065
|
+
|
1066
|
+
frame.addComponentListener(new ComponentAdapter() {
|
1067
|
+
@Override
|
1068
|
+
public void componentResized(ComponentEvent e) {
|
1069
|
+
// Ignore bad resize events fired during setup to fix
|
1070
|
+
// http://dev.processing.org/bugs/show_bug.cgi?id=341
|
1071
|
+
// This should also fix the blank screen on Linux bug
|
1072
|
+
// http://dev.processing.org/bugs/show_bug.cgi?id=282
|
1073
|
+
if (frame.isResizable()) {
|
1074
|
+
// might be multiple resize calls before visible (i.e. first
|
1075
|
+
// when pack() is called, then when it's resized for use).
|
1076
|
+
// ignore them because it's not the user resizing things.
|
1077
|
+
Frame farm = (Frame) e.getComponent();
|
1078
|
+
if (farm.isVisible()) {
|
1079
|
+
Dimension windowSize = farm.getSize();
|
1080
|
+
int x = farm.getX() + currentInsets.left;
|
1081
|
+
int y = farm.getY() + currentInsets.top;
|
1082
|
+
|
1083
|
+
// JFrame (unlike java.awt.Frame) doesn't include the left/top
|
1084
|
+
// insets for placement (though it does seem to need them for
|
1085
|
+
// overall size of the window. Perhaps JFrame sets its coord
|
1086
|
+
// system so that (0, 0) is always the upper-left of the content
|
1087
|
+
// area. Which seems nice, but breaks any f*ing AWT-based code.
|
1088
|
+
int w = windowSize.width - currentInsets.left - currentInsets.right;
|
1089
|
+
int h = windowSize.height - currentInsets.top - currentInsets.bottom;
|
1090
|
+
setSize(w / windowScaleFactor, h / windowScaleFactor);
|
1091
|
+
|
1092
|
+
// correct the location when inset size changes
|
1093
|
+
setLocation(x - currentInsets.left, y - currentInsets.top);
|
1094
|
+
}
|
1095
|
+
}
|
1096
|
+
}
|
1097
|
+
});
|
1098
|
+
}
|
1097
1099
|
|
1098
1100
|
// /**
|
1099
1101
|
// * (No longer in use) Use reflection to call
|
@@ -1135,8 +1137,8 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
1135
1137
|
// e.printStackTrace();
|
1136
1138
|
// }
|
1137
1139
|
// }
|
1138
|
-
|
1139
|
-
|
1140
|
+
//////////////////////////////////////////////////////////////
|
1141
|
+
/*
|
1140
1142
|
// disabling for now; requires Java 1.7 and "precise" semantics are odd...
|
1141
1143
|
// returns 0.1 for tick-by-tick scrolling on OS X, but it's not a matter of
|
1142
1144
|
// calling ceil() on the value: 1.5 goes to 1, but 2.3 goes to 2.
|
@@ -1149,46 +1151,46 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
1149
1151
|
// ignored, the method will just be set to null
|
1150
1152
|
}
|
1151
1153
|
}
|
1152
|
-
|
1153
|
-
|
1154
|
-
|
1155
|
-
|
1156
|
-
|
1157
|
-
|
1158
|
-
|
1159
|
-
|
1160
|
-
|
1161
|
-
|
1162
|
-
|
1163
|
-
|
1164
|
-
|
1165
|
-
|
1166
|
-
|
1167
|
-
|
1168
|
-
|
1169
|
-
|
1170
|
-
|
1171
|
-
|
1172
|
-
|
1173
|
-
|
1174
|
-
|
1175
|
-
|
1176
|
-
|
1177
|
-
|
1178
|
-
|
1179
|
-
|
1180
|
-
|
1181
|
-
|
1182
|
-
|
1183
|
-
|
1184
|
-
|
1185
|
-
|
1186
|
-
|
1187
|
-
|
1188
|
-
|
1189
|
-
|
1190
|
-
|
1191
|
-
|
1154
|
+
*/
|
1155
|
+
/**
|
1156
|
+
* Figure out how to process a mouse event.When loop() has been called, the
|
1157
|
+
* events will be queued up until drawing is complete. If noLoop() has been
|
1158
|
+
* called, then events will happen immediately.
|
1159
|
+
*
|
1160
|
+
* @param nativeEvent
|
1161
|
+
*/
|
1162
|
+
protected void nativeMouseEvent(java.awt.event.MouseEvent nativeEvent) {
|
1163
|
+
// the 'amount' is the number of button clicks for a click event,
|
1164
|
+
// or the number of steps/clicks on the wheel for a mouse wheel event.
|
1165
|
+
int peCount = nativeEvent.getClickCount();
|
1166
|
+
|
1167
|
+
int peAction = 0;
|
1168
|
+
switch (nativeEvent.getID()) {
|
1169
|
+
case java.awt.event.MouseEvent.MOUSE_PRESSED:
|
1170
|
+
peAction = MouseEvent.PRESS;
|
1171
|
+
break;
|
1172
|
+
case java.awt.event.MouseEvent.MOUSE_RELEASED:
|
1173
|
+
peAction = MouseEvent.RELEASE;
|
1174
|
+
break;
|
1175
|
+
case java.awt.event.MouseEvent.MOUSE_CLICKED:
|
1176
|
+
peAction = MouseEvent.CLICK;
|
1177
|
+
break;
|
1178
|
+
case java.awt.event.MouseEvent.MOUSE_DRAGGED:
|
1179
|
+
peAction = MouseEvent.DRAG;
|
1180
|
+
break;
|
1181
|
+
case java.awt.event.MouseEvent.MOUSE_MOVED:
|
1182
|
+
peAction = MouseEvent.MOVE;
|
1183
|
+
break;
|
1184
|
+
case java.awt.event.MouseEvent.MOUSE_ENTERED:
|
1185
|
+
peAction = MouseEvent.ENTER;
|
1186
|
+
break;
|
1187
|
+
case java.awt.event.MouseEvent.MOUSE_EXITED:
|
1188
|
+
peAction = MouseEvent.EXIT;
|
1189
|
+
break;
|
1190
|
+
//case java.awt.event.MouseWheelEvent.WHEEL_UNIT_SCROLL:
|
1191
|
+
case java.awt.event.MouseEvent.MOUSE_WHEEL:
|
1192
|
+
peAction = MouseEvent.WHEEL;
|
1193
|
+
/*
|
1192
1194
|
if (preciseWheelMethod != null) {
|
1193
1195
|
try {
|
1194
1196
|
peAmount = ((Double) preciseWheelMethod.invoke(nativeEvent, (Object[]) null)).floatValue();
|
@@ -1196,29 +1198,29 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
1196
1198
|
preciseWheelMethod = null;
|
1197
1199
|
}
|
1198
1200
|
}
|
1199
|
-
|
1200
|
-
|
1201
|
-
|
1202
|
-
|
1201
|
+
*/
|
1202
|
+
peCount = ((MouseWheelEvent) nativeEvent).getWheelRotation();
|
1203
|
+
break;
|
1204
|
+
}
|
1203
1205
|
|
1204
|
-
|
1205
|
-
|
1206
|
-
|
1207
|
-
|
1208
|
-
|
1209
|
-
|
1210
|
-
|
1211
|
-
|
1212
|
-
|
1213
|
-
|
1214
|
-
|
1215
|
-
|
1216
|
-
|
1217
|
-
|
1218
|
-
|
1219
|
-
|
1220
|
-
|
1221
|
-
|
1206
|
+
//System.out.println(nativeEvent);
|
1207
|
+
//int modifiers = nativeEvent.getModifiersEx();
|
1208
|
+
// If using getModifiersEx(), the regular modifiers don't set properly.
|
1209
|
+
int modifiers = nativeEvent.getModifiers();
|
1210
|
+
|
1211
|
+
int peModifiers = modifiers
|
1212
|
+
& (InputEvent.SHIFT_MASK
|
1213
|
+
| InputEvent.CTRL_MASK
|
1214
|
+
| InputEvent.META_MASK
|
1215
|
+
| InputEvent.ALT_MASK);
|
1216
|
+
|
1217
|
+
// Windows and OS X seem to disagree on how to handle this. Windows only
|
1218
|
+
// sets BUTTON1_DOWN_MASK, while OS X seems to set BUTTON1_MASK.
|
1219
|
+
// This is an issue in particular with mouse release events:
|
1220
|
+
// http://code.google.com/p/processing/issues/detail?id=1294
|
1221
|
+
// The fix for which led to a regression (fixed here by checking both):
|
1222
|
+
// http://code.google.com/p/processing/issues/detail?id=1332
|
1223
|
+
int peButton = 0;
|
1222
1224
|
// if ((modifiers & InputEvent.BUTTON1_MASK) != 0 ||
|
1223
1225
|
// (modifiers & InputEvent.BUTTON1_DOWN_MASK) != 0) {
|
1224
1226
|
// peButton = LEFT;
|
@@ -1229,134 +1231,145 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
1229
1231
|
// (modifiers & InputEvent.BUTTON3_DOWN_MASK) != 0) {
|
1230
1232
|
// peButton = RIGHT;
|
1231
1233
|
// }
|
1232
|
-
|
1233
|
-
|
1234
|
-
|
1235
|
-
|
1236
|
-
|
1237
|
-
|
1238
|
-
|
1239
|
-
|
1240
|
-
// If running on Mac OS, allow ctrl-click as right mouse. Prior to 0215,
|
1241
|
-
// this used isPopupTrigger() on the native event, but that doesn't work
|
1242
|
-
// for mouseClicked and mouseReleased (or others).
|
1243
|
-
if (PApplet.platform == PConstants.MACOSX) {
|
1244
|
-
//if (nativeEvent.isPopupTrigger()) {
|
1245
|
-
if ((modifiers & InputEvent.CTRL_MASK) != 0) {
|
1246
|
-
peButton = PConstants.RIGHT;
|
1247
|
-
}
|
1248
|
-
}
|
1234
|
+
if ((modifiers & InputEvent.BUTTON1_MASK) != 0) {
|
1235
|
+
peButton = PConstants.LEFT;
|
1236
|
+
} else if ((modifiers & InputEvent.BUTTON2_MASK) != 0) {
|
1237
|
+
peButton = PConstants.CENTER;
|
1238
|
+
} else if ((modifiers & InputEvent.BUTTON3_MASK) != 0) {
|
1239
|
+
peButton = PConstants.RIGHT;
|
1240
|
+
}
|
1249
1241
|
|
1250
|
-
|
1251
|
-
|
1252
|
-
|
1253
|
-
|
1254
|
-
|
1255
|
-
|
1242
|
+
// If running on Mac OS, allow ctrl-click as right mouse. Prior to 0215,
|
1243
|
+
// this used isPopupTrigger() on the native event, but that doesn't work
|
1244
|
+
// for mouseClicked and mouseReleased (or others).
|
1245
|
+
if (PApplet.platform == PConstants.MACOSX) {
|
1246
|
+
//if (nativeEvent.isPopupTrigger()) {
|
1247
|
+
if ((modifiers & InputEvent.CTRL_MASK) != 0) {
|
1248
|
+
peButton = PConstants.RIGHT;
|
1249
|
+
}
|
1256
1250
|
}
|
1257
1251
|
|
1258
|
-
|
1259
|
-
|
1260
|
-
|
1261
|
-
|
1262
|
-
|
1263
|
-
|
1264
|
-
|
1265
|
-
|
1266
|
-
|
1267
|
-
|
1268
|
-
|
1269
|
-
|
1270
|
-
|
1252
|
+
sketch.postEvent(new MouseEvent(nativeEvent, nativeEvent.getWhen(),
|
1253
|
+
peAction, peModifiers,
|
1254
|
+
nativeEvent.getX() / windowScaleFactor,
|
1255
|
+
nativeEvent.getY() / windowScaleFactor,
|
1256
|
+
peButton,
|
1257
|
+
peCount));
|
1258
|
+
}
|
1259
|
+
|
1260
|
+
protected void nativeKeyEvent(java.awt.event.KeyEvent event) {
|
1261
|
+
int peAction = 0;
|
1262
|
+
switch (event.getID()) {
|
1263
|
+
case java.awt.event.KeyEvent.KEY_PRESSED:
|
1264
|
+
peAction = KeyEvent.PRESS;
|
1265
|
+
break;
|
1266
|
+
case java.awt.event.KeyEvent.KEY_RELEASED:
|
1267
|
+
peAction = KeyEvent.RELEASE;
|
1268
|
+
break;
|
1269
|
+
case java.awt.event.KeyEvent.KEY_TYPED:
|
1270
|
+
peAction = KeyEvent.TYPE;
|
1271
|
+
break;
|
1272
|
+
}
|
1271
1273
|
|
1272
1274
|
// int peModifiers = event.getModifiersEx() &
|
1273
1275
|
// (InputEvent.SHIFT_DOWN_MASK |
|
1274
1276
|
// InputEvent.CTRL_DOWN_MASK |
|
1275
1277
|
// InputEvent.META_DOWN_MASK |
|
1276
1278
|
// InputEvent.ALT_DOWN_MASK);
|
1277
|
-
|
1278
|
-
|
1279
|
-
|
1280
|
-
|
1281
|
-
|
1282
|
-
|
1283
|
-
|
1284
|
-
|
1285
|
-
|
1286
|
-
|
1279
|
+
int peModifiers = event.getModifiers()
|
1280
|
+
& (InputEvent.SHIFT_MASK
|
1281
|
+
| InputEvent.CTRL_MASK
|
1282
|
+
| InputEvent.META_MASK
|
1283
|
+
| InputEvent.ALT_MASK);
|
1284
|
+
|
1285
|
+
sketch.postEvent(new KeyEvent(event, event.getWhen(),
|
1286
|
+
peAction, peModifiers,
|
1287
|
+
event.getKeyChar(), event.getKeyCode()));
|
1288
|
+
}
|
1287
1289
|
|
1288
|
-
|
1289
|
-
|
1290
|
+
// listeners, for all my men!
|
1291
|
+
protected void addListeners() {
|
1290
1292
|
|
1291
|
-
|
1293
|
+
canvas.addMouseListener(new MouseListener() {
|
1292
1294
|
|
1293
|
-
|
1294
|
-
|
1295
|
-
|
1295
|
+
@Override
|
1296
|
+
public void mousePressed(java.awt.event.MouseEvent e) {
|
1297
|
+
nativeMouseEvent(e);
|
1298
|
+
}
|
1296
1299
|
|
1297
|
-
|
1298
|
-
|
1299
|
-
|
1300
|
+
@Override
|
1301
|
+
public void mouseReleased(java.awt.event.MouseEvent e) {
|
1302
|
+
nativeMouseEvent(e);
|
1303
|
+
}
|
1300
1304
|
|
1301
|
-
|
1302
|
-
|
1303
|
-
|
1305
|
+
@Override
|
1306
|
+
public void mouseClicked(java.awt.event.MouseEvent e) {
|
1307
|
+
nativeMouseEvent(e);
|
1308
|
+
}
|
1304
1309
|
|
1305
|
-
|
1306
|
-
|
1307
|
-
|
1310
|
+
@Override
|
1311
|
+
public void mouseEntered(java.awt.event.MouseEvent e) {
|
1312
|
+
nativeMouseEvent(e);
|
1313
|
+
}
|
1308
1314
|
|
1309
|
-
|
1310
|
-
|
1311
|
-
|
1312
|
-
|
1315
|
+
@Override
|
1316
|
+
public void mouseExited(java.awt.event.MouseEvent e) {
|
1317
|
+
nativeMouseEvent(e);
|
1318
|
+
}
|
1319
|
+
});
|
1313
1320
|
|
1314
|
-
|
1321
|
+
canvas.addMouseMotionListener(new MouseMotionListener() {
|
1315
1322
|
|
1316
|
-
|
1317
|
-
|
1318
|
-
|
1323
|
+
@Override
|
1324
|
+
public void mouseDragged(java.awt.event.MouseEvent e) {
|
1325
|
+
nativeMouseEvent(e);
|
1326
|
+
}
|
1319
1327
|
|
1320
|
-
|
1321
|
-
|
1322
|
-
|
1323
|
-
|
1328
|
+
public void mouseMoved(java.awt.event.MouseEvent e) {
|
1329
|
+
nativeMouseEvent(e);
|
1330
|
+
}
|
1331
|
+
});
|
1324
1332
|
|
1325
|
-
|
1326
|
-
|
1327
|
-
|
1333
|
+
canvas.addMouseWheelListener((MouseWheelEvent e) -> {
|
1334
|
+
nativeMouseEvent(e);
|
1335
|
+
});
|
1328
1336
|
|
1329
|
-
|
1337
|
+
canvas.addKeyListener(new KeyListener() {
|
1330
1338
|
|
1331
|
-
|
1332
|
-
|
1333
|
-
|
1339
|
+
@Override
|
1340
|
+
public void keyPressed(java.awt.event.KeyEvent e) {
|
1341
|
+
nativeKeyEvent(e);
|
1342
|
+
}
|
1334
1343
|
|
1335
|
-
|
1336
|
-
|
1337
|
-
|
1344
|
+
@Override
|
1345
|
+
public void keyReleased(java.awt.event.KeyEvent e) {
|
1346
|
+
nativeKeyEvent(e);
|
1347
|
+
}
|
1338
1348
|
|
1339
|
-
|
1340
|
-
|
1341
|
-
|
1342
|
-
|
1349
|
+
@Override
|
1350
|
+
public void keyTyped(java.awt.event.KeyEvent e) {
|
1351
|
+
nativeKeyEvent(e);
|
1352
|
+
}
|
1353
|
+
});
|
1343
1354
|
|
1344
|
-
|
1355
|
+
canvas.addFocusListener(new FocusListener() {
|
1345
1356
|
|
1346
|
-
|
1347
|
-
|
1348
|
-
|
1349
|
-
|
1357
|
+
@Override
|
1358
|
+
public void focusGained(FocusEvent e) {
|
1359
|
+
sketch.focused = true;
|
1360
|
+
sketch.focusGained();
|
1361
|
+
}
|
1350
1362
|
|
1351
|
-
|
1352
|
-
|
1353
|
-
|
1354
|
-
|
1355
|
-
|
1356
|
-
}
|
1363
|
+
@Override
|
1364
|
+
public void focusLost(FocusEvent e) {
|
1365
|
+
sketch.focused = false;
|
1366
|
+
sketch.focusLost();
|
1367
|
+
}
|
1368
|
+
});
|
1369
|
+
}
|
1357
1370
|
|
1358
1371
|
|
1359
|
-
|
1372
|
+
/*
|
1360
1373
|
public void addListeners(Component comp) {
|
1361
1374
|
comp.addMouseListener(this);
|
1362
1375
|
comp.addMouseWheelListener(this);
|
@@ -1373,7 +1386,7 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
1373
1386
|
comp.removeKeyListener(this);
|
1374
1387
|
comp.removeFocusListener(this);
|
1375
1388
|
}
|
1376
|
-
|
1389
|
+
*/
|
1377
1390
|
// /**
|
1378
1391
|
// * Call to remove, then add, listeners to a component.
|
1379
1392
|
// * Avoids issues with double-adding.
|
@@ -1382,87 +1395,87 @@ public class PSurfaceAWT extends PSurfaceNone {
|
|
1382
1395
|
// removeListeners(comp);
|
1383
1396
|
// addListeners(comp);
|
1384
1397
|
// }
|
1385
|
-
|
1386
|
-
|
1387
|
-
|
1388
|
-
|
1398
|
+
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
|
1399
|
+
int cursorType = PConstants.ARROW;
|
1400
|
+
boolean cursorVisible = true;
|
1401
|
+
Cursor invisibleCursor;
|
1389
1402
|
|
1390
|
-
|
1391
|
-
|
1392
|
-
|
1393
|
-
|
1394
|
-
|
1395
|
-
|
1396
|
-
}
|
1397
|
-
canvas.setCursor(Cursor.getPredefinedCursor(kind));
|
1398
|
-
cursorVisible = true;
|
1399
|
-
this.cursorType = kind;
|
1403
|
+
@Override
|
1404
|
+
public void setCursor(int kind) {
|
1405
|
+
// Swap the HAND cursor because MOVE doesn't seem to be available on OS X
|
1406
|
+
// https://github.com/processing/processing/issues/2358
|
1407
|
+
if (PApplet.platform == PConstants.MACOSX && kind == PConstants.MOVE) {
|
1408
|
+
kind = PConstants.HAND;
|
1400
1409
|
}
|
1410
|
+
canvas.setCursor(Cursor.getPredefinedCursor(kind));
|
1411
|
+
cursorVisible = true;
|
1412
|
+
this.cursorType = kind;
|
1413
|
+
}
|
1401
1414
|
|
1402
|
-
|
1403
|
-
|
1404
|
-
|
1405
|
-
|
1406
|
-
|
1407
|
-
|
1408
|
-
|
1409
|
-
|
1410
|
-
|
1411
|
-
|
1412
|
-
}
|
1413
|
-
|
1414
|
-
Cursor cursor
|
1415
|
-
= canvas.getToolkit().createCustomCursor((Image) img.getNative(),
|
1416
|
-
new Point(x, y),
|
1417
|
-
"custom");
|
1418
|
-
canvas.setCursor(cursor);
|
1419
|
-
cursorVisible = true;
|
1415
|
+
@Override
|
1416
|
+
public void setCursor(PImage img, int x, int y) {
|
1417
|
+
// Don't set cursorType, instead use cursorType to save the last
|
1418
|
+
// regular cursor type used for when cursor() is called.
|
1419
|
+
//cursor_type = Cursor.CUSTOM_CURSOR;
|
1420
|
+
|
1421
|
+
// this is a temporary workaround for the CHIP, will be removed
|
1422
|
+
Dimension cursorSize = Toolkit.getDefaultToolkit().getBestCursorSize(img.width, img.height);
|
1423
|
+
if (cursorSize.width == 0 || cursorSize.height == 0) {
|
1424
|
+
return;
|
1420
1425
|
}
|
1421
1426
|
|
1422
|
-
|
1423
|
-
|
1424
|
-
|
1425
|
-
|
1426
|
-
|
1427
|
-
|
1428
|
-
|
1429
|
-
canvas.setCursor(Cursor.getPredefinedCursor(cursorType));
|
1430
|
-
}
|
1431
|
-
}
|
1427
|
+
Cursor cursor
|
1428
|
+
= canvas.getToolkit().createCustomCursor((Image) img.getNative(),
|
1429
|
+
new Point(x, y),
|
1430
|
+
"custom");
|
1431
|
+
canvas.setCursor(cursor);
|
1432
|
+
cursorVisible = true;
|
1433
|
+
}
|
1432
1434
|
|
1433
|
-
|
1434
|
-
|
1435
|
-
|
1436
|
-
|
1437
|
-
|
1438
|
-
|
1439
|
-
|
1440
|
-
|
1441
|
-
// this is a temporary workaround for the CHIP, will be removed
|
1442
|
-
Dimension cursorSize = Toolkit.getDefaultToolkit().getBestCursorSize(16, 16);
|
1443
|
-
if (cursorSize.width == 0 || cursorSize.height == 0) {
|
1444
|
-
invisibleCursor = Cursor.getDefaultCursor();
|
1445
|
-
} else {
|
1446
|
-
invisibleCursor
|
1447
|
-
= canvas.getToolkit().createCustomCursor(cursorImg, new Point(8, 8), "blank");
|
1448
|
-
}
|
1449
|
-
}
|
1450
|
-
canvas.setCursor(invisibleCursor);
|
1451
|
-
cursorVisible = false;
|
1435
|
+
@Override
|
1436
|
+
public void showCursor() {
|
1437
|
+
// Maybe should always set here? Seems dangerous, since it's likely that
|
1438
|
+
// Java will set the cursor to something else on its own, and the sketch
|
1439
|
+
// will be stuck b/c p5 thinks the cursor is set to one particular thing.
|
1440
|
+
if (!cursorVisible) {
|
1441
|
+
cursorVisible = true;
|
1442
|
+
canvas.setCursor(Cursor.getPredefinedCursor(cursorType));
|
1452
1443
|
}
|
1444
|
+
}
|
1453
1445
|
|
1454
|
-
|
1455
|
-
|
1456
|
-
|
1457
|
-
|
1458
|
-
|
1459
|
-
|
1460
|
-
|
1461
|
-
|
1462
|
-
|
1446
|
+
@Override
|
1447
|
+
public void hideCursor() {
|
1448
|
+
// Because the OS may have shown the cursor on its own,
|
1449
|
+
// don't return if 'cursorVisible' is set to true. [rev 0216]
|
1450
|
+
|
1451
|
+
if (invisibleCursor == null) {
|
1452
|
+
BufferedImage cursorImg
|
1453
|
+
= new BufferedImage(16, 16, BufferedImage.TYPE_INT_ARGB);
|
1454
|
+
// this is a temporary workaround for the CHIP, will be removed
|
1455
|
+
Dimension cursorSize = Toolkit.getDefaultToolkit().getBestCursorSize(16, 16);
|
1456
|
+
if (cursorSize.width == 0 || cursorSize.height == 0) {
|
1457
|
+
invisibleCursor = Cursor.getDefaultCursor();
|
1458
|
+
} else {
|
1459
|
+
invisibleCursor
|
1460
|
+
= canvas.getToolkit().createCustomCursor(cursorImg, new Point(8, 8), "blank");
|
1461
|
+
}
|
1463
1462
|
}
|
1463
|
+
canvas.setCursor(invisibleCursor);
|
1464
|
+
cursorVisible = false;
|
1465
|
+
}
|
1464
1466
|
|
1465
|
-
|
1466
|
-
|
1467
|
-
|
1467
|
+
@Override
|
1468
|
+
public Thread createThread() {
|
1469
|
+
return new AnimationThread() {
|
1470
|
+
@Override
|
1471
|
+
public void callDraw() {
|
1472
|
+
sketch.handleDraw();
|
1473
|
+
render();
|
1474
|
+
}
|
1475
|
+
};
|
1476
|
+
}
|
1477
|
+
|
1478
|
+
void debug(String format, Object... args) {
|
1479
|
+
System.out.format(format + "%n", args);
|
1480
|
+
}
|
1468
1481
|
}
|