Skip to content

GC Examples

A GC widget component.

Basic Snippet

GC Basic Snippet

Demonstrates basic drawing operations using GC (Graphics Context).

This example shows drawing lines, ovals, rectangles, and copying canvas areas

using a paint listener on a canvas widget.

GCBasicSnippet.java 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package dev.equo;

import dev.equo.swt.Config;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

/**
 * Demonstrates basic drawing operations using GC (Graphics Context).
 * This example shows drawing lines, ovals, rectangles, and copying canvas areas
 * using a paint listener on a canvas widget.
 */

public class GCBasicSnippet {
    public static void main (String [] args) {
        Config.forceEquo();
        Display display = new Display();
        Shell shell = new Shell(display);
        shell.setText("GCBasicSnippet");
        shell.setSize(650, 650);

        Canvas canvas = new Canvas(shell, SWT.NONE);
        canvas.setBounds(50, 50, 600, 600);
        canvas.addPaintListener(e -> {
            GC gc = e.gc;
            gc.drawLine(10, 10, 110, 90);
            gc.drawOval(20, 20, 80, 60);
            gc.drawRectangle(30, 30, 60, 40);
            gc.copyArea(10, 10, 100, 80, 200, 10);

            gc.copyArea(10, 10, 100, 80, 50, 150);

        });

        shell.open();
        while (!shell.isDisposed ()) {
            if (!display.readAndDispatch ()) display.sleep ();
        }
        display.dispose ();
    }
}

View on GitHub

Copy Area Image Snippet

GC Copy Area Image Snippet

Tests two copyArea scenarios:

  1. GC from paint listener on a Canvas — should capture drawn shapes.

  2. GC(button).copyArea(image) — does it capture the button's content?

GCCopyAreaImageSnippet.java 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
package dev.equo;

import dev.equo.swt.Config;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;

/**
 * Tests two copyArea scenarios:
 *
 * 1. GC from paint listener on a Canvas  — should capture drawn shapes.
 * 2. GC(button).copyArea(image)          — does it capture the button's content?
 */
public class GCCopyAreaImageSnippet {

    public static void main(String[] args) {
        Config.forceEquo();
        Display display = new Display();
        Shell shell = new Shell(display);
        shell.setText("GCCopyAreaImageSnippet");
        shell.setSize(720, 520);

        // ── Section 1: Canvas paint-listener GC ──────────────────────────────
        Label sec1 = new Label(shell, SWT.NONE);
        sec1.setText("1) GC from paint listener:");
        sec1.setBounds(10, 5, 300, 20);

        final int drawW = 260, drawH = 200;

        Canvas canvas = new Canvas(shell, SWT.BORDER);
        canvas.setBounds(10, 28, 680, 220);
        canvas.addPaintListener(e -> {
            GC gc = e.gc;

            // Left: draw shapes
            gc.setBackground(new Color(220, 240, 255));
            gc.fillRectangle(0, 0, drawW, drawH);
            gc.setBackground(new Color(255, 180, 0));
            gc.fillOval(20, 20, 80, 80);
            gc.setForeground(new Color(180, 0, 0));
            gc.setLineWidth(3);
            gc.drawRectangle(120, 30, 100, 70);
            gc.setBackground(new Color(0, 160, 0));
            gc.fillPolygon(new int[]{30, 180, 100, 110, 170, 180});
            gc.setForeground(new Color(0, 0, 0));
            gc.drawText("Original (direct)", 50, 155, true);

            // Capture left area
            Image snapshot = new Image(display, drawW, drawH);
            gc.copyArea(snapshot, 0, 0);

            // Right: show captured image
            gc.drawText("Snapshot via copyArea:", 290, 0, true);
            gc.drawImage(snapshot, 290, 20);
            snapshot.dispose();
        });

        // ── Section 2: GC(button).copyArea ───────────────────────────────────
        Label sec2 = new Label(shell, SWT.NONE);
        sec2.setText("2) GC(button).copyArea — does it capture the button's content?");
        sec2.setBounds(10, 260, 500, 20);

        Button btn = new Button(shell, SWT.PUSH);
        btn.setText("Hello, Button!");
        btn.setBounds(10, 285, 200, 50);

        Label arrow = new Label(shell, SWT.NONE);
        arrow.setText("→ copyArea result:");
        arrow.setBounds(220, 295, 150, 20);

        final int btnW = 200, btnH = 50;
        Canvas btnResult = new Canvas(shell, SWT.BORDER);
        btnResult.setBounds(375, 285, btnW, btnH);
        btnResult.addPaintListener(e -> {
            GC gcBtn = new GC(btn);
            Image snap = new Image(display, btnW, btnH);
            gcBtn.copyArea(snap, 0, 0);
            gcBtn.dispose();
            e.gc.drawImage(snap, 0, 0);
            snap.dispose();
        });

        Label hint = new Label(shell, SWT.NONE);
        hint.setText("(if blank/black → GC(button) does not capture widget rendering)");
        hint.setBounds(10, 345, 680, 20);

        shell.open();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch()) display.sleep();
        }
        display.dispose();
    }
}

