Library toolkit_lib

All Classes, All Libraries

Index: A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z

• Classes
• Data
• Functions
• OTHER_DOCUMENTATION

Classes

ActionEvent

The ActionEvent class manages ActionEvents, which are sent when an action takes place on a toolkit component. An example of this is when a user presses a FlexButton.

ActionListenerInterface

The ActionListenerInterface class is the abstract base class for ActionListener objects. It is the listener interface for receiving action events.

Adjustable

The Adjustable class is a base class of objects that have a minimum and maximum boundary and a value that is within these boundaries.

AdjustmentEvent

The AdjustmentEvent class manages AdjustmentEvents, which are sent when the value of an Adjustable toolkit component changes. An example of this is when a user presses a scrollbar.

AdjustmentListenerInterface

The AdjustmentListenerInterface class is the abstract base class for AdjustmentListener objects. It is the listener interface for receiving adjustment events.

ComponentAdapter

The ComponentAdapter class is a subclass of ComponentListenerInterface to be notified of component events. This subclass provides empty function definitions so that a new subclass does not have to override all the functions in ComponentListenerInterface.

ComponentEvent

The ComponentEvent is generated and sent to a ComponentListener when a FlexComponent is hidden, moved, resized, or shown.

ComponentListenerInterface

ComponentListenerInterface is the abstract base class for ComponentListener objects. It is the listener interface for receiving component events.

ContainerAdapter

The ContainerAdapter class is a subclass of ContainerListenerInterface. This subclass provides empty function definitions so that a new subclass does not have to override all the functions in ContainerListenerInterface.

ContainerEvent

The ContainerEvent is generated and sent to a ContainerListener when a FlexComponent is added or removed from a container.

ContainerListenerInterface

ContainerListenerInterface is the abstract base class for ContainerListener objects. It is the listener interface for receiving container events.

DialogLayout

The DialogLayout class implements a layout manager that organizes components in a way that is useful for creating dialog boxes.

Dimension

The Dimension class is used to pass height and width information. A Dimension object contains a height and width value that can be retrieved or stored. Dimension objects are used by FlexUI to pass size information of FlexComponents.

EventListenerInterface

EventListenerInterface is the base class for listeners of toolkit events.

FilterEvent

The FilterEvent manages FilterEvents, which are sent out to the FilterListener when a user inputs text into the text object. By changing the value of the _character data member, the application can filter out or change unwanted characters.

FilterListenerInterface

FilterListenerInterface is the abstract base class for text FilterListener objects. It is the listener interface for receiving filter events.

FlexButton

The FlexButton class creates a standard button for use in user interfaces. The button can be labeled with either a string or an image. When the button is pressed, an ActionEvent is sent to all registered ActionListeners. To register an action listener, call AddActionListener.

FlexCanvas

The FlexCanvas class is a component intended for the application writer to subclass. A FlexCanvas object allows the programmer to draw directly to the image by subclassing paint. A programmer can also create custom gadgets by intercepting events, such as mouse presses, on this component.

FlexCheckbox

The FlexCheckbox class creates a standard Checkbox for use in user interfaces. The Checkbox can be labeled with either a string or an image but cannot be labeled with both at the same time. When the Checkbox is selected/deselected, an ItemEvent is sent to all registered ItemListenerInterfaces. To register an ItemListenerInterface, call AddItemListener. FlexCheckboxes can be grouped together in a FlexCheckboxGroup to provide mutual exclusion.

FlexCheckboxGroup

The FlexCheckboxGroup allows a maximum of 255 FlexCheckboxes to be placed together in one mutually exclusive group. Only one (or none) of the checkboxes in a group can be selected at a time.

FlexComponent

This is the base class for the UI components in the toolkit library. This class should not be used by itself. Instead, application writers should use the subclasses of FlexComponent. The common API that all components share for registering listeners, setting and getting the width/height, and drawing to the screen is defined in FlexComponent class.

FlexContainer

FlexContainer is the base class for all Toolkit objects that can have children.

FlexDialog

The FlexDialog class consists of windows that are are displayed over other components on the screen. They are normally used to display momentary information or take input from the user.

FlexFrame

