propane 3.10.0-java → 3.11.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.
Files changed (163) hide show
  1. checksums.yaml +4 -4
  2. data/.mvn/wrapper/maven-wrapper.properties +1 -1
  3. data/CHANGELOG.md +2 -0
  4. data/README.md +7 -7
  5. data/lib/propane/app.rb +2 -5
  6. data/lib/propane/helper_methods.rb +6 -6
  7. data/lib/propane/version.rb +1 -1
  8. data/lib/{propane-3.10.0.jar → propane-3.11.0.jar} +0 -0
  9. data/pom.rb +6 -6
  10. data/pom.xml +6 -6
  11. data/propane.gemspec +3 -3
  12. data/src/main/java/monkstone/noise/OpenSimplex2F.java +838 -737
  13. data/src/main/java/monkstone/vecmath/vec2/Vec2.java +8 -13
  14. data/src/main/java/monkstone/vecmath/vec3/Vec3.java +14 -28
  15. data/src/main/java/processing/awt/PImageAWT.java +6 -4
  16. data/src/main/java/processing/core/PApplet.java +71 -59
  17. data/src/main/java/processing/core/PImage.java +14 -14
  18. data/src/main/java/processing/opengl/PGraphicsOpenGL.java +13 -13
  19. data/src/main/java/processing/opengl/PShader.java +1 -6
  20. data/src/main/java/processing/opengl/PSurfaceJOGL.java +6 -6
  21. data/{lib/java/processing/opengl → src/main/resources}/cursors/arrow.png +0 -0
  22. data/{lib/java/processing/opengl → src/main/resources}/cursors/cross.png +0 -0
  23. data/{lib/java/processing/opengl → src/main/resources}/cursors/hand.png +0 -0
  24. data/{lib/java/processing/opengl → src/main/resources}/cursors/license.txt +0 -0
  25. data/{lib/java/processing/opengl → src/main/resources}/cursors/move.png +0 -0
  26. data/{lib/java/processing/opengl → src/main/resources}/cursors/text.png +0 -0
  27. data/{lib/java/processing/opengl → src/main/resources}/cursors/wait.png +0 -0
  28. data/{lib/java/processing/opengl → src/main/resources}/shaders/ColorFrag.glsl +0 -0
  29. data/{lib/java/processing/opengl → src/main/resources}/shaders/ColorVert.glsl +0 -0
  30. data/{lib/java/processing/opengl → src/main/resources}/shaders/LightFrag.glsl +0 -0
  31. data/{lib/java/processing/opengl → src/main/resources}/shaders/LightVert.glsl +0 -0
  32. data/{lib/java/processing/opengl → src/main/resources}/shaders/LineFrag.glsl +0 -0
  33. data/{lib/java/processing/opengl → src/main/resources}/shaders/LineVert.glsl +0 -0
  34. data/{lib/java/processing/opengl → src/main/resources}/shaders/MaskFrag.glsl +0 -0
  35. data/{lib/java/processing/opengl → src/main/resources}/shaders/PointFrag.glsl +0 -0
  36. data/{lib/java/processing/opengl → src/main/resources}/shaders/PointVert.glsl +0 -0
  37. data/{lib/java/processing/opengl → src/main/resources}/shaders/TexFrag.glsl +0 -0
  38. data/{lib/java/processing/opengl → src/main/resources}/shaders/TexLightFrag.glsl +0 -0
  39. data/{lib/java/processing/opengl → src/main/resources}/shaders/TexLightVert.glsl +0 -0
  40. data/{lib/java/processing/opengl → src/main/resources}/shaders/TexVert.glsl +0 -0
  41. data/test/test_helper.rb +1 -0
  42. data/vendors/Rakefile +1 -1
  43. metadata +29 -155
  44. data/lib/java/japplemenubar/JAppleMenuBar.java +0 -88
  45. data/lib/java/japplemenubar/libjAppleMenuBar.jnilib +0 -0
  46. data/lib/java/monkstone/ColorUtil.java +0 -127
  47. data/lib/java/monkstone/MathToolModule.java +0 -287
  48. data/lib/java/monkstone/PropaneLibrary.java +0 -46
  49. data/lib/java/monkstone/core/LibraryProxy.java +0 -136
  50. data/lib/java/monkstone/fastmath/DegLutTables.java +0 -111
  51. data/lib/java/monkstone/fastmath/Deglut.java +0 -71
  52. data/lib/java/monkstone/fastmath/package-info.java +0 -6
  53. data/lib/java/monkstone/filechooser/Chooser.java +0 -39
  54. data/lib/java/monkstone/noise/FastTerrain.java +0 -874
  55. data/lib/java/monkstone/noise/Noise.java +0 -90
  56. data/lib/java/monkstone/noise/NoiseGenerator.java +0 -75
  57. data/lib/java/monkstone/noise/NoiseMode.java +0 -28
  58. data/lib/java/monkstone/noise/OpenSimplex2F.java +0 -881
  59. data/lib/java/monkstone/noise/OpenSimplex2S.java +0 -1106
  60. data/lib/java/monkstone/noise/SmoothTerrain.java +0 -1099
  61. data/lib/java/monkstone/slider/CustomHorizontalSlider.java +0 -164
  62. data/lib/java/monkstone/slider/CustomVerticalSlider.java +0 -178
  63. data/lib/java/monkstone/slider/SimpleHorizontalSlider.java +0 -145
  64. data/lib/java/monkstone/slider/SimpleSlider.java +0 -166
  65. data/lib/java/monkstone/slider/SimpleVerticalSlider.java +0 -157
  66. data/lib/java/monkstone/slider/Slider.java +0 -61
  67. data/lib/java/monkstone/slider/SliderBar.java +0 -245
  68. data/lib/java/monkstone/slider/SliderGroup.java +0 -56
  69. data/lib/java/monkstone/slider/WheelHandler.java +0 -35
  70. data/lib/java/monkstone/vecmath/GfxRender.java +0 -86
  71. data/lib/java/monkstone/vecmath/JRender.java +0 -56
  72. data/lib/java/monkstone/vecmath/ShapeRender.java +0 -87
  73. data/lib/java/monkstone/vecmath/package-info.java +0 -20
  74. data/lib/java/monkstone/vecmath/vec2/Vec2.java +0 -802
  75. data/lib/java/monkstone/vecmath/vec2/package-info.java +0 -6
  76. data/lib/java/monkstone/vecmath/vec3/Vec3.java +0 -727
  77. data/lib/java/monkstone/vecmath/vec3/package-info.java +0 -6
  78. data/lib/java/monkstone/videoevent/CaptureEvent.java +0 -27
  79. data/lib/java/monkstone/videoevent/MovieEvent.java +0 -32
  80. data/lib/java/monkstone/videoevent/package-info.java +0 -20
  81. data/lib/java/processing/awt/PGraphicsJava2D.java +0 -3040
  82. data/lib/java/processing/awt/PImageAWT.java +0 -377
  83. data/lib/java/processing/awt/PShapeJava2D.java +0 -387
  84. data/lib/java/processing/awt/PSurfaceAWT.java +0 -1581
  85. data/lib/java/processing/awt/ShimAWT.java +0 -581
  86. data/lib/java/processing/core/PApplet.java +0 -15156
  87. data/lib/java/processing/core/PConstants.java +0 -523
  88. data/lib/java/processing/core/PFont.java +0 -1126
  89. data/lib/java/processing/core/PGraphics.java +0 -8600
  90. data/lib/java/processing/core/PImage.java +0 -3377
  91. data/lib/java/processing/core/PMatrix.java +0 -208
  92. data/lib/java/processing/core/PMatrix2D.java +0 -562
  93. data/lib/java/processing/core/PMatrix3D.java +0 -890
  94. data/lib/java/processing/core/PShape.java +0 -3561
  95. data/lib/java/processing/core/PShapeOBJ.java +0 -483
  96. data/lib/java/processing/core/PShapeSVG.java +0 -2016
  97. data/lib/java/processing/core/PStyle.java +0 -63
  98. data/lib/java/processing/core/PSurface.java +0 -198
  99. data/lib/java/processing/core/PSurfaceNone.java +0 -431
  100. data/lib/java/processing/core/PVector.java +0 -1066
  101. data/lib/java/processing/core/ThinkDifferent.java +0 -115
  102. data/lib/java/processing/data/DoubleDict.java +0 -850
  103. data/lib/java/processing/data/DoubleList.java +0 -928
  104. data/lib/java/processing/data/FloatDict.java +0 -847
  105. data/lib/java/processing/data/FloatList.java +0 -936
  106. data/lib/java/processing/data/IntDict.java +0 -807
  107. data/lib/java/processing/data/IntList.java +0 -936
  108. data/lib/java/processing/data/JSONArray.java +0 -1260
  109. data/lib/java/processing/data/JSONObject.java +0 -2282
  110. data/lib/java/processing/data/JSONTokener.java +0 -435
  111. data/lib/java/processing/data/LongDict.java +0 -802
  112. data/lib/java/processing/data/LongList.java +0 -937
  113. data/lib/java/processing/data/Sort.java +0 -46
  114. data/lib/java/processing/data/StringDict.java +0 -613
  115. data/lib/java/processing/data/StringList.java +0 -800
  116. data/lib/java/processing/data/Table.java +0 -4936
  117. data/lib/java/processing/data/TableRow.java +0 -198
  118. data/lib/java/processing/data/XML.java +0 -1156
  119. data/lib/java/processing/dxf/RawDXF.java +0 -404
  120. data/lib/java/processing/event/Event.java +0 -125
  121. data/lib/java/processing/event/KeyEvent.java +0 -70
  122. data/lib/java/processing/event/MouseEvent.java +0 -114
  123. data/lib/java/processing/event/TouchEvent.java +0 -57
  124. data/lib/java/processing/javafx/PGraphicsFX2D.java +0 -32
  125. data/lib/java/processing/javafx/PSurfaceFX.java +0 -173
  126. data/lib/java/processing/net/Client.java +0 -744
  127. data/lib/java/processing/net/Server.java +0 -388
  128. data/lib/java/processing/opengl/FontTexture.java +0 -378
  129. data/lib/java/processing/opengl/FrameBuffer.java +0 -513
  130. data/lib/java/processing/opengl/LinePath.java +0 -627
  131. data/lib/java/processing/opengl/LineStroker.java +0 -681
  132. data/lib/java/processing/opengl/PGL.java +0 -3483
  133. data/lib/java/processing/opengl/PGraphics2D.java +0 -615
  134. data/lib/java/processing/opengl/PGraphics3D.java +0 -281
  135. data/lib/java/processing/opengl/PGraphicsOpenGL.java +0 -13753
  136. data/lib/java/processing/opengl/PJOGL.java +0 -2008
  137. data/lib/java/processing/opengl/PShader.java +0 -1484
  138. data/lib/java/processing/opengl/PShapeOpenGL.java +0 -5269
  139. data/lib/java/processing/opengl/PSurfaceJOGL.java +0 -1385
  140. data/lib/java/processing/opengl/Texture.java +0 -1696
  141. data/lib/java/processing/opengl/VertexBuffer.java +0 -88
  142. data/lib/java/processing/pdf/PGraphicsPDF.java +0 -581
  143. data/lib/java/processing/svg/PGraphicsSVG.java +0 -378
  144. data/src/main/java/processing/opengl/cursors/arrow.png +0 -0
  145. data/src/main/java/processing/opengl/cursors/cross.png +0 -0
  146. data/src/main/java/processing/opengl/cursors/hand.png +0 -0
  147. data/src/main/java/processing/opengl/cursors/license.txt +0 -27
  148. data/src/main/java/processing/opengl/cursors/move.png +0 -0
  149. data/src/main/java/processing/opengl/cursors/text.png +0 -0
  150. data/src/main/java/processing/opengl/cursors/wait.png +0 -0
  151. data/src/main/java/processing/opengl/shaders/ColorFrag.glsl +0 -32
  152. data/src/main/java/processing/opengl/shaders/ColorVert.glsl +0 -34
  153. data/src/main/java/processing/opengl/shaders/LightFrag.glsl +0 -33
  154. data/src/main/java/processing/opengl/shaders/LightVert.glsl +0 -151
  155. data/src/main/java/processing/opengl/shaders/LineFrag.glsl +0 -32
  156. data/src/main/java/processing/opengl/shaders/LineVert.glsl +0 -100
  157. data/src/main/java/processing/opengl/shaders/MaskFrag.glsl +0 -40
  158. data/src/main/java/processing/opengl/shaders/PointFrag.glsl +0 -32
  159. data/src/main/java/processing/opengl/shaders/PointVert.glsl +0 -56
  160. data/src/main/java/processing/opengl/shaders/TexFrag.glsl +0 -37
  161. data/src/main/java/processing/opengl/shaders/TexLightFrag.glsl +0 -37
  162. data/src/main/java/processing/opengl/shaders/TexLightVert.glsl +0 -157
  163. data/src/main/java/processing/opengl/shaders/TexVert.glsl +0 -38
