HowTos Display

Aus Salespoint

Aktuelle Version vom 14:29, 26. Mai 2010

Application

Customize Standard Images

Description: Salespoint uses a set of standard images for Backgrounds and Logos in the Shop, Statusbar, Formsheets, etc. Since version 4.0.2 you have the possibility to changes these Images or even disabling them. The Resources are stored as BufferedImage in the ResourceManager. To Modify one of this resources you have to call setStandardResource of the ResourceManager. The first argument describes the resource you wish to modify. This can be on value of the StandardResource enumeration. The second parameter is the new BufferedImage which should be used or null if you don't wish any background.

Task:

1. Disable Logo in default formsheet
2. Replace Statusbar image

Code:

1
ResourceManager.getInstance().setStandardResource(StandardResource.DEFAULT_FORMSHEET_LOGO, null);
2
ResourceManager.getInstance().setStandardResource(StandardResource.STATUSBAR_BACKGROUND, ResourceManager.getInstance().getCachedImageRessource(ResourceManager.RESOURCE_PNG, "videos.matrix"));

Windows Features

Description:
The Windows Vista/7 platform offers additional features Windows 7 Taskbar Overview which are usually not supported by Java applications. These features are the Glass effect inside Applications and Windows 7 taskbar features like Tab previews, Jumplists, Progress bars in the Taskbar and Image overlay in Taskbar. Currently, this features are only available on Windows 7 RC x86 and x64 platforms and are activated by default.

The Glass Effect
The Desktop Window Manager(DWM) allows to blur contents inside the Window. This feature is activated for FormSheet Buttonbars. To use this effect somewhere else you have to draw with a specific color on your window.

JPanel panel = new JPanel();
if (WindowsExtensions.getInstance().isGlassAvailable())
	panel.setBackground(WindowsExtensions.getInstance().glassColor);

To Disable glass:

WindowsExtensions.getInstance().useGlass = false;

Tab Preview in Win7 Taskbar
Tab Preview works automatically in Salespoints tabbed mode

Progress bar
The progress bar in the taskbar can be manipulated by to methods of the WindowsExtensions class. setProgressValue to set the actual progress and setProgressState do define the state of the taskbar.

//Set progress to 70%
WindowsExtensions.getInstance().setProgressValue(WindowsExtensions.getHandle(Shop.getInstance().getShopFrame()), 70, 100);
//Set state to normal
WindowsExtensions.getInstance().setProgressState(WindowsExtensions.getHandle(Shop.getInstance().getShopFrame()), WindowsExtension.TBPF_NORMAL);

Icon Overlay

//Display icon.ico in the taskbar
WindowsExtensions.getInstance().setOverlayIcon(WindowsExtensions.getHandle(Shop.getInstance().getShopFrame()), "C:\\icon.ico");

FormSheet

Create a FormSheet

Description: Although it is quite easy to initialize and display a FormSheet, it is a bit difficult to describe how to do it because of the vast opportunities to display them and the many possibilities to use the FormSheets and combine them with Components or even JComponents. The first thing you should do before you create your own FormSheet is to consult the framework API and take a closer look at FormSheet. There you will find all methods and of course the subClasses of FormSheet, like the LogOnForm, the MessageFormSheet, ListViewFormSheet or the TableForms, which are all specialized FormSheets of great use. Talking about the elements, every FormSheet needs a caption, which is normally defined by calling the constructor and at least some JComponents to display. These can be put together either by a FormSheetContentCreator or by creating and overwriting methods within a new FormSheet instance before or using it's methods during runtime. It is though recommended to use the ContentCreator as shown in this example, for it is able to serialize the Components and all their properities, esp. their behaviour, which will be lost if you just use FormSheet methods and serialize the Shop's status.

ToDo:

