Mercurial > projects > dwt-win
annotate dwt/graphics/Device.d @ 212:ab60f3309436
reverted the char[] to String and use the an alias.
| author | Frank Benoit <benoit@tionex.de> |
|---|---|
| date | Mon, 05 May 2008 00:12:38 +0200 |
| parents | 184ab53b7785 |
| children | 36f5cb12e1a2 |
| rev | line source |
|---|---|
| 18 | 1 /******************************************************************************* |
| 14 | 2 * Copyright (c) 2000, 2007 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 | |
| 23 | 10 * Port to the D programming language: |
| 11 * Frank Benoit <benoit@tionex.de> | |
| 14 | 12 *******************************************************************************/ |
| 13 module dwt.graphics.Device; | |
| 14 | |
| 15 import dwt.DWT; | |
| 16 import dwt.DWTException; | |
| 17 import dwt.internal.gdip.Gdip; | |
| 18 import dwt.internal.win32.OS; | |
| 19 | 19 |
| 20 import dwt.graphics.Drawable; | |
| 21 import dwt.graphics.DeviceData; | |
| 22 import dwt.graphics.Rectangle; | |
| 23 import dwt.graphics.FontData; | |
| 24 import dwt.graphics.Font; | |
| 25 import dwt.graphics.GCData; | |
| 26 import dwt.graphics.Color; | |
| 27 | |
| 28 import dwt.dwthelper.Runnable; | |
| 29 import dwt.dwthelper.System; | |
| 30 import dwt.dwthelper.utils; | |
| 31 import tango.core.Exception; | |
| 14 | 32 |
| 33 /** | |
| 34 * This class is the abstract superclass of all device objects, | |
| 35 * such as the Display device and the Printer device. Devices | |
| 36 * can have a graphics context (GC) created for them, and they | |
| 37 * can be drawn on by sending messages to the associated GC. | |
| 38 */ | |
| 19 | 39 public abstract class Device : Drawable { |
| 40 | |
| 41 private struct CallbackData { | |
| 42 Device device; | |
| 43 bool scalable; | |
| 44 } | |
| 18 | 45 |
| 14 | 46 /* Debugging */ |
|
174
f906dbcacee5
Minor changes to be more compatible to dwt-linux, formatting in toString, Display.DEBUG=true
Frank Benoit <benoit@tionex.de>
parents:
117
diff
changeset
|
47 public static bool DEBUG = true; |
| 19 | 48 bool debug_; |
| 49 bool tracking; | |
|
57
41dbc4d9faab
Update to tango trunk -r3152. Thanks DavidLeon for the adjustment of TracedException to Exception and creating the patch.
Frank Benoit <benoit@tionex.de>
parents:
53
diff
changeset
|
50 Exception [] errors; |
| 14 | 51 Object [] objects; |
| 18 | 52 |
| 14 | 53 /** |
| 18 | 54 * Palette |
| 14 | 55 * (Warning: This field is platform dependent) |
| 56 * <p> | |
| 57 * <b>IMPORTANT:</b> This field is <em>not</em> part of the DWT | |
| 58 * public API. It is marked public only so that it can be shared | |
| 59 * within the packages provided by DWT. It is not available on all | |
| 60 * platforms and should never be accessed from application code. | |
| 61 * </p> | |
| 62 */ | |
| 19 | 63 public HPALETTE hPalette; |
| 14 | 64 int [] colorRefCount; |
| 18 | 65 |
| 14 | 66 /* System Font */ |
| 19 | 67 HFONT systemFont; |
| 14 | 68 |
| 69 /* Font Enumeration */ | |
| 70 int nFonts = 256; | |
| 19 | 71 LOGFONT* [] logFonts; |
| 14 | 72 TEXTMETRIC metrics; |
| 73 int[] pixels; | |
| 74 | |
| 75 /* Scripts */ | |
| 19 | 76 SCRIPT_PROPERTIES*[] scripts; |
| 14 | 77 |
| 78 /* Advanced Graphics */ | |
|
53
0405e18fec7f
Gdiplus implemented - test build of dwt.lib successful; updated graphics package as necessary
John Reimer <terminal.node@gmail.com
parents:
23
diff
changeset
|
79 ULONG_PTR gdipToken; |
| 14 | 80 |
| 81 bool disposed; | |
| 18 | 82 |
| 14 | 83 /* |
| 84 * TEMPORARY CODE. When a graphics object is | |
| 85 * created and the device parameter is null, | |
| 86 * the current Display is used. This presents | |
| 87 * a problem because DWT graphics does not | |
| 88 * reference classes in DWT widgets. The correct | |
| 89 * fix is to remove this feature. Unfortunately, | |
| 90 * too many application programs rely on this | |
| 91 * feature. | |
| 92 * | |
| 93 * This code will be removed in the future. | |
| 94 */ | |
| 95 protected static Device CurrentDevice; | |
| 96 protected static Runnable DeviceFinder; | |
| 19 | 97 |
| 14 | 98 |
| 99 /* | |
| 100 * TEMPORARY CODE. | |
| 101 */ | |
| 102 static synchronized Device getDevice () { | |
| 103 if (DeviceFinder !is null) DeviceFinder.run(); | |
| 18 | 104 Device device = CurrentDevice; |
| 14 | 105 CurrentDevice = null; |
| 106 return device; | |
| 107 } | |
| 108 | |
| 109 /** | |
| 110 * Constructs a new instance of this class. | |
| 111 * <p> | |
| 18 | 112 * You must dispose the device when it is no longer required. |
| 14 | 113 * </p> |
| 114 * | |
| 115 * @see #create | |
| 116 * @see #init | |
| 18 | 117 * |
| 14 | 118 * @since 3.1 |
| 119 */ | |
| 19 | 120 public this() { |
| 14 | 121 this(null); |
| 122 } | |
| 123 | |
| 124 /** | |
| 125 * Constructs a new instance of this class. | |
| 126 * <p> | |
| 18 | 127 * You must dispose the device when it is no longer required. |
| 14 | 128 * </p> |
| 129 * | |
| 130 * @param data the DeviceData which describes the receiver | |
| 131 * | |
| 132 * @see #create | |
| 133 * @see #init | |
| 134 * @see DeviceData | |
| 135 */ | |
| 19 | 136 public this(DeviceData data) { |
| 137 synchronized (this.classinfo) { | |
| 138 debug_ = DEBUG; | |
| 139 tracking = DEBUG; | |
| 14 | 140 if (data !is null) { |
| 19 | 141 debug_ = data.debug_; |
| 14 | 142 tracking = data.tracking; |
| 143 } | |
| 144 create (data); | |
|
197
184ab53b7785
Changes and fixes for jface
Frank Benoit <benoit@tionex.de>
parents:
174
diff
changeset
|
145 init_ (); |
| 14 | 146 if (tracking) { |
|
57
41dbc4d9faab
Update to tango trunk -r3152. Thanks DavidLeon for the adjustment of TracedException to Exception and creating the patch.
Frank Benoit <benoit@tionex.de>
parents:
53
diff
changeset
|
147 errors = new Exception [128]; |
| 14 | 148 objects = new Object [128]; |
| 149 } | |
| 18 | 150 |
| 14 | 151 /* Initialize the system font slot */ |
| 152 systemFont = getSystemFont().handle; | |
|
53
0405e18fec7f
Gdiplus implemented - test build of dwt.lib successful; updated graphics package as necessary
John Reimer <terminal.node@gmail.com
parents:
23
diff
changeset
|
153 gdipToken = 0; |
| 14 | 154 } |
| 155 } | |
| 156 | |
| 157 /** | |
| 158 * Throws an <code>DWTException</code> if the receiver can not | |
| 159 * be accessed by the caller. This may include both checks on | |
| 160 * the state of the receiver and more generally on the entire | |
| 161 * execution context. This method <em>should</em> be called by | |
| 162 * device implementors to enforce the standard DWT invariants. | |
| 163 * <p> | |
| 164 * Currently, it is an error to invoke any method (other than | |
| 165 * <code>isDisposed()</code> and <code>dispose()</code>) on a | |
| 166 * device that has had its <code>dispose()</code> method called. | |
| 167 * </p><p> | |
| 168 * In future releases of DWT, there may be more or fewer error | |
| 169 * checks and exceptions may be thrown for different reasons. | |
| 170 * <p> | |
| 171 * | |
| 172 * @exception DWTException <ul> | |
| 173 * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> | |
| 174 * </ul> | |
| 175 */ | |
| 176 protected void checkDevice () { | |
| 177 if (disposed) DWT.error(DWT.ERROR_DEVICE_DISPOSED); | |
| 178 } | |
| 179 | |
| 180 void checkGDIP() { | |
|
53
0405e18fec7f
Gdiplus implemented - test build of dwt.lib successful; updated graphics package as necessary
John Reimer <terminal.node@gmail.com
parents:
23
diff
changeset
|
181 if (gdipToken) return; |
| 117 | 182 static if (OS.IsWinCE) DWT.error(DWT.ERROR_NOT_IMPLEMENTED); |
| 14 | 183 int oldErrorMode = OS.SetErrorMode (OS.SEM_FAILCRITICALERRORS); |
| 184 try { | |
|
53
0405e18fec7f
Gdiplus implemented - test build of dwt.lib successful; updated graphics package as necessary
John Reimer <terminal.node@gmail.com
parents:
23
diff
changeset
|
185 ULONG_PTR token; |
| 19 | 186 GdiplusStartupInput input; |
| 14 | 187 input.GdiplusVersion = 1; |
|
53
0405e18fec7f
Gdiplus implemented - test build of dwt.lib successful; updated graphics package as necessary
John Reimer <terminal.node@gmail.com
parents:
23
diff
changeset
|
188 if (Gdip.GdiplusStartup ( &token, &input, null ) is 0) { |
| 14 | 189 gdipToken = token; |
| 190 } | |
|
57
41dbc4d9faab
Update to tango trunk -r3152. Thanks DavidLeon for the adjustment of TracedException to Exception and creating the patch.
Frank Benoit <benoit@tionex.de>
parents:
53
diff
changeset
|
191 } catch (Exception t) { |
| 14 | 192 DWT.error (DWT.ERROR_NO_GRAPHICS_LIBRARY, t, " [GDI+ is required]"); //$NON-NLS-1$ |
| 193 } finally { | |
| 194 OS.SetErrorMode (oldErrorMode); | |
| 195 } | |
| 196 } | |
| 197 | |
| 198 /** | |
| 199 * Creates the device in the operating system. If the device | |
| 200 * does not have a handle, this method may do nothing depending | |
| 201 * on the device. | |
| 202 * <p> | |
| 203 * This method is called before <code>init</code>. | |
| 204 * </p><p> | |
| 205 * Subclasses are supposed to reimplement this method and not | |
| 206 * call the <code>super</code> implementation. | |
| 207 * </p> | |
| 208 * | |
| 209 * @param data the DeviceData which describes the receiver | |
| 210 * | |
| 211 * @see #init | |
| 212 */ | |
| 213 protected void create (DeviceData data) { | |
| 214 } | |
| 215 | |
| 216 int computePixels(float height) { | |
| 19 | 217 auto hDC = internal_new_GC (null); |
| 218 int pixels = -cast(int)(0.5f + (height * OS.GetDeviceCaps(hDC, OS.LOGPIXELSY) / 72f)); | |
| 14 | 219 internal_dispose_GC (hDC, null); |
| 220 return pixels; | |
| 221 } | |
| 222 | |
| 19 | 223 float computePoints(LOGFONT* logFont, HFONT hFont) { |
| 224 auto hDC = internal_new_GC (null); | |
| 14 | 225 int logPixelsY = OS.GetDeviceCaps(hDC, OS.LOGPIXELSY); |
| 18 | 226 int pixels = 0; |
| 14 | 227 if (logFont.lfHeight > 0) { |
| 228 /* | |
| 229 * Feature in Windows. If the lfHeight of the LOGFONT structure | |
| 230 * is positive, the lfHeight measures the height of the entire | |
| 231 * cell, including internal leading, in logical units. Since the | |
| 232 * height of a font in points does not include the internal leading, | |
| 233 * we must subtract the internal leading, which requires a TEXTMETRIC. | |
| 234 */ | |
| 19 | 235 auto oldFont = OS.SelectObject(hDC, hFont); |
| 236 TEXTMETRIC* lptm = new TEXTMETRIC(); | |
| 14 | 237 OS.GetTextMetrics(hDC, lptm); |
| 238 OS.SelectObject(hDC, oldFont); | |
| 239 pixels = logFont.lfHeight - lptm.tmInternalLeading; | |
| 240 } else { | |
| 241 pixels = -logFont.lfHeight; | |
| 242 } | |
| 243 internal_dispose_GC (hDC, null); | |
| 244 return pixels * 72f / logPixelsY; | |
| 245 } | |
| 246 | |
| 247 /** | |
| 248 * Destroys the device in the operating system and releases | |
| 249 * the device's handle. If the device does not have a handle, | |
| 250 * this method may do nothing depending on the device. | |
| 251 * <p> | |
| 252 * This method is called after <code>release</code>. | |
| 253 * </p><p> | |
| 254 * Subclasses are supposed to reimplement this method and not | |
| 255 * call the <code>super</code> implementation. | |
| 256 * </p> | |
| 257 * | |
| 258 * @see #dispose | |
| 259 * @see #release | |
| 260 */ | |
| 261 protected void destroy () { | |
| 262 } | |
| 263 | |
| 264 /** | |
| 265 * Disposes of the operating system resources associated with | |
| 266 * the receiver. After this method has been invoked, the receiver | |
| 267 * will answer <code>true</code> when sent the message | |
| 268 * <code>isDisposed()</code>. | |
| 269 * | |
| 270 * @see #release | |
| 271 * @see #destroy | |
| 272 * @see #checkDevice | |
| 273 */ | |
| 274 public void dispose () { | |
| 275 if (isDisposed()) return; | |
| 276 checkDevice (); | |
| 277 release (); | |
| 278 destroy (); | |
| 279 disposed = true; | |
| 280 if (tracking) { | |
| 281 objects = null; | |
| 282 errors = null; | |
| 283 } | |
| 284 } | |
| 285 | |
| 286 void dispose_Object (Object object) { | |
| 287 for (int i=0; i<objects.length; i++) { | |
| 288 if (objects [i] is object) { | |
| 289 objects [i] = null; | |
| 290 errors [i] = null; | |
| 291 return; | |
| 292 } | |
| 293 } | |
| 294 } | |
| 295 | |
| 19 | 296 static extern(Windows) int EnumFontFamFunc (ENUMLOGFONT* lpelfe, NEWTEXTMETRIC* lpntme, int FontType, int lParam) { |
| 297 auto cbdata = cast(CallbackData*)lParam; | |
| 298 return cbdata.device.EnumFontFamProc( lpelfe, lpntme, FontType, cbdata.scalable ); | |
| 299 } | |
| 300 | |
| 301 int EnumFontFamProc (ENUMLOGFONT* lpelfe, NEWTEXTMETRIC* lpntme, DWORD FontType, bool scalable) { | |
| 14 | 302 bool isScalable = (FontType & OS.RASTER_FONTTYPE) is 0; |
| 303 if (isScalable is scalable) { | |
| 304 /* Add the log font to the list of log fonts */ | |
| 305 if (nFonts is logFonts.length) { | |
| 19 | 306 LOGFONT* [] newLogFonts = new LOGFONT* [logFonts.length + 128]; |
| 307 SimpleType!(LOGFONT*).arraycopy (logFonts, 0, newLogFonts, 0, nFonts); | |
| 14 | 308 logFonts = newLogFonts; |
| 309 int[] newPixels = new int[newLogFonts.length]; | |
| 310 System.arraycopy (pixels, 0, newPixels, 0, nFonts); | |
| 311 pixels = newPixels; | |
| 312 } | |
| 19 | 313 LOGFONT* logFont = logFonts [nFonts]; |
| 314 if (logFont is null) logFont = new LOGFONT (); | |
| 315 *logFont = *cast(LOGFONT*)lpelfe; | |
| 14 | 316 logFonts [nFonts] = logFont; |
| 317 if (logFont.lfHeight > 0) { | |
| 318 /* | |
| 319 * Feature in Windows. If the lfHeight of the LOGFONT structure | |
| 320 * is positive, the lfHeight measures the height of the entire | |
| 321 * cell, including internal leading, in logical units. Since the | |
| 322 * height of a font in points does not include the internal leading, | |
| 323 * we must subtract the internal leading, which requires a TEXTMETRIC, | |
| 324 * which in turn requires font creation. | |
| 325 */ | |
| 19 | 326 metrics = *cast(TEXTMETRIC*)lpntme; |
| 14 | 327 pixels[nFonts] = logFont.lfHeight - metrics.tmInternalLeading; |
| 328 } else { | |
| 329 pixels[nFonts] = -logFont.lfHeight; | |
| 330 } | |
| 331 nFonts++; | |
| 332 } | |
| 333 return 1; | |
| 334 } | |
| 335 | |
| 336 /** | |
| 337 * Returns a rectangle describing the receiver's size and location. | |
| 338 * | |
| 339 * @return the bounding rectangle | |
| 340 * | |
| 341 * @exception DWTException <ul> | |
| 342 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> | |
| 343 * </ul> | |
| 344 */ | |
| 345 public Rectangle getBounds () { | |
| 346 checkDevice (); | |
| 19 | 347 auto hDC = internal_new_GC (null); |
| 14 | 348 int width = OS.GetDeviceCaps (hDC, OS.HORZRES); |
| 349 int height = OS.GetDeviceCaps (hDC, OS.VERTRES); | |
| 350 internal_dispose_GC (hDC, null); | |
| 351 return new Rectangle (0, 0, width, height); | |
| 352 } | |
| 353 | |
| 354 /** | |
| 355 * Returns a <code>DeviceData</code> based on the receiver. | |
| 356 * Modifications made to this <code>DeviceData</code> will not | |
| 357 * affect the receiver. | |
| 358 * | |
| 359 * @return a <code>DeviceData</code> containing the device's data and attributes | |
| 360 * | |
| 361 * @exception DWTException <ul> | |
| 362 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> | |
| 363 * </ul> | |
| 364 * | |
| 365 * @see DeviceData | |
| 366 */ | |
| 367 public DeviceData getDeviceData () { | |
| 368 checkDevice(); | |
| 369 DeviceData data = new DeviceData (); | |
| 19 | 370 data.debug_ = debug_; |
| 14 | 371 data.tracking = tracking; |
| 372 int count = 0, length = 0; | |
| 373 if (tracking) length = objects.length; | |
| 374 for (int i=0; i<length; i++) { | |
| 375 if (objects [i] !is null) count++; | |
| 376 } | |
| 377 int index = 0; | |
| 378 data.objects = new Object [count]; | |
|
57
41dbc4d9faab
Update to tango trunk -r3152. Thanks DavidLeon for the adjustment of TracedException to Exception and creating the patch.
Frank Benoit <benoit@tionex.de>
parents:
53
diff
changeset
|
379 data.errors = new Exception [count]; |
| 14 | 380 for (int i=0; i<length; i++) { |
| 381 if (objects [i] !is null) { | |
| 382 data.objects [index] = objects [i]; | |
| 383 data.errors [index] = errors [i]; | |
| 384 index++; | |
| 385 } | |
| 386 } | |
| 387 return data; | |
| 388 } | |
| 389 | |
| 390 /** | |
| 391 * Returns a rectangle which describes the area of the | |
| 392 * receiver which is capable of displaying data. | |
| 18 | 393 * |
| 14 | 394 * @return the client area |
| 395 * | |
| 396 * @exception DWTException <ul> | |
| 397 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> | |
| 398 * </ul> | |
| 399 * | |
| 400 * @see #getBounds | |
| 401 */ | |
| 402 public Rectangle getClientArea () { | |
| 403 return getBounds (); | |
| 404 } | |
| 405 | |
| 406 /** | |
| 407 * Returns the bit depth of the screen, which is the number of | |
| 408 * bits it takes to represent the number of unique colors that | |
| 18 | 409 * the screen is currently capable of displaying. This number |
| 14 | 410 * will typically be one of 1, 8, 15, 16, 24 or 32. |
| 411 * | |
| 412 * @return the depth of the screen | |
| 413 * | |
| 414 * @exception DWTException <ul> | |
| 415 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> | |
| 416 * </ul> | |
| 417 */ | |
| 418 public int getDepth () { | |
| 419 checkDevice (); | |
| 19 | 420 auto hDC = internal_new_GC (null); |
| 14 | 421 int bits = OS.GetDeviceCaps (hDC, OS.BITSPIXEL); |
| 422 int planes = OS.GetDeviceCaps (hDC, OS.PLANES); | |
| 423 internal_dispose_GC (hDC, null); | |
| 424 return bits * planes; | |
| 425 } | |
| 426 | |
| 427 /** | |
| 428 * Returns a point whose x coordinate is the horizontal | |
| 429 * dots per inch of the display, and whose y coordinate | |
| 430 * is the vertical dots per inch of the display. | |
| 431 * | |
| 432 * @return the horizontal and vertical DPI | |
| 433 * | |
| 434 * @exception DWTException <ul> | |
| 435 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> | |
| 436 * </ul> | |
| 437 */ | |
| 438 public Point getDPI () { | |
| 439 checkDevice (); | |
| 19 | 440 auto hDC = internal_new_GC (null); |
| 14 | 441 int dpiX = OS.GetDeviceCaps (hDC, OS.LOGPIXELSX); |
| 442 int dpiY = OS.GetDeviceCaps (hDC, OS.LOGPIXELSY); | |
| 443 internal_dispose_GC (hDC, null); | |
| 444 return new Point (dpiX, dpiY); | |
| 445 } | |
| 446 | |
| 447 /** | |
| 448 * Returns <code>FontData</code> objects which describe | |
| 449 * the fonts that match the given arguments. If the | |
| 450 * <code>faceName</code> is null, all fonts will be returned. | |
| 451 * | |
| 452 * @param faceName the name of the font to look for, or null | |
| 453 * @param scalable if true only scalable fonts are returned, otherwise only non-scalable fonts are returned. | |
| 454 * @return the matching font data | |
| 455 * | |
| 456 * @exception DWTException <ul> | |
| 457 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> | |
| 458 * </ul> | |
| 459 */ | |
|
212
ab60f3309436
reverted the char[] to String and use the an alias.
Frank Benoit <benoit@tionex.de>
parents:
197
diff
changeset
|
460 public FontData [] getFontList (String faceName, bool scalable) { |
| 14 | 461 checkDevice (); |
| 18 | 462 |
| 14 | 463 /* Create the callback */ |
| 19 | 464 CallbackData cbdata; |
| 465 cbdata.device = this; | |
| 18 | 466 |
| 14 | 467 /* Initialize the instance variables */ |
| 19 | 468 metrics = TEXTMETRIC.init; |
| 14 | 469 pixels = new int[nFonts]; |
| 19 | 470 logFonts = new LOGFONT* [nFonts]; |
| 14 | 471 for (int i=0; i<logFonts.length; i++) { |
| 19 | 472 logFonts [i] = new LOGFONT(); |
| 14 | 473 } |
| 474 nFonts = 0; | |
| 475 | |
| 476 /* Enumerate */ | |
| 477 int offset = 0; | |
| 19 | 478 auto hDC = internal_new_GC (null); |
| 18 | 479 if (faceName is null) { |
| 14 | 480 /* The user did not specify a face name, so they want all versions of all available face names */ |
| 19 | 481 cbdata.scalable = scalable; |
| 482 OS.EnumFontFamilies (hDC, null, &EnumFontFamFunc, cast(int)&cbdata ); | |
| 18 | 483 |
| 14 | 484 /** |
| 485 * For bitmapped fonts, EnumFontFamilies only enumerates once for each font, regardless | |
| 486 * of how many styles are available. If the user wants bitmapped fonts, enumerate on | |
| 487 * each face name now. | |
| 488 */ | |
| 489 offset = nFonts; | |
| 490 for (int i=0; i<offset; i++) { | |
| 19 | 491 LOGFONT* lf = logFonts [i]; |
| 14 | 492 /** |
| 493 * Bug in Windows 98. When EnumFontFamiliesEx is called with a specified face name, it | |
| 494 * should enumerate for each available style of that font. Instead, it only enumerates | |
| 495 * once. The fix is to call EnumFontFamilies, which works as expected. | |
| 496 */ | |
| 19 | 497 cbdata.scalable = scalable; |
|
84
00a333240696
FileDialog, sync dwthelper with dwt-linux, some TCHAR issues
Frank Benoit <benoit@tionex.de>
parents:
81
diff
changeset
|
498 static if (OS.IsUnicode) { |
| 19 | 499 OS.EnumFontFamiliesW (hDC, (cast(LOGFONTW*)lf).lfFaceName.ptr, &EnumFontFamFunc, cast(int)&cbdata); |
| 14 | 500 } else { |
| 19 | 501 OS.EnumFontFamiliesA (hDC, (cast(LOGFONTA*)lf).lfFaceName.ptr, &EnumFontFamFunc, cast(int)&cbdata); |
| 14 | 502 } |
| 503 } | |
| 504 } else { | |
| 505 /* Use the character encoding for the default locale */ | |
| 506 /** | |
| 507 * Bug in Windows 98. When EnumFontFamiliesEx is called with a specified face name, it | |
| 508 * should enumerate for each available style of that font. Instead, it only enumerates | |
| 509 * once. The fix is to call EnumFontFamilies, which works as expected. | |
| 510 */ | |
| 19 | 511 cbdata.scalable = scalable; |
| 512 OS.EnumFontFamilies (hDC, .StrToTCHARz(faceName), &EnumFontFamFunc, cast(int)&cbdata); | |
| 14 | 513 } |
| 514 int logPixelsY = OS.GetDeviceCaps(hDC, OS.LOGPIXELSY); | |
| 515 internal_dispose_GC (hDC, null); | |
| 516 | |
| 517 /* Create the fontData from the logfonts */ | |
| 518 int count = 0; | |
| 519 FontData [] result = new FontData [nFonts - offset]; | |
| 520 for (int i=offset; i<nFonts; i++) { | |
| 521 FontData fd = FontData.win32_new (logFonts [i], pixels [i] * 72f / logPixelsY); | |
| 522 int j; | |
| 523 for (j = 0; j < count; j++) { | |
| 19 | 524 if (fd == result [j]) break; |
| 14 | 525 } |
| 526 if (j is count) result [count++] = fd; | |
| 527 } | |
| 528 if (count !is result.length) { | |
| 529 FontData [] newResult = new FontData [count]; | |
| 530 System.arraycopy (result, 0, newResult, 0, count); | |
| 531 result = newResult; | |
| 532 } | |
| 18 | 533 |
| 14 | 534 /* Clean up */ |
| 535 logFonts = null; | |
| 536 pixels = null; | |
| 19 | 537 metrics = TEXTMETRIC.init; |
| 14 | 538 return result; |
| 539 } | |
| 540 | |
|
212
ab60f3309436
reverted the char[] to String and use the an alias.
Frank Benoit <benoit@tionex.de>
parents:
197
diff
changeset
|
541 String getLastError () { |
| 14 | 542 int error = OS.GetLastError(); |
| 543 if (error is 0) return ""; //$NON-NLS-1$ | |
| 19 | 544 return " [GetLastError=0x" ~ .toHex(error) ~ "]"; //$NON-NLS-1$ //$NON-NLS-2$ |
| 14 | 545 } |
| 546 | |
|
212
ab60f3309436
reverted the char[] to String and use the an alias.
Frank Benoit <benoit@tionex.de>
parents:
197
diff
changeset
|
547 String getLastErrorText () { |
| 14 | 548 int error = OS.GetLastError(); |
| 549 if (error is 0) return ""; //$NON-NLS-1$ | |
| 19 | 550 TCHAR* buffer = null; |
| 14 | 551 int dwFlags = OS.FORMAT_MESSAGE_ALLOCATE_BUFFER | OS.FORMAT_MESSAGE_FROM_SYSTEM | OS.FORMAT_MESSAGE_IGNORE_INSERTS; |
| 19 | 552 int length = OS.FormatMessage(dwFlags, null, error, OS.LANG_USER_DEFAULT, cast(TCHAR*)&buffer, 0, null); |
|
212
ab60f3309436
reverted the char[] to String and use the an alias.
Frank Benoit <benoit@tionex.de>
parents:
197
diff
changeset
|
553 String errorNum = ("[GetLastError=") ~ .toHex(error) ~ "] "; |
| 19 | 554 if (length == 0) return errorNum; |
|
212
ab60f3309436
reverted the char[] to String and use the an alias.
Frank Benoit <benoit@tionex.de>
parents:
197
diff
changeset
|
555 String buffer1 = .TCHARzToStr(buffer, length); |
| 19 | 556 if ( *buffer != 0) |
| 557 OS.LocalFree(cast(HLOCAL)buffer); | |
| 558 return errorNum ~ buffer1; | |
| 14 | 559 } |
| 560 | |
| 561 /** | |
| 562 * Returns the matching standard color for the given | |
| 563 * constant, which should be one of the color constants | |
| 564 * specified in class <code>DWT</code>. Any value other | |
| 565 * than one of the DWT color constants which is passed | |
| 566 * in will result in the color black. This color should | |
| 567 * not be freed because it was allocated by the system, | |
| 568 * not the application. | |
| 569 * | |
| 570 * @param id the color constant | |
| 571 * @return the matching color | |
| 572 * | |
| 573 * @exception DWTException <ul> | |
| 574 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> | |
| 575 * </ul> | |
| 576 * | |
| 577 * @see DWT | |
| 578 */ | |
| 579 public Color getSystemColor (int id) { | |
| 580 checkDevice (); | |
| 581 int pixel = 0x00000000; | |
| 582 switch (id) { | |
| 583 case DWT.COLOR_WHITE: pixel = 0x00FFFFFF; break; | |
| 584 case DWT.COLOR_BLACK: pixel = 0x00000000; break; | |
| 585 case DWT.COLOR_RED: pixel = 0x000000FF; break; | |
| 586 case DWT.COLOR_DARK_RED: pixel = 0x00000080; break; | |
| 587 case DWT.COLOR_GREEN: pixel = 0x0000FF00; break; | |
| 588 case DWT.COLOR_DARK_GREEN: pixel = 0x00008000; break; | |
| 589 case DWT.COLOR_YELLOW: pixel = 0x0000FFFF; break; | |
| 590 case DWT.COLOR_DARK_YELLOW: pixel = 0x00008080; break; | |
| 591 case DWT.COLOR_BLUE: pixel = 0x00FF0000; break; | |
| 592 case DWT.COLOR_DARK_BLUE: pixel = 0x00800000; break; | |
| 593 case DWT.COLOR_MAGENTA: pixel = 0x00FF00FF; break; | |
| 594 case DWT.COLOR_DARK_MAGENTA: pixel = 0x00800080; break; | |
| 595 case DWT.COLOR_CYAN: pixel = 0x00FFFF00; break; | |
| 596 case DWT.COLOR_DARK_CYAN: pixel = 0x00808000; break; | |
| 597 case DWT.COLOR_GRAY: pixel = 0x00C0C0C0; break; | |
| 598 case DWT.COLOR_DARK_GRAY: pixel = 0x00808080; break; | |
| 81 | 599 default: |
| 14 | 600 } |
| 601 return Color.win32_new (this, pixel); | |
| 602 } | |
| 603 | |
| 604 /** | |
| 605 * Returns a reasonable font for applications to use. | |
| 606 * On some platforms, this will match the "default font" | |
| 607 * or "system font" if such can be found. This font | |
| 608 * should not be freed because it was allocated by the | |
| 609 * system, not the application. | |
| 610 * <p> | |
| 611 * Typically, applications which want the default look | |
| 612 * should simply not set the font on the widgets they | |
| 613 * create. Widgets are always created with the correct | |
| 614 * default font for the class of user-interface component | |
| 615 * they represent. | |
| 616 * </p> | |
| 617 * | |
| 618 * @return a font | |
| 619 * | |
| 620 * @exception DWTException <ul> | |
| 621 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> | |
| 622 * </ul> | |
| 623 */ | |
| 624 public Font getSystemFont () { | |
| 625 checkDevice (); | |
| 19 | 626 auto hFont = OS.GetStockObject (OS.SYSTEM_FONT); |
| 14 | 627 return Font.win32_new (this, hFont); |
| 628 } | |
| 629 | |
| 630 /** | |
| 631 * Returns <code>true</code> if the underlying window system prints out | |
| 632 * warning messages on the console, and <code>setWarnings</code> | |
| 633 * had previously been called with <code>true</code>. | |
| 634 * | |
| 635 * @return <code>true</code>if warnings are being handled, and <code>false</code> otherwise | |
| 636 * | |
| 637 * @exception DWTException <ul> | |
| 638 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> | |
| 639 * </ul> | |
| 640 */ | |
| 641 public bool getWarnings () { | |
| 642 checkDevice (); | |
| 643 return false; | |
| 644 } | |
| 645 | |
| 646 /** | |
| 647 * Initializes any internal resources needed by the | |
| 648 * device. | |
| 649 * <p> | |
| 650 * This method is called after <code>create</code>. | |
| 651 * </p><p> | |
| 652 * If subclasses reimplement this method, they must | |
| 653 * call the <code>super</code> implementation. | |
| 654 * </p> | |
| 18 | 655 * |
| 14 | 656 * @see #create |
| 657 */ | |
|
197
184ab53b7785
Changes and fixes for jface
Frank Benoit <benoit@tionex.de>
parents:
174
diff
changeset
|
658 protected void init_ () { |
| 19 | 659 if (debug_) { |
| 117 | 660 static if (!OS.IsWinCE) OS.GdiSetBatchLimit(1); |
| 14 | 661 } |
| 662 | |
| 663 /* Initialize scripts list */ | |
| 117 | 664 static if (!OS.IsWinCE) { |
| 19 | 665 SCRIPT_PROPERTIES** ppSp; |
| 666 int piNumScripts; | |
| 667 OS.ScriptGetProperties (&ppSp, &piNumScripts); | |
| 668 scripts = ppSp[ 0 .. piNumScripts ].dup; | |
| 14 | 669 } |
| 18 | 670 |
| 14 | 671 /* |
| 672 * If we're not on a device which supports palettes, | |
| 673 * don't create one. | |
| 674 */ | |
| 19 | 675 auto hDC = internal_new_GC (null); |
| 14 | 676 int rc = OS.GetDeviceCaps (hDC, OS.RASTERCAPS); |
| 677 int bits = OS.GetDeviceCaps (hDC, OS.BITSPIXEL); | |
| 678 int planes = OS.GetDeviceCaps (hDC, OS.PLANES); | |
| 18 | 679 |
| 14 | 680 bits *= planes; |
| 681 if ((rc & OS.RC_PALETTE) is 0 || bits !is 8) { | |
| 682 internal_dispose_GC (hDC, null); | |
| 683 return; | |
| 684 } | |
| 18 | 685 |
| 14 | 686 int numReserved = OS.GetDeviceCaps (hDC, OS.NUMRESERVED); |
| 687 int numEntries = OS.GetDeviceCaps (hDC, OS.SIZEPALETTE); | |
| 688 | |
| 117 | 689 static if (OS.IsWinCE) { |
| 14 | 690 /* |
| 691 * Feature on WinCE. For some reason, certain 8 bit WinCE | |
| 692 * devices return 0 for the number of reserved entries in | |
| 693 * the system palette. Their system palette correctly contains | |
| 694 * the usual 20 system colors. The workaround is to assume | |
| 695 * there are 20 reserved system colors instead of 0. | |
| 696 */ | |
| 697 if (numReserved is 0 && numEntries >= 20) numReserved = 20; | |
| 698 } | |
| 699 | |
| 700 /* Create the palette and reference counter */ | |
| 701 colorRefCount = new int [numEntries]; | |
| 702 | |
| 703 /* 4 bytes header + 4 bytes per entry * numEntries entries */ | |
| 704 byte [] logPalette = new byte [4 + 4 * numEntries]; | |
| 18 | 705 |
| 14 | 706 /* 2 bytes = special header */ |
| 707 logPalette [0] = 0x00; | |
| 708 logPalette [1] = 0x03; | |
| 18 | 709 |
| 14 | 710 /* 2 bytes = number of colors, LSB first */ |
| 711 logPalette [2] = 0; | |
| 712 logPalette [3] = 1; | |
| 713 | |
| 18 | 714 /* |
| 14 | 715 * Create a palette which contains the system entries |
| 716 * as they are located in the system palette. The | |
| 717 * MSDN article 'Memory Device Contexts' describes | |
| 718 * where system entries are located. On an 8 bit | |
| 719 * display with 20 reserved colors, the system colors | |
| 720 * will be the first 10 entries and the last 10 ones. | |
| 721 */ | |
| 722 byte[] lppe = new byte [4 * numEntries]; | |
| 19 | 723 OS.GetSystemPaletteEntries (hDC, 0, numEntries, cast(PALETTEENTRY*)lppe.ptr); |
| 14 | 724 /* Copy all entries from the system palette */ |
| 725 System.arraycopy (lppe, 0, logPalette, 4, 4 * numEntries); | |
| 726 /* Lock the indices corresponding to the system entries */ | |
| 727 for (int i = 0; i < numReserved / 2; i++) { | |
| 728 colorRefCount [i] = 1; | |
| 729 colorRefCount [numEntries - 1 - i] = 1; | |
| 730 } | |
| 731 internal_dispose_GC (hDC, null); | |
| 19 | 732 hPalette = OS.CreatePalette (cast(LOGPALETTE*)logPalette.ptr); |
| 14 | 733 } |
| 18 | 734 /** |
| 14 | 735 * Invokes platform specific functionality to allocate a new GC handle. |
| 736 * <p> | |
| 737 * <b>IMPORTANT:</b> This method is <em>not</em> part of the public | |
| 738 * API for <code>Device</code>. It is marked public only so that it | |
| 739 * can be shared within the packages provided by DWT. It is not | |
| 740 * available on all platforms, and should never be called from | |
| 741 * application code. | |
| 742 * </p> | |
| 743 * | |
| 18 | 744 * @param data the platform specific GC data |
| 14 | 745 * @return the platform specific GC handle |
| 746 */ | |
| 19 | 747 public abstract HDC internal_new_GC (GCData data); |
| 14 | 748 |
| 18 | 749 /** |
| 14 | 750 * Invokes platform specific functionality to dispose a GC handle. |
| 751 * <p> | |
| 752 * <b>IMPORTANT:</b> This method is <em>not</em> part of the public | |
| 753 * API for <code>Device</code>. It is marked public only so that it | |
| 754 * can be shared within the packages provided by DWT. It is not | |
| 755 * available on all platforms, and should never be called from | |
| 756 * application code. | |
| 757 * </p> | |
| 758 * | |
| 759 * @param hDC the platform specific GC handle | |
| 18 | 760 * @param data the platform specific GC data |
| 14 | 761 */ |
| 19 | 762 public abstract void internal_dispose_GC (HDC hDC, GCData data); |
| 14 | 763 |
| 764 /** | |
| 765 * Returns <code>true</code> if the device has been disposed, | |
| 766 * and <code>false</code> otherwise. | |
| 767 * <p> | |
| 768 * This method gets the dispose state for the device. | |
| 769 * When a device has been disposed, it is an error to | |
| 770 * invoke any other method using the device. | |
| 771 * | |
| 772 * @return <code>true</code> when the device is disposed and <code>false</code> otherwise | |
| 773 */ | |
| 774 public bool isDisposed () { | |
| 775 return disposed; | |
| 776 } | |
| 777 | |
| 778 /** | |
| 779 * Loads the font specified by a file. The font will be | |
| 780 * present in the list of fonts available to the application. | |
| 781 * | |
| 782 * @param path the font file path | |
| 783 * @return whether the font was successfully loaded | |
| 784 * | |
| 785 * @exception DWTException <ul> | |
| 786 * <li>ERROR_NULL_ARGUMENT - if path is null</li> | |
| 787 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> | |
| 788 * </ul> | |
| 789 * | |
| 790 * @see Font | |
| 18 | 791 * |
| 14 | 792 * @since 3.3 |
| 793 */ | |
|
212
ab60f3309436
reverted the char[] to String and use the an alias.
Frank Benoit <benoit@tionex.de>
parents:
197
diff
changeset
|
794 public bool loadFont (String path) { |
| 14 | 795 checkDevice(); |
| 796 if (path is null) DWT.error (DWT.ERROR_NULL_ARGUMENT); | |
| 797 if (OS.IsWinNT && OS.WIN32_VERSION >= OS.VERSION (4, 10)) { | |
| 19 | 798 //TCHAR lpszFilename = new TCHAR (0, path, true); |
| 799 return OS.AddFontResourceEx ( .StrToTCHARz(path), OS.FR_PRIVATE, null) !is 0; | |
| 14 | 800 } |
| 801 return false; | |
| 802 } | |
| 803 | |
| 804 void new_Object (Object object) { | |
| 805 for (int i=0; i<objects.length; i++) { | |
| 806 if (objects [i] is null) { | |
| 807 objects [i] = object; | |
|
57
41dbc4d9faab
Update to tango trunk -r3152. Thanks DavidLeon for the adjustment of TracedException to Exception and creating the patch.
Frank Benoit <benoit@tionex.de>
parents:
53
diff
changeset
|
808 errors [i] = new Exception ( "" ); |
| 14 | 809 return; |
| 810 } | |
| 811 } | |
| 812 Object [] newObjects = new Object [objects.length + 128]; | |
| 813 System.arraycopy (objects, 0, newObjects, 0, objects.length); | |
| 814 newObjects [objects.length] = object; | |
| 815 objects = newObjects; | |
|
57
41dbc4d9faab
Update to tango trunk -r3152. Thanks DavidLeon for the adjustment of TracedException to Exception and creating the patch.
Frank Benoit <benoit@tionex.de>
parents:
53
diff
changeset
|
816 Exception [] newErrors = new Exception [errors.length + 128]; |
| 14 | 817 System.arraycopy (errors, 0, newErrors, 0, errors.length); |
|
57
41dbc4d9faab
Update to tango trunk -r3152. Thanks DavidLeon for the adjustment of TracedException to Exception and creating the patch.
Frank Benoit <benoit@tionex.de>
parents:
53
diff
changeset
|
818 newErrors [errors.length] = new Exception (""); |
| 14 | 819 errors = newErrors; |
| 820 } | |
| 821 | |
| 822 /** | |
| 823 * Releases any internal resources back to the operating | |
| 824 * system and clears all fields except the device handle. | |
| 825 * <p> | |
| 826 * When a device is destroyed, resources that were acquired | |
| 827 * on behalf of the programmer need to be returned to the | |
| 828 * operating system. For example, if the device allocated a | |
| 829 * font to be used as the system font, this font would be | |
| 830 * freed in <code>release</code>. Also,to assist the garbage | |
| 831 * collector and minimize the amount of memory that is not | |
| 832 * reclaimed when the programmer keeps a reference to a | |
| 833 * disposed device, all fields except the handle are zero'd. | |
| 834 * The handle is needed by <code>destroy</code>. | |
| 835 * </p> | |
| 836 * This method is called before <code>destroy</code>. | |
| 837 * </p><p> | |
| 838 * If subclasses reimplement this method, they must | |
| 839 * call the <code>super</code> implementation. | |
| 840 * </p> | |
| 841 * | |
| 842 * @see #dispose | |
| 843 * @see #destroy | |
| 844 */ | |
| 845 protected void release () { | |
|
53
0405e18fec7f
Gdiplus implemented - test build of dwt.lib successful; updated graphics package as necessary
John Reimer <terminal.node@gmail.com
parents:
23
diff
changeset
|
846 if (gdipToken) { |
|
0405e18fec7f
Gdiplus implemented - test build of dwt.lib successful; updated graphics package as necessary
John Reimer <terminal.node@gmail.com
parents:
23
diff
changeset
|
847 Gdip.GdiplusShutdown ( gdipToken ); |
| 14 | 848 } |
|
53
0405e18fec7f
Gdiplus implemented - test build of dwt.lib successful; updated graphics package as necessary
John Reimer <terminal.node@gmail.com
parents:
23
diff
changeset
|
849 gdipToken = 0; // TODO: assignment of 0 might not be valid for token |
| 14 | 850 scripts = null; |
| 19 | 851 if (hPalette !is null) OS.DeleteObject (hPalette); |
| 852 hPalette = null; | |
| 14 | 853 colorRefCount = null; |
| 854 logFonts = null; | |
| 855 nFonts = 0; | |
| 856 } | |
| 857 | |
| 858 /** | |
| 859 * If the underlying window system supports printing warning messages | |
| 860 * to the console, setting warnings to <code>false</code> prevents these | |
| 861 * messages from being printed. If the argument is <code>true</code> then | |
| 862 * message printing is not blocked. | |
| 863 * | |
| 864 * @param warnings <code>true</code>if warnings should be printed, and <code>false</code> otherwise | |
| 865 * | |
| 866 * @exception DWTException <ul> | |
| 867 * <li>ERROR_DEVICE_DISPOSED - if the receiver has been disposed</li> | |
| 868 * </ul> | |
| 869 */ | |
| 870 public void setWarnings (bool warnings) { | |
| 871 checkDevice (); | |
| 872 } | |
| 873 | |
| 874 } | |
| 875 | |
| 876 |