This type of window is used mostly as a background for the contents of a main screen.

FlexHorizontalPanel

The FlexHorizontalPanel comes with a default HorizontalFlowLayout layout manager. The application does not have to worry about tracking and destroying the default layout manager.

FlexImage

The FlexImage is a components that displays a bitmap. The FlexImage class will not destroy the Bitmap object in its destructor; it is up to the application to destroy the data.

FlexInk

The FlexInk is used to accept ink data from the user and display ink data.

FlexLabel

A component that displays a single line of read-only text.

FlexList

The FlexList is a component that maintains a list of strings. A FlexScrollbar is automatically added when there are more elements in the FlexList than can be displayed given the number of rows with which the FlexList has been initialized. FlexLists have two modes. In single mode, the FlexList can have only one item selected at a time. A selected item can only be deselected by selecting a different item. In multiple mode, multiple items can be selected at one time, and an item can be toggled selected/deselected. See SetMultipleMode(). When an item in the FlexList is selected/deselected, an ItemEvent is sent to all registered ItemListenerInterfaces. To register an ItemListenerInterface, call AddItemListener. The maximum number of items that can be added to a list is MAX_LIST_ITEMS. #ifdef __arm

FlexMenu

The FlexMenu class implements a menu component.

FlexMenuButton

The FlexMenuButton class implements a standard menu item.

FlexPanel

The FlexPanel class is used for grouping components that need to be laid out together. This object is similar to the FlexContainer, with the exception that it is instantiated via the UIFactory, which allows the specific-ui library to create a custom appearance (for example, a border) or to support custom geometry managers.

FlexScrollPane

This is a special type of FlexContainer that scrolls a single child by providing automatic scrollbars, or can be scrolled by calling SetScrollPosition().

FlexScrollbar

The FlexScrollbar class creates a scrollbar for use in user interfaces. When the FlexScrollbar's value changes, an AdjustmentEvent is sent to all registered AdjustmentListenerInterfaces.

FlexTable

The FlexTable class manages the table component, which provides a way to display data formatted into rows and columns. The table can scroll in the vertical direction to show rows that do not fit on the screen. Tables can have a selection bar that highlights a group of cells.

FlexTextArea

The FlexTextArea is a multi-line text component that allows you to edit or view multiple lines of text.

FlexTextComponent

FlexTextComponent is the parent class of FlexTextField and FlexTextArea. This class implements the functions common to both classes.

FlexTextField

The FlexTextField class creates a single-line text object that is user-editable.

FlexVerticalPanel

The FlexVerticalPanel comes with a default VerticalFlowLayout layout manager. The application does not have to worry about tracking and destroying the default layout manager.

FlexWindow

This is the superclass for all window-style containers.

FlowLayout

FlowLayout is the base class for layout managers that arrange components in a straight line.

FocusAdapter

The FocusAdapter class is a subclass of FocusListenerInterface to be notified of FocusEvents. This subclass provides empty function definitions so that a new subclass does not have to override all the functions in FocusListenerInterface.

FocusChangeEvent

The FocusChangeEvent class implements FocusChangeEvents, which are passed to FocusChangeListener objects that are registered with the AppBase via AddFocusChangeListener(). This event is generated whenever the focus changes under the application.

FocusChangeListenerInterface

FocusChangeListenerInterface is a listener class that is notified when the focus under an application changes. It is registered with the AppBase object when you call AppBase::AddFocusChangeListener() and unregistered when you call AppBase::RemoveFocusChangeListener().

FocusEvent

The FocusEvent is created and sent to a FocusListener when a FlexComponent has gained or received focus.

FocusListenerInterface

FocusListenerInterface is the abstract base class for FocusListener objects. It is the listener interface for receiving focus events.

FocusManagerInterface

FocusManagerInterface is the interface class from which all FocusManager objects are subclassed.

HorizontalFlowLayout

The HorizontalFlowLayout class implements a layout manager that arranges components along a horizontal line with a variety of spacing options.

InkAdapter

The InkAdapter class is a subclass of InkListenerInterface to be notified of ink events. This subclass provides empty function definitions so that a new subclass does not have to override all the functions in InkListenerInterface.

InkEvent

