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

/**
 * AbstractFactory: Defines the creation contract for product families.
 * 
 * DESIGN DECISIONS:
 * 
 * 1. Interface vs Abstract Class:
 *    - Use interface when factories have no shared implementation
 *    - Use abstract class when factories share common behavior
 *    
 * 2. Return types are ALWAYS abstract product types:
 *    - Button, not WindowsButton
 *    - This enforces client abstraction
 *    
 * 3. Method naming convention: "create" + ProductType
 *    - Clearly communicates object creation
 *    - Consistent across all factory patterns
 *    
 * 4. No state by default:
 *    - The interface declares only creation methods
 *    - Concrete factories may hold configuration state
 */
public interface GUIFactory {
    
    // Each method returns an ABSTRACT product type
    Button createButton();
    TextField createTextField();
    Checkbox createCheckbox();
    Menu createMenu();
    Dialog createDialog();
    
    // Optional: Factory method for creating configured panels
    // This shows how factories can create composite products
    default Panel createLoginPanel() {
        Button submit = createButton();
        TextField username = createTextField();
        TextField password = createTextField();
        
        submit.setText("Login");
        username.setPlaceholder("Username");
        password.setPlaceholder("Password");
        
        return new Panel(submit, username, password);
    }
}

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

/**
 * ConcreteFactory: Creates products for the Windows family.
 * 
 * KEY CHARACTERISTICS:
 * 
 * 1. Knows about ONE family only (Windows)
 *    - Imports only Windows-specific classes
 *    - Knows nothing about macOS or Linux
 * 
 * 2. May hold family-specific configuration
 *    - Theme settings, DPI scaling, etc.
 *    - Detected at construction time
 * 
 * 3. Each creation method returns the interface type
 *    - Returns Button, not WindowsButton
 *    - Internal type is WindowsButton, but signature hides this
 */
public class WindowsFactory implements GUIFactory {
    
    // Family-specific configuration (detected at construction)
    private final WindowsTheme theme;
    private final DpiScale dpiScale;
    private final AccessibilitySettings a11y;
    
    public WindowsFactory() {
        this.theme = WindowsTheme.detectCurrent();
        this.dpiScale = DpiScale.detectSystem();
        this.a11y = AccessibilitySettings.load();
    }
    
    @Override
    public Button createButton() {
        // 1. Instantiate family-specific class
        WindowsButton button = new WindowsButton();
        
        // 2. Apply family-specific configuration
        button.applyTheme(theme);
        button.setDpiScale(dpiScale);
        button.setHighContrastMode(a11y.isHighContrastEnabled());
        button.setFlatAppearance(theme.isModernStyle());
        
        // 3. Return as abstract type (Button, not WindowsButton)
        return button;
    }
    
    @Override
    public TextField createTextField() {
        WindowsTextField field = new WindowsTextField();
        field.applyTheme(theme);
        field.setDpiScale(dpiScale);
        field.setBorderStyle(theme.getTextFieldBorder());
        return field;
    }
    
    @Override
    public Checkbox createCheckbox() {
        WindowsCheckbox checkbox = new WindowsCheckbox();
        checkbox.applyTheme(theme);
        checkbox.setDpiScale(dpiScale);
        checkbox.setCheckStyle(theme.getCheckboxStyle());
        return checkbox;
    }
    
    @Override
    public Menu createMenu() {
        WindowsMenu menu = new WindowsMenu();
        menu.applyTheme(theme);
        menu.setDpiScale(dpiScale);
        // Windows: menus are attached to windows, not screen-level
        menu.setMenuBarLocation(MenuBarLocation.IN_WINDOW);
        return menu;
    }
    
    @Override
    public Dialog createDialog() {
        WindowsDialog dialog = new WindowsDialog();
        dialog.applyTheme(theme);
        dialog.setDpiScale(dpiScale);
        // Windows convention: OK button before Cancel
        dialog.setButtonOrder(ButtonOrder.OK_CANCEL);
        return dialog;
    }
}
 
/**
 * ConcreteFactory: Creates products for the macOS family.
 * 
 * Different family = different conventions:
 * - Button order in dialogs is opposite (Cancel, OK)
 * - Menus appear at screen level, not in windows
 * - Different animation styles
 */
public class MacOSFactory implements GUIFactory {
    
    private final MacOSAppearance appearance;
    private final RetinaScale retina;
    
    public MacOSFactory() {
        this.appearance = MacOSAppearance.detectCurrent();
        this.retina = RetinaScale.detectDisplay();
    }
    
    @Override
    public Button createButton() {
        MacOSButton button = new MacOSButton();
        button.setAppearance(appearance);
        button.setRetinaScale(retina);
        button.setRoundedStyle(true);         // macOS signature
        button.setHasPulseAnimation(true);     // Pulse on focus
        return button;
    }
    