View on GitHub

Fill Oval Snippet

GC Fill Oval Snippet

Demonstrates fillOval operations using GC (Graphics Context).

This example shows filled ovals of different sizes, colors, aspect ratios,

overlapping shapes, and handling of negative dimensions.

GCFillOvalSnippet.java 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
package dev.equo;

import dev.equo.swt.Config;
import org.eclipse.swt.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.widgets.*;

/**
 * Demonstrates fillOval operations using GC (Graphics Context).
 * This example shows filled ovals of different sizes, colors, aspect ratios,
 * overlapping shapes, and handling of negative dimensions.
 */

public class GCFillOvalSnippet {

    public static void main (String [] args) {
        Config.forceEquo();
        final Display display = new Display ();
        final Shell shell = new Shell (display, SWT.SHELL_TRIM);
        shell.setText("GCFillOvalSnippet");
        shell.setSize (650, 650);

        Canvas canvas = new Canvas(shell, SWT.NONE);
        canvas.setBounds(50, 50, 600, 600);
        canvas.addPaintListener(e -> {
            GC gc = e.gc;
            // Demo 1: Basic filled ovals with different colors
            gc.setBackground(new Color(255, 0, 0)); // Red
            gc.fillOval(50, 50, 100, 80);

            gc.setBackground(new Color(0, 255, 0)); // Green
            gc.fillOval(200, 50, 120, 120); // Circle

            gc.setBackground(new Color(0, 0, 255)); // Blue
            gc.fillOval(350, 50, 80, 120); // Tall oval

            // Demo 2: Filled oval with outline
            gc.setBackground(new Color(255, 255, 0)); // Yellow
            gc.setForeground(new Color(0, 0, 0)); // Black
            gc.fillOval(50, 200, 150, 100);
            gc.drawOval(50, 200, 150, 100); // Add black outline

            // Demo 3: Overlapping filled ovals
            gc.setBackground(new Color(0, 255, 255)); // Cyan
            gc.fillOval(250, 200, 100, 100);

            gc.setBackground(new Color(255, 0, 255)); // Magenta
            gc.fillOval(280, 230, 100, 100);

            // Demo 4: Negative width/height handling
            gc.setBackground(new Color(0, 128, 0)); // Dark Green
            gc.fillOval(450, 250, -80, -60); // Should draw at (370, 190)

            // Add labels
            gc.setForeground(new Color(0, 0, 0)); // Black
            gc.drawText("Red Oval", 50, 140, true);
            gc.drawText("Green Circle", 200, 180, true);
            gc.drawText("Blue Tall", 350, 180, true);
            gc.drawText("Yellow + Outline", 50, 310, true);
            gc.drawText("Overlapping", 250, 310, true);
            gc.drawText("Negative coords", 370, 260, true);
        });

        shell.setSize (650, 650);
        shell.open ();

        while (!shell.isDisposed ()) {
            if (!display.readAndDispatch ())
                display.sleep ();
        }
        display.dispose ();
    }
}

View on GitHub

Font Snippet

GC Font Snippet

Example demonstrating GCFontSnippet.