The InkEvent is created and sent to an InkListener when a FlexInk has started and finished drawing.

InkListenerInterface

InkListenerInterface is the abstract base class for InkListener objects. It is the listener interface for receiving ink events.

InputEvent

The InputEvent class is a base class for input events, specifically MouseEvent and KeyEvent. Consume() an event if someone wants it to not be used any more. IsConsumed() verifies that the event is no longer valid.

InsetHorizontalFlowLayout

The InsetHorizontalFlowLayout class implements a horizontal flow layout that can be used as a starting point for more complicated layouts. It provides the ability to constrain the flow within a particular area of the container and to limit the range of affected children.

InsetVerticalFlowLayout

The InsetVerticalFlowLayoutclass implements a vertical flow layout that can be used as a starting point for more complicated layouts. It provides the ability to constrain the flow within a particular area of the container and to limit the range of affected children.

Insets

The Insets class implements storage for the margins of a FlexContainer. Layout managers usually operate within these margins.

ItemEvent

The ItemEvent is sent when the selected state of an ItemSelectable object changes. An example of this is when the selected state of a FlexCheckbox changes from TRUE to FALSE.

ItemListenerInterface

ItemListenerInterface is the abstract base class for ItemListener objects. It is the listener interface for receiving item events.

ItemSelectable

ItemSelectable is a base class that contains a set of items for which zero or more can be selected. Examples include FlexCheckbox, FlexList, FlexChoice, and FlexCheckboxMenuItem.

KeyAdapter

The KeyAdapter class is a subclass of KeyListenerInterface to be notified of key events. This subclass provides empty function definitions so that a new subclass does not have to override all the functions in KeyListenerInterface.

KeyEvent

The KeyEvent is created and sent to a KeyListener when the FlexComponent receives a key press or key release.

KeyListenerInterface

KeyListenerInterface is the abstract base class for KeyListener objects. It is the listener interface for receiving key events.

LayoutManagerInterface

LayoutManagerInterface is the interface class from which all LayoutManager objects are subclassed.

MenuAdapter

The MenuAdapter class is a subclass of MenuListenerInterface to be notified of menu events. This subclass provides empty function definitions so that a new subclass does not have to override all the functions in MenuListenerInterface.

MenuEvent

The MenuEvent is created and sent to a MenuListener when a menu item is chosen.

MenuItem

The MenuItem class forms part of the inheritance hierarchy for any component that is placed inside a menu window. The other part of the inheritance comes from some FlexComponent that best represents the desired behavior of the item (like a button or a checkbox). In other words, a FlexComponent can become 'menuable' by multiply inheriting from MenuItem (with some extra customizations).

MenuListenerInterface

This class is the abstract base class for MenuListener objects. It is the listener interface for receiving menu events.

MouseAdapter

The MouseAdapter class is a subclass of MouseListenerInterface to be notified of mouse events. This subclass provides empty function definitions so that a new subclass does not have to override all the functions in MouseListenerInterface.

MouseEvent

The MouseEvent is created and sent to a MouseListener when a FlexComponent has received a mouse press, mouse release, or mouse drag. For definitions of PointerState and PointerAction, please refer to include/driver/pointer.h

MouseListenerInterface

MouseListenerInterface is the abstract base class for MouseListener objects. It is the listener interface for receiving mouse events.

MouseMotionAdapter

The MouseMotionAdapter class is a subclass of MouseMotionListenerInterface to be notified of mouse motion events. This subclass provides empty function definitions so that a new subclass does not have to override all the functions in MouseMotionListenerInterface.

MouseMotionListenerInterface

MouseMotionListenerInterface is the abstract base class for MouseMotionListener objects. It is the listener interface for receiving mouse motion events.

TableAdapter

The TableAdapter class is a subclass of TableListenerInterface to be notified of table events. This subclass provides empty function definitions so that a new subclass does not have to override all the functions in TableListenerInterface.

TableEvent

The TableEvent is created and sent to a TableListenerInterface when the FlexTable needs to be redrawn or the selection has changed. This event is subclassed from TitleEvent to get the drawing functionality. Usage Please note that TableEvent is a subclass of TitleEvent. In TitleEvent you will find data members that represent the drawing boundaries as well as other drawing related information.