    @Override
    public TextField createTextField() {
        MacOSTextField field = new MacOSTextField();
        field.setAppearance(appearance);
        field.setRetinaScale(retina);
        field.setFocusRingEnabled(true);       // Blue focus ring
        return field;
    }
    
    @Override
    public Checkbox createCheckbox() {
        MacOSCheckbox checkbox = new MacOSCheckbox();
        checkbox.setAppearance(appearance);
        checkbox.setRetinaScale(retina);
        checkbox.setAnimated(true);            // Smooth animation
        return checkbox;
    }
    
    @Override
    public Menu createMenu() {
        MacOSMenu menu = new MacOSMenu();
        menu.setAppearance(appearance);
        menu.setRetinaScale(retina);
        // macOS: menus are at the top of the screen
        menu.setMenuBarLocation(MenuBarLocation.SCREEN_TOP);
        menu.setShowsAppleMenu(true);
        return menu;
    }
    
    @Override
    public Dialog createDialog() {
        MacOSDialog dialog = new MacOSDialog();
        dialog.setAppearance(appearance);
        dialog.setRetinaScale(retina);
        // macOS convention: Cancel button before OK (opposite of Windows!)
        dialog.setButtonOrder(ButtonOrder.CANCEL_OK);
        dialog.setSheetStyle(true);            // Slides from title bar
        return dialog;
    }
}

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

/**
 * AbstractProduct: Button
 * 
 * DESIGN CONSIDERATIONS:
 * 
 * 1. Include only cross-family operations:
 *    - render(), onClick(), setText() — all buttons do this
 *    - NOT: setFlatStyle() — Windows-specific
 *    - NOT: setPulseAnimation() — macOS-specific
 * 
 * 2. Generic enough for all implementations:
 *    - Don't assume specific rendering technology
 *    - Don't assume specific event systems
 * 
 * 3. Rich enough for client needs:
 *    - If clients need a behavior, it must be in the interface
 *    - Otherwise clients must downcast (defeats the pattern)
 */
public interface Button {
    
    /**
     * Renders the button to the screen.
     * Implementation will use platform-specific rendering APIs.
     */
    void render();
    
    /**
     * Registers a click handler.
     * @param handler The action to execute when clicked
     */
    void onClick(Runnable handler);
    
    /**
     * Sets the button's display text.
     * @param text The text to display
     */
    void setText(String text);
    
    /**
     * Gets the button's current text.
     * @return The current display text
     */
    String getText();
    
    /**
     * Enables or disables the button.
     * Disabled buttons don't respond to clicks.
     * @param enabled true to enable, false to disable
     */
    void setEnabled(boolean enabled);
    
    /**
     * Checks if the button is currently enabled.
     * @return true if enabled
     */
    boolean isEnabled();
    
    /**
     * Sets keyboard shortcut for this button.
     * Implementation maps to platform-specific shortcut system.
     * @param modifiers Modifier keys (Ctrl, Alt, etc.)
     * @param key The primary key
     */
    void setShortcut(int modifiers, int key);
    
    /**
     * Sets the button's visual style.
     * Platform implementations may interpret this differently.
     * @param style PRIMARY, SECONDARY, DANGER, etc.
     */
    void setStyle(ButtonStyle style);
}
 
/**
 * AbstractProduct: Dialog
 * 
 * Demonstrates more complex product interface with
 * platform-specific behavioral differences abstracted away.
 */
public interface Dialog {
    
    /**
     * Shows the dialog modally.
     * On macOS, this may appear as a sheet sliding from the title bar.
     * On Windows, this appears as a centered modal window.
     */
    void show();
    
    /**
     * Hides the dialog.
     */
    void hide();
    
    /**
     * Sets the dialog title.
     * @param title The title text
     */
    void setTitle(String title);
    
    /**
     * Sets the dialog's main content.
     * @param content The component to display in the dialog body
     */
    void setContent(Component content);
    
    /**
     * Adds a button to the dialog's button bar.
     * Button order is determined by platform conventions,
     * NOT by the order buttons are added.
     * 
     * @param button The button to add
     * @param role CONFIRM, CANCEL, or NEUTRAL
     */
    void addButton(Button button, DialogButtonRole role);
    
    /**
     * Gets the result after dialog is closed.
     * @return The result indicating how the dialog was closed
     */
    DialogResult getResult();
    
    /**
     * Registers a handler for dialog close events.
     * @param handler Called when the dialog closes for any reason
     */
    void onClose(Consumer<DialogResult> handler);
}

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
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205