GCFontSnippet.java 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
package dev.equo;

import dev.equo.swt.Config;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

public class GCFontSnippet {
    public static void main(String[] args) {
        //Config.forceEquo();
        Config.useEquo(Canvas.class);
        //Config.useEquo(Font.class);
        Display display = new Display();
        Shell shell = new Shell(display);
        shell.setText("GC Font Variety Snippet");
        shell.setSize(600, 800);

        FontData fd = new FontData("Arial", 12, SWT.NORMAL);
        // Create various fonts with different families, sizes and styles
        Font arial12Normal = new Font(display, fd);
        Font arial16Bold = new Font(display, "Arial", 16, SWT.BOLD);
        Font arial14Italic = new Font(display, "Arial", 14, SWT.ITALIC);
        Font arial18BoldItalic = new Font(display, new FontData("Arial", 18, SWT.BOLD | SWT.ITALIC));

        Font courierNew10Normal = new Font(display, "Courier New", 10, SWT.NORMAL);
        Font courierNew14Bold = new Font(display, "Courier New", 14, SWT.BOLD);
        Font courierNew16Italic = new Font(display, "Courier New", 16, SWT.ITALIC);

        Font timesNewRoman14Normal = new Font(display, "Times New Roman", 14, SWT.NORMAL);
        Font timesNewRoman18Bold = new Font(display, "Times New Roman", 18, SWT.BOLD);
        Font timesNewRoman16Italic = new Font(display, "Times New Roman", 16, SWT.ITALIC);
        Font timesNewRoman20BoldItalic = new Font(display, "Times New Roman", 20, SWT.BOLD | SWT.ITALIC);

        Font helvetica12Normal = new Font(display, "Helvetica", 12, SWT.NORMAL);
        Font helvetica15Bold = new Font(display, "Helvetica", 15, SWT.BOLD);
        Font helvetica13Italic = new Font(display, "Helvetica", 13, SWT.ITALIC);

        Font verdana11Normal = new Font(display, "Verdana", 11, SWT.NORMAL);
        Font verdana14Bold = new Font(display, "Verdana", 14, SWT.BOLD);
        Font verdana12BoldItalic = new Font(display, "Verdana", 12, SWT.BOLD | SWT.ITALIC);

        Font georgia13Normal = new Font(display, "Georgia", 13, SWT.NORMAL);
        Font georgia17Bold = new Font(display, "Georgia", 17, SWT.BOLD);
        Font georgia15Italic = new Font(display, "Georgia", 15, SWT.ITALIC);

        Canvas canvas = new Canvas(shell, SWT.NONE);
        canvas.setBounds(25, 25, 550, 750);
        canvas.addPaintListener(e -> {
            GC gc = e.gc;
            int y = 20;
            int lineHeight = 30;

            // Default font
            gc.drawText("Default System Font", 10, y, 0);
            y += lineHeight;

            // Arial variations
            gc.setFont(arial12Normal);
            gc.drawText("Arial 12 Normal - The quick brown fox", 10, y, 0);
            y += lineHeight;

            gc.setFont(arial16Bold);
            gc.drawText("Arial 16 Bold - The quick brown fox", 10, y, 0);
            y += lineHeight;

            gc.setFont(arial14Italic);
            gc.drawText("Arial 14 Italic - The quick brown fox", 10, y, 0);
            y += lineHeight;

            gc.setFont(arial18BoldItalic);
            gc.drawText("Arial 18 Bold+Italic - The quick brown fox", 10, y, 0);
            y += lineHeight + 5;

            // Courier New variations
            gc.setFont(courierNew10Normal);
            gc.drawText("Courier New 10 Normal - The quick brown fox", 10, y, 0);
            y += lineHeight;

            gc.setFont(courierNew14Bold);
            gc.drawText("Courier New 14 Bold - The quick brown fox", 10, y, 0);
            y += lineHeight;

            gc.setFont(courierNew16Italic);
            gc.drawText("Courier New 16 Italic - The quick brown fox", 10, y, 0);
            y += lineHeight + 5;

            // Times New Roman variations
            gc.setFont(timesNewRoman14Normal);
            gc.drawText("Times New Roman 14 Normal - The quick brown fox", 10, y, 0);
            y += lineHeight;

            gc.setFont(timesNewRoman18Bold);
            gc.drawText("Times New Roman 18 Bold - The quick brown fox", 10, y, 0);
            y += lineHeight;

            gc.setFont(timesNewRoman16Italic);
            gc.drawText("Times New Roman 16 Italic - The quick brown fox", 10, y, 0);
            y += lineHeight;

            gc.setFont(timesNewRoman20BoldItalic);
            gc.drawText("Times New Roman 20 Bold+Italic - The quick brown fox", 10, y, 0);
            y += lineHeight + 5;

            // Helvetica variations
            gc.setFont(helvetica12Normal);
            gc.drawText("Helvetica 12 Normal - The quick brown fox", 10, y, 0);
            y += lineHeight;

            gc.setFont(helvetica15Bold);
            gc.drawText("Helvetica 15 Bold - The quick brown fox", 10, y, 0);
            y += lineHeight;

            gc.setFont(helvetica13Italic);
            gc.drawText("Helvetica 13 Italic - The quick brown fox", 10, y, 0);
            y += lineHeight + 5;

            // Verdana variations
            gc.setFont(verdana11Normal);
            gc.drawText("Verdana 11 Normal - The quick brown fox", 10, y, 0);
            y += lineHeight;

            gc.setFont(verdana14Bold);
            gc.drawText("Verdana 14 Bold - The quick brown fox", 10, y, 0);
            y += lineHeight;

            gc.setFont(verdana12BoldItalic);
            gc.drawText("Verdana 12 Bold+Italic - The quick brown fox", 10, y, 0);
            y += lineHeight + 5;

            // Georgia variations
            gc.setFont(georgia13Normal);
            gc.drawText("Georgia 13 Normal - The quick brown fox", 10, y, 0);
            y += lineHeight;

            gc.setFont(georgia17Bold);
            gc.drawText("Georgia 17 Bold - The quick brown fox", 10, y, 0);
            y += lineHeight;

            gc.setFont(georgia15Italic);
            gc.drawText("Georgia 15 Italic - The quick brown fox", 10, y, 0);
            y += lineHeight;

            // Reset to default
            gc.setFont(null);
            gc.drawText("Back to Default System Font", 10, y, 0);
        });

        shell.open();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch()) display.sleep();
        }

        // Dispose fonts
        arial12Normal.dispose();
        arial16Bold.dispose();
        arial14Italic.dispose();
        arial18BoldItalic.dispose();
        courierNew10Normal.dispose();
        courierNew14Bold.dispose();
        courierNew16Italic.dispose();
        timesNewRoman14Normal.dispose();
        timesNewRoman18Bold.dispose();
        timesNewRoman16Italic.dispose();
        timesNewRoman20BoldItalic.dispose();
        helvetica12Normal.dispose();
        helvetica15Bold.dispose();
        helvetica13Italic.dispose();
        verdana11Normal.dispose();
        verdana14Bold.dispose();
        verdana12BoldItalic.dispose();
        georgia13Normal.dispose();
        georgia17Bold.dispose();
        georgia15Italic.dispose();

        display.dispose();
    }
}