TableListenerInterface

TableListenerInterface is the abstract base class for TableListener objects. It is the listener interface for receiving table events.

TargetChangeEvent

The TargetChangeEvent class implements TargetChangeEvents, which are passed to TargetChangeListener objects that are registered with the AppBase via AddTargetChangeListener(). This event is generated whenever the target changes under the application.

TargetChangeListenerInterface

TargetChangeListenerInterface is a listener class that is notified when the target under an application changes. It is registered with the AppBase object when you call AppBase::AddTargetChangeListener() and unregistered when you call AppBase::RemoveTargetChangeListener().

TextAdapter

The TextAdapter class is a subclass of the TextListenerInterface class. This subclass is provided so that a user does not have to subclass all the methods.

TextEvent

The TextEvent is sent when a Text object is acted on. An example of this is when a character is added to the Text object or when a FlexTextArea is scrolled.

TextListenerInterface

TextListenerInterface is the abstract base class for TextListener objects. It is the listener interface for receiving text events.

TitleEvent

The TitleEvent is sent via a TitleListenerInterface object when titled components are about to draw their title.

TitleListenerInterface

TitleListenerInterface is the base class for TitleListener objects. This class is used for receiving notification that a title is about to be drawn.

ToolkitEvent

The ToolkitEvent class is the base class for tookit events.

TreeFocusManager

The TreeFocusManager class navigates the focus between the descendants of a container.

UIFactory

The UIFactory class allows the application programmer to instantiate visible components in the toolkit. The FlexUI library can use the optional lookHint parameter to determine which subclass of an object to create, or as a data instance that determines how a given UI object should be drawn. There is a global instance of UIFactory called theUIFactory that is used to instantiate visible components.

VerticalFlowLayout

The VerticalFlowLayout class implements a layout manager that arranges components along a vertical line with a variety of spacing options.

WindowAdapter

The WindowAdapter class is a subclass of WindowListenerInterface to be notified of window events. This subclass provides empty function definitions so that a new subclass does not have to override all the functions in WindowListenerInterface.

WindowEvent

The WindowEvent is created and sent to a WindowListener when certain window-related events take place.

WindowListenerInterface

WindowListenerInterface is the abstract base class for WindowListener objects. It is the interface for receiving window events.

Back to the top of toolkit_lib

Data

Back to the top of toolkit_lib

Global Functions

Back to the top of toolkit_lib

OTHER_DOCUMENTATION

• Introduction
• UIFactory
• Focus Manager
• Geometry Management

Back to the top of toolkit_lib

const uint32 FC_CHILD_NOT_FOUND = UINT32_MAX;

This constant is used by FlexContainer::Find() to indicate that a component was not found to be a child of the container.

FC_CHILD_NOT_FOUND

Declared as:

    const uint32 FC_CHILD_NOT_FOUND = UINT32_MAX;

Back to the top of toolkit_lib

enum TitleHorizontalJustificationType;

Identifies the horizontal positioning of the title with respect to the title drawing area.

THJT_LEFT

Left justify the text.

THJT_CENTER

Center the text.

THJT_RIGHT

Right justify the text.

THJT_NONE

Position the text according to the _position instance in the TextState.

Declared as:

    enum TitleHorizontalJustificationType {
      THJT_LEFT    = 0,
      THJT_CENTER  = 1,
      THJT_RIGHT   = 2,
      THJT_NONE    = 3
    };

Back to the top of toolkit_lib

enum TitleVerticalJustificationType;

Identifies the horizontal positioning of the title with respect to the title drawing area.

TVJT_TOP

Top justify the text.

TVJT_CENTER

Center the text.

TVJT_BOTTOM

Bottom justify the text.

TVJT_NONE

Position the text according to the _position instance in the TextState.

Declared as:

    enum TitleVerticalJustificationType {
      TVJT_TOP     = 0,
      TVJT_CENTER  = 1,
      TVJT_BOTTOM  = 2,
      TVJT_NONE    = 3
    };

Back to the top of toolkit_lib

struct TitleEventInfoFlags ;

Stores the justification information and several flags to allow communication between the event sender and receiver.