/**
 * ConcreteProduct: Windows Button Implementation
 * 
 * This class knows about Windows-specific:
 * - Win32 API for rendering
 * - Windows message loop for events
 * - Windows DPI scaling
 * - Windows accessibility APIs
 */
public class WindowsButton implements Button {
    
    // Windows-specific state
    private HWND hwnd;                    // Win32 window handle
    private WindowsTheme theme;
    private DpiScale dpiScale;
    private boolean flatStyle = false;
    private boolean highContrast = false;
    
    // Common state
    private String text = "";
    private boolean enabled = true;
    private Runnable clickHandler;
    private ButtonStyle style = ButtonStyle.SECONDARY;
    
    @Override
    public void render() {
        if (hwnd == null) {
            // Create the Win32 button control
            hwnd = User32.CreateWindowEx(
                0,
                "BUTTON",
                text,
                flatStyle ? WS_FLAT : WS_RAISED,
                // ... position and size from layout
            );
        }
        
        // Apply current visual state
        applyThemeColors();
        applyDpiScaling();
        
        if (highContrast) {
            applyHighContrastColors();
        }
        
        // Trigger Win32 repaint
        User32.InvalidateRect(hwnd, null, true);
    }
    
    @Override
    public void onClick(Runnable handler) {
        this.clickHandler = handler;
        // Windows: register WM_COMMAND handler
        WindowsMessageLoop.registerHandler(hwnd, WM_COMMAND, () -> {
            if (enabled && clickHandler != null) {
                clickHandler.run();
            }
        });
    }
    
    @Override
    public void setText(String text) {
        this.text = text;
        if (hwnd != null) {
            User32.SetWindowText(hwnd, text);
        }
    }
    
    @Override
    public String getText() {
        return text;
    }
    
    @Override
    public void setEnabled(boolean enabled) {
        this.enabled = enabled;
        if (hwnd != null) {
            User32.EnableWindow(hwnd, enabled);
        }
    }
    
    @Override
    public boolean isEnabled() {
        return enabled;
    }
    
    @Override
    public void setShortcut(int modifiers, int key) {
        // Register Windows keyboard accelerator
        WindowsAccelerator accelerator = new WindowsAccelerator(modifiers, key);
        AcceleratorTable.register(hwnd, accelerator, clickHandler);
    }
    
    @Override
    public void setStyle(ButtonStyle style) {
        this.style = style;
        // Map to Windows button styles
        switch (style) {
            case PRIMARY -> setBSStyle(BS_DEFPUSHBUTTON);
            case DANGER -> setCustomColors(Colors.RED, Colors.WHITE);
            default -> setBSStyle(BS_PUSHBUTTON);
        }
    }
    
    // Windows-specific configuration (called by factory)
    public void applyTheme(WindowsTheme theme) {
        this.theme = theme;
    }
    
    public void setDpiScale(DpiScale scale) {
        this.dpiScale = scale;
    }
    
    public void setFlatAppearance(boolean flat) {
        this.flatStyle = flat;
    }
    
    public void setHighContrastMode(boolean highContrast) {
        this.highContrast = highContrast;
    }
}
 
/**
 * ConcreteProduct: macOS Button Implementation
 * 
 * Uses Cocoa/AppKit APIs for native macOS appearance.
 */
public class MacOSButton implements Button {
    
    // macOS-specific state (Cocoa/AppKit)
    private NSButton nsButton;
    private MacOSAppearance appearance;
    private RetinaScale retinaScale;
    private boolean rounded = true;
    private boolean pulseAnimation = false;
    
    // Common state
    private String text = "";
    private boolean enabled = true;
    private Runnable clickHandler;
    
    @Override
    public void render() {
        if (nsButton == null) {
            // Create Cocoa button
            nsButton = NSButton.alloc().init();
            nsButton.setBezelStyle(
                rounded ? NSBezelStyleRounded : NSBezelStyleSquare
            );
        }
        
        nsButton.setTitle(text);
        nsButton.setEnabled(enabled);
        
        // Apply retina scaling
        if (retinaScale.isRetina()) {
            nsButton.layer().setContentsScale(2.0);
        }
        
        // Apply appearance (light/dark mode)
        nsButton.setAppearance(
            appearance.isDarkMode() 
                ? NSAppearance.darkAqua() 
                : NSAppearance.aqua()
        );
    }
    
    @Override
    public void onClick(Runnable handler) {
        this.clickHandler = handler;
        // macOS: target-action pattern
        nsButton.setTarget(this);
        nsButton.setAction("buttonClicked:");
    }
    
    // Called by Cocoa runtime
    public void buttonClicked(NSObject sender) {
        if (enabled && clickHandler != null) {
            clickHandler.run();
        }
    }
    
