Lesson 4
Real-world Application of Structural Patterns
Real-world Application of Structural Patterns

We are progressing in our understanding of Structural Patterns. In this lesson, we’ll see how to apply them in a practical example by creating a GUI library. So far, we’ve explored the Adapter, Composite, and Decorator Patterns independently. Now, we’ll integrate these patterns within a GUI library context to form a cohesive project. Note, these patterns are abstract and can be applied in various other scenarios beyond GUI libraries.

Adapter Pattern Recap

Let's quickly revisit the Adapter Pattern. This pattern allows two incompatible interfaces to work together. We accomplish this by creating an adapter class that converts one interface to another. In the context of our GUI library, consider the following classes:

Python
1class WinButton:
2    def render(self):
3        print("Rendering a button in a Windows style.")
4
5class MacButton:
6    def display(self):
7        print("Rendering a button in a Mac style.")

Our WinButton class has a render method, while the MacButton class has a display method. To adapt MacButton to work within systems expecting a WinButton interface, we apply the Adapter Pattern by creating an adapter class:

Python
1class ButtonAdapter(WinButton):
2    def __init__(self, button):
3        self.button = button
4    
5    def render(self):
6        self.button.display()

Here, ButtonAdapter adapts MacButton to the WinButton interface, allowing it to be used interchangeably. This allows the MacButton instance to be treated like a WinButton.

Intermediate Adapter Steps

First, let's create the MacButton and wrap it with the ButtonAdapter:

Python
1mac_button = MacButton()
2win_button = ButtonAdapter(mac_button)
3win_button.render() # Output: Rendering a button in a Mac style.

This code instantiates a MacButton and adapts it using ButtonAdapter, enabling it to render with Windows style.

Composite Pattern Recap

The Composite Pattern helps us compose objects into tree structures to represent part-whole hierarchies. This allows clients to treat individual objects and compositions of objects uniformly. For our GUI library, we use the Composite Pattern to manage components:

Python
1from abc import ABC, abstractmethod
2
3class Component(ABC):
4    @abstractmethod
5    def render(self):
6        pass

Let's create a Container class that will act as a composite class containing other components:

Python
1class Container(Component):
2    def __init__(self):
3        self.components = []
4
5    def add(self, component):
6        self.components.append(component)
7
8    def remove(self, component):
9        self.components.remove(component)
10    
11    def render(self):
12        for component in self.components:
13            component.render()

We also need a Button class that will be a concrete component:

Python
1class Button(Component):
2    def render(self):
3        print("Rendering a button.")

The Container can hold and manage multiple components, such as buttons, efficiently, implementing the Composite Pattern.

Intermediate Composite Steps

Next, we create a Container and add multiple Button elements to it:

Python
1container = Container()
2container.add(Button())
3container.add(Button())
4container.render()
5# Output:
6# Rendering a button.
7# Rendering a button.

This code creates a container and adds two buttons to it, allowing the entire container to be rendered, demonstrating the Composite Pattern in action.

Bringing It All Together

By combining the Adapter and Composite Patterns, we create a flexible GUI library. We have adaptive buttons and composite containers managing multiple GUI elements. This way, we can render complex interfaces with ease, maintaining compatibility and modularity.

Here is a glimpse of how the final structure looks in our main function:

Python
1if __name__ == "__main__":
2    mac_button = MacButton()
3    win_button = ButtonAdapter(mac_button)
4    win_button.render()
5    # Output: Rendering a button in a Mac style.
6
7    container = Container()
8    container.add(Button())
9    container.add(Button())
10    container.render()
11    # Output:
12    # Rendering a button.
13    # Rendering a button.

In this code snippet, we create and adapt a MacButton to a WinButton, then render it. We also create a Container and add multiple Button elements to it, demonstrating the combination of both Adapter and Composite Patterns in a practical scenario.

Decorator Pattern Recap

The Decorator Pattern allows behavior to be added to individual objects, dynamically, without affecting the behavior of other objects from the same class. This pattern is particularly useful for enhancing the functionality of GUI components.

Let's consider the following simple Button class:

Python
1class Button(Component):
2    def render(self):
3        print("Rendering a button.")

To dynamically add behavior, such as adding a border or enabling/disabling the button, we use the Decorator Pattern:

Python
1class ButtonDecorator(Component):
2    def __init__(self, button):
3        self.button = button
4
5    def render(self):
6        self.button.render()

This ButtonDecorator class encapsulates the Button object and can add additional behavior.

Adding Behavior with Decorators

We can now create specific decorators to enhance our Button:

Python
1class BorderDecorator(ButtonDecorator):
2    def render(self):
3        self.button.render()
4        self.add_border()
5
6    def add_border(self):
7        print("Adding border.")
Python
1class EnabledDecorator(ButtonDecorator):
2    def render(self):
3        if self.is_enabled():
4            self.button.render()
5        else:
6            print("Button is disabled.")
7
8    def is_enabled(self):
9        # Assuming some logic here to determine if the button is enabled
10        return True  # Just for demonstration

We have now created two decorators — BorderDecorator and EnabledDecorator — that add specific behaviors to buttons.

Intermediate Decorator Steps

Let's see how to use these decorators with a Button:

Python
1button = Button()
2decorated_button = BorderDecorator(button)
3decorated_button.render()
4# Output:
5# Rendering a button.
6# Adding border.

This code wraps a Button object with a BorderDecorator, dynamically adding the border-rendering behavior.

To add multiple decorators, you simply stack them:

Python
1button = Button()
2decorated_button = EnabledDecorator(BorderDecorator(button))
3decorated_button.render()
4# Output:
5# If enabled: Rendering a button. Adding border.
6# If disabled: Button is disabled.

This code adds both the border and enabled behaviors to the Button.

Combining with Composite and Adapter Patterns

Finally, let's integrate decorators into our existing structure with Adapter and Composite Patterns:

Python
1if __name__ == "__main__":
2    mac_button = MacButton()
3    win_button = ButtonAdapter(mac_button)
4    decorated_win_button = BorderDecorator(win_button)
5    decorated_win_button.render()
6    # Output:
7    # Rendering a button in a Mac style.
8    # Adding border.
9
10    container = Container()
11    button1 = Button()
12    button2 = Button()
13    decorated_button1 = BorderDecorator(button1)
14    decorated_button2 = EnabledDecorator(button2)
15    container.add(decorated_button1)
16    container.add(decorated_button2)
17    container.render()
18    # Output:
19    # Rendering a button.
20    # Adding border.
21    # Rendering a button.

In this extended version of the main function, we wrap the adapted MacButton in a BorderDecorator. We also decorate individual Button objects before adding them to the Container.

Complete Code
Python
1from abc import ABC, abstractmethod
2
3class WinButton:
4    def render(self):
5        print("Rendering a button in a Windows style.")
6
7class MacButton:
8    def display(self):
9        print("Rendering a button in a Mac style.")
10
11class ButtonAdapter(WinButton):
12    def __init__(self, button):
13        self.button = button
14    
15    def render(self):
16        self.button.display()
17
18class Component(ABC):
19    @abstractmethod
20    def render(self):
21        pass
22
23class Container(Component):
24    def __init__(self):
25        self.components = []
26
27    def add(self, component):
28        self.components.append(component)
29
30    def remove(self, component):
31        self.components.remove(component)
32    
33    def render(self):
34        for component in self.components:
35            component.render()
36
37class Button(Component):
38    def render(self):
39        print("Rendering a button.")
40
41class ButtonDecorator(Component):
42    def __init__(self, button):
43        self.button = button
44
45    def render(self):
46        self.button.render()
47
48class BorderDecorator(ButtonDecorator):
49    def render(self):
50        self.button.render()
51        self.add_border()
52
53    def add_border(self):
54        print("Adding border.")
55
56class EnabledDecorator(ButtonDecorator):
57    def render(self):
58        if self.is_enabled():
59            self.button.render()
60        else:
61            print("Button is disabled.")
62
63    def is_enabled(self):
64        # Assuming some logic here to determine if the button is enabled
65        return True
66
67if __name__ == "__main__":
68    mac_button = MacButton()
69    win_button = ButtonAdapter(mac_button)
70    decorated_win_button = BorderDecorator(win_button)
71    decorated_win_button.render()
72    # Output:
73    # Rendering a button in a Mac style.
74    # Adding border.
75
76    container = Container()
77    button1 = Button()
78    button2 = Button()
79    decorated_button1 = BorderDecorator(button1)
80    decorated_button2 = EnabledDecorator(button2)
81    container.add(decorated_button1)
82    container.add(decorated_button2)
83    container.render()
84    # Output:
85    # Rendering a button.
86    # Adding border.
87    # Rendering a button.

By incorporating the Decorator Pattern alongside Adapter and Composite Patterns, we've demonstrated a powerful approach to building extensible and maintainable GUI libraries. This enables you to compose flexible, dynamic behaviors within your GUI components seamlessly.

Conclusion

By merging the Adapter, Composite, and Decorator Patterns, we can build a versatile and efficient GUI library. This combination helps us create adaptive buttons and manage complex GUI elements through composite containers, showcasing how different structural patterns can be used together to enhance design and functionality. This approach not only makes the system more robust but also ensures ease of maintenance and extension.

Enjoy this lesson? Now it's time to practice with Cosmo!
Practice is how you turn knowledge into actual skills.