View on GitHub

Image Snippet

GC Image Snippet

Demonstrates basic image rendering operations using GC (Graphics Context).

This example shows loading an image from resources and drawing it at

original size and scaled down

GCImageSnippet.java 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package dev.equo;

import dev.equo.swt.Config;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

/**
 * Demonstrates basic image rendering operations using GC (Graphics Context).
 * This example shows loading an image from resources and drawing it at
 * original size and scaled down
 */

public class GCImageSnippet {
    public static void main (String [] args) {
        Config.forceEquo();
        Display display = new Display();
        Shell shell = new Shell(display);
        shell.setText("GCImageSnippet");
        shell.setSize(900, 720);

        Canvas canvas = new Canvas(shell, SWT.NONE);
        canvas.setBounds(50, 50, 800, 600);
        canvas.addPaintListener(e -> {
            GC gc = e.gc;

            Image image = new Image(display, GCImageSnippet.class.getClassLoader().getResourceAsStream("swt-evolve.png"));

            // 1. Original size (256x256)
            gc.drawImage(image, 20, 20);
            gc.drawText("Original (256x265)", 20, 5, true);

            // 2. Scaled down (128x128)
            gc.drawImage(image, 0, 0, 256, 256,
                       20, 300, 128, 128);
            gc.drawText("Scaled 0.5x (128x128)", 20, 285, true);

            image.dispose();
        });

        shell.open();
        while (!shell.isDisposed ()) {
            if (!display.readAndDispatch ()) display.sleep ();
        }
        display.dispose ();
    }
}