    @Override
    public void setShortcut(int modifiers, int key) {
        // macOS: key equivalents
        nsButton.setKeyEquivalent(keyCodeToString(key));
        nsButton.setKeyEquivalentModifierMask(mapModifiers(modifiers));
    }
    
    // macOS-specific configuration
    public void setRoundedStyle(boolean rounded) {
        this.rounded = rounded;
    }
    
    public void setHasPulseAnimation(boolean pulse) {
        this.pulseAnimation = pulse;
        if (pulse && nsButton != null) {
            // Add Core Animation pulse effect
            nsButton.layer().addAnimation(
                createPulseAnimation(), 
                "focusPulse"
            );
        }
    }
}

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

/**
 * Client: Uses abstract factories without knowing concrete types.
 * 
 * CRITICAL RULES FOR CLIENTS:
 * 
 * 1. No imports of concrete factories:
 *    - ✓ import GUIFactory;
 *    - ✗ import WindowsFactory;
 * 
 * 2. No imports of concrete products:
 *    - ✓ import Button;
 *    - ✗ import WindowsButton;
 * 
 * 3. No instanceof checks for families:
 *    - ✗ if (button instanceof WindowsButton)
 * 
 * 4. No platform-specific code:
 *    - ✗ if (System.getProperty("os.name").contains("Windows"))
 */
public class FormBuilder {
    
    private final GUIFactory factory;  // Only abstraction!
    
    /**
     * Constructor injection: factory provided from outside.
     * The client doesn't know or care which factory it receives.
     */
    public FormBuilder(GUIFactory factory) {
        this.factory = factory;
    }
    
    /**
     * Builds a contact form.
     * This method is completely platform-agnostic.
     */
    public Form buildContactForm() {
        // Create products through factory
        TextField nameField = factory.createTextField();
        TextField emailField = factory.createTextField();
        TextField messageField = factory.createTextField();
        Button submitButton = factory.createButton();
        Button clearButton = factory.createButton();
        
        // Configure using abstract interfaces
        nameField.setPlaceholder("Your Name");
        emailField.setPlaceholder("Email Address");
        emailField.setValidation(Validators.email());
        messageField.setPlaceholder("Message");
        
        submitButton.setText("Send");
        submitButton.setStyle(ButtonStyle.PRIMARY);
        submitButton.onClick(this::handleSubmit);
        
        clearButton.setText("Clear");
        clearButton.onClick(this::handleClear);
        
        // Build and return form
        return new Form(
            nameField, emailField, messageField,
            submitButton, clearButton
        );
    }
    
    /**
     * Shows a confirmation dialog.
     * Works identically on Windows, macOS, Linux.
     */
    public boolean showConfirmation(String title, String message) {
        Dialog dialog = factory.createDialog();
        Button confirmButton = factory.createButton();
        Button cancelButton = factory.createButton();
        
        dialog.setTitle(title);
        dialog.setContent(new Label(message));
        
        confirmButton.setText("Confirm");
        cancelButton.setText("Cancel");
        
        // Note: button ORDER is platform-specific,
        // but we use ROLES so the platform can order correctly.
        dialog.addButton(confirmButton, DialogButtonRole.CONFIRM);
        dialog.addButton(cancelButton, DialogButtonRole.CANCEL);
        
        dialog.show();  // Blocks until closed
        
        return dialog.getResult() == DialogResult.CONFIRMED;
    }
    
    /**
     * Builds a complex settings panel with multiple sections.
     */
    public Panel buildSettingsPanel() {
        // Create nested structure using factory
        Panel generalSection = buildGeneralSettings();
        Panel appearanceSection = buildAppearanceSettings();
        Panel advancedSection = buildAdvancedSettings();
        
        // Create section headers
        Menu sectionsMenu = factory.createMenu();
        sectionsMenu.addItem("General", () -> showSection(generalSection));
        sectionsMenu.addItem("Appearance", () -> showSection(appearanceSection));
        sectionsMenu.addItem("Advanced", () -> showSection(advancedSection));
        
        return new SettingsPanel(sectionsMenu, 
            generalSection, appearanceSection, advancedSection);
    }
    
    private Panel buildGeneralSettings() {
        Checkbox autoSave = factory.createCheckbox();
        Checkbox showWelcome = factory.createCheckbox();
        
        autoSave.setLabel("Auto-save changes");
        showWelcome.setLabel("Show welcome screen at startup");
        
        // All checkboxes are configured through abstract interface.
        // Whether they animate smoothly (macOS) or respond
        // instantly (Windows) is encapsulated in the product.
        
        return new Panel(autoSave, showWelcome);
    }
}