continueDraw

Set to tell sender to call the Draw method.

drawInverted

Set if sender is drawing the inverted look.

drawDisabled

Set if sender is drawing the disabled look.

horizontalJustification

TitleHorizontalJustificationType.

verticalJustification

TitleVerticalJustificationType.

Declared as:

    struct TitleEventInfoFlags {
      uint8 unused : 1;
      uint8 continueDraw : 1;
      uint8 drawInverted : 1;
      uint8 drawDisabled : 1;
      uint8 horizontalJustification : 2;
      uint8 verticalJustification   : 2;
    };

Back to the top of toolkit_lib

const uint32 MAX_LIST_ITEMS = 0xFFFF;

The maximum number of items in a FlexList. MAX_LIST_ITEMS is equal to the maximum value for a uint16 - 1. Although a FlexList can legally contain this many items, a FlexTable should be used if more than 100 items will be in the list.

Declared as:

    const uint32 MAX_LIST_ITEMS = 0xFFFF;

Back to the top of toolkit_lib

const int32 NO_ITEM_SELECTED = -1;

When the FlexList is in Multiple mode the _currentSelectedItem = NO_ITEM_SELECTED. When the FlexList is not in multiple mode, the _currentSelectedItem is the index of the only selected item on the FlexList.

Declared as:

    const int32 NO_ITEM_SELECTED = -1;

Back to the top of toolkit_lib

const LayoutTagType LT_MAIN = 0;

LT_MAIN

This tag identifies the components that will be placed in the main flow area (dialogs will probably put a text object there).

Declared as:

    const LayoutTagType LT_MAIN = 0;

Back to the top of toolkit_lib

const uint16 FLOW_SIZE_COMPONENTS_AS_THEY_WISH = UINT16_MAX;

Value that tells the FlowLayout to calculate the size of its components based on their preferred size. Used in FlowLayout::SetComponentSizes().

Declared as:

    const uint16 FLOW_SIZE_COMPONENTS_AS_THEY_WISH  = UINT16_MAX;

Back to the top of toolkit_lib

const uint16 FLOW_SIZE_COMPONENTS_TO_FIT_PARENT = UINT16_MAX - 1;

Value that tells the FlowLayout to calculate the size of its components by dividing the parent size among the compoents. Used in FlowLayout::SetComponentSizes().

Declared as:

    const uint16 FLOW_SIZE_COMPONENTS_TO_FIT_PARENT = UINT16_MAX - 1;

Back to the top of toolkit_lib

typedef uint16 LayoutTagType;

This is the type used for creating layout tags. All system-wide layout tags are defined at the upper end of the number range.

LT_NULL

This is the default tag given if none is specified.

LT_CUSTOM

This tag is used to identify components that should not be laid out by the layout manager.

Declared as:

    typedef uint16 LayoutTagType;

Back to the top of toolkit_lib

const uint32 MENU_NO_SELECTION = UINT32_MAX;

This constant is used to indicate that no MenuItems are selected within a menu.

MENU_NO_SELECTION

Declared as:

    const uint32 MENU_NO_SELECTION = UINT32_MAX; 

Back to the top of toolkit_lib

typedef uint32 MenuItemID;

This is the type used for creating menu item ID values.

Declared as:

    typedef uint32 MenuItemID;

Back to the top of toolkit_lib

const int32 SB_MAX = 0x3FFFFFFF;

The maximum value a FlexScrollbar can have. This should not be confused with the default maximum value a FlexScrollbar is initialized to. In general, the default maximum value is Ox3FFF.

Declared as:

    const int32  SB_MAX  = 0x3FFFFFFF;

Back to the top of toolkit_lib

const int32 SB_MIN = 0xC0000000;

The minimum value a FlexScrollbar can have. This should not be confused with the default minimum value a FlexScrollbar is initialized to. In general, the default minimum value is 0.

Declared as:

    const int32  SB_MIN  = 0xC0000000;

Back to the top of toolkit_lib

const int32 SB_MIN_DEFAULT = 0x0;

The default minimum value for the FlexScrollbar.

Declared as:

    const int32  SB_MIN_DEFAULT  =  0x0;

Back to the top of toolkit_lib