1. Instantiate a subclass of FormSheetContentCreator.
2. Add the constructor and call the superclass to inherit its methods.
3. Add the protected void createFormSheetContent(FormSheet fs) method and therein add/remove your components to the FormSheet.
4. Add the FormSheetContentCreator to your FormSheet class by calling the method addContentCreator(FormSheetContentCreator or by initializing in the constructor.

Example Source Code:

FormSheetContentCreator class:

1
public class DisplayFormSheetContentCreator extends FormSheetContentCreator
{
 
    2
    public DisplayFormSheetContentCreator()
    {
        super();
    }
 
    3
    protected void createFormSheetContent(FormSheet fs)
    {
        // add/remove your components here
        fs.removeAllButtons();
        fs.addButton("TutorialButton", 1, new ArchitectureCustomAction());
    }
}

Class that uses a FormSheet:

4
// adding the FormSheetContentCreator in FormSheet constructor
        FormSheet fs = new FormSheet("DisplayFormSheet",
                new DisplayFormSheetContentCreator(),
                false);
 
// adding the FormSheetContentCreator by using the addContentCreator method
        SingleTableFormSheet fs = SingleTableFormSheet.create(
                "DisplayFormSheet",
                catalog,
                uigate);
        fs.addContentCreator(new DisplayFormSheetContentCreator());

Define a FormSheet for a SalesPoint

Description: The recommended way to define a FormSheet for a SalesPoint is to redefine the method getDefaultFormSheet() of your Salespoint instance, which is used by the Framework to resolve the FormSheet which shall be displayed at that SalesPoint. You may also add a FormSheet during runtime by using the method setFormSheet(SaleProcess sp, FormSheet fs). As you can see, this method is also used to add a SalesProcess to the SalesPoint, which itself is able to display FormSheets. This example describes how to add a FormSheet to the SalesPoint, while the FormSheet itself should be assembled in a FormSheetContentCreator.

ToDo:

1. Redefine the method getDefaultFormSheet() in the SalesPoint class.
2. Return the FormSheet you want to use.

Example Source Code:

public class DisplaySalesPoint extends SalesPoint
{
    public DisplaySalesPoint(String sName)
    {
        super(sName);
    }
 
    1
    protected FormSheet getDefaultFormSheet()
    {
        2
        return new FormSheet("DefaultFormSheet",
                new DisplayFormSheetContentCreator(), false);
    }
}

Define a StatusFormSheet for a SalesPoint

Description: SalesPoints are being displayed in a separate window but also have a StatusDisplay at the Shop, which is the TabbedPane in the Shop's Frame, labled the name of the SalesPoint. By bringing it on top, it shows what is defined as the StatusDisplay in your SalesPoint instance and also adds the Menu defined as StatusMenuSheet in the SalesPoint instance to the Shop's MenuSheet. By default, both, the StatusFormSheet and the StatusMenuSheet are empty. Feel free to use the StatusDisplay and MenuSheet, which are equally handled to the DefaultFormSheet and the DefaultMenuSheet except that due to the strong division of the Shop and it's SalesPoints it is not possible to have processes running on it. You may trigger a Processes on it, but they will always be displayed by the SalesPoint's window. Therefor a more suitable name would be "Statical Display". For further information on Processes refer to the section "Processes". This example describes how to define a FormSheet as the SalesPoint's StatusFormSheet, while the FormSheet itself should be assembled in a FormSheetContentCreator.

ToDo:

1. Redefine the method getDefaultStatusFormSheet() in the SalesPoint class.
2. Return the FormSheet you want to use.

Example Source Code:

public class DisplaySalesPoint extends SalesPoint
{
    public DisplaySalesPoint(String sName)
    {
        super(sName);
    }
 
    1
    protected FormSheet getDefaultStatusFormSheet()
    {
        2
        return new FormSheet("StatusFormSheet",
                new DisplayFormSheetContentCreator(), false);
    }
}

Change the standard OK or CANCEL button behaviour

Description: A FormSheet initially has two buttons, one labeled "ok" and one with "cancel" on it. But they don't do anything by default, so you have to define their behaviour. There are mainly three ways to define the behaviour of the buttons. One is to create your own FormSheet and implement the methods ok() and cancel() and the other one is to remove the buttons and add your own ones with a FormSheetContentCreator. The second one is more commonly used, because it is less effort to add two buttons instead of creating lots of new FormSheets just to define the behaviour of a single click on a button. The third one is almost as common but due to the lack of influence on the button's look and feel less used. It's because here you only set an action to the standard button by resolving it with getButton(int id) and using setAction(Action action) on it. The button's ids are stored as static int in the FormSheet, where BTNID_CANCEL stands for the cancel button and BTNID_OK for the ok button. In order to make the behaviour serializable you have to define it within a FormSheetContentCreator. Otherwise the information will be lost after loading. It is also possible to alter the buttons design and caption when adding new ones.

ToDo:

1. Initialize a new FormSheet.
2. Create a new FormSheetContentCreator for the FormSheet and add it.
3. In the protected void createFormSheetContent(FormSheet fs) method of the FormSheetContentCreator remove the OK-Button by calling removeButton(int id).
4. Add a new FormButton using the addButton method. Like here you can shortly add an sale.Action to the button.
5. Set a new sale.Action to the CANCEL-Button by fetching it with the getButton(int id) method and setting the action with setAction(Action).

Example Source Code:

class where FormSheet is set:

1
FormSheet sheet = new FormSheet("DisplaySheet", null);
 
2
sheet.addContentCreator(new DisplayFormSheetContentCreator());

FormSheetContentCreator class:

2
public class DisplayFormSheetContentCreator extends FormSheetContentCreator
{
 
    3
    protected void createFormSheetContent(FormSheet fs)
    {
        fs.removeButton(FormSheet.BTNID_OK);
 
        4
        fs.addButton("Ok", 102, new DisplayCustomAction());
 
        5
        fs.getButton(FormSheet.BTNID_CANCEL).setAction(new DisplayCustomAction());
 
    }
}

Define an Action for a FormSheet Button

Description: The reason for adding buttons to your application is of course to let the user interact with it. By default, buttons don't have any functions, so you have to add a sale.Action to the button either by the method setAction(Action aAction) provided by the button or by already initializing the button with an action. Remember to put all this into a FormSheetContentCreator in order to have the Actions serialized as you save the Shop's status. Otherwise all the information will be lost after loading and the buttons will be useless.

ToDo:

1. There are two ways of defining an Action:
   1. Create a class implementing the interface Action and add the public void doAction(SaleProcess process, SalesPoint point) throws Throwable method to it. Therein define what to do if the action was called.
   2. Create an anonymous implementation of Action and define what to do if triggered.

Example Source Code:

1 a
public class DisplayCustomAction implements Action
{
 
    public void doAction(SaleProcess process, SalesPoint point) throws Throwable
    {
    // define what shall be done when triggering the action
        point.runProcess(new DisplaySaleProcess("SampleProcess"));
    }
}
 
1 b
public class DisplaySalesPoint extends SalesPoint
{
 
    protected FormSheet getDefaultFormSheet()
    {
 
        FormSheet fs = new FormSheet("FormSheet", null);
        fs.getButton(FormSheet.BTNID_OK).setAction(
                new Action()
                {
                    public void doAction(SaleProcess process, SalesPoint point) throws Throwable
                    {
                        // define what shall be done when triggering the action
                        point.runProcess(new DisplaySaleProcess("SampleProcess"));
                    }
                });
    }
}

Define an Action for a Button in a Component

Description: Sometimes you will need to add Buttons in the component part of a FormSheet, since the Button bar at the bottom may be not sufficient (e.g. too small). This has to be done within a FormSheetContentCreator when serialization is needed.

ToDo:

1. Create a new FormSheetContentCreator with the standard constructor and add the createFormSheetContent() method.
2. Create the JButton according to your needs.
3. Associate the Action that should be executed when clicking with the Button. This is done with the ActionActionListener, that takes the Action itself aswell as the FormSheet that contains the button.
4. Add the button to the FormSheet component. In this case this is done by creating a container for the button and setting it as FormSheet component. You could also use the getComponent() method of the FormSheet and manipulate the component directly (e.g. if it is already a special FormSheet).

Example Source Code:

1
public class DisplayFormSheetContentCreator extends FormSheetContentCreator
{
    public DisplayFormSheetContentCreator()
    {
        super();
    }
    protected void createFormSheetContent(FormSheet fs)
    {
        2
        JButton button = new JButton("TutorialButton");
        3
        button.addActionListener(new ActionActionListener(fs, new DisplayCustomAction()));
        4
        JPanel container = new JPanel();
        container.add(button);
        fs.setComponent(container);
    }
}

Set error handling for a FormSheet

Description: According to the type of FormSheet you use (and the purpose you use them for), it could be useful to react on errors occurring in different ways. So it is, for example, not always senseful to stop the currently running process, whenever an error occurs if you are able to correct it programatically.

Most of the FormSheets use their own strategies for handling their tasks. Here you can setup the error handlers.

ToDo:

1. Create a new FormSheetContentCreator with the standard constructor and add the createFormSheetContent() method.
2. Get the FormSheet of the type you need. In our case we assume, we've been given a DataExchangeFormSheet and therefore can use it's strategy.
3. Set the error handler you need. Basically, there are three possibilities:
   1. If the process has to be aborted immediately and an error message has to be displayed for the user, you can use the FormSheetStrategy.DEFAULT_ERROR_HANDLER. This is also set by default, so normally you don't have to do anything in this case.
   2. If the process can be continued, but a popup dialog shall be used displaying the error message for the user, you can use the FormSheetStrategy.MSG_POPUP_ERROR_HANDLER.
   3. In any other case, you will have to implement your own ErrorHandler.

Example Source Code:

1
public class DisplayFormSheetContentCreator extends FormSheetContentCreator
{
    public DisplayFormSheetContentCreator()
    {
        super();
    }
    protected void createFormSheetContent(FormSheet fs)
    {
        2
        DataExchangeFormSheet defs = (TwoTableFormSheet) fs;
        3 a
        defs.getStrategy().setErrorHandler(FormSheetStrategy.DEFAULT_ERROR_HANDLER);
        3 b
        defs.getStrategy().setErrorHandler(FormSheetStrategy.MSG_POPUP_ERROR_HANDLER);
        3 c
        defs.getStrategy().setErrorHandler(new FormSheetStrategy.ErrorHandler() {
            public void error(SaleProcess p, int nErrorCode) {
                System.out.println(p.getErrorMsg(nErrorCode));
            }
        });
    }
}

Standard FormSheet tasks

Description: As described in #Create a FormSheet, SalesPoint provides you with a vast collection of standard FormSheets that are able to take care of most of the tasks that will occur in your application. We will now have a closer look at some tasks and how to solve them.

Display contents of containers: Containers are all kinds of Catalogs, Stocks, user lists and DataBastkets that are registered in your Shop. In order to display them, you can use a SingleTableFormSheet:

SingleTableFormSheet fs = SingleTableFormSheet.create(
                "DisplayFormSheet",
                catalog,
                uigate);
        fs.addContentCreator(new DisplayFormSheetContentCreator());

You can use any of the container types mentioned above by using the appropriate static create(...) method of the SingleTableFormSheet.

Add items to or remove items from containers: Adding or removing items is a bit more complicated than simply displaying them. In this example, we will concentrate on adding and removing items in a catalog.

1. Create a SingleTableFormSheet as needed. Make sure to give the FormSheet exactly the same DataBasket that is currently used. If you are in process, you can simply use it's getBasket() method. If you don't, there will be no valid display update when changes on the container are performed.
2. Add a new FormSheetContentCreator.
3. If adding items is needed:
   1. Create an appropriate EditButtonStrategy:
      • If you wish to add items to a catalog, you can use the AbstractAddCatalogItemStrategy class. Then you simply have to override it's createCatalogItem() method according to your needs and the type of CatalogItem you need.
      • If you wish to add items to another container, you will have to create your own EditButtonStrategy. You can have a look at the AbstractAddCatalogItemStrategy as an example.
   2. Add the button to the FormSheet. Therefore we have to cast the FormSheet given to a SingleTableFormSheet.
4. If deleting items is needed:
   1. Create an appropriate EditButtonStrategy:
      • If you wish to remove items from a catalog, you can simply use the DefaultRemoveCatalogItemStrategy class. No additional implementations are needed.
      • If you wish to remove items from another container, you will have to create your own EditButtonStrategy. You can have a look at the DefaultRemoveCatalogItemStrategy as an example.
   2. Add the button to the FormSheet. Therefore we have to cast the FormSheet given to a SingleTableFormSheet.

// The catalog item needed
public class DisplayCatalogItem extends CatalogItemImpl {
    @RecoveryConstructor(parameters = {"m_sName"})
    public DisplayCatalogItem(String sName) {
        super(sName);
        setValue(new DoubleValue(100.0d));
    }
 
    protected CatalogItemImpl getShallowClone() {
        return null;
    }
}

1
        SingleTableFormSheet fs = SingleTableFormSheet.create(
                "DisplayFormSheet",
                catalog,
                uigate);
        2
        fs.addContentCreator(new FormSheetContentCreator() {
            protected void createFormSheetContent(FormSheet fs) {
                3 a
                EditButtonStrategy ebs = new AbstractAddCatalogItemStrategy(catalog) {
                    protected CatalogItem createCatalogItem(String sKey) {
                        return new DisplayCatalogItem(sKey);
                    }
                };
                3 b
                ((SingleTableFormSheet) fs).addAddButton(ebs);
                4 a
                ebs = new DefaultRemoveCatalogItemStrategy(catalog);
                4 b
                ((SingleTableFormSheet) fs).addRemoveButton(ebs);
            }
        });

Move items between containers: In order to move items between containers, you can use the TwoTableFormSheet, that has been designed especially for this kind of task. Therefore you choose a source and a destination container. The FormSheet can move items between them in both directions, depending on how you wish to use it. There are exactly eleven possible combinations of source and destination containers:

You can refer to the individual documentations on how they exactly work. When creating the DataExchangeFormSheet, simply use the create() that you need (giving null as DataBasket means the FormSheet will work outside any transitional context, causing all data manipulations to be executed immediately, without any rollback possibilities).

private FormSheet getMoveContentFormSheet(UIGate uigate, Catalog cSource, Catalog cDest)
    {
        DataExchangeFormSheet defs = DataExchangeFormSheet.create("Title", 
                    cSource, cDest, (DataBasket)null, uigate, null);
        return defs;
    }

Update a formsheet display

Description: A common problem is notifying FormSheets that the data, or at least a part of it, has been changed by some process. Now it shall display the new data. The solution for this task is to use DataBaskets in the right way. You do not tell the formsheet that it shall update itself, rather you tell the modified data element to notify all it's listeners to update all their necessary parts (e.g. table cells).

ToDo:

1. Create a new DataBasket.
2. Retrieve the CatalogItem relative to the DataBasket and tell the get method to prepare the item for editing. After that you can manipulate it in any way you want.
3. Call the DataBasket's commit method. This will put the updated item back in the container appropriately and tells all listeners such as visual display components to update themselves.

Example Source Code:

1
        DataBasket db = new DataBasketImpl();
	2
        CatalogItem ci = catalog.get("TheItemsKey", db, true);
	3
        db.commit();

Use MessageForm and MessageFormSheet

Description:
The MessageForm class is a dialog which contains a MessageFormSheet. You can use the MessageFormSheet to display some information to the user inside your SalesPoint. Or you can use the MessageForm to do this inside a popup window. A MessageForm consists of the following parts:

To display the MessageForm you need to call show() or showParallel(). Both methods differ in the fact that show() will end in a synchronous call and the other one in an asynchronous call. The asynchronous way should be preferred, but it is unable to return the pressed button. show() instead does this because it blocks until the user made its choice. If you have to call show() you need to do this form some thread outside the process machine, otherwise the application will hang because of a deadlock.

Tasks:

1. Show an asyncronous MessageForm
2. Show a "synchronous" MessageForm

Example Code:

1
new MessageForm(null, "ola", "Everything works.", MessageFormType.OK, MessageFormIcon.INFORMATION, null).showParallel();
 
2
new Thread() {
  public void run() {
    if (new MessageForm(null, "ola", "Sure you want to end the world?", MessageFormType.YES_NO, MessageFormIcon.QUESTION, null).show() == MessageFormResult.YES) {
      //lets end the world
    }
  }
}.start();
//note that code execution will continue while showing the MessageForm, because we started it in a new thread

Use The multiple Layers

Description:
Each FromSheet has a JLayeredPane, which allows you put your components on 4 different layers. The first one is the normal content layer which you can get via

formsheet.getWrappedComponent();

The next one in the order is the modal layer

formsheet.getModalLayer();

Followed by the popup layer

formsheet.getPopupLayer();

And the drag layer on which all drag'n drop operations take place

formsheet.getDragLayer();

All layers, except the first one, have no layout manager by default so you need to set position and size of your component by hand, otherwise you won't see it. Theese layers make it possible to create some fancy effects.

Tasks:

1. create a button
2. set button's position and size
3. put it in the popup layer

Example Code:

1
JButton button = new JButton("Hello, from popup layer");
2
button.setBounds(10, 10, 200, 40);
3
formsheet.getPopupLayer().add(button);

Customize the FormSheet

Description:
The FormSheetCustomizationListener allows you to paint your own background for the FormSheet's content area, for the button bar and even change the structure of the button bar.

Tasks:

1. set the FormSheetCustomizationListener
2. paint a rectangle in the content area
3. paint a rectangle in the button bar
4. add a label to the button bar

Example Code:

1
fs.setFormsheetCustomizationListener(new FormsheetCustomizationListener() {
 
  public void paintButtonBarBackground(Graphics2D g, JComponent c) {
    3
    g.fillRect(10, 10, 100, 100);			
  }
 
  public void paintComponentsBackground(Graphics2D g, JComponent c) {
    2
    g.fillRect(10, 10, 100, 100);
  }
 
  public JPanel setupButtonBar(JPanel bb) {
    4
    bb.add(new JLabel("Hello from button bar");
    JPanel buttonPanel = new JPanel();
    buttonPanel.setOpaque(false);
    bb.add(buttonPanel);
    return buttonPanel;
  }			
});

MenuSheet

Define a MenuSheet

Description: A MenuSheet displays a menu, either as a JMenuBar, a JMenu or a JPopUpMenu . It is important to know that a MenuSheet can be displayed in both ways, horizontally and vertically. In the first case you see the added MenuSheetItems as dropdownmenus (like File, Edit, Help) or submenus (like About) and in the other case as the menuItems in the submenus (like new, load, save). You can define MenuSheets wherever you need them / want them to be. But in most cases you might want them to be just a Menubar at top of the Shop window or the ones of the SalesPoints. To put them right where they belong, you overwrite the method getDefaultMenuSheet() of your SalesPoint or the createMenuSheet() method of your Shop. As mentioned above, the MenuItems or MenuSheets contained by the first defined MenuSheet will be displayed horizontally. All the other MenuSheets and Items appear in the dropdown menu of the first MenuSheet. You can "group" the Items with MenuSheetSeparators.

ToDo:

1. Locate the method where you want to define the MenuSheet. In this case a SalesPoint is chosen and its getDefaultMenuSheet() method overwritten.
2. Create the top-level MenuSheet, it's the one that will be displayed horizontally and where all other MenuSheets in this case will be added to.
3. Create another MenuSheet, it will the dropdown menu of the currently defined horizontal MenuSheet.
4. Create one MenuSheetItem, name it and add the Action that should be performed when the item is clicked.
   Add the MenuSheetItem to the dropdown menu.
5. Create a MenuSheetSeperator and add it to the menu.
6. Create and add another MenuSheetItem to the menu.
7. Add the newly created dropdown menu to the horizontal menu.
8. Return the horizontal menu.
9. Note: You can nest as many MenuSheets as you like and create really complex MenuSheet structures.

Example Source Code:

1
    public MenuSheet getDefaultMenuSheet()
    {
 
        2
        MenuSheet msMenu = new MenuSheet("HorizontalMenuSheet");
 
        3
        MenuSheet msSubMenu = new MenuSheet("myMenu");
 
        4
        MenuSheetItem msiSubItem1 = new MenuSheetItem("Perform an action",
                new DisplayCustomAction());
        msSubMenu.add(msiSubItem1);
 
        5
        MenuSheetSeparator mssSeperator = new MenuSheetSeparator();
        msSubMenu.add(mssSeperator);
 
        6
        MenuSheetItem msiSubItem2 = new MenuSheetItem("Perform another action",
                new DisplayCustomAction());
        msSubMenu.add(msiSubItem2);
 
        // add as many MenuSheetItems or MenuSheet as you like
        .
        .
        .
 
        7
        msMenu.add(msSubMenu);
 
        8
        return msSubMenu;
 
    }

Define a MenuSheet with JComponents

Description: If you want to improve the look of your menu, feel free to use JComponents. For further explanations on JComponents in menus "Using Swing Components" of java.sun.com. Adding JComponents to a MenuSheet is not as easy as adding framework MenuItems, because you can only add MenuSheetObjects with the add method. To add a JComponent anyway, you have to acces the JMenuBar in which the MenuSheet is being displayed by calling the getMenuBar() method. To this you add the JMenu with all the JMenuItems like CheckBoxes or RadioButtons added to it and which you initialize before.

ToDo:

1. Locate the method where you want to define the MenuSheet. In this case a new method getJComponentMenuSheet() was created.
2. Create the top-level MenuSheet, the one that is displayed horizontally.
3. Initialize a JMenu using the javax.swing package.
4. Initialize chosen JMenuItems and add them to the JMenu. Refer to "Using Swing Components" about possible item types.
   In this case a JCheckBoxMenuItem and a JRadioButtonMenuItem where added.
5. Get the JMenuBar of the top-level MenuSheet and add the newly created JMenu to it.
6. Finally return the MenuSheet.

Example Source Code:

1
    public MenuSheet getJComponentMenuSheet()
    {
 
        2
        MenuSheet msMenu = new MenuSheet("JComponentMenu");
 
        3
        JMenu jmMenu = new JMenu("JMenuItems");
 
        4
        JCheckBoxMenuItem jcbItem1 = new JCheckBoxMenuItem("JCheckBox");
        jmMenu.add(jcbItem1);
        JRadioButtonMenuItem jrbmItem2 = new JRadioButtonMenuItem("JRadioButtonMenuItem");
        jmMenu.add(jrbmItem2);
 
        5
        msMenu.getMenuBar().add(jmMenu);
 
        6
        return msMenu;
    }

Define a MenuSheet for a Shop

Description: Menus are essential for users interacting with an application. To create a menu in a Shop you will need to redefine the method createShopMenuSheet() of your instance of Shop.

ToDo:

In your Shop class create the method createShopMenuSheet(). Create your desired MenuSheet and return it. Therefore refer to #Define a MenuSheet.

Example Source Code:

1
public class DisplayShop extends Shop
{
 
    .
    .
    .
 
    public MenuSheet createShopMenuSheet()
    {
 
        2
        MenuSheet msMenu = new MenuSheet("ShopMenu");
 
        // add your MenuSheets and MenuSheetItems as needed
 
        .
        .
        .
 
        return msMenu;
    }
 
    .
    .
    .
 
}

Define a MenuSheet for a SalesPoint

Description: Normally you display a SalesPoint in a new window. To add a menu to it, you simply have to redefine the method getDefaultMenuSheet() of your instance of SalesPoint.

ToDo:

1. In your SalesPoint class create the method getDefaultFormSheet().
2. Create your desired MenuSheet and return it. Therefore refer to #Define a MenuSheet.

Example Source Code:

1
public class DisplaySalesPoint extends SalesPoint
{
 
    .
    .
    .
 
    public MenuSheet getDefaultMenuSheet()
    {
 
        2
        MenuSheet msMenu = new MenuSheet("HorizontalMenuSheet");
 
        // add your MenuSheets and MenuSheetItems as needed
 
        .
        .
        .
 
        return msSubMenu;
    }
 
    .
    .
    .
 
}

Define a StatusMenuSheet for a SalesPoint

Description: SalesPoints are being displayed in a separate window but also have a StatusDisplay at the Shop, which is the TabbedPane in the Shop's Frame, labled the name of the SalesPoint. By bringing it on top, it shows what is defined as the StatusDisplay in your SalesPoint instance and also adds the Menu defined as StatusMenuSheet in the SalesPoint instance to the Shop's MenuSheet. By default, both, the StatusFormSheet and the StatusMenuSheet are empty. Feel free to use the StatusDisplay and MenuSheet, which are equally handled to the DefaultFormSheet and the DefaultMenuSheet except that due to the strong division of the Shop and it's SalesPoints it is not possible to have processes running on it. You may trigger a Processes on it, but they will always be displayed by the SalesPoint's window. Therefor a more suitable name would be "Statical Display".

ToDo:

1. In your SalesPoint class create the method getDefaultStatusMenuSheet().
2. Create your desired MenuSheet and return it. Therefore refer to #Define a MenuSheet.

Example Source Code:

1
public class DisplaySalesPoint extends SalesPoint
{
 
    .
    .
    .
 
    public MenuSheet getDefaultStatusMenuSheet()
    {
 
        2
        MenuSheet msMenu = new MenuSheet("StatusMenu");
 
        // add your MenuSheets and MenuSheetItems as needed
 
        .
        .
        .
 
        return msMenu;
    }
 
    .
    .
    .
 
}

Alter a Shop's MenuSheet during runtime

Description: Sometimes there are reasons to change a Shop's MenuSheet during runtime. But in the class Shop a method setMenuSheet(MenuSheet ms) like the one in the class SalesPoint doesn't exists. This makes it a little more complicate. It is necessary to get the Shop's frame, which is actually a MultiWindow. The class MultiWindow provides the necessary public void setMenuSheet(MenuSheet newMenuSheet) method. Like this it is possible to change the MenuSheet, whenever wanted.

ToDo:

1. Get the Shop's frame, while casting it as a MultiWindow.
2. Create the new MenuSheet for the Shop.
   (See also: #Define a MenuSheet).
3. Set the new MenuSheet on the MultiWindow.

Example Source Code:

1
        DisplayShop displayShop = new DisplayShop();
        MultiWindow multiWindow = (MultiWindow) displayShop.getShopFrame();
 
    2
        MenuSheet menuShop = super.createShopMenuSheet();
        // get the first menu bar
        MenuSheet menuBar = (MenuSheet)menuShop.getTaggedItem(SHOP_MENU_TAG, false);
        // create new MenuSheetItem
        MenuSheetItem menuItemNew = new MenuSheetItem("Important", "Important_TAG",
                new sale.Action()
                {
                   public void doAction (SaleProcess p, SalesPoint sp)
                   {
                      System.out.println("very important action!");
                   }
                });
        // add it to the MenuSheet
        menuBar.add(menuItemNew);
 
    3
        multiWindow.setMenuSheet(menuShop);

Create your own MenuSheet type

Description: If you regularly need your own MenuSheet types, it may seem a bit inconvenient to create the item and afterwards manually change it's peer as described in #Define a MenuSheet with JComponents. In these cases you can create your own MenuSheet type by extending SalesPoint's MenuSheetObject according to your needs. This example describes how to create a quite simple radion button menusheet item. You can also refer to the MenuSheetItem if you wish extra functionality. Some omitted features are:

• Thread safety (via locks and synchronization)
• Support for adding Actions
• Button grouping

For the first two features, have a look at MenuSheetItem (link above), where they are already implemented. The third one could be realized using maps and Integers.

ToDo:

1. Subclass the MenuSheetObject. Since we wish to react on clicks on the item afterwards, we also implement the ActionListener interface.
2. Create a new constructor and explicitely invoke the super constructor with the given name. While doing so, we can already think of any parameters the constructor could need later. In our case these are (besides the caption) the intial checked state.
3. Add the members the item we will need. These are, in our case a reference to the swing peer radio menuitem and a menu and the checked state.
4. Implement the constructor. You could also add additional constructors that use standard values for some of the parameters.
5. Override the neccessary methods from MenuSheetObject, such that they reflect the changes in the correspondend peers:
   1. getPeer:
      Returns a JMenuItem (or a subclass of it) that represents the MenuSheetItem in a JMenu.
   2. getMenuPeer:
      Returns a JMenu that has the same caption as this MenuSheetItem and has this item as single entry.
   3. setCaption:
      Sets the caption of both the menu item peer and the menu peer.
   4. setVisible:
      Set the visibility as needed. If it is set to false, you can invalidate the peers (e.g. by setting them to null) and then recreate them when needed.
6. Add methods according to the needs of the new MenuSheetItem type. In our case we need a getter and a setter for the checked status.
7. Implement the method from the ActionListener interface. Since we added the item itself as ActionListener for the menu item peer, we can react on clicks on it and synchronize it's checked state with the checked member of the MenuSheetItem itself.

Example Source Code:

// needed imports
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JRadioButtonMenuItem;
 
import sale.MenuSheetObject;
1
public class DisplayMenuSheetItem extends MenuSheetObject implements ActionListener {
    3
    protected transient JRadioButtonMenuItem m_jrbmiPeer;
 
    protected transient JMenu m_jmMenuPeer;
 
    private boolean  m_fChecked;
    2
    public DisplayMenuSheetItem(String sCaption, boolean checked) {
        super(sCaption);
        4
        m_jrbmiPeer = null;
        m_jmMenuPeer = null;
        m_fChecked = checked;
    }
    5 a
    public JMenuItem getPeer() {
        if (m_jrbmiPeer == null) {
            m_jrbmiPeer = new JRadioButtonMenuItem(getCaption(), m_fChecked);
            m_jrbmiPeer.addActionListener(this);
            m_jmMenuPeer = null;
        }
        return m_jrbmiPeer;
    }
    5 b
    public JMenu getMenuPeer() {
        if (m_jmMenuPeer == null) {
            m_jmMenuPeer = new JMenu(getCaption());
            JRadioButtonMenuItem jmi = new JRadioButtonMenuItem(getCaption(), m_fChecked);
            jmi.addActionListener(this);
            m_jmMenuPeer.add(jmi);
        }
        return m_jmMenuPeer;
    }
    5 c
    public void setCaption(String caption) {
        super.setCaption(caption);
 
        if (m_jrbmiPeer != null) {
            m_jrbmiPeer.setText(getCaption());
        }
 
        if (m_jmMenuPeer != null) {
            m_jmMenuPeer.setText(getCaption());
            m_jmMenuPeer.getItem(0).setText(getCaption());
        }
    }
    5 d
    public void setVisible(boolean fVisible) {
        super.setVisible(fVisible);
 
        if (!fVisible) {
            m_jrbmiPeer = null;
            m_jmMenuPeer = null;
        }
    }
    6
    public boolean isChecked() {
        return m_fChecked;
    }
 
    public void setChecked(boolean checked) {
        m_fChecked = checked;
        getPeer().setSelected(m_fChecked);
    }
    7
    public void actionPerformed(ActionEvent e) {
        m_fChecked = m_jrbmiPeer.isSelected();
    }
}