View on GitHub

Shapes Gradient Snippet

GC Shapes Gradient Snippet

Demonstrates filled shapes and gradients using GC (Graphics Context).

This example renders rectangles, ovals, polygons, and gradient effects,

including a composite landscape scene combining multiple drawing operations.

GCShapesGradientSnippet.java 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
package dev.equo;

import dev.equo.swt.Config;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

/**
 * Demonstrates filled shapes and gradients using GC (Graphics Context).
 * This example renders rectangles, ovals, polygons, and gradient effects,
 * including a composite landscape scene combining multiple drawing operations.
 */

public class GCShapesGradientSnippet {
    public static void main(String[] args) {
        Config.forceEquo();
        Display display = new Display();
        Shell shell = new Shell(display);
        shell.setText("GCShapesGradientSnippet");
        shell.setSize(850, 850);

        Canvas canvas = new Canvas(shell, SWT.NONE);
        canvas.setBounds(50, 50, 800, 800);
        canvas.addPaintListener(e -> {
            GC gc = e.gc;
            gc.setForeground(new Color(0, 0, 0));

            // Demo 1: Basic filled shapes
            gc.drawText("Basic Filled Shapes:", 50, 30, true);

            // Filled rectangle
            gc.setBackground(new Color(255, 100, 100));
            gc.fillRectangle(50, 60, 80, 60);
            gc.drawText("Rectangle", 50, 130, true);

            // Filled oval
            gc.setBackground(new Color(100, 255, 100));
            gc.fillOval(150, 60, 80, 60);
            gc.drawText("Oval", 150, 130, true);

            // Filled round rectangle
            gc.setBackground(new Color(100, 100, 255));
            gc.fillRoundRectangle(250, 60, 80, 60, 20, 20);
            gc.drawText("Round Rect", 250, 130, true);

            // Filled arc
            gc.setBackground(new Color(255, 255, 100));
            gc.fillArc(350, 60, 80, 60, 45, 180);
            gc.drawText("Arc (45°-225°)", 350, 130, true);

            // Demo 2: Filled polygons
            gc.drawText("Filled Polygons:", 50, 170, true);

            // Triangle
            gc.setBackground(new Color(255, 0, 255));
            int[] triangle = {50, 250, 100, 200, 150, 250};
            gc.fillPolygon(triangle);
            gc.drawText("Triangle", 75, 260, true);

            // Diamond
            gc.setBackground(new Color(0, 255, 255));
            int[] diamond = {225, 200, 250, 225, 225, 250, 200, 225};
            gc.fillPolygon(diamond);
            gc.drawText("Diamond", 200, 260, true);

            // Star (approximation)
            gc.setBackground(new Color(255, 165, 0));
            int[] star = {
                300, 200,   // top
                310, 220,   // right inner
                330, 220,   // right outer
                315, 235,   // right bottom inner
                325, 255,   // bottom right
                300, 245,   // bottom inner
                275, 255,   // bottom left
                285, 235,   // left bottom inner
                270, 220,   // left outer
                290, 220    // left inner
            };
            gc.fillPolygon(star);
            gc.drawText("Star", 290, 260, true);

            // Demo 3: Horizontal gradients
            gc.drawText("Horizontal Gradients:", 50, 300, true);

            gc.setForeground(new Color(255, 0, 0));  // Start color (red)
            gc.setBackground(new Color(255, 255, 0)); // End color (yellow)
            gc.fillGradientRectangle(50, 330, 150, 40, false); // Horizontal
            gc.setForeground(new Color(0, 0, 0));
            gc.drawText("Red to Yellow", 50, 380, true);

            gc.setForeground(new Color(0, 0, 255));    // Start color (blue)
            gc.setBackground(new Color(255, 255, 255)); // End color (white)
            gc.fillGradientRectangle(220, 330, 150, 40, false); // Horizontal
            gc.drawText("Blue to White", 220, 380, true);

            gc.setForeground(new Color(0, 255, 0));   // Start color (green)
            gc.setBackground(new Color(0, 0, 0));     // End color (black)
            gc.fillGradientRectangle(390, 330, 150, 40, false); // Horizontal
            gc.drawText("Green to Black", 390, 380, true);

            // Demo 4: Vertical gradients
            gc.drawText("Vertical Gradients:", 50, 410, true);

            gc.setForeground(new Color(255, 0, 255));  // Magenta
            gc.setBackground(new Color(0, 255, 255));  // Cyan
            gc.fillGradientRectangle(50, 440, 60, 80, true); // Vertical
            gc.drawText("Magenta", 50, 525, true);
            gc.drawText("to Cyan", 50, 540, true);

            gc.setForeground(new Color(255, 165, 0));  // Orange
            gc.setBackground(new Color(128, 0, 128));  // Purple
            gc.fillGradientRectangle(130, 440, 60, 80, true); // Vertical
            gc.drawText("Orange", 130, 525, true);
            gc.drawText("to Purple", 130, 540, true);

            gc.setForeground(new Color(255, 255, 255)); // White
            gc.setBackground(new Color(100, 100, 100)); // Gray
            gc.fillGradientRectangle(210, 440, 60, 80, true); // Vertical
            gc.drawText("White", 210, 525, true);
            gc.drawText("to Gray", 210, 540, true);

            // Demo 5: Mixed shapes with gradients and fills
            gc.drawText("Complex Scene:", 350, 410, true);

            // Gradient background
            gc.setForeground(new Color(135, 206, 235)); // Sky blue
            gc.setBackground(new Color(255, 255, 255)); // White
            gc.fillGradientRectangle(350, 440, 200, 100, true);

            // Sun (filled circle)
            gc.setBackground(new Color(255, 255, 0));
            gc.fillOval(450, 450, 30, 30);

            // Mountains (filled triangles)
            gc.setBackground(new Color(139, 69, 19)); // Brown
            int[] mountain1 = {350, 540, 380, 480, 410, 540};
            gc.fillPolygon(mountain1);

            int[] mountain2 = {390, 540, 430, 470, 470, 540};
            gc.fillPolygon(mountain2);

            // Trees (filled shapes)
            gc.setBackground(new Color(34, 139, 34)); // Forest green
            gc.fillOval(500, 510, 20, 20); // Tree crown
            gc.setBackground(new Color(139, 69, 19)); // Brown
            gc.fillRectangle(507, 525, 6, 15); // Tree trunk

            gc.setBackground(new Color(34, 139, 34));
            gc.fillOval(525, 505, 25, 25); // Larger tree crown
            gc.setBackground(new Color(139, 69, 19));
            gc.fillRectangle(535, 525, 6, 15); // Tree trunk

            gc.drawText("Landscape scene", 350, 550, true);
            gc.drawText("with gradients", 350, 565, true);
        });

        shell.open();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch()) display.sleep();
        }
        display.dispose();
    }
}

