projects/dwt-win: dwt/graphics/GC.d comparison

comparison dwt/graphics/GC.d @ 213:36f5cb12e1a2

Update to SWT 3.4M7

author	Frank Benoit <benoit@tionex.de>
date	Sat, 17 May 2008 17:34:28 +0200
parents	ab60f3309436
children	4436505b216f

comparison

equal deleted inserted replaced

-:ab60f3309436
+:36f5cb12e1a2
 * @see dwt.events.PaintEvent
 */
 public final class GC : Resource {
+alias Resource.init_ init_;
 /**
 * the handle to the OS device context
 * (Warning: This field is platform dependent)
 * <p>
 * <b>IMPORTANT:</b> This field is <em>not</em> part of the DWT
 Device device = data.device;
 if (device is null) device = Device.getDevice();
 if (device is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
 this.device = data.device = device;
 init_ (drawable, data, hDC);
-if (device.tracking) device.new_Object(this);
+init_();
 }
 static int checkStyle(int style) {
 if ((style & DWT.LEFT_TO_RIGHT) !is 0) style &= ~DWT.RIGHT_TO_LEFT;
 return style & (DWT.LEFT_TO_RIGHT | DWT.RIGHT_TO_LEFT);
 }
 }
 default:
 }
 if (dashes !is null) {
-Gdip.Pen_SetDashPattern(pen, dashes, dashes.length);
+Gdip.Pen_SetDashPattern(pen, dashes.ptr, dashes.length);
 Gdip.Pen_SetDashStyle(pen, Gdip.DashStyleCustom);
 Gdip.Pen_SetDashOffset(pen, dashOffset);
 } else {
 Gdip.Pen_SetDashStyle(pen, dashStyle);
 }
 data.gdipBrush = cast(Gdip.Brush)brush;
 data.gdipBgBrush = brush;
 }
 }
 if ((state & FONT) !is 0) {
-OS.SelectObject(handle, data.hFont);
+Font font = data.font;
-auto font = createGdipFont(handle, data.hFont);
+OS.SelectObject(handle, font.handle);
+auto gdipFont = createGdipFont(handle, font.handle);
 if (data.gdipFont !is null) Gdip.Font_delete(data.gdipFont);
-data.gdipFont = font;
+data.gdipFont = gdipFont;
 }
 if ((state & DRAW_OFFSET) !is 0) {
 data.gdipXOffset = data.gdipYOffset = 0;
 auto matrix = Gdip.Matrix_new(1, 0, 0, 1, 0, 0);
-float[6] elements;
+float[2] point; point[0]=1.0; point[1]=1.0;
 Gdip.Graphics_GetTransform(gdipGraphics, matrix);
-Gdip.Matrix_GetElements(matrix, elements );
+Gdip.Matrix_TransformPoints(matrix, cast(Gdip.PointF*)point.ptr, 1);
 Gdip.Matrix_delete(matrix);
-float scaling = elements[0];
+float scaling = point[0];
 if (scaling < 0) scaling = -scaling;
 float penWidth = data.lineWidth * scaling;
 if (penWidth is 0 || (cast(int)penWidth % 2) is 1) {
 data.gdipXOffset = 0.5f / scaling;
 }
-scaling = elements[3];
+scaling = point[1];
 if (scaling < 0) scaling = -scaling;
 penWidth = data.lineWidth * scaling;
 if (penWidth is 0 || (cast(int)penWidth % 2) is 1) {
 data.gdipYOffset = 0.5f / scaling;
 }
 }
 if ((state & FOREGROUND_TEXT) !is 0) {
 OS.SetTextColor(handle, data.foreground);
 }
 if ((state & FONT) !is 0) {
-OS.SelectObject(handle, data.hFont);
+Font font = data.font;
+OS.SelectObject(handle, font.handle);
 }
 }
 /**
 * Copies a rectangular area of the receiver at the specified
 *
 * @exception DWTError <ul>
 *    <li>ERROR_THREAD_INVALID_ACCESS if not called from the thread that created the drawable</li>
 * </ul>
 */
-override public void dispose() {
+void destroy() {
-if (handle is null) return;
+bool gdip = data.gdipGraphics !is null;
-if (data.device.isDisposed()) return;
 disposeGdip();
+if (gdip && (data.style & DWT.MIRRORED) !is 0) {
+OS.SetLayout(handle, OS.GetLayout(handle) | OS.LAYOUT_RTL);
+}
 /* Select stock pen and brush objects and free resources */
 if (data.hPen !is null) {
 OS.SelectObject(handle, OS.GetStockObject(OS.NULL_PEN));
 OS.DeleteObject(data.hPen);
 if (image !is null) image.memGC = null;
 /*
 * Dispose the HDC.
 */
-Device device = data.device;
 if (drawable !is null) drawable.internal_dispose_GC(handle, data);
 drawable = null;
 handle = null;
 data.image = null;
 data.ps = null;
-if (device.tracking) device.dispose_Object(this);
-data.device = null;
 data = null;
 }
 void disposeGdip() {
 if (data.gdipPen !is null) Gdip.Pen_delete(data.gdipPen);
 * @see #drawRectangle(int, int, int, int)
 */
 public void drawFocus (int x, int y, int width, int height) {
 if (handle is null) DWT.error(DWT.ERROR_GRAPHIC_DISPOSED);
 if ((data.uiState & OS.UISF_HIDEFOCUS) !is 0) return;
+data.focusDrawn = true;
 HDC hdc = handle;
 int state = 0;
 auto gdipGraphics = data.gdipGraphics;
 if (gdipGraphics !is null) {
 HRGN clipRgn;
 auto matrix = Gdip.Matrix_new(1, 0, 0, 1, 0, 0);
 if (matrix is null) DWT.error(DWT.ERROR_NO_HANDLES);
 Gdip.Graphics_GetTransform(gdipGraphics, matrix);
 if (!Gdip.Matrix_IsIdentity(matrix)) {
 gotElements = true;
-Gdip.Matrix_GetElements(matrix, lpXform);
+Gdip.Matrix_GetElements(matrix, lpXform.ptr);
 }
 Gdip.Matrix_delete(matrix);
 hdc = Gdip.Graphics_GetHDC(gdipGraphics);
 state = OS.SaveDC(hdc);
-OS.SetBkColor(hdc, data.background);
-OS.SetTextColor(hdc, data.foreground);
 if (gotElements) {
 OS.SetGraphicsMode(hdc, OS.GM_ADVANCED);
 OS.SetWorldTransform(hdc, cast(XFORM*)lpXform.ptr);
 }
 if (clipRgn !is null) {
 OS.SelectClipRgn(hdc, clipRgn);
 OS.DeleteObject(clipRgn);
 }
 }
+OS.SetBkColor(hdc, 0xFFFFFF);
+OS.SetTextColor(hdc, 0x000000);
 RECT rect;
 OS.SetRect(&rect, x, y, x + width, y + height);
 OS.DrawFocusRect(hdc, &rect);
 if (gdipGraphics !is null) {
 OS.RestoreDC(hdc, state);
 Gdip.Graphics_ReleaseHDC(gdipGraphics, hdc);
+} else {
+data.state &= ~(BACKGROUND_TEXT | FOREGROUND_TEXT);
 }
 }
 /**
 * Draws the given image in the receiver at the specified
 }
 void drawImage(Image srcImage, int srcX, int srcY, int srcWidth, int srcHeight, int destX, int destY, int destWidth, int destHeight, bool simple) {
 if (data.gdipGraphics !is null) {
 //TODO - cache bitmap
-int[] gdipImage = srcImage.createGdipImage();
+int /*long*/ [] gdipImage = srcImage.createGdipImage();
 auto img = cast(Gdip.Image) gdipImage[0];
 int imgWidth = Gdip.Image_GetWidth(img);
 int imgHeight = Gdip.Image_GetHeight(img);
 if (simple) {
 srcWidth = destWidth = imgWidth;
 srcColor = srcMask;
 srcColorY += imgHeight;
 }
 auto srcHdc = OS.CreateCompatibleDC(handle);
 auto oldSrcBitmap = OS.SelectObject(srcHdc, srcColor);
-auto destHdc = handle, x = destX, y = destY;
+auto destHdc = handle;
+int x = destX, y = destY;
 HDC tempHdc;
 HBITMAP tempBitmap;
 HBITMAP oldTempBitmap;
 int oldBkColor = 0, oldTextColor = 0;
 if (offscreen) {
 if (pointArray is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
 checkGC(DRAW);
 auto gdipGraphics = data.gdipGraphics;
 if (gdipGraphics !is null) {
 Gdip.Graphics_TranslateTransform(gdipGraphics, data.gdipXOffset, data.gdipYOffset, Gdip.MatrixOrderPrepend);
-Gdip.Graphics_DrawPolygon(gdipGraphics, data.gdipPen, cast(Gdip.Point[])pointArray, pointArray.length/2);
+Gdip.Graphics_DrawPolygon(gdipGraphics, data.gdipPen, cast(Gdip.Point*)pointArray.ptr, pointArray.length/2);
 Gdip.Graphics_TranslateTransform(gdipGraphics, -data.gdipXOffset, -data.gdipYOffset, Gdip.MatrixOrderPrepend);
 return;
 }
 if ((data.style & DWT.MIRRORED) !is 0) {
 if (data.lineWidth !is 0 && data.lineWidth % 2 is 0) {
 if (pointArray is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
 checkGC(DRAW);
 auto gdipGraphics = data.gdipGraphics;
 if (gdipGraphics !is null) {
 Gdip.Graphics_TranslateTransform(gdipGraphics, data.gdipXOffset, data.gdipYOffset, Gdip.MatrixOrderPrepend);
-Gdip.Graphics_DrawLines(gdipGraphics, data.gdipPen, cast(Gdip.Point[])pointArray, pointArray.length / 2);
+Gdip.Graphics_DrawLines(gdipGraphics, data.gdipPen, cast(Gdip.Point*)pointArray.ptr, pointArray.length / 2);
 Gdip.Graphics_TranslateTransform(gdipGraphics, -data.gdipXOffset, -data.gdipYOffset, Gdip.MatrixOrderPrepend);
 return;
 }
 if ((data.style & DWT.MIRRORED) !is 0) {
 if (data.lineWidth !is 0 && data.lineWidth % 2 is 0) {
 public void drawRectangle (int x, int y, int width, int height) {
 if (handle is null) DWT.error(DWT.ERROR_GRAPHIC_DISPOSED);
 checkGC(DRAW);
 auto gdipGraphics = data.gdipGraphics;
 if (gdipGraphics !is null) {
+if (width < 0) {
+x = x + width;
+width = -width;
+}
+if (height < 0) {
+y = y + height;
+height = -height;
+}
 Gdip.Graphics_TranslateTransform(gdipGraphics, data.gdipXOffset, data.gdipYOffset, Gdip.MatrixOrderPrepend);
 Gdip.Graphics_DrawRectangle(gdipGraphics, data.gdipPen, x, y, width, height);
 Gdip.Graphics_TranslateTransform(gdipGraphics, -data.gdipXOffset, -data.gdipYOffset, Gdip.MatrixOrderPrepend);
 return;
 }
 naw = 0 - naw;
 if (nah < 0)
 nah = 0 - nah;
 Gdip.Graphics_TranslateTransform(gdipGraphics, data.gdipXOffset, data.gdipYOffset, Gdip.MatrixOrderPrepend);
-auto path = Gdip.GraphicsPath_new(Gdip.FillModeAlternate);
+if (naw is 0 || nah is 0) {
-if (path is null) DWT.error(DWT.ERROR_NO_HANDLES);
+Gdip.Graphics_DrawRectangle(gdipGraphics, data.gdipPen, x, y, width, height);
-if (nw > naw) {
+} else {
-if (nh > nah) {
+auto path = Gdip.GraphicsPath_new(Gdip.FillModeAlternate);
-Gdip.GraphicsPath_AddArc(path, nx + nw - naw, ny, naw, nah, 0, -90);
+if (path is null) DWT.error(DWT.ERROR_NO_HANDLES);
-Gdip.GraphicsPath_AddArc(path, nx, ny, naw, nah, -90, -90);
+if (nw > naw) {
-Gdip.GraphicsPath_AddArc(path, nx, ny + nh - nah, naw, nah, -180, -90);
+if (nh > nah) {
-Gdip.GraphicsPath_AddArc(path, nx + nw - naw, ny + nh - nah, naw, nah, -270, -90);
+Gdip.GraphicsPath_AddArc(path, nx + nw - naw, ny, naw, nah, 0, -90);
+Gdip.GraphicsPath_AddArc(path, nx, ny, naw, nah, -90, -90);
+Gdip.GraphicsPath_AddArc(path, nx, ny + nh - nah, naw, nah, -180, -90);
+Gdip.GraphicsPath_AddArc(path, nx + nw - naw, ny + nh - nah, naw, nah, -270, -90);
+} else {
+Gdip.GraphicsPath_AddArc(path, nx + nw - naw, ny, naw, nh, -270, -180);
+Gdip.GraphicsPath_AddArc(path, nx, ny, naw, nh, -90, -180);
+}
 } else {
-Gdip.GraphicsPath_AddArc(path, nx + nw - naw, ny, naw, nh, -270, -180);
+if (nh > nah) {
-Gdip.GraphicsPath_AddArc(path, nx, ny, naw, nh, -90, -180);
+Gdip.GraphicsPath_AddArc(path, nx, ny, nw, nah, 0, -180);
-}
+Gdip.GraphicsPath_AddArc(path, nx, ny + nh - nah, nw, nah, -180, -180);
 } else {
-if (nh > nah) {
+Gdip.GraphicsPath_AddArc(path, nx, ny, nw, nh, 0, 360);
-Gdip.GraphicsPath_AddArc(path, nx, ny, nw, nah, 0, -180);
+}
-Gdip.GraphicsPath_AddArc(path, nx, ny + nh - nah, nw, nah, -180, -180);
+}
-} else {
+Gdip.GraphicsPath_CloseFigure(path);
-Gdip.GraphicsPath_AddArc(path, nx, ny, nw, nh, 0, 360);
+Gdip.Graphics_DrawPath(gdipGraphics, pen, path);
-}
+Gdip.GraphicsPath_delete(path);
 }
-Gdip.GraphicsPath_CloseFigure(path);
-Gdip.Graphics_DrawPath(gdipGraphics, pen, path);
-Gdip.GraphicsPath_delete(path);
 Gdip.Graphics_TranslateTransform(gdipGraphics, -data.gdipXOffset, -data.gdipYOffset, Gdip.MatrixOrderPrepend);
 }
 /**
 * Draws the given string, using the receiver's current font and
 auto format = Gdip.StringFormat_Clone(Gdip.StringFormat_GenericTypographic());
 int formatFlags = Gdip.StringFormat_GetFormatFlags(format) | Gdip.StringFormatFlagsMeasureTrailingSpaces;
 if ((data.style & DWT.MIRRORED) !is 0) formatFlags |= Gdip.StringFormatFlagsDirectionRightToLeft;
 Gdip.StringFormat_SetFormatFlags(format, formatFlags);
 float[] tabs = (flags & DWT.DRAW_TAB) !is 0 ? [ cast(float) measureSpace(data.gdipFont, format) * 8] : new float[1];
-Gdip.StringFormat_SetTabStops(format, 0, tabs.length, tabs);
+Gdip.StringFormat_SetTabStops(format, 0, tabs.length, tabs.ptr);
 int hotkeyPrefix = (flags & DWT.DRAW_MNEMONIC) !is 0 ? Gdip.HotkeyPrefixShow : Gdip.HotkeyPrefixNone;
 if ((flags & DWT.DRAW_MNEMONIC) !is 0 && (data.uiState & OS.UISF_HIDEACCEL) !is 0) hotkeyPrefix = Gdip.HotkeyPrefixHide;
 Gdip.StringFormat_SetHotkeyPrefix(format, hotkeyPrefix);
 if ((flags & DWT.DRAW_TRANSPARENT) is 0) {
 Gdip.RectF bounds;
 if (handle is null) DWT.error(DWT.ERROR_GRAPHIC_DISPOSED);
 if (pointArray is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
 checkGC(FILL);
 if (data.gdipGraphics !is null) {
 int mode = OS.GetPolyFillMode(handle) is OS.WINDING ? Gdip.FillModeWinding : Gdip.FillModeAlternate;
-Gdip.Graphics_FillPolygon(data.gdipGraphics, data.gdipBrush, cast(Gdip.Point[])pointArray, pointArray.length / 2, mode);
+Gdip.Graphics_FillPolygon(data.gdipGraphics, data.gdipBrush, cast(Gdip.Point*)pointArray.ptr, pointArray.length / 2, mode);
 return;
 }
 if ((data.style & DWT.MIRRORED) !is 0) {
 for (int i = 0; i < pointArray.length; i+=2) {
 pointArray[i]--;
 */
 public void fillRectangle (int x, int y, int width, int height) {
 if (handle is null) DWT.error(DWT.ERROR_GRAPHIC_DISPOSED);
 checkGC(FILL);
 if (data.gdipGraphics !is null) {
+if (width < 0) {
+x = x + width;
+width = -width;
+}
+if (height < 0) {
+y = y + height;
+height = -height;
+}
 Gdip.Graphics_FillRectangle(data.gdipGraphics, data.gdipBrush, x, y, width, height);
 return;
 }
 int rop2 = 0;
 static if (OS.IsWinCE) {
 if (naw < 0)
 naw = 0 - naw;
 if (nah < 0)
 nah = 0 - nah;
-auto path = Gdip.GraphicsPath_new(Gdip.FillModeAlternate);
+if (naw is 0 || nah is 0) {
-if (path is null) DWT.error(DWT.ERROR_NO_HANDLES);
+Gdip.Graphics_FillRectangle(data.gdipGraphics, data.gdipBrush, x, y, width, height);
-if (nw > naw) {
+} else {
-if (nh > nah) {
+auto path = Gdip.GraphicsPath_new(Gdip.FillModeAlternate);
-Gdip.GraphicsPath_AddArc(path, nx + nw - naw, ny, naw, nah, 0, -90);
+if (path is null) DWT.error(DWT.ERROR_NO_HANDLES);
-Gdip.GraphicsPath_AddArc(path, nx, ny, naw, nah, -90, -90);
+if (nw > naw) {
-Gdip.GraphicsPath_AddArc(path, nx, ny + nh - nah, naw, nah, -180, -90);
+if (nh > nah) {
-Gdip.GraphicsPath_AddArc(path, nx + nw - naw, ny + nh - nah, naw, nah, -270, -90);
+Gdip.GraphicsPath_AddArc(path, nx + nw - naw, ny, naw, nah, 0, -90);
+Gdip.GraphicsPath_AddArc(path, nx, ny, naw, nah, -90, -90);
+Gdip.GraphicsPath_AddArc(path, nx, ny + nh - nah, naw, nah, -180, -90);
+Gdip.GraphicsPath_AddArc(path, nx + nw - naw, ny + nh - nah, naw, nah, -270, -90);
+} else {
+Gdip.GraphicsPath_AddArc(path, nx + nw - naw, ny, naw, nh, -270, -180);
+Gdip.GraphicsPath_AddArc(path, nx, ny, naw, nh, -90, -180);
+}
 } else {
-Gdip.GraphicsPath_AddArc(path, nx + nw - naw, ny, naw, nh, -270, -180);
+if (nh > nah) {
-Gdip.GraphicsPath_AddArc(path, nx, ny, naw, nh, -90, -180);
+Gdip.GraphicsPath_AddArc(path, nx, ny, nw, nah, 0, -180);
-}
+Gdip.GraphicsPath_AddArc(path, nx, ny + nh - nah, nw, nah, -180, -180);
 } else {
-if (nh > nah) {
+Gdip.GraphicsPath_AddArc(path, nx, ny, nw, nh, 0, 360);
-Gdip.GraphicsPath_AddArc(path, nx, ny, nw, nah, 0, -180);
+}
-Gdip.GraphicsPath_AddArc(path, nx, ny + nh - nah, nw, nah, -180, -180);
+}
-} else {
+Gdip.GraphicsPath_CloseFigure(path);
-Gdip.GraphicsPath_AddArc(path, nx, ny, nw, nh, 0, 360);
+Gdip.Graphics_FillPath(gdipGraphics, brush, path);
-}
+Gdip.GraphicsPath_delete(path);
 }
-Gdip.GraphicsPath_CloseFigure(path);
-Gdip.Graphics_FillPath(gdipGraphics, brush, path);
-Gdip.GraphicsPath_delete(path);
 }
 void flush () {
 if (data.gdipGraphics !is null) {
 Gdip.Graphics_Flush(data.gdipGraphics, 0);
 *    <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed</li>
 * </ul>
 */
 public Font getFont () {
 if (handle is null) DWT.error(DWT.ERROR_GRAPHIC_DISPOSED);
-return Font.win32_new(data.device, data.hFont);
+return data.font;
 }
 /**
 * Returns a FontMetrics which contains information
 * about the font currently being used by the receiver
 }
 Gdip.Matrix identity() {
 if ((data.style & DWT.MIRRORED) !is 0) {
 int width = 0;
-Image image = data.image;
+int technology = OS.GetDeviceCaps(handle, OS.TECHNOLOGY);
-if (image !is null) {
+if (technology is OS.DT_RASPRINTER) {
+width = OS.GetDeviceCaps(handle, OS.PHYSICALWIDTH);
+} else {
+Image image = data.image;
+if (image !is null) {
 BITMAP bm;
 OS.GetObject(image.handle, BITMAP.sizeof, &bm);
 width = bm.bmWidth;
-} else if (data.hwnd !is null) {
+} else {
-RECT rect;
+HWND hwnd;
-OS.GetClientRect(data.hwnd, &rect);
+static if( OS.IsWinCE ){
-width = rect.right - rect.left;
+hwnd = data.hwnd;
+}
+else{
+hwnd = OS.WindowFromDC(handle);
+}
+if (hwnd !is null) {
+RECT rect;
+OS.GetClientRect(hwnd, &rect);
+width = rect.right - rect.left;
+} else {
+auto hBitmap = OS.GetCurrentObject(handle, OS.OBJ_BITMAP);
+BITMAP bm;
+OS.GetObject(hBitmap, BITMAP.sizeof, &bm);
+width = bm.bmWidth;
+}
+}
 }
 POINT pt;
 static if (!OS.IsWinCE) OS.GetWindowOrgEx (handle, &pt);
 return Gdip.Matrix_new(-1, 0, 0, 1, width + 2 * pt.x, 0);
 }
 data.state &= ~(BACKGROUND | BACKGROUND_TEXT | BRUSH);
 } else {
 data.background = OS.GetBkColor(hDC);
 }
 data.state &= ~(NULL_BRUSH | NULL_PEN);
-auto hFont = data.hFont;
+Font font = data.font;
-if (hFont !is null && hFont !is cast(HFONT)-1 ) {
+if (font !is null) {
 data.state &= ~FONT;
 } else {
-data.hFont = OS.GetCurrentObject(hDC, OS.OBJ_FONT);
+data.font = Font.win32_new(device, OS.GetCurrentObject(hDC, OS.OBJ_FONT));
 }
 auto hPalette = data.device.hPalette;
 if (hPalette !is null) {
 OS.SelectPalette(hDC, hPalette, true);
 OS.RealizePalette(hDC);
 *    <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed</li>
 * </ul>
 */
 public bool isClipped() {
 if (handle is null) DWT.error(DWT.ERROR_GRAPHIC_DISPOSED);
+auto gdipGraphics = data.gdipGraphics;
+if (gdipGraphics !is null) {
+auto rgn = Gdip.Region_new();
+Gdip.Graphics_GetClip(data.gdipGraphics, rgn);
+bool isInfinite = Gdip.Region_IsInfinite(rgn, gdipGraphics) !is 0;
+Gdip.Region_delete(rgn);
+return !isInfinite;
+}
 auto region = OS.CreateRectRgn(0, 0, 0, 0);
-auto result = OS.GetClipRgn(handle, region);
+int result = OS.GetClipRgn(handle, region);
 OS.DeleteObject(region);
 return result > 0;
 }
 /**
 setClipping(cast(HRGN)null);
 if (path !is null) {
 initGdip();
 int mode = OS.GetPolyFillMode(handle) is OS.WINDING ? Gdip.FillModeWinding : Gdip.FillModeAlternate;
 Gdip.GraphicsPath_SetFillMode(path.handle, mode);
-Gdip.Graphics_SetClip(data.gdipGraphics, path.handle);
+Gdip.Graphics_SetClipPath(data.gdipGraphics, path.handle);
 }
 }
 /**
 * Sets the area of the receiver which can be changed
 * </ul>
 */
 public void setFont (Font font) {
 if (handle is null) DWT.error(DWT.ERROR_GRAPHIC_DISPOSED);
 if (font !is null && font.isDisposed()) DWT.error(DWT.ERROR_INVALID_ARGUMENT);
-data.hFont = font !is null ? font.handle : data.device.systemFont;
+data.font = font !is null ? font : data.device.systemFont;
 data.state &= ~FONT;
 }
 /**
 * Sets the foreground color. The foreground color is used
 break;
 default:
 DWT.error(DWT.ERROR_INVALID_ARGUMENT);
 }
 }
-int cap = attributes.join;
+int cap = attributes.cap;
 if (cap !is data.lineCap) {
 mask |= LINE_CAP;
 switch (cap) {
 case DWT.JOIN_MITER:
 case DWT.JOIN_ROUND:
 auto format = Gdip.StringFormat_Clone(Gdip.StringFormat_GenericTypographic());
 int formatFlags = Gdip.StringFormat_GetFormatFlags(format) | Gdip.StringFormatFlagsMeasureTrailingSpaces;
 if ((data.style & DWT.MIRRORED) !is 0) formatFlags |= Gdip.StringFormatFlagsDirectionRightToLeft;
 Gdip.StringFormat_SetFormatFlags(format, formatFlags);
 float[] tabs = (flags & DWT.DRAW_TAB) !is 0 ? [measureSpace(data.gdipFont, format) * 8] : new float[1];
-Gdip.StringFormat_SetTabStops(format, 0, tabs.length, tabs);
+Gdip.StringFormat_SetTabStops(format, 0, tabs.length, tabs.ptr);
 Gdip.StringFormat_SetHotkeyPrefix(format, (flags & DWT.DRAW_MNEMONIC) !is 0 ? Gdip.HotkeyPrefixShow : Gdip.HotkeyPrefixNone);
 Gdip.Graphics_MeasureString(data.gdipGraphics, buffer, length_, data.gdipFont, pt, format, bounds);
 Gdip.StringFormat_delete(format);
 return new Point(length_ is 0 ? 0 : Math.rndint(bounds.Width), Math.rndint(bounds.Height));
 }
 * @return a new <code>GC</code>
 */
 public static GC win32_new(HDC hDC, GCData data) {
 GC gc = new GC();
 gc.device = data.device;
+data.style |= DWT.LEFT_TO_RIGHT;
+if (OS.WIN32_VERSION >= OS.VERSION (4, 10)) {
+int flags = OS.GetLayout (hDC);
+if ((flags & OS.LAYOUT_RTL) !is 0) {
+data.style |= DWT.RIGHT_TO_LEFT | DWT.MIRRORED;
+}
+}
 gc.init_(null, data, hDC);
 return gc;
 }
 }

Mercurial > projects > dwt-win

comparison dwt/graphics/GC.d @ 213:36f5cb12e1a2