/** @see org.eclipse.swt.events.PaintListener#paintControl(org.eclipse.swt.events.PaintEvent) */ public void paintControl(PaintEvent e) { GC gc; int offsetX, offsetY; if (!doubleBuffering) { gc = e.gc; gc.setClipping(e.x, e.y, e.width, e.height); offsetX = 0; offsetY = 0; } else { if (backBuffer == null) { setMaxVisibleArea(e.width, e.height); } else { Rectangle b = backBuffer.getBounds(); if (b.width < e.width || b.height < e.height) { setMaxVisibleArea(Math.max(e.width, b.width), Math.max(e.height, b.height)); } } gc = new GC(backBuffer); offsetX = e.x; offsetY = e.y; gc.setClipping(0, 0, e.width, e.height); } renderer.paintWorld(gc, offsetX, offsetY); if (doubleBuffering) { e.gc.drawImage(backBuffer, 0, 0, e.width, e.height, e.x, e.y, e.width, e.height); gc.dispose(); } }
public void setClip(Shape s) { Path path = convertToPath(s); if (path == null) { _gc.setClipping((Rectangle) null); } else { _gc.setClipping(path); } if (_clippingPath != null) { _clippingPath.dispose(); } _clippingPath = path; _clippingArea = (s == null ? null : new Area(s)); }
private void drawHeader(GC gc, Rectangle bounds) { gc.setClipping(bounds); int x = bounds.x; int y = bounds.y; int w = bounds.width; int h = bounds.height; int rw = 7 * tileSize + border * 2; int rh = tileSize + border * 2; int rx = (w - rw) / 2 + x; drawTileRack(gc, new Rectangle(rx, y, rw, rh)); IPlayer[] players = game.getPlayers(); if (players.length >= 1) { IPlayer player = players[0]; int sw = rx - x - padding; drawPlayerStats(gc, new Rectangle(x, y, sw, h), player, SWT.LEFT); } if (players.length >= 2) { IPlayer player = players[1]; int sw = rx - x - padding; int sx = w - sw + x; drawPlayerStats(gc, new Rectangle(sx, y, sw, h), player, SWT.RIGHT); } }
@Override public void paintLayer( ILayer natLayer, GC gc, int xOffset, int yOffset, Rectangle rectangle, IConfigRegistry configRegistry) { super.paintLayer(natLayer, gc, xOffset, yOffset, rectangle, configRegistry); Color separatorColor = configRegistry.getConfigAttribute( IFreezeConfigAttributes.SEPARATOR_COLOR, DisplayMode.NORMAL); if (separatorColor == null) { separatorColor = GUIHelper.COLOR_BLUE; } gc.setClipping(rectangle); Color oldFg = gc.getForeground(); gc.setForeground(separatorColor); final int freezeWidth = freezeLayer.getWidth() - 1; if (freezeWidth > 0) { gc.drawLine( xOffset + freezeWidth, yOffset, xOffset + freezeWidth, yOffset + getHeight() - 1); } final int freezeHeight = freezeLayer.getHeight() - 1; if (freezeHeight > 0) { gc.drawLine( xOffset, yOffset + freezeHeight, xOffset + getWidth() - 1, yOffset + freezeHeight); } gc.setForeground(oldFg); }
public void paint(GC gc, int x, int y) { // Remember clipping region Region region = new Region(); gc.getClipping(region); // Set clipping region so only the portion of the target we want is // printed. gc.setClipping(x, y, size.x, size.y); // Paint the target. target.paint(gc, x - offset.x, y - offset.y); // Restore clipping region gc.setClipping(region); region.dispose(); }
private void onPaint(GC gc) { Rectangle clientArea = getClientArea(); gc.setClipping(clientArea); gc.setBackground(getDisplay().getSystemColor(SWT.COLOR_GRAY)); int boxSize = 10; int maxCol = clientArea.width / boxSize + 1; int maxRow = clientArea.height / boxSize + 1; for (int r = 0; r < maxRow; r++) { for (int c = 0; c < maxCol; c++) { if (r % 2 == c % 2) { gc.fillRectangle(c * boxSize, r * boxSize, boxSize, boxSize); } } } if (image == null || image.isDisposed()) { return; } Rectangle imageBounds = image.getBounds(); int x = -getHorizontalBar().getSelection(); int y = -getVerticalBar().getSelection(); if (clientArea.width > imageBounds.width) { x += (clientArea.width - imageBounds.width) / 2; } if (clientArea.height > imageBounds.height) { y += (clientArea.height - imageBounds.height) / 2; } gc.drawImage(image, x, y); }
private void drawTile(GC gc, Rectangle bounds, Tile tile, boolean highlight) { if (tile == null || tile.equals(Tile.NONE)) return; gc.setClipping(bounds); int x = bounds.x; int y = bounds.y; int w = bounds.width; int h = bounds.height; int s = Math.min(w, h); int n = Math.max(s / 12, 1); int x1 = x; int x2 = x1 + n; int x3 = x + s - n; int x4 = x + s; int y1 = y; int y2 = y1 + n; int y3 = y + s - n; int y4 = y + s; int[] p1 = new int[] {x1, y1, x4, y1, x3, y2, x2, y2, x2, y3, x1, y4}; int[] p2 = new int[] {x4, y4, x1, y4, x2, y3, x3, y3, x3, y2, x4, y1}; gc.setBackground(tileFill); gc.fillRectangle(x, y, w, h); gc.setBackground(highlight ? tileLightHighlight : tileLight); gc.fillPolygon(p1); gc.setBackground(highlight ? tileDarkHighlight : tileDark); gc.fillPolygon(p2); if (tile.isWild()) { if (!bounds.contains(mousex, mousey)) { return; } } Font font = new Font(null, tileFont, s / 2 + 1, SWT.BOLD); String string = Character.toString(tile.getLetter()).toUpperCase(); gc.setFont(font); Point extent = gc.stringExtent(string); int sx = x + w / 2 - extent.x / 2 - n; // n * 2; //w / 2 - extent.x / 2 - s/8; int sy = y + h / 2 - extent.y / 2; gc.setForeground(textColor); gc.drawString(string, sx, sy, true); font.dispose(); font = new Font(null, tileFont, s / 5, SWT.BOLD); string = Integer.toString(game.getTileValues().getValue(tile)); gc.setFont(font); extent = gc.stringExtent(string); sx = x + w - n - extent.x - 1; sy = y + h - n - extent.y; gc.setForeground(textColor); gc.drawString(string, sx, sy, true); font.dispose(); }
private void drawBoardBorder(GC gc, Rectangle bounds) { gc.setClipping(bounds); int x = bounds.x; int y = bounds.y; int w = bounds.width; int h = bounds.height; gc.setBackground(boardBorder); gc.fillRoundRectangle(x, y, w, h, border + 1, border + 1); }
private void drawBoard(GC gc, Rectangle bounds) { gc.setClipping(bounds); int padding = border; int x = bounds.x + padding; int y = bounds.y + padding; int w = bounds.width - padding * 2; int h = bounds.height - padding * 2; drawBoardBorder(gc, bounds); drawBoardGrid(gc, new Rectangle(x, y, w, h)); }
private void drawCoordinates(GC gc, Rectangle bounds, int coord) { gc.setClipping(bounds); drawCoordinates( game.getBoard(), gc, bounds.x + border + coord, bounds.y + border + coord, bounds.width - border * 2 - coord, 0); }
private void drawBoardArea(GC gc, Rectangle bounds, int coord) { gc.setClipping(bounds); int x = bounds.x; int y = bounds.y; int w = bounds.width; int h = bounds.height; if (showCoordinates) { drawCoordinates(gc, bounds, coord); } drawBoard(gc, new Rectangle(x + coord, y + coord, w - coord, h - coord)); }
/* * (non-Javadoc) * * @see * org.xmind.gef.image.FigureRenderer#render(org.eclipse.swt.graphics.GC) */ @Override public void render(GC gc) { gc.setClipping(pageClientArea.x, pageClientArea.y, pageClientArea.width, pageClientArea.height); drawSourceContent(gc); gc.setClipping(pageClientArea.x, pageClientArea.y, pageClientArea.width, pageClientArea.height); if (!settings.getBoolean(PrintConstants.NO_BORDER)) { drawBorder(gc); } String headerText = settings.get(PrintConstants.HEADER_TEXT); if (headerText != null && !"".equals(headerText)) { // $NON-NLS-1$ drawHeader(gc, headerText); } String footerText = settings.get(PrintConstants.FOOTER_TEXT); if (footerText != null && !"".equals(footerText)) { // $NON-NLS-1$ drawFooter(gc, footerText); } }
/* Paint function */ private void paint(GC gc) { Rectangle clientRect = getClientArea(); // Canvas' painting area if (sourceImage != null) { Rectangle imageRect = SWTUtil.inverseTransformRect(transform, clientRect); int gap = 2; // find a better start point to render imageRect.x -= gap; imageRect.y -= gap; imageRect.width += 2 * gap; imageRect.height += 2 * gap; Rectangle imageBound = sourceImage.getBounds(); imageRect = imageRect.intersection(imageBound); Rectangle destRect = SWTUtil.transformRect(transform, imageRect); if (screenImage != null) screenImage.dispose(); screenImage = new Image(getDisplay(), clientRect.width, clientRect.height); GC newGC = new GC(screenImage); newGC.setClipping(clientRect); newGC.drawImage( sourceImage, imageRect.x, imageRect.y, imageRect.width, imageRect.height, destRect.x, destRect.y, destRect.width, destRect.height); newGC.dispose(); gc.drawImage(screenImage, 0, 0); } else { gc.setClipping(clientRect); gc.fillRectangle(clientRect); initScrollBars(); } }
/** Clean used resources. */ public void clean() { if (_clippingPath != null) { _gc.setClipping((Rectangle) null); _clippingPath.dispose(); _clippingPath = null; _clippingArea = null; } if (_color != null) { _color.dispose(); _color = null; } if (_transform != null) { _gc.setTransform(null); _transform.dispose(); } }
private void drawContainer(GC gc, Rectangle bounds) { gc.setClipping(bounds); dragSources.clear(); dragTargets.clear(); // gc.setTextAntialias(SWT.ON); // gc.setAntialias(SWT.OFF); // gc.setAdvanced(false); gc.setBackground(light); gc.fillRectangle(bounds); if (game == null) { return; } IBoard board = game.getBoard(); int x = bounds.x; int y = bounds.y; int w = bounds.width; int h = bounds.height; int coord = showCoordinates ? coordinates : 0; // compute tile size int height = bounds.height - (4 * border + 3 * padding + 1 * coord); int width = bounds.width - (2 * border + 2 * padding + 1 * coord); tileSize = Math.min(width / board.getWidth(), height / (board.getHeight() + 1)); // compute header size and position int hh = tileSize + border * 2; int hw = tileSize * board.getWidth() + border * 2; int hx = (w - hw + coord) / 2; int hy = y + padding; drawHeader(gc, new Rectangle(hx, hy, hw, hh)); // compute board area size and position int cx = x + padding; int cy = y + hh + padding * 2; int cw = w - padding * 2; int ch = h - hh - padding * 3; drawCenter(gc, new Rectangle(cx, cy, cw, ch)); }
void paint(PaintEvent e) { GC gc = e.gc; Point size = comp.getSize(); if (curveColor == null) curveColor = e.display.getSystemColor(SWT.COLOR_BLACK); int h = size.y; int[] simpleCurve = new int[] {0, h - 1, 1, h - 1, 2, h - 2, 2, 1, 3, 0}; // draw border gc.setForeground(curveColor); gc.setAdvanced(true); if (gc.getAdvanced()) { gc.setAntialias(SWT.ON); } gc.drawPolyline(simpleCurve); Rectangle bounds = ((Control) e.widget).getBounds(); bounds.x = bounds.y = 0; Region r = new Region(); r.add(bounds); int[] simpleCurveClose = new int[simpleCurve.length + 4]; System.arraycopy(simpleCurve, 0, simpleCurveClose, 0, simpleCurve.length); int index = simpleCurve.length; simpleCurveClose[index++] = bounds.width; simpleCurveClose[index++] = 0; simpleCurveClose[index++] = bounds.width; simpleCurveClose[index++] = bounds.height; r.subtract(simpleCurveClose); Region clipping = new Region(); gc.getClipping(clipping); r.intersect(clipping); gc.setClipping(r); Image b = toolParent.getBackgroundImage(); if (b != null && !b.isDisposed()) gc.drawImage(b, 0, 0); r.dispose(); clipping.dispose(); // // gc.fillRectangle(bounds); // Rectangle mappedBounds = e.display.map(comp, comp.getParent(), // bounds); // ((Composite) toolParent).drawBackground(gc, bounds.x, bounds.y, // bounds.width, // bounds.height, mappedBounds.x, mappedBounds.y); }
private void paint(PaintEvent event) { GC gc = event.gc; gc.setAntialias(SWT.ON); gc.setLineWidth(1); Rectangle rect = getClientArea(); gc.setClipping(rect); gc.setForeground(getForeground()); gc.setBackground(getForeground()); Color[] palette = new Color[32]; for (int i = 0; i < palette.length; i++) { float hue = 270.0f * i / (palette.length - 1); palette[palette.length - 1 - i] = new Color(Display.getDefault(), new RGB(hue, 1.0f, 1.0f)); // gc.setBackground(palette[i]); // gc.fillRectangle(rect.x + i*rect.width/palette.length, rect.y, rect.width/palette.length, // 100); } frame.adjust(); int x = (int) (rect.x - frame.offsetX); int y = (int) (rect.y - frame.offsetY); int extent = (int) (Math.min(rect.width, rect.height) * frame.scale); treeMap.paint(x, y, extent, gc, curve, palette); for (Color color : palette) color.dispose(); gc.setAlpha(255); gc.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_WHITE)); gc.setLineStyle(SWT.LINE_DASHDOT); gc.setLineWidth(1); gc.drawRectangle(x - 1, y - 1, extent + 2, extent + 2); if (selection.size() > 0) { gc.setLineStyle(SWT.LINE_SOLID); gc.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_LIST_SELECTION)); for (TreeMap subtree : selection) { gc.drawRectangle(getItemBounds(subtree)); } } }
private void drawTileRack(GC gc, Rectangle bounds) { gc.setClipping(bounds); int x = bounds.x; int y = bounds.y; int w = bounds.width; int h = bounds.height; gc.setBackground(tileRackBorder); gc.fillRoundRectangle(x, y, w, h, border + 1, border + 1); gc.setBackground(tileRackFill); gc.fillRectangle(x + border, y + border, w - border * 2, h - border * 2); // TileRack tileRack = getLocalTileRack(); if (tileRack == null) return; Tile[] tiles = tileRack.getTiles(); x += border; y += border; for (int i = 0; i < tiles.length; i++) { Tile tile = tiles[i]; Rectangle rectangle = new Rectangle(x, y, tileSize, tileSize); DragSource source = new DragSource(); source.rectangle = rectangle; source.x = i; source.y = -1; source.tile = tile; dragSources.put(rectangle, source); DragTarget target = new DragTarget(); target.rectangle = rectangle; target.x = i; target.y = -1; dragTargets.add(target); drawTile(gc, rectangle, tile); x += tileSize; } }
void paintStripes(GC gc) { if (!showStripes) return; Rectangle rect = getClientArea(); // Subtracted border painted by paint. rect = new Rectangle(rect.x + 2, rect.y + 2, rect.width - 4, rect.height - 4); gc.setLineWidth(2); gc.setClipping(rect); Color color = getDisplay().getSystemColor(SWT.COLOR_LIST_SELECTION); gc.setBackground(color); gc.fillRectangle(rect); gc.setForeground(this.getBackground()); int step = 12; int foregroundValue = value == 0 ? step - 2 : value - 2; if (orientation == SWT.HORIZONTAL) { int y = rect.y - 1; int w = rect.width; int h = rect.height + 2; for (int i = 0; i < w; i += step) { int x = i + foregroundValue; gc.drawLine(x, y, x, h); } } else { int x = rect.x - 1; int w = rect.width + 2; int h = rect.height; for (int i = 0; i < h; i += step) { int y = i + foregroundValue; gc.drawLine(x, y, w, y); } } if (active) { value = (value + 2) % step; } }
private void drawCenter(GC gc, Rectangle bounds) { gc.setClipping(bounds); int x = bounds.x; int y = bounds.y; int w = bounds.width; int h = bounds.height; gc.setFont(coordinateFont); int coord = showCoordinates ? coordinates : 0; int n = coord + border * 2; IBoard board = game.getBoard(); int t = Math.min((w - n) / board.getWidth(), (h - n) / board.getHeight()); int bw = t * board.getWidth() + n; int bh = t * board.getHeight() + n; int px = (w - bw) / 2; int py = (h - bh) / 2; int rx = (w - bw) % 2; int ry = (h - bh) % 2; drawBoardArea(gc, new Rectangle(x + px, y + 0, w - px * 2 - rx, h - py * 2 - ry), coord); }
protected void paint(GC gc, Display display) { if (bounds == null) buildCaches(); gc.setAntialias(SWT.ON); gc.setTextAntialias(SWT.ON); int x, y, w, h; boolean focused = getControl().isFocusControl() || isForceFocus(); boolean hasBackgroundAndBorder = pressed || hovered || focused; if (hasBackgroundAndBorder) { // draw control background gc.setBackground(getBorderBackground(display)); gc.fillRoundRectangle( bounds.x, bounds.y, bounds.width, bounds.height, CORNER_SIZE, CORNER_SIZE); } if (focused) { // draw focused content background x = contentArea.x - FOCUS_BORDER; y = contentArea.y - FOCUS_BORDER; w = contentArea.width + FOCUS_BORDER * 2; h = contentArea.height + FOCUS_BORDER * 2; gc.setBackground(getRealTextBackground(display)); gc.fillRoundRectangle(x, y, w, h, FOCUS_CORNER_SIZE, FOCUS_CORNER_SIZE); } boolean hasImage = hasImage(); boolean hasText = hasText(); if (hasImage) { Rectangle clipping = gc.getClipping(); if (clipping == null || clipping.intersects(imgArea)) { // draw image Point imgSize = getImageSize(); x = imgArea.x + (imgArea.width - imgSize.x) / 2; y = imgArea.y + (imgArea.height - imgSize.y) / 2; gc.setClipping(imgArea); gc.drawImage(image, x, y); gc.setClipping(clipping); } } if (hasText) { Rectangle clipping = gc.getClipping(); if (clipping == null || clipping.intersects(textArea)) { // draw text String text = getAppliedText(); gc.setFont(getControl().getFont()); Point ext = gc.stringExtent(text); // if (hasImage) { x = textArea.x; // } else { // x = textArea.x + (textArea.width - ext.x) / 2; // } y = textArea.y + (textArea.height - ext.y) / 2; gc.setClipping(textArea); gc.setForeground(getRealTextForeground(display)); gc.drawString(text, x, y, true); gc.setClipping(clipping); } } // draw arrows if (hasArrows() && arrowLoc != null) { gc.setBackground(Display.getCurrent().getSystemColor(SWT.COLOR_WIDGET_NORMAL_SHADOW)); x = arrowLoc.x + ARROW_WIDTH / 2; y = arrowLoc.y; int x1 = arrowLoc.x - 1; int y1 = arrowLoc.y + ARROW_HEIGHT + 1; int x2 = arrowLoc.x + ARROW_WIDTH; gc.fillPolygon(new int[] {x, y, x1, y1, x2, y1}); y += ARROW_HEIGHT * 2 + ARROWS_SPACING + 1; x1 = arrowLoc.x; y1 += ARROWS_SPACING; gc.fillPolygon(new int[] {x, y, x2, y1, x1 - 1, y1}); } // draw border if (focused) { x = bounds.x; y = bounds.y; w = bounds.width; h = bounds.height; if (DRAWS_FOCUS) { gc.drawFocus(x - MARGIN + 1, y - MARGIN + 1, w + MARGIN * 2 - 2, h + MARGIN * 2 - 2); } else { gc.setForeground(getBorderForeground(display, focused)); gc.drawRoundRectangle(x, y, w, h, CORNER_SIZE, CORNER_SIZE); } } }
/** * Paints the preview at the given x/y position * * @param gc the graphics context to paint it into * @param x the x coordinate to paint the preview at * @param y the y coordinate to paint the preview at */ void paint(GC gc, int x, int y) { mTitleHeight = paintTitle(gc, x, y, true /*showFile*/); y += mTitleHeight; y += 2; int width = getWidth(); int height = getHeight(); if (mThumbnail != null && mError == null) { gc.drawImage(mThumbnail, x, y); if (mActive) { int oldWidth = gc.getLineWidth(); gc.setLineWidth(3); gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_LIST_SELECTION)); gc.drawRectangle(x - 1, y - 1, width + 2, height + 2); gc.setLineWidth(oldWidth); } } else if (mError != null) { if (mThumbnail != null) { gc.drawImage(mThumbnail, x, y); } else { gc.setBackground(gc.getDevice().getSystemColor(SWT.COLOR_WIDGET_BORDER)); gc.drawRectangle(x, y, width, height); } gc.setClipping(x, y, width, height); Image icon = IconFactory.getInstance().getIcon("renderError"); // $NON-NLS-1$ ImageData data = icon.getImageData(); int prevAlpha = gc.getAlpha(); int alpha = 96; if (mThumbnail != null) { alpha -= 32; } gc.setAlpha(alpha); gc.drawImage(icon, x + (width - data.width) / 2, y + (height - data.height) / 2); String msg = mError; Density density = mConfiguration.getDensity(); if (density == Density.TV || density == Density.LOW) { msg = "Broken rendering library; unsupported DPI. Try using the SDK manager " + "to get updated layout libraries."; } int charWidth = gc.getFontMetrics().getAverageCharWidth(); int charsPerLine = (width - 10) / charWidth; msg = SdkUtils.wrap(msg, charsPerLine, null); gc.setAlpha(255); gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_BLACK)); gc.drawText(msg, x + 5, y + HEADER_HEIGHT, true); gc.setAlpha(prevAlpha); gc.setClipping((Region) null); } else { gc.setBackground(gc.getDevice().getSystemColor(SWT.COLOR_WIDGET_BORDER)); gc.drawRectangle(x, y, width, height); Image icon = IconFactory.getInstance().getIcon("refreshPreview"); // $NON-NLS-1$ ImageData data = icon.getImageData(); int prevAlpha = gc.getAlpha(); gc.setAlpha(96); gc.drawImage(icon, x + (width - data.width) / 2, y + (height - data.height) / 2); gc.setAlpha(prevAlpha); } if (mActive) { int left = x; int prevAlpha = gc.getAlpha(); gc.setAlpha(208); Color bg = mCanvas.getDisplay().getSystemColor(SWT.COLOR_WHITE); gc.setBackground(bg); gc.fillRectangle(left, y, x + width - left, HEADER_HEIGHT); gc.setAlpha(prevAlpha); y += 2; // Paint icons gc.drawImage(CLOSE_ICON, left, y); left += CLOSE_ICON_WIDTH; gc.drawImage(ZOOM_IN_ICON, left, y); left += ZOOM_IN_ICON_WIDTH; gc.drawImage(ZOOM_OUT_ICON, left, y); left += ZOOM_OUT_ICON_WIDTH; gc.drawImage(EDIT_ICON, left, y); left += EDIT_ICON_WIDTH; } }
/** * Paints the preview title at the given position (and returns the required height) * * @param gc the graphics context to paint into * @param x the left edge of the preview rectangle * @param y the top edge of the preview rectangle * @param displayName the title string to be used */ int paintTitle(GC gc, int x, int y, boolean showFile, String displayName) { int titleHeight = 0; if (showFile && mIncludedWithin != null) { if (mManager.getMode() != INCLUDES) { displayName = "<include>"; } else { // Skip: just paint footer instead displayName = null; } } int width = getWidth(); int labelTop = y + 1; gc.setClipping(x, labelTop, width, 100); // Use font height rather than extent height since we want two adjacent // previews (which may have different display names and therefore end // up with slightly different extent heights) to have identical title // heights such that they are aligned identically int fontHeight = gc.getFontMetrics().getHeight(); if (displayName != null && displayName.length() > 0) { gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_WHITE)); Point extent = gc.textExtent(displayName); int labelLeft = Math.max(x, x + (width - extent.x) / 2); Image icon = null; Locale locale = mConfiguration.getLocale(); if (locale != null && (locale.hasLanguage() || locale.hasRegion()) && (!(mConfiguration instanceof NestedConfiguration) || ((NestedConfiguration) mConfiguration).isOverridingLocale())) { icon = locale.getFlagImage(); } if (icon != null) { int flagWidth = icon.getImageData().width; int flagHeight = icon.getImageData().height; labelLeft = Math.max(x + flagWidth / 2, labelLeft); gc.drawImage(icon, labelLeft - flagWidth / 2 - 1, labelTop); labelLeft += flagWidth / 2 + 1; gc.drawText(displayName, labelLeft, labelTop - (extent.y - flagHeight) / 2, true); } else { gc.drawText(displayName, labelLeft, labelTop, true); } labelTop += extent.y; titleHeight += fontHeight; } if (showFile && (mAlternateInput != null || mIncludedWithin != null)) { // Draw file flag, and parent folder name IFile file = mAlternateInput != null ? mAlternateInput : mIncludedWithin.getFile(); String fileName = file.getParent().getName() + File.separator + file.getName(); Point extent = gc.textExtent(fileName); Image icon = IconFactory.getInstance().getIcon("android_file"); // $NON-NLS-1$ int flagWidth = icon.getImageData().width; int flagHeight = icon.getImageData().height; int labelLeft = Math.max(x, x + (width - extent.x - flagWidth - 1) / 2); gc.drawImage(icon, labelLeft, labelTop); gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_GRAY)); labelLeft += flagWidth + 1; labelTop -= (extent.y - flagHeight) / 2; gc.drawText(fileName, labelLeft, labelTop, true); titleHeight += Math.max(titleHeight, icon.getImageData().height); } gc.setClipping((Region) null); return titleHeight; }
private void drawPlayerStats(GC gc, Rectangle bounds, IPlayer player, int align) { gc.setClipping(bounds); int x = bounds.x; int y = bounds.y; int w = bounds.width; int h = bounds.height; int p = w / 32; Color fillColor = null; Color handleColor = null; Color scoreColor = null; Color clockColor = null; if (game.getGameState() == GameState.ENDED) { if (player == game.getWinner()) { fillColor = new Color(null, 0, 164, 0); handleColor = new Color(null, 255, 255, 255); scoreColor = new Color(null, 255, 255, 255); clockColor = new Color(null, 255, 255, 255); } else { fillColor = new Color(null, 164, 0, 0); handleColor = new Color(null, 255, 255, 255); scoreColor = new Color(null, 255, 255, 255); clockColor = new Color(null, 255, 255, 255); } } else { if (player == game.getCurrentPlayer()) { fillColor = new Color(null, 0, 0, 192); handleColor = new Color(null, 205, 205, 255); scoreColor = new Color(null, 255, 255, 255); clockColor = new Color(null, 215, 215, 215); } else { fillColor = new Color(null, 153, 153, 153); handleColor = new Color(null, 0, 0, 128); scoreColor = new Color(null, 0, 0, 0); clockColor = new Color(null, 0, 0, 0); } } // fill gc.setBackground(fillColor); gc.fillRoundRectangle(x, y, w, h, border + 1, border + 1); // draw handle int n = h / 4; Font font = new Font(null, "Arial", n, SWT.BOLD); String s = player.getName(); gc.setFont(font); gc.setForeground(handleColor); Point extent = gc.stringExtent(s); if (align == SWT.LEFT) { gc.drawString(s, x + p, y, true); } else { gc.drawString(s, x + w - p - extent.x, y, true); } font.dispose(); // save width int i = extent.x + p; // draw clock font = new Font(null, "Courier New", n, SWT.BOLD); s = player.getClock().toString(); gc.setFont(font); gc.setForeground(clockColor); extent = gc.stringExtent(s); if (align == SWT.LEFT) { gc.drawString(s, x + p, y + h - extent.y, true); } else { gc.drawString(s, x + w - p - extent.x, y + h - extent.y, true); } font.dispose(); // draw score font = new Font(null, "Arial", h / 2, SWT.BOLD); s = Integer.toString(player.getScore()); gc.setFont(font); gc.setForeground(scoreColor); extent = gc.stringExtent(s); if (align == SWT.LEFT) { gc.drawString(s, x + i + (w - i) / 2 - extent.x / 2, y + h / 2 - extent.y / 2, true); } else { gc.drawString(s, x + (w - i) / 2 - extent.x / 2, y + h / 2 - extent.y / 2, true); } font.dispose(); fillColor.dispose(); handleColor.dispose(); scoreColor.dispose(); clockColor.dispose(); }
int XmNexposureCallback(int w, int client_data, int call_data) { if ((style & SWT.SEPARATOR) != 0) return 0; int xDisplay = OS.XtDisplay(handle); if (xDisplay == 0) return 0; int xWindow = OS.XtWindow(handle); if (xWindow == 0) return 0; int[] argList = { OS.XmNcolormap, 0, OS.XmNwidth, 0, OS.XmNheight, 0, }; OS.XtGetValues(handle, argList, argList.length / 2); int width = argList[3], height = argList[5]; Image currentImage = image; boolean enabled = getEnabled(); if ((parent.style & SWT.FLAT) != 0) { boolean hasCursor = hasCursor(); /* Set the shadow thickness */ int thickness = 0; if (set || (hasCursor && enabled)) { thickness = Math.min(2, display.buttonShadowThickness); } argList = new int[] {OS.XmNshadowThickness, thickness}; OS.XtSetValues(handle, argList, argList.length / 2); /* Determine if hot image should be used */ if (enabled && hasCursor && hotImage != null) { currentImage = hotImage; } } GCData data = new GCData(); data.device = display; data.display = xDisplay; data.drawable = xWindow; data.font = parent.font; data.colormap = argList[1]; int xGC = OS.XCreateGC(xDisplay, xWindow, 0, null); if (xGC == 0) SWT.error(SWT.ERROR_NO_HANDLES); GC gc = GC.motif_new(xGC, data); XmAnyCallbackStruct cb = new XmAnyCallbackStruct(); OS.memmove(cb, call_data, XmAnyCallbackStruct.sizeof); if (cb.event != 0) { XExposeEvent xEvent = new XExposeEvent(); OS.memmove(xEvent, cb.event, XExposeEvent.sizeof); Rectangle rect = new Rectangle(xEvent.x, xEvent.y, xEvent.width, xEvent.height); gc.setClipping(rect); } if (!enabled) { currentImage = disabledImage; if (currentImage == null && image != null) { currentImage = new Image(display, image, SWT.IMAGE_DISABLE); } Color disabledColor = display.getSystemColor(SWT.COLOR_WIDGET_NORMAL_SHADOW); gc.setForeground(disabledColor); } else { gc.setForeground(parent.getForeground()); } gc.setBackground(parent.getBackground()); int textX = 0, textY = 0, textWidth = 0, textHeight = 0; if (text.length() != 0) { int flags = SWT.DRAW_DELIMITER | SWT.DRAW_TAB | SWT.DRAW_MNEMONIC; Point textExtent = gc.textExtent(text, flags); textWidth = textExtent.x; textHeight = textExtent.y; } int imageX = 0, imageY = 0, imageWidth = 0, imageHeight = 0; if (currentImage != null) { Rectangle imageBounds = currentImage.getBounds(); imageWidth = imageBounds.width; imageHeight = imageBounds.height; } int spacing = 0; if (textWidth != 0 && imageWidth != 0) spacing = 2; if ((parent.style & SWT.RIGHT) != 0) { imageX = (width - imageWidth - textWidth - spacing) / 2; imageY = (height - imageHeight) / 2; textX = spacing + imageX + imageWidth; textY = (height - textHeight) / 2; } else { imageX = (width - imageWidth) / 2; imageY = (height - imageHeight - textHeight - spacing) / 2; textX = (width - textWidth) / 2; textY = spacing + imageY + imageHeight; } if ((style & SWT.DROP_DOWN) != 0) { textX -= 6; imageX -= 6; } if (textWidth > 0) { int flags = SWT.DRAW_DELIMITER | SWT.DRAW_TAB | SWT.DRAW_MNEMONIC | SWT.DRAW_TRANSPARENT; gc.drawText(text, textX, textY, flags); } if (imageWidth > 0) gc.drawImage(currentImage, imageX, imageY); if ((style & SWT.DROP_DOWN) != 0) { int startX = width - 12, startY = (height - 2) / 2; int[] arrow = {startX, startY, startX + 3, startY + 3, startX + 6, startY}; gc.setBackground(parent.getForeground()); gc.fillPolygon(arrow); gc.drawPolygon(arrow); } gc.dispose(); OS.XFreeGC(xDisplay, xGC); if (!enabled && disabledImage == null) { if (currentImage != null) currentImage.dispose(); } return 0; }
private void drawBoardGrid(GC gc, Rectangle bounds) { gc.setClipping(bounds); drawBoard(game.getBoard(), gc, bounds.x, bounds.y, bounds.width); }
private void drawTile(IBoard b, GC gc, int x, int y, int xo, int yo, int size) { gc.setClipping(xo, yo, size + 1, size + 1); Color c = background; if (b.getLetterMultiplier(y, x) == 2) c = doubleLetter; else if (b.getLetterMultiplier(y, x) == 3) c = tripleLetter; else if (b.getLetterMultiplier(y, x) == 4) c = quadLetter; else if (b.getWordMultiplier(y, x) == 2) c = doubleWord; else if (b.getWordMultiplier(y, x) == 3) c = tripleWord; else if (b.getWordMultiplier(y, x) == 4) c = quadWord; gc.setBackground(c); gc.fillRectangle(xo, yo, size, size); c = light; if (b.getLetterMultiplier(y, x) == 2) c = doubleLetterLight; else if (b.getLetterMultiplier(y, x) == 3) c = tripleLetterLight; else if (b.getLetterMultiplier(y, x) == 4) c = quadLetterLight; else if (b.getWordMultiplier(y, x) == 2) c = doubleWordLight; else if (b.getWordMultiplier(y, x) == 3) c = tripleWordLight; else if (b.getWordMultiplier(y, x) == 4) c = quadWordLight; gc.setForeground(c); gc.drawLine(xo, yo, xo + size, yo); gc.drawLine(xo, yo, xo, yo + size); gc.setForeground(dark); gc.drawLine(xo + size, yo + size, xo + size, yo); gc.drawLine(xo + size, yo + size, xo, yo + size); Tile tile = b.getTile(y, x); if (tile.equals(Tile.NONE)) { for (Iterator i = placedTiles.entrySet().iterator(); i.hasNext(); ) { Map.Entry entry = (Map.Entry) i.next(); Point point = (Point) entry.getKey(); if (point.x == x && point.y == y) { tile = (Tile) entry.getValue(); DragSource source = new DragSource(); source.rectangle = new Rectangle(xo, yo, size + 1, size + 1); source.x = x; source.y = y; source.tile = tile; dragSources.put(source.rectangle, source); } } } boolean highlight = false; IGameAction action = game.getLastAction(); if (action != null && action instanceof MoveAction) { MoveAction moveAction = (MoveAction) action; MoveResult result = moveAction.getMoveResult(); Tile[] tiles = result.getPreviousBoardState(); Move move = result.getMove(); Orientation orientation = move.getOrientation(); int dx = orientation.getDx(); int dy = orientation.getDy(); int mx = move.getColumn(); int my = move.getRow(); for (int i = 0; i < tiles.length; i++) { Tile t = tiles[i]; if (mx == x && my == y && t.equals(Tile.NONE)) { highlight = true; } mx += dx; my += dy; } } drawTile(gc, new Rectangle(xo, yo, size + 1, size + 1), tile, highlight); if (arrow != null && arrow.x == x && arrow.y == y) { drawArrow(gc, xo, yo, size); } }