View on GitHub

Text Flags Snippet

GC Text Flags Snippet

Demonstrates text drawing flags in GC (Graphics Context).

This example shows the effect of DRAW_TRANSPARENT, DRAW_DELIMITER, and DRAW_TAB flags

when rendering text, with side-by-side comparisons to illustrate the differences.

GCTextFlagsSnippet.java 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
package dev.equo;

import dev.equo.swt.Config;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;

/**
 * Demonstrates text drawing flags in GC (Graphics Context).
 * This example shows the effect of DRAW_TRANSPARENT, DRAW_DELIMITER, and DRAW_TAB flags
 * when rendering text, with side-by-side comparisons to illustrate the differences.
 */

public class GCTextFlagsSnippet {
    public static void main(String[] args) {
        Config.forceEquo();
        Display display = new Display();
        Shell shell = new Shell(display);
        shell.setText("GCTextFlagsSnippet");
        shell.setSize(800, 800);

        Canvas canvas = new Canvas(shell, SWT.NONE);
        canvas.setBounds(50, 50, 750, 750);
        canvas.addPaintListener(e -> {
            GC gc = e.gc;
            gc.setForeground(new Color(0, 0, 0));
            gc.setBackground(new Color(255, 255, 255));

            // Demo 1: DRAW_TRANSPARENT flag
            gc.drawText("1. SWT.DRAW_TRANSPARENT Flag Test:", 20, 50, SWT.DRAW_TRANSPARENT);
            gc.setBackground(new Color(255, 200, 200));
            gc.fillRectangle(20, 80, 400, 80);

            // Transparent text (default behavior)
            gc.setForeground(new Color(0, 0, 0));
            gc.drawText("This text is TRANSPARENT (background shows through)", 30, 90, SWT.DRAW_TRANSPARENT);

            // Non-transparent text 
            gc.setBackground(new Color(255, 255, 255)); // White background
            gc.drawText("This text is NON-TRANSPARENT (white background)", 30, 110, 0); // No flags = opaque

            // Compare side by side
            gc.setBackground(new Color(200, 255, 200)); // Light green
            gc.fillRectangle(30, 130, 200, 25);
            gc.drawText("Transparent", 35, 135, SWT.DRAW_TRANSPARENT);

            gc.setBackground(new Color(255, 255, 255));
            gc.drawText("vs Non-transparent", 150, 135, 0);

            // Demo 2: DRAW_DELIMITER flag
            gc.setForeground(new Color(0, 0, 0));
            gc.drawText("2. SWT.DRAW_DELIMITER Flag Test:", 20, 180, SWT.DRAW_TRANSPARENT);

            // Text with various newline characters - WITH DRAW_DELIMITER
            String textWithNewlines = "Line 1\nLine 2\r\nLine 3\rLine 4";
            gc.setForeground(new Color(0, 100, 0));
            gc.drawText("WITH DRAW_DELIMITER (preserves newlines):", 30, 210, SWT.DRAW_TRANSPARENT);
            gc.drawText(textWithNewlines, 30, 230, SWT.DRAW_DELIMITER | SWT.DRAW_TRANSPARENT);

            // Text with various newline characters - WITHOUT DRAW_DELIMITER  
            gc.setForeground(new Color(100, 0, 0));
            gc.drawText("WITHOUT DRAW_DELIMITER (converts to spaces):", 30, 310, SWT.DRAW_TRANSPARENT);
            gc.drawText(textWithNewlines, 30, 330, SWT.DRAW_TRANSPARENT);

            // Demo 3: DRAW_TAB flag
            gc.setForeground(new Color(0, 0, 0)); 
            gc.drawText("3. SWT.DRAW_TAB Flag Test:", 20, 370, SWT.DRAW_TRANSPARENT);
            String textWithTabs = "Column1\tColumn2\tColumn3\tColumn4";

            // WITH DRAW_TAB flag
            gc.setForeground(new Color(0, 0, 100));
            gc.drawText("WITH DRAW_TAB (preserves tab spacing):", 30, 400, SWT.DRAW_TRANSPARENT);
            gc.drawText(textWithTabs, 30, 420, SWT.DRAW_TAB | SWT.DRAW_TRANSPARENT);

            // WITHOUT DRAW_TAB flag
            gc.setForeground(new Color(100, 0, 0));
            gc.drawText("WITHOUT DRAW_TAB (converts to spaces):", 30, 450, SWT.DRAW_TRANSPARENT);
            gc.drawText(textWithTabs, 30, 470, SWT.DRAW_TRANSPARENT);

        });

        shell.open();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch()) display.sleep();
        }
        display.dispose();
    }
}

View on GitHub