@@ -1,1581 +0,0 @@
1
- /* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2
-
3
- /*
4
- Part of the Processing project - http://processing.org
5
-
6
- Copyright (c) 2014-15 The Processing Foundation
7
-
8
- This library is free software; you can redistribute it and/or
9
- modify it under the terms of the GNU Lesser General Public
10
- License as published by the Free Software Foundation, version 2.1.
11
-
12
- This library is distributed in the hope that it will be useful,
13
- but WITHOUT ANY WARRANTY; without even the implied warranty of
14
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15
- Lesser General Public License for more details.
16
-
17
- You should have received a copy of the GNU Lesser General
18
- Public License along with this library; if not, write to the
19
- Free Software Foundation, Inc., 59 Temple Place, Suite 330,
20
- Boston, MA 02111-1307 USA
21
- */
22
-
23
- package processing.awt;
24
-
25
- import java.awt.Canvas;
26
- import java.awt.Color;
27
- import java.awt.Cursor;
28
- import java.awt.Dimension;
29
- import java.awt.Frame;
30
- import java.awt.Graphics;
31
- import java.awt.Graphics2D;
32
- import java.awt.GraphicsConfiguration;
33
- import java.awt.GraphicsDevice;
34
- import java.awt.GraphicsEnvironment;
35
- import java.awt.Image;
36
- import java.awt.Insets;
37
- import java.awt.Label;
38
- import java.awt.Point;
39
- import java.awt.Rectangle;
40
- import java.awt.Toolkit;
41
- import java.awt.event.*;
42
- import java.awt.geom.Rectangle2D;
43
- import java.awt.image.*;
44
- import java.io.File;
45
- import java.lang.management.ManagementFactory;
46
- import java.lang.reflect.InvocationTargetException;
47
- import java.lang.reflect.Method;
48
- import java.net.URL;
49
- import java.util.ArrayList;
50
- import java.util.List;
51
-
52
- import javax.swing.JFrame;
53
-
54
- import processing.core.PApplet;
55
- import processing.core.PConstants;
56
- import processing.core.PGraphics;
57
- import processing.core.PImage;
58
- import processing.core.PSurfaceNone;
59
- import processing.event.KeyEvent;
60
- import processing.event.MouseEvent;
61
-
62
-
63
- public class PSurfaceAWT extends PSurfaceNone {
64
- GraphicsDevice displayDevice;
65
-
66
- // used for canvas to determine whether resizable or not
67
- // boolean resizable; // default is false
68
-
69
- // Internally, we know it's always a JFrame (not just a Frame)
70
- // JFrame frame;
71
- // Trying Frame again with a11 to see if this avoids some Swing nastiness.
72
- // In the past, AWT Frames caused some problems on Windows and Linux,
73
- // but those may not be a problem for our reworked PSurfaceAWT class.
74
- Frame frame;
75
-
76
- // Note that x and y may not be zero, depending on the display configuration
77
- Rectangle screenRect;
78
-
79
- // Used for resizing, at least on Windows insets size changes when
80
- // frame.setResizable() is called, and in resize listener we need
81
- // to know what size the window was before.
82
- Insets currentInsets = new Insets(0, 0, 0, 0);
83
-
84
- // 3.0a5 didn't use strategy, and active was shut off during init() w/ retina
85
- // boolean useStrategy = true;
86
-
87
- Canvas canvas;
88
- // Component canvas;
89
-
90
- // PGraphics graphics; // moved to PSurfaceNone
91
-
92
- int sketchWidth;
93
- int sketchHeight;
94
-
95
- int windowScaleFactor;
96
-
97
-
98
- public PSurfaceAWT(PGraphics graphics) {
99
- //this.graphics = graphics;
100
- super(graphics);
101
-
102
- /*
103
- if (checkRetina()) {
104
- // System.out.println("retina in use");
105
-
106
- // The active-mode rendering seems to be 2x slower, so disable it
107
- // with retina. On a non-retina machine, however, useActive seems
108
- // the only (or best) way to handle the rendering.
109
- // useActive = false;
110
- // canvas = new JPanel(true) {
111
- // @Override
112
- // public void paint(Graphics screen) {
113
- //// if (!sketch.insideDraw) {
114
- // screen.drawImage(PSurfaceAWT.this.graphics.image, 0, 0, sketchWidth, sketchHeight, null);
115
- //// }
116
- // }
117
- // };
118
- // Under 1.8 and the current 3.0a6 threading regime, active mode w/o
119
- // strategy is far faster, but perhaps only because it's blitting with
120
- // flicker--pushing pixels out before the screen has finished rendering.
121
- // useStrategy = false;
122
- }
123
- */
124
- canvas = new SmoothCanvas();
125
- // if (useStrategy) {
126
- //canvas.setIgnoreRepaint(true);
127
- // }
128
-
129
- // Pass tab key to the sketch, rather than moving between components
130
- canvas.setFocusTraversalKeysEnabled(false);
131
-
132
- canvas.addComponentListener(new ComponentAdapter() {
133
- @Override
134
- public void componentResized(ComponentEvent e) {
135
- if (!sketch.isLooping()) {
136
- // make sure this is a real resize event, not just initial setup
137
- // https://github.com/processing/processing/issues/3310
138
- Dimension canvasSize = canvas.getSize();
139
- if (canvasSize.width != sketch.sketchWidth() ||
140
- canvasSize.height != sketch.sketchHeight()) {
141
- sketch.redraw();
142
- }
143
- }
144
- }
145
- });
146
- addListeners();
147
- }
148
-
149
-
150
- // /**
151
- // * Handle grabbing the focus on startup. Other renderers can override this
152
- // * if handling needs to be different. For the AWT, the request is invoked
153
- // * later on the EDT. Other implementations may not require that, so the
154
- // * invokeLater() happens in here rather than requiring the caller to wrap it.
155
- // */
156
- // @Override
157
- // void requestFocus() {
158
- //// System.out.println("requesFocus() outer " + EventQueue.isDispatchThread());
159
- // // for 2.0a6, moving this request to the EDT
160
- // EventQueue.invokeLater(new Runnable() {
161
- // public void run() {
162
- // // Call the request focus event once the image is sure to be on
163
- // // screen and the component is valid. The OpenGL renderer will
164
- // // request focus for its canvas inside beginDraw().
165
- // // http://java.sun.com/j2se/1.4.2/docs/api/java/awt/doc-files/FocusSpec.html
166
- // // Disabling for 0185, because it causes an assertion failure on OS X
167
- // // http://code.google.com/p/processing/issues/detail?id=258
168
- // // requestFocus();
169
- //
170
- // // Changing to this version for 0187
171
- // // http://code.google.com/p/processing/issues/detail?id=279
172
- // //requestFocusInWindow();
173
- //
174
- // // For 3.0, just call this directly on the Canvas object
175
- // if (canvas != null) {
176
- // //System.out.println("requesting focus " + EventQueue.isDispatchThread());
177
- // //System.out.println("requesting focus " + frame.isVisible());
178
- // //canvas.requestFocusInWindow();
179
- // canvas.requestFocus();
180
- // }
181
- // }
182
- // });
183
- // }
184
-
185
-
186
- // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
187
-
188
-
189
- public class SmoothCanvas extends Canvas {
190
- private Dimension oldSize = new Dimension(0, 0);
191
- private Dimension newSize = new Dimension(0, 0);
192
-
193
-
194
- // Turns out getParent() returns a JPanel on a JFrame. Yech.
195
- public Frame getFrame() {
196
- return frame;
197
- }
198
-
199
-
200
- @Override
201
- public Dimension getPreferredSize() {
202
- return new Dimension(sketchWidth, sketchHeight);
203
- }
204
-
205
-
206
- @Override
207
- public Dimension getMinimumSize() {
208
- return getPreferredSize();
209
- }
210
-
211
-
212
- @Override
213
- public Dimension getMaximumSize() {
214
- //return resizable ? super.getMaximumSize() : getPreferredSize();
215
- return frame.isResizable() ? super.getMaximumSize() : getPreferredSize();
216
- }
217
-
218
-
219
- @Override
220
- public void validate() {
221
- super.validate();
222
- newSize.width = getWidth();
223
- newSize.height = getHeight();
224
- // if (oldSize.equals(newSize)) {
225
- //// System.out.println("validate() return " + oldSize);
226
- // return;
227
- // } else {
228
- if (!oldSize.equals(newSize)) {
229
- // System.out.println("validate() render old=" + oldSize + " -> new=" + newSize);
230
- oldSize = newSize;
231
- sketch.setSize(newSize.width / windowScaleFactor, newSize.height / windowScaleFactor);
232
- // try {
233
- render();
234
- // } catch (IllegalStateException ise) {
235
- // System.out.println(ise.getMessage());
236
- // }
237
- }
238
- }
239
-
240
-
241
- @Override
242
- public void update(Graphics g) {
243
- // System.out.println("updating");
244
- paint(g);
245
- }
246
-
247
-
248
- @Override
249
- public void paint(Graphics screen) {
250
- // System.out.println("painting");
251
- // if (useStrategy) {
252
- render();
253
- /*
254
- if (graphics != null) {
255
- System.out.println("drawing to screen " + canvas);
256
- screen.drawImage(graphics.image, 0, 0, sketchWidth, sketchHeight, null);
257
- }
258
- */
259
-
260
- // } else {
261
- //// new Exception("painting").printStackTrace(System.out);
262
- //// if (graphics.image != null) { // && !sketch.insideDraw) {
263
- // if (onscreen != null) {
264
- //// synchronized (graphics.image) {
265
- // // Needs the width/height to be set so that retina images are properly scaled down
266
- //// screen.drawImage(graphics.image, 0, 0, sketchWidth, sketchHeight, null);
267
- // synchronized (offscreenLock) {
268
- // screen.drawImage(onscreen, 0, 0, sketchWidth, sketchHeight, null);
269
- // }
270
- // }
271
- // }
272
- }
273
- }
274
-
275
- /*
276
- @Override
277
- public void addNotify() {
278
- // System.out.println("adding notify");
279
- super.addNotify();
280
- // prior to Java 7 on OS X, this no longer works [121222]
281
- // createBufferStrategy(2);
282
- }
283
- */
284
-
285
-
286
- synchronized protected void render() {
287
- if (canvas.isDisplayable() &&
288
- graphics.image != null) {
289
- if (canvas.getBufferStrategy() == null) {
290
- canvas.createBufferStrategy(2);
291
- }
292
- BufferStrategy strategy = canvas.getBufferStrategy();
293
- if (strategy != null) {
294
- // Render single frame
295
- // try {
296
- do {
297
- // The following loop ensures that the contents of the drawing buffer
298
- // are consistent in case the underlying surface was recreated
299
- do {
300
- Graphics2D draw = (Graphics2D) strategy.getDrawGraphics();
301
- // draw to width/height, since this may be a 2x image
302
- draw.drawImage(graphics.image, 0, 0, sketchWidth, sketchHeight, null);
303
- draw.dispose();
304
- } while (strategy.contentsRestored());
305
-
306
- // Display the buffer
307
- strategy.show();
308
-
309
- // Repeat the rendering if the drawing buffer was lost
310
- } while (strategy.contentsLost());
311
- }
312
- }
313
- }
314
-
315
-
316
- /*
317
- protected void blit() {
318
- // Other folks that call render() (i.e. paint()) are already on the EDT.
319
- // We need to be using the EDT since we're messing with the Canvas
320
- // object and BufferStrategy and friends.
321
- //EventQueue.invokeLater(new Runnable() {
322
- //public void run() {
323
- //((SmoothCanvas) canvas).render();
324
- //}
325
- //});
326
-
327
- if (useStrategy) {
328
- // Not necessary to be on the EDT to update BufferStrategy
329
- //((SmoothCanvas) canvas).render();
330
- render();
331
- } else {
332
- if (graphics.image != null) {
333
- BufferedImage graphicsImage = (BufferedImage) graphics.image;
334
- if (offscreen == null ||
335
- offscreen.getWidth() != graphicsImage.getWidth() ||
336
- offscreen.getHeight() != graphicsImage.getHeight()) {
337
- System.out.println("creating new image");
338
- offscreen = (BufferedImage)
339
- canvas.createImage(graphicsImage.getWidth(),
340
- graphicsImage.getHeight());
341
- // off = offscreen.getGraphics();
342
- }
343
- // synchronized (offscreen) {
344
- Graphics2D off = (Graphics2D) offscreen.getGraphics();
345
- // off.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1));
346
- off.drawImage(graphicsImage, 0, 0, null);
347
- // }
348
- off.dispose();
349
- synchronized (offscreenLock) {
350
- BufferedImage temp = onscreen;
351
- onscreen = offscreen;
352
- offscreen = temp;
353
- }
354
- canvas.repaint();
355
- }
356
- }
357
- }
358
- */
359
-
360
-
361
- /*
362
- @Override
363
- public int displayDensity() {
364
- return shim.displayDensity();
365
- }
366
-
367
-
368
- @Override
369
- public int displayDensity(int display) {
370
- return shim.displayDensity(display);
371
- }
372
- */
373
-
374
-
375
- @Override
376
- public void selectInput(String prompt, String callback,
377
- File file, Object callbackObject) {
378
- ShimAWT.selectInput(prompt, callback, file, callbackObject);
379
- }
380
-
381
-
382
- @Override
383
- public void selectOutput(String prompt, String callback,
384
- File file, Object callbackObject) {
385
- ShimAWT.selectOutput(prompt, callback, file, callbackObject);
386
- }
387
-
388
-
389
- @Override
390
- public void selectFolder(String prompt, String callback,
391
- File file, Object callbackObject) {
392
- ShimAWT.selectFolder(prompt, callback, file, callbackObject);
393
- }
394
-
395
-
396
- // what needs to happen here?
397
- @Override
398
- public void initOffscreen(PApplet sketch) {
399
- this.sketch = sketch;
400
- }
401
-
402
- /*
403
- public Frame initOffscreen() {
404
- Frame dummy = new Frame();
405
- dummy.pack(); // get legit AWT graphics
406
- // but don't show it
407
- return dummy;
408
- }
409
- */
410
-
411
- /*
412
- @Override
413
- public Component initComponent(PApplet sketch) {
414
- this.sketch = sketch;
415
-
416
- // needed for getPreferredSize() et al
417
- sketchWidth = sketch.sketchWidth();
418
- sketchHeight = sketch.sketchHeight();
419
-
420
- return canvas;
421
- }
422
- */
423
-
424
-
425
- @Override
426
- public void initFrame(final PApplet sketch) {/*, int backgroundColor,
427
- int deviceIndex, boolean fullScreen, boolean spanDisplays) {*/
428
- this.sketch = sketch;
429
-
430
- GraphicsEnvironment environment =
431
- GraphicsEnvironment.getLocalGraphicsEnvironment();
432
-
433
- int displayNum = sketch.sketchDisplay();
434
- // System.out.println("display from sketch is " + displayNum);
435
- if (displayNum > 0) { // if -1, use the default device
436
- GraphicsDevice[] devices = environment.getScreenDevices();
437
- if (displayNum <= devices.length) {
438
- displayDevice = devices[displayNum - 1];
439
- } else {
440
- System.err.format("Display %d does not exist, " +
441
- "using the default display instead.%n", displayNum);
442
- for (int i = 0; i < devices.length; i++) {
443
- System.err.format("Display %d is %s%n", (i+1), devices[i]);
444
- }
445
- }
446
- }
447
- if (displayDevice == null) {
448
- displayDevice = environment.getDefaultScreenDevice();
449
- }
450
-
451
- // Need to save the window bounds at full screen,
452
- // because pack() will cause the bounds to go to zero.
453
- // http://dev.processing.org/bugs/show_bug.cgi?id=923
454
- boolean spanDisplays = sketch.sketchDisplay() == PConstants.SPAN;
455
- screenRect = spanDisplays ? getDisplaySpan() :
456
- displayDevice.getDefaultConfiguration().getBounds();
457
- // DisplayMode doesn't work here, because we can't get the upper-left
458
- // corner of the display, which is important for multi-display setups.
459
-
460
- // Set the displayWidth/Height variables inside PApplet, so that they're
461
- // usable and can even be returned by the sketchWidth()/Height() methods.
462
- sketch.displayWidth = screenRect.width;
463
- sketch.displayHeight = screenRect.height;
464
-
465
- windowScaleFactor = PApplet.platform == PConstants.MACOS ?
466
- 1 : sketch.pixelDensity;
467
-
468
- sketchWidth = sketch.sketchWidth() * windowScaleFactor;
469
- sketchHeight = sketch.sketchHeight() * windowScaleFactor;
470
-
471
- boolean fullScreen = sketch.sketchFullScreen();
472
- // Removing the section below because sometimes people want to do the
473
- // full screen size in a window, and it also breaks insideSettings().
474
- // With 3.x, fullScreen() is so easy, that it's just better that way.
475
- // https://github.com/processing/processing/issues/3545
476
- /*
477
- // Sketch has already requested to be the same as the screen's
478
- // width and height, so let's roll with full screen mode.
479
- if (screenRect.width == sketchWidth &&
480
- screenRect.height == sketchHeight) {
481
- fullScreen = true;
482
- sketch.fullScreen(); // won't change the renderer
483
- }
484
- */
485
-
486
- if (fullScreen || spanDisplays) {
487
- sketchWidth = screenRect.width;
488
- sketchHeight = screenRect.height;
489
- }
490
-
491
- // Using a JFrame fixes a Windows problem with Present mode. This might
492
- // be our error, but usually this is the sort of crap we usually get from
493
- // OS X. It's time for a turnaround: Redmond is thinking different too!
494
- // https://github.com/processing/processing/issues/1955
495
- frame = new JFrame(displayDevice.getDefaultConfiguration());
496
- // frame = new Frame(displayDevice.getDefaultConfiguration());
497
- // // Default Processing gray, which will be replaced below if another
498
- // // color is specified on the command line (i.e. in the prefs).
499
- // ((JFrame) frame).getContentPane().setBackground(WINDOW_BGCOLOR);
500
- // // Cannot call setResizable(false) until later due to OS X (issue #467)
501
-
502
- // // Removed code above, also removed from what's now in the placeXxxx()
503
- // // methods. Not sure why it was being double-set; hopefully anachronistic.
504
- // if (backgroundColor == 0) {
505
- // backgroundColor = WINDOW_BGCOLOR;
506
- // }
507
- final Color windowColor = new Color(sketch.sketchWindowColor(), false);
508
- if (frame instanceof JFrame) {
509
- ((JFrame) frame).getContentPane().setBackground(windowColor);
510
- } else {
511
- frame.setBackground(windowColor);
512
- }
513
-
514
- // Put the p5 logo in the Frame's corner to override the Java coffee cup.
515
- setProcessingIcon(frame);
516
-
517
- // For 0149, moving this code (up to the pack() method) before init().
518
- // For OpenGL (and perhaps other renderers in the future), a peer is
519
- // needed before a GLDrawable can be created. So pack() needs to be
520
- // called on the Frame before applet.init(), which itself calls size(),
521
- // and launches the Thread that will kick off setup().
522
- // http://dev.processing.org/bugs/show_bug.cgi?id=891
523
- // http://dev.processing.org/bugs/show_bug.cgi?id=908
524
-
525
- frame.add(canvas);
526
- setSize(sketchWidth / windowScaleFactor, sketchHeight / windowScaleFactor);
527
-
528
- /*
529
- if (fullScreen) {
530
- // Called here because the graphics device is needed before we can
531
- // determine whether the sketch wants size(displayWidth, displayHeight),
532
- // and getting the graphics device will be PSurface-specific.
533
- PApplet.hideMenuBar();
534
-
535
- // Tried to use this to fix the 'present' mode issue.
536
- // Did not help, and the screenRect setup seems to work fine.
537
- //frame.setExtendedState(Frame.MAXIMIZED_BOTH);
538
-
539
- // https://github.com/processing/processing/pull/3162
540
- frame.dispose(); // release native resources, allows setUndecorated()
541
- frame.setUndecorated(true);
542
- // another duplicate?
543
- // if (backgroundColor != null) {
544
- // frame.getContentPane().setBackground(backgroundColor);
545
- // }
546
- // this may be the bounds of all screens
547
- frame.setBounds(screenRect);
548
- // will be set visible in placeWindow() [3.0a10]
549
- //frame.setVisible(true); // re-add native resources
550
- }
551
- */
552
- frame.setLayout(null);
553
- //frame.add(applet);
554
-
555
- // Need to pass back our new sketchWidth/Height here, because it may have
556
- // been overridden by numbers we calculated above if fullScreen and/or
557
- // spanScreens was in use.
558
- // pg = sketch.makePrimaryGraphics(sketchWidth, sketchHeight);
559
- // pg = sketch.makePrimaryGraphics();
560
-
561
- // resize sketch to sketchWidth/sketchHeight here
562
-
563
- if (fullScreen) {
564
- frame.invalidate();
565
- } else {
566
- // frame.pack();
567
- }
568
-
569
- // insufficient, places the 100x100 sketches offset strangely
570
- //frame.validate();
571
-
572
- // disabling resize has to happen after pack() to avoid apparent Apple bug
573
- // http://code.google.com/p/processing/issues/detail?id=467
574
- frame.setResizable(false);
575
-
576
- frame.addWindowListener(new WindowAdapter() {
577
- @Override
578
- public void windowClosing(WindowEvent e) {
579
- sketch.exit(); // don't quit, need to just shut everything down (0133)
580
- }
581
- });
582
-
583
- // sketch.setFrame(frame);
584
- }
585
-
586
-
587
- @Override
588
- public Object getNative() {
589
- return canvas;
590
- }
591
-
592
-
593
- // public Toolkit getToolkit() {
594
- // return canvas.getToolkit();
595
- // }
596
-
597
-
598
- /** Set the window (and dock, or whatever necessary) title.
599
- * @param title */
600
- @Override
601
- public void setTitle(String title) {
602
- frame.setTitle(title);
603
- // Workaround for apparent Java bug on OS X?
604
- // https://github.com/processing/processing/issues/3472
605
- if (cursorVisible &&
606
- (PApplet.platform == PConstants.MACOS) &&
607
- (cursorType != PConstants.ARROW)) {
608
- hideCursor();
609
- showCursor();
610
- }
611
- }
612
-
613
-
614
- /** Set true if we want to resize things (default is not resizable)
615
- * @param resizable */
616
- @Override
617
- public void setResizable(boolean resizable) {
618
- //this.resizable = resizable; // really only used for canvas
619
-
620
- if (frame != null) {
621
- frame.setResizable(resizable);
622
- }
623
- }
624
-
625
-
626
- @Override
627
- public void setIcon(PImage image) {
628
- Image awtImage = (Image) image.getNative();
629
-
630
- if (PApplet.platform != PConstants.MACOS) {
631
- frame.setIconImage(awtImage);
632
-
633
- } else {
634
- try {
635
- final String td = "processing.core.ThinkDifferent";
636
- Class<?> thinkDifferent =
637
- Thread.currentThread().getContextClassLoader().loadClass(td);
638
- Method method =
639
- thinkDifferent.getMethod("setIconImage", Image.class);
640
- method.invoke(null, awtImage);
641
- } catch (ClassNotFoundException | IllegalAccessException | IllegalArgumentException | NoSuchMethodException | SecurityException | InvocationTargetException e) {
642
- // That's unfortunate
643
-
644
- }
645
- }
646
- }
647
-
648
-
649
- @Override
650
- public void setAlwaysOnTop(boolean always) {
651
- frame.setAlwaysOnTop(always);
652
- }
653
-
654
-
655
- @Override
656
- public void setLocation(int x, int y) {
657
- frame.setLocation(x, y);
658
- }
659
-
660
-
661
- List<Image> iconImages;
662
-
663
- protected void setProcessingIcon(Frame frame) {
664
- // On OS X, this only affects what shows up in the dock when minimized.
665
- // So replacing it is actually a step backwards. Brilliant.
666
- if (PApplet.platform != PConstants.MACOS) {
667
- //Image image = Toolkit.getDefaultToolkit().createImage(ICON_IMAGE);
668
- //frame.setIconImage(image);
669
- try {
670
- if (iconImages == null) {
671
- iconImages = new ArrayList<>();
672
- final int[] sizes = { 16, 32, 48, 64, 128, 256, 512 };
673
-
674
- for (int sz : sizes) {
675
- //URL url = getClass().getResource("/icon/icon-" + sz + ".png");
676
- URL url = PApplet.class.getResource("/icon/icon-" + sz + ".png");
677
- Image image = Toolkit.getDefaultToolkit().getImage(url);
678
- iconImages.add(image);
679
- //iconImages.add(Toolkit.getLibImage("icons/pde-" + sz + ".png", frame));
680
- }
681
- }
682
- frame.setIconImages(iconImages);
683
-
684
- } catch (Exception e) { } // harmless; keep this to ourselves
685
-
686
- } else { // handle OS X differently
687
- if (!dockIconSpecified()) { // don't override existing -Xdock param
688
- // On OS X, set this for AWT surfaces, which handles the dock image
689
- // as well as the cmd-tab image that's shown. Just one size, I guess.
690
- URL url = PApplet.class.getResource("/icon/icon-512.png");
691
- // Seems dangerous to have this in code instead of using reflection, no?
692
- //ThinkDifferent.setIconImage(Toolkit.getDefaultToolkit().getImage(url));
693
- try {
694
- final String td = "processing.core.ThinkDifferent";
695
- Class<?> thinkDifferent =
696
- Thread.currentThread().getContextClassLoader().loadClass(td);
697
- Method method =
698
- thinkDifferent.getMethod("setIconImage", Image.class);
699
- method.invoke(null, Toolkit.getDefaultToolkit().getImage(url));
700
- } catch (ClassNotFoundException | IllegalAccessException | IllegalArgumentException | NoSuchMethodException | SecurityException | InvocationTargetException e) {
701
- // That's unfortunate
702
-
703
- }
704
- }
705
- }
706
- }
707
-
708
-
709
- /**
710
- * @return true if -Xdock:icon was specified on the command line
711
- */
712
- private boolean dockIconSpecified() {
713
- // TODO This is incomplete... Haven't yet found a way to figure out if
714
- // the app has an icns file specified already. Help?
715
- List<String> jvmArgs =
716
- ManagementFactory.getRuntimeMXBean().getInputArguments();
717
- // dock image already set
718
- return jvmArgs.stream().anyMatch((arg) -> (arg.startsWith("-Xdock:icon")));
719
- }
720
-
721
-
722
- @Override
723
- public void setVisible(boolean visible) {
724
- frame.setVisible(visible);
725
-
726
- // Generally useful whenever setting the frame visible
727
- if (canvas != null) {
728
- //canvas.requestFocusInWindow();
729
- canvas.requestFocus();
730
- }
731
-
732
- // removing per https://github.com/processing/processing/pull/3162
733
- // can remove the code below once 3.0a6 is tested and behaving
734
- /*
735
- if (visible && PApplet.platform == PConstants.LINUX) {
736
- // Linux doesn't deal with insets the same way. We get fake insets
737
- // earlier, and then the window manager will slap its own insets
738
- // onto things once the frame is realized on the screen. Awzm.
739
- if (PApplet.platform == PConstants.LINUX) {
740
- Insets insets = frame.getInsets();
741
- frame.setSize(Math.max(sketchWidth, MIN_WINDOW_WIDTH) +
742
- insets.left + insets.right,
743
- Math.max(sketchHeight, MIN_WINDOW_HEIGHT) +
744
- insets.top + insets.bottom);
745
- }
746
- }
747
- */
748
- }
749
-
750
-
751
- //public void placeFullScreen(boolean hideStop) {
752
- @Override
753
- public void placePresent(int stopColor) {
754
- setFullFrame();
755
-
756
- // After the pack(), the screen bounds are gonna be 0s
757
- // frame.setBounds(screenRect); // already called in setFullFrame()
758
- canvas.setBounds((screenRect.width - sketchWidth) / 2,
759
- (screenRect.height - sketchHeight) / 2,
760
- sketchWidth, sketchHeight);
761
-
762
- // if (PApplet.platform == PConstants.MACOSX) {
763
- // macosxFullScreenEnable(frame);
764
- // macosxFullScreenToggle(frame);
765
- // }
766
-
767
- if (stopColor != 0) {
768
- Label label = new Label("stop");
769
- label.setForeground(new Color(stopColor, false));
770
- label.addMouseListener(new MouseAdapter() {
771
- @Override
772
- public void mousePressed(java.awt.event.MouseEvent e) {
773
- sketch.exit();
774
- }
775
- });
776
- frame.add(label);
777
-
778
- Dimension labelSize = label.getPreferredSize();
779
- // sometimes shows up truncated on mac
780
- //System.out.println("label width is " + labelSize.width);
781
- labelSize = new Dimension(100, labelSize.height);
782
- label.setSize(labelSize);
783
- label.setLocation(20, screenRect.height - labelSize.height - 20);
784
- }
785
-
786
- // if (sketch.getGraphics().displayable()) {
787
- // setVisible(true);
788
- // }
789
- }
790
-
791
-
792
- /*
793
- @Override
794
- public void placeWindow(int[] location) {
795
- setFrameSize(); //sketchWidth, sketchHeight);
796
-
797
- if (location != null) {
798
- // a specific location was received from the Runner
799
- // (applet has been run more than once, user placed window)
800
- frame.setLocation(location[0], location[1]);
801
-
802
- } else { // just center on screen
803
- // Can't use frame.setLocationRelativeTo(null) because it sends the
804
- // frame to the main display, which undermines the --display setting.
805
- frame.setLocation(screenRect.x + (screenRect.width - sketchWidth) / 2,
806
- screenRect.y + (screenRect.height - sketchHeight) / 2);
807
- }
808
- Point frameLoc = frame.getLocation();
809
- if (frameLoc.y < 0) {
810
- // Windows actually allows you to place frames where they can't be
811
- // closed. Awesome. http://dev.processing.org/bugs/show_bug.cgi?id=1508
812
- frame.setLocation(frameLoc.x, 30);
813
- }
814
-
815
- // if (backgroundColor != null) {
816
- // ((JFrame) frame).getContentPane().setBackground(backgroundColor);
817
- // }
818
-
819
- setCanvasSize(); //sketchWidth, sketchHeight);
820
-
821
- frame.addWindowListener(new WindowAdapter() {
822
- @Override
823
- public void windowClosing(WindowEvent e) {
824
- System.exit(0);
825
- }
826
- });
827
-
828
- // handle frame resizing events
829
- setupFrameResizeListener();
830
-
831
- // all set for rockin
832
- if (sketch.getGraphics().displayable()) {
833
- frame.setVisible(true);
834
- }
835
- }
836
- */
837
-
838
-
839
- private void setCanvasSize() {
840
- // System.out.format("setting canvas size %d %d%n", sketchWidth, sketchHeight);
841
- // new Exception().printStackTrace(System.out);
842
- int contentW = Math.max(sketchWidth, MIN_WINDOW_WIDTH);
843
- int contentH = Math.max(sketchHeight, MIN_WINDOW_HEIGHT);
844
-
845
- canvas.setBounds((contentW - sketchWidth)/2,
846
- (contentH - sketchHeight)/2,
847
- sketchWidth, sketchHeight);
848
- }
849
-
850
-
851
- /** Resize frame for these sketch (canvas) dimensions. */
852
- private Dimension setFrameSize() { //int sketchWidth, int sketchHeight) {
853
- // https://github.com/processing/processing/pull/3162
854
- frame.addNotify(); // using instead of show() to add the peer [fry]
855
-
856
- // System.out.format("setting frame size %d %d %n", sketchWidth, sketchHeight);
857
- // new Exception().printStackTrace(System.out);
858
- currentInsets = frame.getInsets();
859
- int windowW = Math.max(sketchWidth, MIN_WINDOW_WIDTH) +
860
- currentInsets.left + currentInsets.right;
861
- int windowH = Math.max(sketchHeight, MIN_WINDOW_HEIGHT) +
862
- currentInsets.top + currentInsets.bottom;
863
- frame.setSize(windowW, windowH);
864
- return new Dimension(windowW, windowH);
865
- }
866
-
867
-
868
- private void setFrameCentered() {
869
- // Can't use frame.setLocationRelativeTo(null) because it sends the
870
- // frame to the main display, which undermines the --display setting.
871
- frame.setLocation(screenRect.x + (screenRect.width - sketchWidth) / 2,
872
- screenRect.y + (screenRect.height - sketchHeight) / 2);
873
- }
874
-
875
-
876
- /** Hide the menu bar, make the Frame undecorated, set it to screenRect. */
877
- private void setFullFrame() {
878
- // Called here because the graphics device is needed before we can
879
- // determine whether the sketch wants size(displayWidth, displayHeight),
880
- // and getting the graphics device will be PSurface-specific.
881
- PApplet.hideMenuBar();
882
-
883
- // Tried to use this to fix the 'present' mode issue.
884
- // Did not help, and the screenRect setup seems to work fine.
885
- //frame.setExtendedState(Frame.MAXIMIZED_BOTH);
886
-
887
- // https://github.com/processing/processing/pull/3162
888
- //frame.dispose(); // release native resources, allows setUndecorated()
889
- frame.removeNotify();
890
- frame.setUndecorated(true);
891
- frame.addNotify();
892
-
893
- // this may be the bounds of all screens
894
- frame.setBounds(screenRect);
895
- // will be set visible in placeWindow() [3.0a10]
896
- //frame.setVisible(true); // re-add native resources
897
- }
898
-
899
-
900
- @Override
901
- public void placeWindow(int[] location, int[] editorLocation) {
902
- //Dimension window = setFrameSize(sketchWidth, sketchHeight);
903
- Dimension window = setFrameSize(); //sketchWidth, sketchHeight);
904
-
905
- int contentW = Math.max(sketchWidth, MIN_WINDOW_WIDTH);
906
- int contentH = Math.max(sketchHeight, MIN_WINDOW_HEIGHT);
907
-
908
- if (sketch.sketchFullScreen()) {
909
- setFullFrame();
910
- }
911
-
912
- // Ignore placement of previous window and editor when full screen
913
- if (!sketch.sketchFullScreen()) {
914
- if (location != null) {
915
- // a specific location was received from the Runner
916
- // (applet has been run more than once, user placed window)
917
- frame.setLocation(location[0], location[1]);
918
-
919
- } else if (editorLocation != null) {
920
- int locationX = editorLocation[0] - 20;
921
- int locationY = editorLocation[1];
922
-
923
- if (locationX - window.width > 10) {
924
- // if it fits to the left of the window
925
- frame.setLocation(locationX - window.width, locationY);
926
-
927
- } else { // doesn't fit
928
- // if it fits inside the editor window,
929
- // offset slightly from upper lefthand corner
930
- // so that it's plunked inside the text area
931
- //locationX = editorLocation[0] + 66;
932
- //locationY = editorLocation[1] + 66;
933
- locationX = (sketch.displayWidth - window.width) / 2;
934
- locationY = (sketch.displayHeight - window.height) / 2;
935
-
936
- /*
937
- if ((locationX + window.width > sketch.displayWidth - 33) ||
938
- (locationY + window.height > sketch.displayHeight - 33)) {
939
- // otherwise center on screen
940
- locationX = (sketch.displayWidth - window.width) / 2;
941
- locationY = (sketch.displayHeight - window.height) / 2;
942
- }
943
- */
944
- frame.setLocation(locationX, locationY);
945
- }
946
- } else { // just center on screen
947
- setFrameCentered();
948
- }
949
- Point frameLoc = frame.getLocation();
950
- if (frameLoc.y < 0) {
951
- // Windows actually allows you to place frames where they can't be
952
- // closed. Awesome. http://dev.processing.org/bugs/show_bug.cgi?id=1508
953
- frame.setLocation(frameLoc.x, 30);
954
- }
955
- }
956
-
957
- canvas.setBounds((contentW - sketchWidth)/2,
958
- (contentH - sketchHeight)/2,
959
- sketchWidth, sketchHeight);
960
-
961
- // handle frame resizing events
962
- setupFrameResizeListener();
963
-
964
- /*
965
- // If displayable() is false, then PSurfaceNone should be used, but...
966
- if (sketch.getGraphics().displayable()) {
967
- frame.setVisible(true);
968
- // System.out.println("setting visible on EDT? " + EventQueue.isDispatchThread());
969
- //requestFocus();
970
- // if (canvas != null) {
971
- // //canvas.requestFocusInWindow();
972
- // canvas.requestFocus();
973
- // }
974
- }
975
- */
976
- // if (sketch.getGraphics().displayable()) {
977
- // setVisible(true);
978
- // }
979
- }
980
-
981
-
982
- // needs to resize the frame, which will resize the canvas, and so on...
983
- @Override
984
- public void setSize(int wide, int high) {
985
- // When the surface is set to resizable via surface.setResizable(true),
986
- // a crash may occur if the user sets the window to size zero.
987
- // https://github.com/processing/processing/issues/5052
988
- if (high <= 0) {
989
- high = 1;
990
- }
991
- if (wide <= 0) {
992
- wide = 1;
993
- }
994
-
995
- // if (PApplet.DEBUG) {
996
- // //System.out.format("frame visible %b, setSize(%d, %d) %n", frame.isVisible(), wide, high);
997
- // new Exception(String.format("setSize(%d, %d)", wide, high)).printStackTrace(System.out);
998
- // }
999
-
1000
- //if (wide == sketchWidth && high == sketchHeight) { // doesn't work on launch
1001
- if (wide == sketch.width && high == sketch.height &&
1002
- (frame == null || currentInsets.equals(frame.getInsets()))) {
1003
- // if (PApplet.DEBUG) {
1004
- // new Exception("w/h unchanged " + wide + " " + high).printStackTrace(System.out);
1005
- // }
1006
- return; // unchanged, don't rebuild everything
1007
- }
1008
-
1009
- sketchWidth = wide * windowScaleFactor;
1010
- sketchHeight = high * windowScaleFactor;
1011
-
1012
- // canvas.setSize(wide, high);
1013
- // frame.setSize(wide, high);
1014
- if (frame != null) { // skip if just a canvas
1015
- setFrameSize(); //wide, high);
1016
- }
1017
- setCanvasSize();
1018
- // if (frame != null) {
1019
- // frame.setLocationRelativeTo(null);
1020
- // }
1021
-
1022
- //initImage(graphics, wide, high);
1023
-
1024
- //throw new RuntimeException("implement me, see readme.md");
1025
- sketch.setSize(wide, high);
1026
- // sketch.width = wide;
1027
- // sketch.height = high;
1028
-
1029
- // set PGraphics variables for width/height/pixelWidth/pixelHeight
1030
- graphics.setSize(wide, high);
1031
- // System.out.println("out of setSize()");
1032
- }
1033
-
1034
-
1035
- //public void initImage(PGraphics gr, int wide, int high) {
1036
- /*
1037
- @Override
1038
- public void initImage(PGraphics graphics) {
1039
- GraphicsConfiguration gc = canvas.getGraphicsConfiguration();
1040
- // If not realized (off-screen, i.e the Color Selector Tool), gc will be null.
1041
- if (gc == null) {
1042
- System.err.println("GraphicsConfiguration null in initImage()");
1043
- GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
1044
- gc = ge.getDefaultScreenDevice().getDefaultConfiguration();
1045
- }
1046
-
1047
- // Formerly this was broken into separate versions based on offscreen or
1048
- // not, but we may as well create a compatible image; it won't hurt, right?
1049
- int wide = graphics.width * graphics.pixelFactor;
1050
- int high = graphics.height * graphics.pixelFactor;
1051
- graphics.image = gc.createCompatibleImage(wide, high);
1052
- }
1053
- */
1054
-
1055
-
1056
- // @Override
1057
- // public Component getComponent() {
1058
- // return canvas;
1059
- // }
1060
-
1061
-
1062
- // @Override
1063
- // public void setSmooth(int level) {
1064
- // }
1065
-
1066
-
1067
- /*
1068
- private boolean checkRetina() {
1069
- if (PApplet.platform == PConstants.MACOSX) {
1070
- // This should probably be reset each time there's a display change.
1071
- // A 5-minute search didn't turn up any such event in the Java 7 API.
1072
- // Also, should we use the Toolkit associated with the editor window?
1073
- final String javaVendor = System.getProperty("java.vendor");
1074
- if (javaVendor.contains("Oracle")) {
1075
- GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
1076
- GraphicsDevice device = env.getDefaultScreenDevice();
1077
-
1078
- try {
1079
- Field field = device.getClass().getDeclaredField("scale");
1080
- if (field != null) {
1081
- field.setAccessible(true);
1082
- Object scale = field.get(device);
1083
-
1084
- if (scale instanceof Integer && ((Integer)scale).intValue() == 2) {
1085
- return true;
1086
- }
1087
- }
1088
- } catch (Exception ignore) { }
1089
- }
1090
- }
1091
- return false;
1092
- }
1093
- */
1094
-
1095
-
1096
- /** Get the bounds rectangle for all displays. */
1097
- static Rectangle getDisplaySpan() {
1098
- Rectangle bounds = new Rectangle();
1099
- GraphicsEnvironment environment =
1100
- GraphicsEnvironment.getLocalGraphicsEnvironment();
1101
- for (GraphicsDevice device : environment.getScreenDevices()) {
1102
- for (GraphicsConfiguration config : device.getConfigurations()) {
1103
- Rectangle2D.union(bounds, config.getBounds(), bounds);
1104
- }
1105
- }
1106
- return bounds;
1107
- }
1108
-
1109
-
1110
- /*
1111
- private void checkDisplaySize() {
1112
- if (canvas.getGraphicsConfiguration() != null) {
1113
- GraphicsDevice displayDevice = getGraphicsConfiguration().getDevice();
1114
-
1115
- if (displayDevice != null) {
1116
- Rectangle screenRect =
1117
- displayDevice.getDefaultConfiguration().getBounds();
1118
-
1119
- displayWidth = screenRect.width;
1120
- displayHeight = screenRect.height;
1121
- }
1122
- }
1123
- }
1124
- */
1125
-
1126
-
1127
- /**
1128
- * Set this sketch to communicate its state back to the PDE.
1129
- *
1130
- * This uses the stderr stream to write positions of the window
1131
- * (so that it will be saved by the PDE for the next run) and
1132
- * notify on quit. See more notes in the Worker class.
1133
- */
1134
- @Override
1135
- public void setupExternalMessages() {
1136
- frame.addComponentListener(new ComponentAdapter() {
1137
- @Override
1138
- public void componentMoved(ComponentEvent e) {
1139
- Point where = ((Frame) e.getSource()).getLocation();
1140
- sketch.frameMoved(where.x, where.y);
1141
- }
1142
- });
1143
- }
1144
-
1145
-
1146
- /**
1147
- * Set up a listener that will fire proper component resize events
1148
- * in cases where frame.setResizable(true) is called.
1149
- */
1150
- private void setupFrameResizeListener() {
1151
- frame.addWindowStateListener((WindowEvent e) -> {
1152
- // This seems to be firing when dragging the window on OS X
1153
- // https://github.com/processing/processing/issues/3092
1154
- if (Frame.MAXIMIZED_BOTH == e.getNewState()) {
1155
- // Supposedly, sending the frame to back and then front is a
1156
- // workaround for this bug:
1157
- // http://stackoverflow.com/a/23897602
1158
- // but is not working for me...
1159
- //frame.toBack();
1160
- //frame.toFront();
1161
- // Packing the frame works, but that causes the window to collapse
1162
- // on OS X when the window is dragged. Changing to addNotify() for
1163
- // https://github.com/processing/processing/issues/3092
1164
- //frame.pack();
1165
- frame.addNotify();
1166
- }
1167
- });
1168
-
1169
- frame.addComponentListener(new ComponentAdapter() {
1170
- @Override
1171
- public void componentResized(ComponentEvent e) {
1172
- // Ignore bad resize events fired during setup to fix
1173
- // http://dev.processing.org/bugs/show_bug.cgi?id=341
1174
- // This should also fix the blank screen on Linux bug
1175
- // http://dev.processing.org/bugs/show_bug.cgi?id=282
1176
- if (frame.isResizable()) {
1177
- // might be multiple resize calls before visible (i.e. first
1178
- // when pack() is called, then when it's resized for use).
1179
- // ignore them because it's not the user resizing things.
1180
- Frame farm = (Frame) e.getComponent();
1181
- if (farm.isVisible()) {
1182
- Dimension windowSize = farm.getSize();
1183
- int x = farm.getX() + currentInsets.left;
1184
- int y = farm.getY() + currentInsets.top;
1185
-
1186
- // JFrame (unlike java.awt.Frame) doesn't include the left/top
1187
- // insets for placement (though it does seem to need them for
1188
- // overall size of the window. Perhaps JFrame sets its coord
1189
- // system so that (0, 0) is always the upper-left of the content
1190
- // area. Which seems nice, but breaks any f*ing AWT-based code.
1191
- int w = windowSize.width - currentInsets.left - currentInsets.right;
1192
- int h = windowSize.height - currentInsets.top - currentInsets.bottom;
1193
- setSize(w / windowScaleFactor, h / windowScaleFactor);
1194
-
1195
- // correct the location when inset size changes
1196
- setLocation(x - currentInsets.left, y - currentInsets.top);
1197
- }
1198
- }
1199
- }
1200
- });
1201
- }
1202
-
1203
-
1204
- // /**
1205
- // * (No longer in use) Use reflection to call
1206
- // * <code>com.apple.eawt.FullScreenUtilities.setWindowCanFullScreen(window, true);</code>
1207
- // */
1208
- // static void macosxFullScreenEnable(Window window) {
1209
- // try {
1210
- // Class<?> util = Class.forName("com.apple.eawt.FullScreenUtilities");
1211
- // Class params[] = new Class[] { Window.class, Boolean.TYPE };
1212
- // Method method = util.getMethod("setWindowCanFullScreen", params);
1213
- // method.invoke(util, window, true);
1214
- //
1215
- // } catch (ClassNotFoundException cnfe) {
1216
- // // ignored
1217
- // } catch (Exception e) {
1218
- // e.printStackTrace();
1219
- // }
1220
- // }
1221
- //
1222
- //
1223
- // /**
1224
- // * (No longer in use) Use reflection to call
1225
- // * <code>com.apple.eawt.Application.getApplication().requestToggleFullScreen(window);</code>
1226
- // */
1227
- // static void macosxFullScreenToggle(Window window) {
1228
- // try {
1229
- // Class<?> appClass = Class.forName("com.apple.eawt.Application");
1230
- //
1231
- // Method getAppMethod = appClass.getMethod("getApplication");
1232
- // Object app = getAppMethod.invoke(null, new Object[0]);
1233
- //
1234
- // Method requestMethod =
1235
- // appClass.getMethod("requestToggleFullScreen", Window.class);
1236
- // requestMethod.invoke(app, window);
1237
- //
1238
- // } catch (ClassNotFoundException cnfe) {
1239
- // // ignored
1240
- // } catch (Exception e) {
1241
- // e.printStackTrace();
1242
- // }
1243
- // }
1244
-
1245
-
1246
- //////////////////////////////////////////////////////////////
1247
-
1248
-
1249
- /*
1250
- // disabling for now; requires Java 1.7 and "precise" semantics are odd...
1251
- // returns 0.1 for tick-by-tick scrolling on OS X, but it's not a matter of
1252
- // calling ceil() on the value: 1.5 goes to 1, but 2.3 goes to 2.
1253
- // "precise" is a whole different animal, so add later API to shore that up.
1254
- static protected Method preciseWheelMethod;
1255
- static {
1256
- try {
1257
- preciseWheelMethod = MouseWheelEvent.class.getMethod("getPreciseWheelRotation", new Class[] { });
1258
- } catch (Exception e) {
1259
- // ignored, the method will just be set to null
1260
- }
1261
- }
1262
- */
1263
-
1264
-
1265
- /**
1266
- * Figure out how to process a mouse event.When loop() has been
1267
- called, the events will be queued up until drawing is complete. If noLoop() has been called, then events will happen immediately.
1268
- * @param nativeEvent
1269
- */
1270
- protected void nativeMouseEvent(java.awt.event.MouseEvent nativeEvent) {
1271
- // the 'amount' is the number of button clicks for a click event,
1272
- // or the number of steps/clicks on the wheel for a mouse wheel event.
1273
- int peCount = nativeEvent.getClickCount();
1274
-
1275
- int peAction = 0;
1276
- switch (nativeEvent.getID()) {
1277
- case java.awt.event.MouseEvent.MOUSE_PRESSED:
1278
- peAction = MouseEvent.PRESS;
1279
- break;
1280
- case java.awt.event.MouseEvent.MOUSE_RELEASED:
1281
- peAction = MouseEvent.RELEASE;
1282
- break;
1283
- case java.awt.event.MouseEvent.MOUSE_CLICKED:
1284
- peAction = MouseEvent.CLICK;
1285
- break;
1286
- case java.awt.event.MouseEvent.MOUSE_DRAGGED:
1287
- peAction = MouseEvent.DRAG;
1288
- break;
1289
- case java.awt.event.MouseEvent.MOUSE_MOVED:
1290
- peAction = MouseEvent.MOVE;
1291
- break;
1292
- case java.awt.event.MouseEvent.MOUSE_ENTERED:
1293
- peAction = MouseEvent.ENTER;
1294
- break;
1295
- case java.awt.event.MouseEvent.MOUSE_EXITED:
1296
- peAction = MouseEvent.EXIT;
1297
- break;
1298
- //case java.awt.event.MouseWheelEvent.WHEEL_UNIT_SCROLL:
1299
- case java.awt.event.MouseEvent.MOUSE_WHEEL:
1300
- peAction = MouseEvent.WHEEL;
1301
- /*
1302
- if (preciseWheelMethod != null) {
1303
- try {
1304
- peAmount = ((Double) preciseWheelMethod.invoke(nativeEvent, (Object[]) null)).floatValue();
1305
- } catch (Exception e) {
1306
- preciseWheelMethod = null;
1307
- }
1308
- }
1309
- */
1310
- peCount = ((MouseWheelEvent) nativeEvent).getWheelRotation();
1311
- break;
1312
- }
1313
-
1314
- // Switching to getModifiersEx() for 4.0a2 because of Java 9 deprecation.
1315
- // Had trouble with this in the past and rolled it back because it was
1316
- // optional at the time. This time around, just need to iron out the issue.
1317
- // http://code.google.com/p/processing/issues/detail?id=1294
1318
- // http://code.google.com/p/processing/issues/detail?id=1332
1319
- int modifiers = nativeEvent.getModifiersEx();
1320
-
1321
- int peButton = 0;
1322
- if ((modifiers & InputEvent.BUTTON1_DOWN_MASK) != 0) {
1323
- peButton = PConstants.LEFT;
1324
- } else if ((modifiers & InputEvent.BUTTON2_DOWN_MASK) != 0) {
1325
- peButton = PConstants.CENTER;
1326
- } else if ((modifiers & InputEvent.BUTTON3_DOWN_MASK) != 0) {
1327
- peButton = PConstants.RIGHT;
1328
- }
1329
-
1330
- sketch.postEvent(new MouseEvent(nativeEvent, nativeEvent.getWhen(),
1331
- peAction, modifiers,
1332
- nativeEvent.getX() / windowScaleFactor,
1333
- nativeEvent.getY() / windowScaleFactor,
1334
- peButton,
1335
- peCount));
1336
- }
1337
-
1338
-
1339
- protected void nativeKeyEvent(java.awt.event.KeyEvent event) {
1340
- int peAction = 0;
1341
- switch (event.getID()) {
1342
- case java.awt.event.KeyEvent.KEY_PRESSED:
1343
- peAction = KeyEvent.PRESS;
1344
- break;
1345
- case java.awt.event.KeyEvent.KEY_RELEASED:
1346
- peAction = KeyEvent.RELEASE;
1347
- break;
1348
- case java.awt.event.KeyEvent.KEY_TYPED:
1349
- peAction = KeyEvent.TYPE;
1350
- break;
1351
- }
1352
-
1353
- int modifiers = event.getModifiersEx();
1354
-
1355
- /*
1356
- // int peModifiers = event.getModifiersEx() &
1357
- // (InputEvent.SHIFT_DOWN_MASK |
1358
- // InputEvent.CTRL_DOWN_MASK |
1359
- // InputEvent.META_DOWN_MASK |
1360
- // InputEvent.ALT_DOWN_MASK);
1361
- int peModifiers = event.getModifiers() &
1362
- (InputEvent.SHIFT_MASK |
1363
- InputEvent.CTRL_MASK |
1364
- InputEvent.META_MASK |
1365
- InputEvent.ALT_MASK);
1366
- */
1367
-
1368
- sketch.postEvent(new KeyEvent(event, event.getWhen(),
1369
- peAction, modifiers,
1370
- event.getKeyChar(), event.getKeyCode()));
1371
- }
1372
-
1373
-
1374
- // listeners, for all my men!
1375
- protected void addListeners() {
1376
-
1377
- canvas.addMouseListener(new MouseListener() {
1378
-
1379
- @Override
1380
- public void mousePressed(java.awt.event.MouseEvent e) {
1381
- nativeMouseEvent(e);
1382
- }
1383
-
1384
- @Override
1385
- public void mouseReleased(java.awt.event.MouseEvent e) {
1386
- nativeMouseEvent(e);
1387
- }
1388
-
1389
- @Override
1390
- public void mouseClicked(java.awt.event.MouseEvent e) {
1391
- nativeMouseEvent(e);
1392
- }
1393
-
1394
- @Override
1395
- public void mouseEntered(java.awt.event.MouseEvent e) {
1396
- nativeMouseEvent(e);
1397
- }
1398
-
1399
- @Override
1400
- public void mouseExited(java.awt.event.MouseEvent e) {
1401
- nativeMouseEvent(e);
1402
- }
1403
- });
1404
-
1405
- canvas.addMouseMotionListener(new MouseMotionListener() {
1406
-
1407
- @Override
1408
- public void mouseDragged(java.awt.event.MouseEvent e) {
1409
- nativeMouseEvent(e);
1410
- }
1411
-
1412
- @Override
1413
- public void mouseMoved(java.awt.event.MouseEvent e) {
1414
- nativeMouseEvent(e);
1415
- }
1416
- });
1417
-
1418
- canvas.addMouseWheelListener((MouseWheelEvent e) -> {
1419
- nativeMouseEvent(e);
1420
- });
1421
-
1422
- canvas.addKeyListener(new KeyListener() {
1423
-
1424
- @Override
1425
- public void keyPressed(java.awt.event.KeyEvent e) {
1426
- nativeKeyEvent(e);
1427
- }
1428
-
1429
-
1430
- @Override
1431
- public void keyReleased(java.awt.event.KeyEvent e) {
1432
- nativeKeyEvent(e);
1433
- }
1434
-
1435
-
1436
- @Override
1437
- public void keyTyped(java.awt.event.KeyEvent e) {
1438
- nativeKeyEvent(e);
1439
- }
1440
- });
1441
-
1442
- canvas.addFocusListener(new FocusListener() {
1443
-
1444
- @Override
1445
- public void focusGained(FocusEvent e) {
1446
- sketch.focused = true;
1447
- sketch.focusGained();
1448
- }
1449
-
1450
- @Override
1451
- public void focusLost(FocusEvent e) {
1452
- sketch.focused = false;
1453
- sketch.focusLost();
1454
- }
1455
- });
1456
- }
1457
-
1458
-
1459
- /*
1460
- public void addListeners(Component comp) {
1461
- comp.addMouseListener(this);
1462
- comp.addMouseWheelListener(this);
1463
- comp.addMouseMotionListener(this);
1464
- comp.addKeyListener(this);
1465
- comp.addFocusListener(this);
1466
- }
1467
-
1468
-
1469
- public void removeListeners(Component comp) {
1470
- comp.removeMouseListener(this);
1471
- comp.removeMouseWheelListener(this);
1472
- comp.removeMouseMotionListener(this);
1473
- comp.removeKeyListener(this);
1474
- comp.removeFocusListener(this);
1475
- }
1476
- */
1477
-
1478
-
1479
- // /**
1480
- // * Call to remove, then add, listeners to a component.
1481
- // * Avoids issues with double-adding.
1482
- // */
1483
- // public void updateListeners(Component comp) {
1484
- // removeListeners(comp);
1485
- // addListeners(comp);
1486
- // }
1487
-
1488
-
1489
-
1490
- // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1491
-
1492
-
1493
- int cursorType = PConstants.ARROW;
1494
- boolean cursorVisible = true;
1495
- Cursor invisibleCursor;
1496
-
1497
-
1498
- @Override
1499
- public void setCursor(int kind) {
1500
- // Swap the HAND cursor because MOVE doesn't seem to be available on OS X
1501
- // https://github.com/processing/processing/issues/2358
1502
- if (PApplet.platform == PConstants.MACOS && kind == PConstants.MOVE) {
1503
- kind = PConstants.HAND;
1504
- }
1505
- canvas.setCursor(Cursor.getPredefinedCursor(kind));
1506
- cursorVisible = true;
1507
- this.cursorType = kind;
1508
- }
1509
-
1510
-
1511
- @Override
1512
- public void setCursor(PImage img, int x, int y) {
1513
- // Don't set cursorType, instead use cursorType to save the last
1514
- // regular cursor type used for when cursor() is called.
1515
- //cursor_type = Cursor.CUSTOM_CURSOR;
1516
-
1517
- // this is a temporary workaround for the CHIP, will be removed
1518
- Dimension cursorSize = Toolkit.getDefaultToolkit().getBestCursorSize(img.width, img.height);
1519
- if (cursorSize.width == 0 || cursorSize.height == 0) {
1520
- return;
1521
- }
1522
-
1523
- Cursor cursor =
1524
- canvas.getToolkit().createCustomCursor((Image) img.getNative(),
1525
- new Point(x, y),
1526
- "custom");
1527
- canvas.setCursor(cursor);
1528
- cursorVisible = true;
1529
- }
1530
-
1531
-
1532
- @Override
1533
- public void showCursor() {
1534
- // Maybe should always set here? Seems dangerous, since it's likely that
1535
- // Java will set the cursor to something else on its own, and the sketch
1536
- // will be stuck b/c p5 thinks the cursor is set to one particular thing.
1537
- if (!cursorVisible) {
1538
- cursorVisible = true;
1539
- canvas.setCursor(Cursor.getPredefinedCursor(cursorType));
1540
- }
1541
- }
1542
-
1543
-
1544
- @Override
1545
- public void hideCursor() {
1546
- // Because the OS may have shown the cursor on its own,
1547
- // don't return if 'cursorVisible' is set to true. [rev 0216]
1548
-
1549
- if (invisibleCursor == null) {
1550
- BufferedImage cursorImg =
1551
- new BufferedImage(16, 16, BufferedImage.TYPE_INT_ARGB);
1552
- // this is a temporary workaround for the CHIP, will be removed
1553
- Dimension cursorSize = Toolkit.getDefaultToolkit().getBestCursorSize(16, 16);
1554
- if (cursorSize.width == 0 || cursorSize.height == 0) {
1555
- invisibleCursor = Cursor.getDefaultCursor();
1556
- } else {
1557
- invisibleCursor =
1558
- canvas.getToolkit().createCustomCursor(cursorImg, new Point(8, 8), "blank");
1559
- }
1560
- }
1561
- canvas.setCursor(invisibleCursor);
1562
- cursorVisible = false;
1563
- }
1564
-
1565
-
1566
- @Override
1567
- public Thread createThread() {
1568
- return new AnimationThread() {
1569
- @Override
1570
- public void callDraw() {
1571
- sketch.handleDraw();
1572
- render();
1573
- }
1574
- };
1575
- }
1576
-
1577
-
1578
- void debug(String format, Object ... args) {
1579
- System.out.format(format + "%n", args);
1580
- }
1581
- }