const int32 SB_MAX_DEFAULT = 0x7fff;

The default maximum value for the FlexScrollbar.

Declared as:

    const int32  SB_MAX_DEFAULT  =  0x7fff;

Back to the top of toolkit_lib

const int32 SB_VISIBLE_DEFAULT = 0x1;

The value the visible amount defaults to if the user doesn't set it, or sets it incorrectly.

Declared as:

    const int32  SB_VISIBLE_DEFAULT = 0x1;

Back to the top of toolkit_lib

const int32 SB_VISIBLE_MINIMUM = 0x0;

The minimum visible amount value.

Declared as:

    const int32  SB_VISIBLE_MINIMUM = 0x0;

Back to the top of toolkit_lib

const int32 SB_INCREMENT_DEFAULT = 1;

The default increment for the FlexScrollbar.

Declared as:

    const int32  SB_INCREMENT_DEFAULT = 1;

Back to the top of toolkit_lib

const int32 SB_THUMB_DEFAULT = 1;

The default value that the scroll bar will change by when the FlexScrollbar's thumb is dragged.

Declared as:

    const int32  SB_THUMB_DEFAULT = 1;

Back to the top of toolkit_lib

const int32 SB_BLOCK_DEFAULT = 1;

The default value that the FlexScrollbar will change by when the FlexScrollbar's block is affected. This could happen when a mouse click happens on the FlexScrollbar between the thumb and the arrow.

Declared as:

    const int32 SB_BLOCK_DEFAULT = 1;

Back to the top of toolkit_lib

enum ScrollbarScrollType;

Different types of scrolling. These will be used in subclasses to determine how to update the FlexScrollbar's value.

SST_SCROLL_NO_SCROLL

SST_SCROLL_BY_THUMB

SST_SCROLL_BY_BACK_ARROW

SST_SCROLL_BY_FORWARD_ARROW

SST_SCROLL_BY_BACK_BLOCK

SST_SCROLL_BY_FORWARD_BLOCK

SST_SCROLL_RELEASED

Declared as:

    enum ScrollbarScrollType {   
        SST_SCROLL_NO_SCROLL        = 0,
        SST_SCROLL_BY_THUMB         = 1,
        SST_SCROLL_BY_BACK_ARROW    = 2,
        SST_SCROLL_BY_FORWARD_ARROW = 3,
        SST_SCROLL_BY_BACK_BLOCK    = 4,
        SST_SCROLL_BY_FORWARD_BLOCK = 5,
        SST_SCROLL_RELEASED         = 6,
    };

Back to the top of toolkit_lib

const int32 TABLE_SELECTION_NONE = -1;

Returned by GetLeftColumn(), GetRightColumn(), GetTopRow(), and GetBottomRow() if the table has no selection.

TABLE_SELECTION_NONE

Value returned to indicate no selection

Declared as:

const int32 TABLE_SELECTION_NONE = -1;

Back to the top of toolkit_lib

const WinCoord TABLE_INVALID_POSITION = INT16_MIN;

Returned by GetXPosAt() and GetYPosAt() to indicate an invalid graphics coordinate for the specifed row or column entry.

TABLE_INVALID_POSITION

Value returned to indicate an invalid graphics coordinate.

Declared as:

const WinCoord TABLE_INVALID_POSITION = INT16_MIN;

Back to the top of toolkit_lib

typedef uint16 FontStyle;

Font styles supported by FlexTextArea.

Declared as:

typedef uint16 FontStyle;

Back to the top of toolkit_lib

typedef uint32 LookHint;

LookHint typedef to be used when defining the look of an object created by the UIFactory.

Declared as:

typedef uint32 LookHint;

Back to the top of toolkit_lib

dll_link extern UIFactory *theUIFactory;

The global pointer to the current UIFactory. Applications create new visible objects by calling the methods on this object. It is safe for applications to assume that this pointer will never be NULL. For example, to create a FlexButton the pointer is used in the following manner.
FlexButton *button = theUIFactory->CreateFlexButton(). Of course the user must provide the correct parameters for this function.

Declared as:

dll_link extern UIFactory *theUIFactory;

Back to the top of toolkit_lib