Panel Factory Interface¶

The Panel Factory module defines a framework based on the Abstract Factory design pattern. The framework includes the abstract classes PanelFactory and PanelAssembler. Since these classes inherit from ABCMeta, they are truly abstract and you cannot instantiate them. Instead, you must subclass them to get concrete instances.

In our framework, any classes that inherit from PanelFactory will provide all the neccessary components for it’s particular specialization. For example, a cell panel does not have a dismiss button the way that a window panel would. As a result, we should define one factory that specializes in building cell parts and another factory that specializes in producing window parts. Some panels may have resizeable borders, others may have a fixed size. These types of panel variations would be defined by the PanelFactory.

The PanelAssembler classes will do the work of actually putting the panel parts together. Here is where the internal functionality of the panel is defined. Where the PanelFactory defines the panel type, the PanelAssembler defines a panel’s functionality.

For the sake of example, suppose you have defined your own PanelAssembler as MenuBarAssembler and a PanelFactory called MenuFactory:

 
 
 
class MenuFactory(PanelFactory):

    def add_panel(self):
        print("Creating the panel in memory.")

    def add_icon(self, icon):
        print("Adding an icon to the panel.")

    def add_title(self, title):
        pass  # menus don't have titles

    def add_borders(self):
        print("Adding borders.")

    def add_inner(self, inner):
        print("Filling in the inner content.")

    def add_dismiss(self):
        pass  # You cannot dismiss this menu

    def get_panel(self):
        print("Supplying the panel object that was configured.")


class MenuBarAssembler(PanelAssembler):

    def build_inner(self):
        return "Fancy inner menu contents."

    def create_panel(self, factory):
        factory.add_panel()
        factory.add_borders()
        factory.add_inner(self.build_inner())
        result = factory.get_panel()
        result.append("Special customizations.")
        return result

We can now use the assembler with the factory to build a menu object. The result would be:

 
 
 
>>> ma = MenuBarAssembler()
>>> mf = MenuFactory()
>>> menu_instance = ma.create_panel(mf)
Creating the panel in memory.
Adding borders.
Filling in the inner content.
Supplying the panel object that was configured.

Notice that we first create instances of the factory and the assembler. We then use the assembler and supply the factory to the assembler. Different factories would result in a different object coming out of the assembler. If we inspect the menu_instance we find:

 
>>> print(menu_instance)
['Special customizations.']

Note

PanelFactory and PanelAssembler are both modeled as singletons. As a result, when you derive from them, your subclasses will also be singletons.

class panel_factory.PanelAssembler¶

This abstract class defines the interface for producing panel instances. The PanelAssembler subclasses are able to take any PanelFactory and use it to assemble a fully functional panel. The classes which inherit from PanelAssembler also houses the logic to produce contents inside the panel as well as all the logic that makes it work.

create_panel(panel_factory, **kwargs)¶

Assemble the panel components by using the supplied factory.

Parameters:	panel_factory (PanelFactory) – Provides panel parts.

class panel_factory.PanelFactory¶

This abstract class defines an interface that all subclasses must implement. A PanelFactory produces panel parts. Different subtypes may produce parts differently or omit certain parts altogether. For example, some types of panels may not have a titlebar.

add_borders(**kwargs)¶: Build border elements for the panel.

add_dismiss(**kwargs)¶: Build any dismissal mechanisms for the panel.

add_icon(icon, **kwargs)¶

Add an icon to the panel’s title bar.

Parameters:	icon (string) – The icon used to represent the panel. Any markup will be processed before rendering.

add_inner(inner_content, **kwargs)¶

Add a placeholder in the panel where inner contents will be placed.

Parameters:	inner_content (kivy.Widget) – The root element of a widget tree containing all the interior content of the panel.

add_panel(**kwargs)¶: Instantiate the base panel widget.

add_title(title_text, **kwargs)¶

Build the panel’s title bar.

Parameters:	title_text (string) – The panel title. Markup will be processed before rendering.

get_panel(**kwargs)¶: Return the panel object.

Panel Factory Interface¶

Concrete Panel Factories¶

Panel UI Elements¶

From the Blog

Working with Pandas in Quantum