Library toolkit_lib

GEOS-SC:  Library toolkit_lib



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

const uint32 FC_CHILD_NOT_FOUND = UINT32_MAX;
enum TitleHorizontalJustificationType;
enum TitleVerticalJustificationType;
struct TitleEventInfoFlags ;
const uint32 MAX_LIST_ITEMS = 0xFFFF;
const int32 NO_ITEM_SELECTED = -1;
const LayoutTagType LT_MAIN = 0;
const uint16 FLOW_SIZE_COMPONENTS_AS_THEY_WISH = UINT16_MAX;
const uint16 FLOW_SIZE_COMPONENTS_TO_FIT_PARENT = UINT16_MAX - 1;
typedef uint16 LayoutTagType;
const uint32 MENU_NO_SELECTION = UINT32_MAX;
typedef uint32 MenuItemID;
const int32 SB_MAX = 0x3FFFFFFF;
const int32 SB_MIN = 0xC0000000;
const int32 SB_MIN_DEFAULT = 0x0;
const int32 SB_MAX_DEFAULT = 0x7fff;
const int32 SB_VISIBLE_DEFAULT = 0x1;
const int32 SB_VISIBLE_MINIMUM = 0x0;
const int32 SB_INCREMENT_DEFAULT = 1;
const int32 SB_THUMB_DEFAULT = 1;
const int32 SB_BLOCK_DEFAULT = 1;
enum ScrollbarScrollType;
const int32 TABLE_SELECTION_NONE = -1;
const WinCoord TABLE_INVALID_POSITION = INT16_MIN;
typedef uint16 FontStyle;
typedef uint32 LookHint;
dll_link extern UIFactory *theUIFactory;

Back to the top of toolkit_lib


Global Functions

Back to the top of toolkit_lib


OTHER_DOCUMENTATION

The Toolkit library provides the graphical user interface components and mechanisms needed to create user-interactable applications.

Back to the top of toolkit_lib


const uint32 FC_CHILD_NOT_FOUND = UINT32_MAX;

#include <toolkit/containr.h>

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;

#include <toolkit/evttitle.h>

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;

#include <toolkit/evttitle.h>

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 ;

#include <toolkit/evttitle.h>

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;

#include <toolkit/listcomp.h>

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;

#include <toolkit/listcomp.h>

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;

#include <toolkit/lmdialog.h>

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;

#include <toolkit/lmflow.h>

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;

#include <toolkit/lmflow.h>

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;

#include <toolkit/lmgr.h>

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;

#include <toolkit/menu.h>

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;

#include <toolkit/menuitem.h>

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;

#include <toolkit/scrllbar.h>

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;

#include <toolkit/scrllbar.h>

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;

#include <toolkit/scrllbar.h>

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;

#include <toolkit/scrllbar.h>

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;

#include <toolkit/scrllbar.h>

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;

#include <toolkit/scrllbar.h>

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;

#include <toolkit/scrllbar.h>

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;

#include <toolkit/scrllbar.h>

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;

#include <toolkit/scrllbar.h>

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;

#include <toolkit/scrllbar.h>

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;

#include <toolkit/table.h>

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;

#include <toolkit/table.h>

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;

#include <toolkit/textarea.h>

Font styles supported by FlexTextArea.

Declared as:

typedef uint16 FontStyle;

Back to the top of toolkit_lib


typedef uint32 LookHint;

#include <toolkit/uifact.h>

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;

#include <toolkit/uifact.h>

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


Generated from source by Geoworks on Sat Dec 12 18:30:57 1998 .