25
|
1 /*******************************************************************************
|
|
2 * Copyright (c) 2000, 2008 IBM Corporation and others.
|
|
3 * All rights reserved. This program and the accompanying materials
|
|
4 * are made available under the terms of the Eclipse Public License v1.0
|
|
5 * which accompanies this distribution, and is available at
|
|
6 * http://www.eclipse.org/legal/epl-v10.html
|
|
7 *
|
|
8 * Contributors:
|
|
9 * IBM Corporation - initial API and implementation
|
|
10 * Port to the D programming language:
|
|
11 * Frank Benoit <benoit@tionex.de>
|
|
12 *******************************************************************************/
|
|
13 module org.eclipse.swt.graphics.Device;
|
|
14
|
|
15 import org.eclipse.swt.graphics.Color;
|
|
16 import org.eclipse.swt.graphics.Font;
|
|
17 import org.eclipse.swt.graphics.Drawable;
|
|
18 import org.eclipse.swt.graphics.DeviceData;
|
|
19 import org.eclipse.swt.graphics.Rectangle;
|
|
20 import org.eclipse.swt.graphics.FontData;
|
|
21 import org.eclipse.swt.graphics.Font;
|
|
22 import org.eclipse.swt.graphics.GCData;
|
|
23 import org.eclipse.swt.SWT;
|
|
24 import org.eclipse.swt.SWTError;
|
|
25 import org.eclipse.swt.internal.Compatibility;
|
|
26 import org.eclipse.swt.internal.gtk.OS;
|
|
27 import java.lang.all;
|
|
28
|
|
29
|
|
30 /**
|
|
31 * This class is the abstract superclass of all device objects,
|
|
32 * such as the Display device and the Printer device. Devices
|
|
33 * can have a graphics context (GC) created for them, and they
|
|
34 * can be drawn on by sending messages to the associated GC.
|
|
35 *
|
|
36 * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a>
|
|
37 */
|
|
38 public abstract class Device : Drawable {
|
|
39 /**
|
|
40 * the handle to the X Display
|
|
41 * (Warning: This field is platform dependent)
|
|
42 * <p>
|
|
43 * <b>IMPORTANT:</b> This field is <em>not</em> part of the SWT
|
|
44 * public API. It is marked protected only so that it can be shared
|
|
45 * within the packages provided by SWT. It is not available on all
|
|
46 * platforms and should never be accessed from application code.
|
|
47 * </p>
|
|
48 */
|
|
49 protected void* xDisplay;
|
|
50 GtkWidget* shellHandle;
|
|
51
|
|
52 /* Debugging */
|
|
53 public static bool DEBUG = true;
|
|
54 bool debugging;
|
|
55 bool tracking;
|
|
56 Exception [] errors;
|
|
57 Object [] objects;
|
|
58 Object trackingLock;
|
|
59
|
|
60 /* Colormap and reference count */
|
|
61 GdkColor *[] gdkColors;
|
|
62 int [] colorRefCount;
|
|
63
|
|
64 /* Disposed flag */
|
|
65 bool disposed;
|
|
66
|
|
67 /* Warning and Error Handlers */
|
|
68 //int /*long*/ logProcFld;
|
|
69 //GLogFunc logCallback;
|
|
70 //NOT DONE - get list of valid names
|
|
71 String [] log_domains = ["GLib-GObject"[], "GLib", "GObject", "Pango", "ATK", "GdkPixbuf", "Gdk", "Gtk", "GnomeVFS"];
|
|
72 int [] handler_ids;// = new int [log_domains.length];
|
|
73 int warningLevel;
|
|
74
|
|
75 /* X Warning and Error Handlers */
|
|
76 static extern(C) int function(void *) mXIOErrorHandler;
|
|
77 static extern(C) int function(void *, XErrorEvent *) mXErrorHandler;
|
|
78 //static int mXErrorCallback, mXIOErrorCallback;
|
|
79
|
|
80 static int /*long*/ XErrorProc, XIOErrorProc, XNullErrorProc, XNullIOErrorProc;
|
|
81 static Device[] Devices;
|
|
82
|
|
83 /*
|
|
84 * The following colors are listed in the Windows
|
|
85 * Programmer's Reference as the colors in the default
|
|
86 * palette.
|
|
87 */
|
|
88 Color COLOR_BLACK, COLOR_DARK_RED, COLOR_DARK_GREEN, COLOR_DARK_YELLOW, COLOR_DARK_BLUE;
|
|
89 Color COLOR_DARK_MAGENTA, COLOR_DARK_CYAN, COLOR_GRAY, COLOR_DARK_GRAY, COLOR_RED;
|
|
90 Color COLOR_GREEN, COLOR_YELLOW, COLOR_BLUE, COLOR_MAGENTA, COLOR_CYAN, COLOR_WHITE;
|
|
91
|
|
92 /* System Font */
|
|
93 Font systemFont;
|
|
94
|
|
95 PangoTabArray* emptyTab;
|
|
96
|
|
97 bool useXRender;
|
|
98
|
|
99 static bool CAIRO_LOADED;
|
|
100
|
|
101 /*
|
|
102 * TEMPORARY CODE. When a graphics object is
|
|
103 * created and the device parameter is null,
|
|
104 * the current Display is used. This presents
|
|
105 * a problem because SWT graphics does not
|
|
106 * reference classes in SWT widgets. The correct
|
|
107 * fix is to remove this feature. Unfortunately,
|
|
108 * too many application programs rely on this
|
|
109 * feature.
|
|
110 *
|
|
111 * This code will be removed in the future.
|
|
112 */
|
|
113 protected static Device CurrentDevice;
|
|
114 protected static Runnable DeviceFinder;
|
|
115
|
|
116 //synchronized static void static_this(){
|
|
117 // CREATE_LOCK = new Object();
|
|
118 // Devices = new Device[4];
|
|
119 //}
|
|
120 /*
|
|
121 * TEMPORARY CODE.
|
|
122 */
|
|
123 static synchronized Device getDevice () {
|
|
124 if (DeviceFinder !is null) DeviceFinder.run();
|
|
125 Device device = CurrentDevice;
|
|
126 CurrentDevice = null;
|
|
127 return device;
|
|
128 }
|
|
129
|
|
130 /**
|
|
131 * Constructs a new instance of this class.
|
|
132 * <p>
|
|
133 * You must dispose the device when it is no longer required.
|
|
134 * </p>
|
|
135 *
|
|
136 * @see #create
|
|
137 * @see #init
|
|
138 *
|
|
139 * @since 3.1
|
|
140 */
|
|
141 public this() {
|
|
142 this(null);
|
|
143 }
|
|
144
|
|
145 /**
|
|
146 * Constructs a new instance of this class.
|
|
147 * <p>
|
|
148 * You must dispose the device when it is no longer required.
|
|
149 * </p>
|
|
150 *
|
|
151 * @param data the DeviceData which describes the receiver
|
|
152 *
|
|
153 * @see #create
|
|
154 * @see #init
|
|
155 * @see DeviceData
|
|
156 */
|
|
157 public this(DeviceData data) {
|
|
158 handler_ids = new int [log_domains.length];
|
|
159 debugging = DEBUG;
|
|
160 tracking = DEBUG;
|
|
161
|
|
162 synchronized ( this.classinfo ) {
|
|
163 if (data !is null) {
|
|
164 debugging = data.debugging;
|
|
165 tracking = data.tracking;
|
|
166 }
|
|
167 if (tracking) {
|
|
168 errors = new Exception [128];
|
|
169 objects = new Object [128];
|
|
170 trackingLock = new Object ();
|
|
171 }
|
|
172 create (data);
|
|
173 init_ ();
|
|
174 register (this);
|
|
175 }
|
|
176 }
|
|
177
|
|
178 void checkCairo() {
|
|
179 }
|
|
180
|
|
181 /**
|
|
182 * Throws an <code>SWTException</code> if the receiver can not
|
|
183 * be accessed by the caller. This may include both checks on
|
|
184 * the state of the receiver and more generally on the entire
|
|
185 * execution context. This method <em>should</em> be called by
|
|
186 * device implementors to enforce the standard SWT invariants.
|
|
187 * <p>
|
|
188 * Currently, it is an error to invoke any method (other than
|
|
189 * <code>isDisposed()</code> and <code>dispose()</code>) on a
|
|
190 * device that has had its <code>dispose()</code> method called.
|
|
191 * </p><p>
|
|
192 * In future releases of SWT, there may be more or fewer error
|
|
193 * checks and exceptions may be thrown for different reasons.
|
|
194 * <p>
|
|
195 *
|
|
196 * @exception SWTException <ul>
|
|
197 * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
|
|
198 * </ul>
|
|
199 */
|
|
200 protected void checkDevice () {
|
|
201 if (disposed) SWT.error(SWT.ERROR_DEVICE_DISPOSED);
|
|
202 }
|
|
203
|
|
204 /**
|
|
205 * Creates the device in the operating system. If the device
|
|
206 * does not have a handle, this method may do nothing depending
|
|
207 * on the device.
|
|
208 * <p>
|
|
209 * This method is called before <code>init</code>.
|
|
210 * </p><p>
|
|
211 * Subclasses are supposed to reimplement this method and not
|
|
212 * call the <code>super</code> implementation.
|
|
213 * </p>
|
|
214 *
|
|
215 * @param data the DeviceData which describes the receiver
|
|
216 *
|
|
217 * @see #init
|
|
218 */
|
|
219 protected void create (DeviceData data) {
|
|
220 }
|
|
221
|
|
222 /**
|
|
223 * Disposes of the operating system resources associated with
|
|
224 * the receiver. After this method has been invoked, the receiver
|
|
225 * will answer <code>true</code> when sent the message
|
|
226 * <code>isDisposed()</code>.
|
|
227 *
|
|
228 * @see #release
|
|
229 * @see #destroy
|
|
230 * @see #checkDevice
|
|
231 */
|
|
232 public void dispose () {
|
|
233 synchronized (Device.classinfo) {
|
|
234 if (isDisposed()) return;
|
|
235 checkDevice ();
|
|
236 release ();
|
|
237 destroy ();
|
|
238 deregister (this);
|
|
239 xDisplay = null;
|
|
240 disposed = true;
|
|
241 if (tracking) {
|
|
242 synchronized (trackingLock) {
|
|
243 objects = null;
|
|
244 errors = null;
|
|
245 trackingLock = null;
|
|
246 }
|
|
247 }
|
|
248 }
|
|
249 }
|
|
250
|
|
251 void dispose_Object (Object object) {
|
|
252 synchronized (trackingLock) {
|
|
253 for (int i=0; i<objects.length; i++) {
|
|
254 if (objects [i] is object) {
|
|
255 objects [i] = null;
|
|
256 errors [i] = null;
|
|
257 return;
|
|
258 }
|
|
259 }
|
|
260 }
|
|
261 }
|
|
262
|
|
263 static synchronized Device findDevice (void* xDisplay) {
|
|
264 for (int i=0; i<Devices.length; i++) {
|
|
265 Device device = Devices [i];
|
|
266 if (device !is null && device.xDisplay is xDisplay) {
|
|
267 return device;
|
|
268 }
|
|
269 }
|
|
270 return null;
|
|
271 }
|
|
272
|
|
273 synchronized static void deregister (Device device) {
|
|
274 for (int i=0; i<Devices.length; i++) {
|
|
275 if (device is Devices [i]) Devices [i] = null;
|
|
276 }
|
|
277 }
|
|
278
|
|
279 /**
|
|
280 * Destroys the device in the operating system and releases
|
|
281 * the device's handle. If the device does not have a handle,
|
|
282 * this method may do nothing depending on the device.
|
|
283 * <p>
|
|
284 * This method is called after <code>release</code>.
|
|
285 * </p><p>
|
|
286 * Subclasses are supposed to reimplement this method and not
|
|
287 * call the <code>super</code> implementation.
|
|
288 * </p>
|
|
289 *
|
|
290 * @see #dispose
|
|
291 * @see #release
|
|
292 */
|
|
293 protected void destroy () {
|
|
294 }
|
|
295
|
|
296 /**
|
|
297 * Returns a rectangle describing the receiver's size and location.
|
|
298 *
|
|
299 * @return the bounding rectangle
|
|
300 *
|
|
301 * @exception SWTException <ul>
|
|
302 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li>
|
|
303 * </ul>
|
|
304 */
|
|
305 public Rectangle getBounds () {
|
|
306 checkDevice ();
|
|
307 return new Rectangle(0, 0, 0, 0);
|
|
308 }
|
|
309
|
|
310 /**
|
|
311 * Returns a <code>DeviceData</code> based on the receiver.
|
|
312 * Modifications made to this <code>DeviceData</code> will not
|
|
313 * affect the receiver.
|
|
314 *
|
|
315 * @return a <code>DeviceData</code> containing the device's data and attributes
|
|
316 *
|
|
317 * @exception SWTException <ul>
|
|
318 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li>
|
|
319 * </ul>
|
|
320 *
|
|
321 * @see DeviceData
|
|
322 */
|
|
323 public DeviceData getDeviceData () {
|
|
324 checkDevice();
|
|
325 DeviceData data = new DeviceData ();
|
|
326 data.debugging = debugging;
|
|
327 data.tracking = tracking;
|
|
328 if (tracking) {
|
|
329 synchronized (trackingLock) {
|
|
330 int count = 0, length = objects.length;
|
|
331 for (int i=0; i<length; i++) {
|
|
332 if (objects [i] !is null) count++;
|
|
333 }
|
|
334 int index = 0;
|
|
335 data.objects = new Object [count];
|
|
336 data.errors = new Exception [count];
|
|
337 for (int i=0; i<length; i++) {
|
|
338 if (objects [i] !is null) {
|
|
339 data.objects [index] = objects [i];
|
|
340 data.errors [index] = errors [i];
|
|
341 index++;
|
|
342 }
|
|
343 }
|
|
344 }
|
|
345 } else {
|
|
346 data.objects = null;
|
|
347 data.errors = null;
|
|
348 }
|
|
349 return data;
|
|
350 }
|
|
351
|
|
352 /**
|
|
353 * Returns a rectangle which describes the area of the
|
|
354 * receiver which is capable of displaying data.
|
|
355 *
|
|
356 * @return the client area
|
|
357 *
|
|
358 * @exception SWTException <ul>
|
|
359 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li>
|
|
360 * </ul>
|
|
361 *
|
|
362 * @see #getBounds
|
|
363 */
|
|
364 public Rectangle getClientArea () {
|
|
365 checkDevice ();
|
|
366 return getBounds ();
|
|
367 }
|
|
368
|
|
369 /**
|
|
370 * Returns the bit depth of the screen, which is the number of
|
|
371 * bits it takes to represent the number of unique colors that
|
|
372 * the screen is currently capable of displaying. This number
|
|
373 * will typically be one of 1, 8, 15, 16, 24 or 32.
|
|
374 *
|
|
375 * @return the depth of the screen
|
|
376 *
|
|
377 * @exception SWTException <ul>
|
|
378 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li>
|
|
379 * </ul>
|
|
380 */
|
|
381 public int getDepth () {
|
|
382 checkDevice ();
|
|
383 return 0;
|
|
384 }
|
|
385
|
|
386 /**
|
|
387 * Returns a point whose x coordinate is the horizontal
|
|
388 * dots per inch of the display, and whose y coordinate
|
|
389 * is the vertical dots per inch of the display.
|
|
390 *
|
|
391 * @return the horizontal and vertical DPI
|
|
392 *
|
|
393 * @exception SWTException <ul>
|
|
394 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li>
|
|
395 * </ul>
|
|
396 */
|
|
397 public Point getDPI () {
|
|
398 checkDevice ();
|
|
399 return new Point (72, 72);
|
|
400 }
|
|
401
|
|
402 /**
|
|
403 * Returns <code>FontData</code> objects which describe
|
|
404 * the fonts that match the given arguments. If the
|
|
405 * <code>faceName</code> is null, all fonts will be returned.
|
|
406 *
|
|
407 * @param faceName the name of the font to look for, or null
|
|
408 * @param scalable if true only scalable fonts are returned, otherwise only non-scalable fonts are returned.
|
|
409 * @return the matching font data
|
|
410 *
|
|
411 * @exception SWTException <ul>
|
|
412 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li>
|
|
413 * </ul>
|
|
414 */
|
|
415 public FontData[] getFontList (String faceName, bool scalable) {
|
|
416 checkDevice ();
|
|
417 if (!scalable) return new FontData[0];
|
|
418 PangoFontFamily* family;
|
|
419 PangoFontFace * face;
|
|
420 PangoFontFamily** families;
|
|
421 int n_families;
|
|
422 PangoFontFace ** faces;
|
|
423 int n_faces;
|
|
424 auto context = OS.gdk_pango_context_get();
|
|
425 OS.pango_context_list_families(context, &families, &n_families);
|
|
426 int nFds = 0;
|
|
427 FontData[] fds = new FontData[faceName !is null ? 4 : n_families];
|
|
428 for (int i=0; i<n_families; i++) {
|
|
429 family = families[i];
|
|
430 bool match = true;
|
|
431 if (faceName !is null) {
|
|
432 auto familyName = OS.pango_font_family_get_name(family);
|
|
433 match = Compatibility.equalsIgnoreCase(faceName, fromStringz( familyName ));
|
|
434 }
|
|
435 if (match) {
|
|
436 OS.pango_font_family_list_faces(family, &faces, &n_faces);
|
|
437 for (int j=0; j<n_faces; j++) {
|
|
438 face = faces[j];
|
|
439 auto fontDesc = OS.pango_font_face_describe(face);
|
|
440 Font font = Font.gtk_new(this, fontDesc);
|
|
441 FontData data = font.getFontData()[0];
|
|
442 if (nFds is fds.length) {
|
|
443 FontData[] newFds = new FontData[fds.length + n_families];
|
|
444 System.arraycopy(fds, 0, newFds, 0, nFds);
|
|
445 fds = newFds;
|
|
446 }
|
|
447 fds[nFds++] = data;
|
|
448 OS.pango_font_description_free(fontDesc);
|
|
449 }
|
|
450 OS.g_free(faces);
|
|
451 if (faceName !is null) break;
|
|
452 }
|
|
453 }
|
|
454 OS.g_free(families);
|
|
455 OS.g_object_unref(context);
|
|
456 if (nFds is fds.length) return fds;
|
|
457 FontData[] result = new FontData[nFds];
|
|
458 System.arraycopy(fds, 0, result, 0, nFds);
|
|
459 return result;
|
|
460 }
|
|
461
|
|
462 /**
|
|
463 * Returns the matching standard color for the given
|
|
464 * constant, which should be one of the color constants
|
|
465 * specified in class <code>SWT</code>. Any value other
|
|
466 * than one of the SWT color constants which is passed
|
|
467 * in will result in the color black. This color should
|
|
468 * not be freed because it was allocated by the system,
|
|
469 * not the application.
|
|
470 *
|
|
471 * @param id the color constant
|
|
472 * @return the matching color
|
|
473 *
|
|
474 * @exception SWTException <ul>
|
|
475 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li>
|
|
476 * </ul>
|
|
477 *
|
|
478 * @see SWT
|
|
479 */
|
|
480 public Color getSystemColor (int id) {
|
|
481 checkDevice ();
|
|
482 switch (id) {
|
|
483 case SWT.COLOR_BLACK: return COLOR_BLACK;
|
|
484 case SWT.COLOR_DARK_RED: return COLOR_DARK_RED;
|
|
485 case SWT.COLOR_DARK_GREEN: return COLOR_DARK_GREEN;
|
|
486 case SWT.COLOR_DARK_YELLOW: return COLOR_DARK_YELLOW;
|
|
487 case SWT.COLOR_DARK_BLUE: return COLOR_DARK_BLUE;
|
|
488 case SWT.COLOR_DARK_MAGENTA: return COLOR_DARK_MAGENTA;
|
|
489 case SWT.COLOR_DARK_CYAN: return COLOR_DARK_CYAN;
|
|
490 case SWT.COLOR_GRAY: return COLOR_GRAY;
|
|
491 case SWT.COLOR_DARK_GRAY: return COLOR_DARK_GRAY;
|
|
492 case SWT.COLOR_RED: return COLOR_RED;
|
|
493 case SWT.COLOR_GREEN: return COLOR_GREEN;
|
|
494 case SWT.COLOR_YELLOW: return COLOR_YELLOW;
|
|
495 case SWT.COLOR_BLUE: return COLOR_BLUE;
|
|
496 case SWT.COLOR_MAGENTA: return COLOR_MAGENTA;
|
|
497 case SWT.COLOR_CYAN: return COLOR_CYAN;
|
|
498 case SWT.COLOR_WHITE: return COLOR_WHITE;
|
|
499 default:
|
|
500 }
|
|
501 return COLOR_BLACK;
|
|
502 }
|
|
503
|
|
504 /**
|
|
505 * Returns a reasonable font for applications to use.
|
|
506 * On some platforms, this will match the "default font"
|
|
507 * or "system font" if such can be found. This font
|
|
508 * should not be freed because it was allocated by the
|
|
509 * system, not the application.
|
|
510 * <p>
|
|
511 * Typically, applications which want the default look
|
|
512 * should simply not set the font on the widgets they
|
|
513 * create. Widgets are always created with the correct
|
|
514 * default font for the class of user-interface component
|
|
515 * they represent.
|
|
516 * </p>
|
|
517 *
|
|
518 * @return a font
|
|
519 *
|
|
520 * @exception SWTException <ul>
|
|
521 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li>
|
|
522 * </ul>
|
|
523 */
|
|
524 public Font getSystemFont () {
|
|
525 checkDevice ();
|
|
526 return systemFont;
|
|
527 }
|
|
528
|
|
529 /**
|
|
530 * Returns <code>true</code> if the underlying window system prints out
|
|
531 * warning messages on the console, and <code>setWarnings</code>
|
|
532 * had previously been called with <code>true</code>.
|
|
533 *
|
|
534 * @return <code>true</code>if warnings are being handled, and <code>false</code> otherwise
|
|
535 *
|
|
536 * @exception SWTException <ul>
|
|
537 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li>
|
|
538 * </ul>
|
|
539 */
|
|
540 public bool getWarnings () {
|
|
541 checkDevice ();
|
|
542 return warningLevel is 0;
|
|
543 }
|
|
544
|
|
545 /**
|
|
546 * Initializes any internal resources needed by the
|
|
547 * device.
|
|
548 * <p>
|
|
549 * This method is called after <code>create</code>.
|
|
550 * </p><p>
|
|
551 * If subclasses reimplement this method, they must
|
|
552 * call the <code>super</code> implementation.
|
|
553 * </p>
|
|
554 *
|
|
555 * @see #create
|
|
556 */
|
|
557 protected void init_ () {
|
|
558 if (xDisplay !is null) {
|
|
559 int event_basep, error_basep;
|
|
560 if (OS.XRenderQueryExtension (xDisplay, &event_basep, &error_basep)) {
|
|
561 int major_version, minor_version;
|
|
562 OS.XRenderQueryVersion (xDisplay, &major_version, &minor_version);
|
|
563 useXRender = major_version > 0 || (major_version is 0 && minor_version >= 8);
|
|
564 }
|
|
565 }
|
|
566
|
|
567 if (debugging) {
|
|
568 if (xDisplay !is null) {
|
|
569 /* Create the warning and error callbacks */
|
|
570 synchronized (this.classinfo) {
|
|
571 int index = 0;
|
|
572 while (index < Devices.length) {
|
|
573 if (Devices [index] !is null) break;
|
|
574 index++;
|
|
575 }
|
|
576 if (index is Devices.length) {
|
|
577 OS.XSetErrorHandler ( & XErrorProcFunc );
|
|
578 OS.XSetIOErrorHandler ( & XIOErrorProcFunc );
|
|
579 }
|
|
580 }
|
|
581 OS.XSynchronize (xDisplay, true);
|
|
582 }
|
|
583 }
|
|
584
|
|
585 /* Create GTK warnings and error callbacks */
|
|
586 if (xDisplay !is null) {
|
|
587 /* Set GTK warning and error handlers */
|
|
588 if (debugging) {
|
|
589 int flags = OS.G_LOG_LEVEL_MASK | OS.G_LOG_FLAG_FATAL | OS.G_LOG_FLAG_RECURSION;
|
|
590 for (int i=0; i<log_domains.length; i++) {
|
|
591 handler_ids [i] = OS.g_log_set_handler (log_domains [i].toStringzValidPtr(), flags, & logFunction, cast(void*)this);
|
|
592 }
|
|
593 }
|
|
594 }
|
|
595
|
|
596 /* Create the standard colors */
|
|
597 COLOR_BLACK = new Color (this, 0,0,0);
|
|
598 COLOR_DARK_RED = new Color (this, 0x80,0,0);
|
|
599 COLOR_DARK_GREEN = new Color (this, 0,0x80,0);
|
|
600 COLOR_DARK_YELLOW = new Color (this, 0x80,0x80,0);
|
|
601 COLOR_DARK_BLUE = new Color (this, 0,0,0x80);
|
|
602 COLOR_DARK_MAGENTA = new Color (this, 0x80,0,0x80);
|
|
603 COLOR_DARK_CYAN = new Color (this, 0,0x80,0x80);
|
|
604 COLOR_GRAY = new Color (this, 0xC0,0xC0,0xC0);
|
|
605 COLOR_DARK_GRAY = new Color (this, 0x80,0x80,0x80);
|
|
606 COLOR_RED = new Color (this, 0xFF,0,0);
|
|
607 COLOR_GREEN = new Color (this, 0,0xFF,0);
|
|
608 COLOR_YELLOW = new Color (this, 0xFF,0xFF,0);
|
|
609 COLOR_BLUE = new Color (this, 0,0,0xFF);
|
|
610 COLOR_MAGENTA = new Color (this, 0xFF,0,0xFF);
|
|
611 COLOR_CYAN = new Color (this, 0,0xFF,0xFF);
|
|
612 COLOR_WHITE = new Color (this, 0xFF,0xFF,0xFF);
|
|
613
|
|
614 emptyTab = OS.pango_tab_array_new(1, false);
|
|
615 if (emptyTab is null) SWT.error(SWT.ERROR_NO_HANDLES);
|
|
616 OS.pango_tab_array_set_tab(emptyTab, 0, OS.PANGO_TAB_LEFT, 1);
|
|
617
|
|
618 shellHandle = OS.gtk_window_new(OS.GTK_WINDOW_TOPLEVEL);
|
|
619 if (shellHandle is null) SWT.error(SWT.ERROR_NO_HANDLES);
|
|
620 OS.gtk_widget_realize(shellHandle);
|
|
621
|
|
622 /* Initialize the system font slot */
|
|
623 systemFont = getSystemFont ();
|
|
624 }
|
|
625
|
|
626 /**
|
|
627 * Invokes platform specific functionality to allocate a new GC handle.
|
|
628 * <p>
|
|
629 * <b>IMPORTANT:</b> This method is <em>not</em> part of the public
|
|
630 * API for <code>Device</code>. It is marked public only so that it
|
|
631 * can be shared within the packages provided by SWT. It is not
|
|
632 * available on all platforms, and should never be called from
|
|
633 * application code.
|
|
634 * </p>
|
|
635 *
|
|
636 * @param data the platform specific GC data
|
|
637 * @return the platform specific GC handle
|
|
638 */
|
|
639 public abstract GdkGC* internal_new_GC (GCData data);
|
|
640
|
|
641 /**
|
|
642 * Invokes platform specific functionality to dispose a GC handle.
|
|
643 * <p>
|
|
644 * <b>IMPORTANT:</b> This method is <em>not</em> part of the public
|
|
645 * API for <code>Device</code>. It is marked public only so that it
|
|
646 * can be shared within the packages provided by SWT. It is not
|
|
647 * available on all platforms, and should never be called from
|
|
648 * application code.
|
|
649 * </p>
|
|
650 *
|
|
651 * @param hDC the platform specific GC handle
|
|
652 * @param data the platform specific GC data
|
|
653 */
|
|
654 public abstract void internal_dispose_GC (GdkGC* handle, GCData data);
|
|
655
|
|
656 /**
|
|
657 * Returns <code>true</code> if the device has been disposed,
|
|
658 * and <code>false</code> otherwise.
|
|
659 * <p>
|
|
660 * This method gets the dispose state for the device.
|
|
661 * When a device has been disposed, it is an error to
|
|
662 * invoke any other method using the device.
|
|
663 *
|
|
664 * @return <code>true</code> when the device is disposed and <code>false</code> otherwise
|
|
665 */
|
|
666 public bool isDisposed () {
|
|
667 synchronized (Device.classinfo) {
|
|
668 return disposed;
|
|
669 }
|
|
670 }
|
|
671
|
|
672 /**
|
|
673 * Loads the font specified by a file. The font will be
|
|
674 * present in the list of fonts available to the application.
|
|
675 *
|
|
676 * @param path the font file path
|
|
677 * @return whether the font was successfully loaded
|
|
678 *
|
|
679 * @exception SWTException <ul>
|
|
680 * <li>ERROR_NULL_ARGUMENT - if path is null</li>
|
|
681 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li>
|
|
682 * </ul>
|
|
683 *
|
|
684 * @see Font
|
|
685 *
|
|
686 * @since 3.3
|
|
687 */
|
|
688 public bool loadFont (String path) {
|
|
689 checkDevice();
|
|
690 if (path is null) SWT.error (SWT.ERROR_NULL_ARGUMENT);
|
|
691 return cast(bool) OS.FcConfigAppFontAddFile (null, path.toStringzValidPtr());
|
|
692 }
|
|
693
|
|
694 private static extern(C) void logFunction (char* log_domain, int log_level, char* message, void* user_data) {
|
|
695 Device dev = cast(Device)user_data;
|
|
696 if (dev.warningLevel is 0) {
|
|
697 if (DEBUG || dev.debugging) {
|
|
698 ExceptionPrintStackTrace(new Exception (""));
|
|
699 }
|
|
700 OS.g_log_default_handler (log_domain, log_level, message, user_data);
|
|
701 }
|
|
702 return 0;
|
|
703 }
|
|
704
|
|
705 void new_Object (Object object) {
|
|
706 synchronized (trackingLock) {
|
|
707 for (int i=0; i<objects.length; i++) {
|
|
708 if (objects [i] is null) {
|
|
709 objects [i] = object;
|
|
710 errors [i] = new Exception ("");
|
|
711 return;
|
|
712 }
|
|
713 }
|
|
714 Object [] newObjects = new Object [objects.length + 128];
|
|
715 System.arraycopy (objects, 0, newObjects, 0, objects.length);
|
|
716 newObjects [objects.length] = object;
|
|
717 objects = newObjects;
|
|
718 Exception [] newErrors = new Exception [errors.length + 128];
|
|
719 System.arraycopy (errors, 0, newErrors, 0, errors.length);
|
|
720 newErrors [errors.length] = new Exception ("");
|
|
721 errors = newErrors;
|
|
722 }
|
|
723 }
|
|
724
|
|
725 static synchronized void register (Device device) {
|
|
726 for (int i=0; i<Devices.length; i++) {
|
|
727 if (Devices [i] is null) {
|
|
728 Devices [i] = device;
|
|
729 return;
|
|
730 }
|
|
731 }
|
|
732 Device [] newDevices = new Device [Devices.length + 4];
|
|
733 System.arraycopy (Devices, 0, newDevices, 0, Devices.length);
|
|
734 newDevices [Devices.length] = device;
|
|
735 Devices = newDevices;
|
|
736 }
|
|
737
|
|
738 /**
|
|
739 * Releases any internal resources back to the operating
|
|
740 * system and clears all fields except the device handle.
|
|
741 * <p>
|
|
742 * When a device is destroyed, resources that were acquired
|
|
743 * on behalf of the programmer need to be returned to the
|
|
744 * operating system. For example, if the device allocated a
|
|
745 * font to be used as the system font, this font would be
|
|
746 * freed in <code>release</code>. Also,to assist the garbage
|
|
747 * collector and minimize the amount of memory that is not
|
|
748 * reclaimed when the programmer keeps a reference to a
|
|
749 * disposed device, all fields except the handle are zero'd.
|
|
750 * The handle is needed by <code>destroy</code>.
|
|
751 * </p>
|
|
752 * This method is called before <code>destroy</code>.
|
|
753 * </p><p>
|
|
754 * If subclasses reimplement this method, they must
|
|
755 * call the <code>super</code> implementation.
|
|
756 * </p>
|
|
757 *
|
|
758 * @see #dispose
|
|
759 * @see #destroy
|
|
760 */
|
|
761 protected void release () {
|
|
762 if (shellHandle !is null) OS.gtk_widget_destroy(shellHandle);
|
|
763 shellHandle = null;
|
|
764
|
|
765 if (gdkColors !is null) {
|
|
766 auto colormap = OS.gdk_colormap_get_system();
|
|
767 for (int i = 0; i < gdkColors.length; i++) {
|
|
768 GdkColor* color = gdkColors [i];
|
|
769 if (color !is null) {
|
|
770 while (colorRefCount [i] > 0) {
|
|
771 OS.gdk_colormap_free_colors(colormap, color, 1);
|
|
772 --colorRefCount [i];
|
|
773 }
|
|
774 }
|
|
775 }
|
|
776 }
|
|
777 gdkColors = null;
|
|
778 colorRefCount = null;
|
|
779 COLOR_BLACK = COLOR_DARK_RED = COLOR_DARK_GREEN = COLOR_DARK_YELLOW = COLOR_DARK_BLUE =
|
|
780 COLOR_DARK_MAGENTA = COLOR_DARK_CYAN = COLOR_GRAY = COLOR_DARK_GRAY = COLOR_RED =
|
|
781 COLOR_GREEN = COLOR_YELLOW = COLOR_BLUE = COLOR_MAGENTA = COLOR_CYAN = COLOR_WHITE = null;
|
|
782
|
|
783 if (emptyTab !is null ) OS.pango_tab_array_free(emptyTab);
|
|
784 emptyTab = null;
|
|
785
|
|
786 /* Free the GTK error and warning handler */
|
|
787 if (xDisplay !is null) {
|
|
788 for (int i=0; i<handler_ids.length; i++) {
|
|
789 if (handler_ids [i] !is 0 ) {
|
|
790 OS.g_log_remove_handler (log_domains [i].toStringzValidPtr(), handler_ids [i]);
|
|
791 handler_ids [i] = 0;
|
|
792 }
|
|
793 }
|
|
794 //logCallback.dispose (); logCallback = null;
|
|
795 handler_ids = null; log_domains = null;
|
|
796 //logProcFld = 0;
|
|
797 }
|
|
798 }
|
|
799
|
|
800 /**
|
|
801 * If the underlying window system supports printing warning messages
|
|
802 * to the console, setting warnings to <code>false</code> prevents these
|
|
803 * messages from being printed. If the argument is <code>true</code> then
|
|
804 * message printing is not blocked.
|
|
805 *
|
|
806 * @param warnings <code>true</code>if warnings should be printed, and <code>false</code> otherwise
|
|
807 *
|
|
808 * @exception SWTException <ul>
|
|
809 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li>
|
|
810 * </ul>
|
|
811 */
|
|
812 public void setWarnings (bool warnings) {
|
|
813 checkDevice ();
|
|
814 if (warnings) {
|
|
815 if (--warningLevel is 0) {
|
|
816 if (debugging) return;
|
|
817 for (int i=0; i<handler_ids.length; i++) {
|
|
818 if (handler_ids [i] !is 0) {
|
|
819 OS.g_log_remove_handler (log_domains [i].toStringzValidPtr(), handler_ids [i]);
|
|
820 handler_ids [i] = 0;
|
|
821 }
|
|
822 }
|
|
823 }
|
|
824 } else {
|
|
825 if (warningLevel++ is 0) {
|
|
826 if (debugging) return;
|
|
827 int flags = OS.G_LOG_LEVEL_MASK | OS.G_LOG_FLAG_FATAL | OS.G_LOG_FLAG_RECURSION;
|
|
828 for (int i=0; i<log_domains.length; i++) {
|
|
829 handler_ids [i] = OS.g_log_set_handler (log_domains [i].toStringzValidPtr(), flags, & logFunction, cast(void*)this );
|
|
830 }
|
|
831 }
|
|
832 }
|
|
833 }
|
|
834
|
|
835 private static extern(C) int /*long*/ XErrorProcFunc (void* xDisplay, org.eclipse.swt.internal.gtk.OS.XErrorEvent* xErrorEvent) {
|
|
836 Device device = findDevice (xDisplay);
|
|
837 if (device !is null) {
|
|
838 if (device.warningLevel is 0) {
|
|
839 if (DEBUG || device.debugging) {
|
|
840 foreach( msg; (new Exception ("")).info ){
|
|
841 getDwtLogger().error( __FILE__, __LINE__, "{}", msg );
|
|
842 }
|
|
843 }
|
|
844 //PORTING_FIXME ??
|
|
845 //OS.Call (XErrorProc, xDisplay, xErrorEvent);
|
|
846 }
|
|
847 } else {
|
|
848 if (DEBUG) (new SWTError ()).printStackTrace ();
|
|
849 //PORTING_FIXME ??
|
|
850 //OS.Call (XErrorProc, xDisplay, xErrorEvent);
|
|
851 }
|
|
852 return 0;
|
|
853 }
|
|
854
|
|
855 private static extern(C) int /*long*/ XIOErrorProcFunc (void* xDisplay) {
|
|
856 Device device = findDevice (xDisplay);
|
|
857 if (device !is null) {
|
|
858 if (DEBUG || device.debugging) {
|
|
859 foreach( msg; (new Exception ("")).info ){
|
|
860 getDwtLogger().error( __FILE__, __LINE__, "trc {}", msg );
|
|
861 }
|
|
862 }
|
|
863 } else {
|
|
864 if (DEBUG) {
|
|
865 foreach( msg; (new Exception ("")).info ){
|
|
866 getDwtLogger().error( __FILE__, __LINE__, "{}", msg );
|
|
867 }
|
|
868 }
|
|
869 }
|
|
870 //PORTING_FIXME ??
|
|
871 //OS.Call (XIOErrorProc, xDisplay, 0);
|
|
872 return 0;
|
|
873 }
|
|
874
|
|
875 }
|