Reference for the Mosaic unit Core

Class Overview
Core::CursorHit
Core::Event
Core::CursorEvent
Core::CursorGrabEvent
Core::DragEvent
Core::KeyEvent
Core::LanguageEvent
Core::StylesEvent
Core::KeyPressHandler
Core::PropertyObserver
Core::SystemEvent
Core::SystemEventHandler
Core::Task
Core::TaskQueue
Core::Time
Core::Timer
Core::TimeSpan
Core::View
Core::LineView
Core::QuadView
Core::SimpleTouchHandler
Core::RectView
Core::Group
Core::HorizontalList
Core::Root
Core::VerticalList
Core::Outline
Core::RotateTouchHandler
Core::SlideTouchHandler
Core::WipeTouchHandler
Enumerations
Core::Direction
Core::Formation
Core::KeyCode
Sets
Core::Layout
Core::RetargetReason
Core::ViewState

The unit 'Core' provides the fundamental classes of the 'Mosaic' framework. They are responsible for all aspects respective the screen updates, handling of user keyboard and touch events (also called cursor events), timers, and much more:

enum Direction
{
item None;
item TopLeft;
item Left;
item BottomLeft;
item Top;
item Bottom;
item TopRight;
item Right;
item BottomRight;
}

The definition Core::Direction determines available directions the user can navigate in the GUI.

enum Formation
{
item None;
item TopToBottom;
item BottomToTop;
item LeftToRight;
item RightToLeft;
item TopToBottom_LeftToRight;
item TopToBottom_RightToLeft;
item BottomToTop_LeftToRight;
item BottomToTop_RightToLeft;
item LeftToRight_TopToBottom;
item LeftToRight_BottomToTop;
item RightToLeft_TopToBottom;
item RightToLeft_BottomToTop;
}

The definition Core::Formation determines the available arrangement modes to apply on all views embedded within a Core::Outline view. Depending on the mode, the embedded views can be arranged in rows or columns. If the mode == Core::Formation.None, no automatic row/column arrangement is performed and the views are simply aligned inside the outline boundary area.

Items Description
BottomToTop The mode 'BottomToTop' enables the vertical formation of a column beginning at the lower edge of the outline view. The views are arranged bottom up.
BottomToTop_LeftToRight The mode 'BottomToTop_LeftToRight' enables a grid formation with views being arranged in multiple columns beginning at the bottom left corner of the outline view.
BottomToTop_RightToLeft The mode 'BottomToTop_RightToLeft' enables a grid formation with views being arranged in multiple columns beginning at the bottom right corner of the outline view.
LeftToRight The mode 'LeftToRight' enables the horizontal formation of a row beginning at the left edge of the outline view. The views are arranged from left to right.
LeftToRight_BottomToTop The mode 'LeftToRight_BottomToTop' enables a grid formation with views being arranged in multiple rows beginning at the bottom left corner of the outline view.
LeftToRight_TopToBottom The mode 'LeftToRight_TopToBottom' enables a grid formation with views being arranged in multiple rows beginning at the top left corner of the outline view.
None The mode 'None' disables the automatic arrangement in row and column formations. The views are simply aligned inside the boundary area of the outline view.
RightToLeft The mode 'RightToLeft' enables the horizontal formation of a row beginning at the right edge of the outline view. The views are arranged from right to left.
RightToLeft_BottomToTop The mode 'RightToLeft_BottomToTop' enables a grid formation with views being arranged in multiple rows beginning at the bottom right corner of the outline view.
RightToLeft_TopToBottom The mode 'RightToLeft_TopToBottom' enables a grid formation with views being arranged in multiple rows beginning at the top right corner of the outline view.
TopToBottom The mode 'TopToBottom' enables the vertical formation of a column beginning at the upper edge of the outline view. The views are arranged top down.
TopToBottom_LeftToRight The mode 'TopToBottom_LeftToRight' enables a grid formation with views being arranged in multiple columns beginning at the upper left corner of the outline view.
TopToBottom_RightToLeft The mode 'TopToBottom_RightToLeft' enables a grid formation with views being arranged in multiple columns beginning at the upper right corner of the outline view.

 

enum KeyCode
{
item NoKey;
item Ok;
item Exit;
item Menu;
item Up;
item Down;
item Left;
item Right;
item PageUp;
item PageDown;
item Key0;
item Key1;
item Key2;
item Key3;
item Key4;
item Key5;
item Key6;
item Key7;
item Key8;
item Key9;
item Red;
item Green;
item Blue;
item Yellow;
item White;
item Magenta;
item F1;
item F2;
item F3;
item F4;
item F5;
item F6;
item F7;
item F8;
item F9;
item F10;
item ChannelUp;
item ChannelDown;
item Display;
item SkipPrev;
item SkipNext;
item Home;
item End;
item Insert;
item Delete;
item Clear;
item VolumeUp;
item VolumeDown;
item Show;
item Hide;
item Play;
item Pause;
item Record;
item Stop;
item Rev;
item Fwd;
item SlowRev;
item SlowFwd;
item SkipBwd;
item SkipFwd;
item Repeat;
item Eject;
item Help;
item TV;
item DVD;
item VCR;
item EPG;
item OSD;
item Text;
item PIP;
item Audio;
item Clock;
item Timer;
item Navigation;
item Karaoke;
item Game;
item Subtitle;
item Zoom;
item Index;
item Info;
item Power;
item Setup;
item Angle;
item Mode;
item Mute;
item User0;
item User1;
item User2;
item User3;
item User4;
item User5;
item User6;
item User7;
item User8;
item User9;
item User10;
item User11;
item User12;
item User13;
item User14;
item User15;
item User16;
item User17;
item User18;
item User19;
item KeyA;
item KeyB;
item KeyC;
item KeyD;
item KeyE;
item KeyF;
item KeyG;
item KeyH;
item KeyI;
item KeyJ;
item KeyK;
item KeyL;
item KeyM;
item KeyN;
item KeyO;
item KeyP;
item KeyQ;
item KeyR;
item KeyS;
item KeyT;
item KeyU;
item KeyV;
item KeyW;
item KeyX;
item KeyY;
item KeyZ;
item Space;
item Plus;
item Minus;
item Multiply;
item Divide;
item Equals;
item Period;
item Comma;
item Colon;
item Semicolon;
item AlphaKeys;
item AlphaOrDigitKeys;
item DigitKeys;
item HexDigitKeys;
item CharacterKeys;
item ControlKeys;
item CursorKeys;
item AnyKey;
item Enter;
item Escape;
item Backspace;
item Tab;
item CtrlKeyA;
item CtrlKeyB;
item CtrlKeyC;
item CtrlKeyD;
item CtrlKeyE;
item CtrlKeyF;
item CtrlKeyG;
item CtrlKeyH;
item CtrlKeyI;
item CtrlKeyJ;
item CtrlKeyK;
item CtrlKeyL;
item CtrlKeyM;
item CtrlKeyN;
item CtrlKeyO;
item CtrlKeyP;
item CtrlKeyQ;
item CtrlKeyR;
item CtrlKeyS;
item CtrlKeyT;
item CtrlKeyU;
item CtrlKeyV;
item CtrlKeyW;
item CtrlKeyX;
item CtrlKeyY;
item CtrlKeyZ;
item CtrlSpace;
item CtrlKey0;
item CtrlKey1;
item CtrlKey2;
item CtrlKey3;
item CtrlKey4;
item CtrlKey5;
item CtrlKey6;
item CtrlKey7;
item CtrlKey8;
item CtrlKey9;
item CtrlF1;
item CtrlF2;
item CtrlF3;
item CtrlF4;
item CtrlF5;
item CtrlF6;
item CtrlF7;
item CtrlF8;
item CtrlF9;
item CtrlF10;
item CtrlEnter;
item CtrlEscape;
item CtrlUp;
item CtrlDown;
item CtrlLeft;
item CtrlRight;
item CtrlPageUp;
item CtrlPageDown;
item CtrlBackspace;
item CtrlInsert;
item CtrlDelete;
item CtrlHome;
item CtrlEnd;
item CtrlTab;
item CtrlShiftKeyA;
item CtrlShiftKeyB;
item CtrlShiftKeyC;
item CtrlShiftKeyD;
item CtrlShiftKeyE;
item CtrlShiftKeyF;
item CtrlShiftKeyG;
item CtrlShiftKeyH;
item CtrlShiftKeyI;
item CtrlShiftKeyJ;
item CtrlShiftKeyK;
item CtrlShiftKeyL;
item CtrlShiftKeyM;
item CtrlShiftKeyN;
item CtrlShiftKeyO;
item CtrlShiftKeyP;
item CtrlShiftKeyQ;
item CtrlShiftKeyR;
item CtrlShiftKeyS;
item CtrlShiftKeyT;
item CtrlShiftKeyU;
item CtrlShiftKeyV;
item CtrlShiftKeyW;
item CtrlShiftKeyX;
item CtrlShiftKeyY;
item CtrlShiftKeyZ;
item CtrlShiftSpace;
item CtrlShiftKey0;
item CtrlShiftKey1;
item CtrlShiftKey2;
item CtrlShiftKey3;
item CtrlShiftKey4;
item CtrlShiftKey5;
item CtrlShiftKey6;
item CtrlShiftKey7;
item CtrlShiftKey8;
item CtrlShiftKey9;
item CtrlShiftF1;
item CtrlShiftF2;
item CtrlShiftF3;
item CtrlShiftF4;
item CtrlShiftF5;
item CtrlShiftF6;
item CtrlShiftF7;
item CtrlShiftF8;
item CtrlShiftF9;
item CtrlShiftF10;
item CtrlShiftEnter;
item CtrlShiftEscape;
item CtrlShiftUp;
item CtrlShiftDown;
item CtrlShiftLeft;
item CtrlShiftRight;
item CtrlShiftPageUp;
item CtrlShiftPageDown;
item CtrlShiftBackspace;
item CtrlShiftInsert;
item CtrlShiftDelete;
item CtrlShiftHome;
item CtrlShiftEnd;
item CtrlShiftTab;
item AltF1;
item AltF2;
item AltF3;
item AltF4;
item AltF5;
item AltF6;
item AltF7;
item AltF8;
item AltF9;
item AltF10;
item AltEnter;
item AltEscape;
item AltUp;
item AltDown;
item AltLeft;
item AltRight;
item AltPageUp;
item AltPageDown;
item AltBackspace;
item AltInsert;
item AltDelete;
item AltHome;
item AltEnd;
item AltTab;
item AltShiftF1;
item AltShiftF2;
item AltShiftF3;
item AltShiftF4;
item AltShiftF5;
item AltShiftF6;
item AltShiftF7;
item AltShiftF8;
item AltShiftF9;
item AltShiftF10;
item AltShiftEnter;
item AltShiftEscape;
item AltShiftUp;
item AltShiftDown;
item AltShiftLeft;
item AltShiftRight;
item AltShiftPageUp;
item AltShiftPageDown;
item AltShiftBackspace;
item AltShiftInsert;
item AltShiftDelete;
item AltShiftHome;
item AltShiftEnd;
item AltShiftTab;
item ShiftF1;
item ShiftF2;
item ShiftF3;
item ShiftF4;
item ShiftF5;
item ShiftF6;
item ShiftF7;
item ShiftF8;
item ShiftF9;
item ShiftF10;
item ShiftEnter;
item ShiftEscape;
item ShiftUp;
item ShiftDown;
item ShiftLeft;
item ShiftRight;
item ShiftPageUp;
item ShiftPageDown;
item ShiftBackspace;
item ShiftInsert;
item ShiftDelete;
item ShiftHome;
item ShiftEnd;
item ShiftTab;
}

The enumeration Core::KeyCode provides a set of predefined keyboard codes very common to mobile and remote control devices, e.g. Menu, Left, Up, Ok, Exit, Play, Record, etc. The usage of these predefined key codes increases the platform independence of your GUI application. For special key codes, which are not included in this set, a range of UserXX key codes is provided.

Beside the key codes the enumeration also provides some few key categories like AlphaKeys, DigitKeys or CursorKeys. They stand for an entire range of key codes and are used when key codes are evaluated or filtered by the Core::KeyPressHandler.

Items Description
AlphaKeys The code 'AlphaKeys' defines a category of keys in the range KeyA .. KeyZ.
AlphaOrDigitKeys The code 'AlphaOrDigitKeys' defines a category of keys in the range KeyA .. KeyZ and Key0 .. Key9.
AnyKey The code 'AnyKey' defines a category for all keys.
CharacterKeys The code 'CharacterKeys' defines a category of keys including all UNICODE signs.
ControlKeys The code 'ControlKeys' defines a category of all keys excluding the UNICODE signs.
CursorKeys The code 'CursorKeys' defines a category of navigation keys Left, Right, Up, Down.
DigitKeys The code 'DigitKeys' defines a category of keys in the range Key0 .. Key9.
HexDigitKeys The code 'HexDigitKeys' defines a category of keys in the range KeyA .. KeyF and Key0 .. Key9.
NoKey The code 'NoKey' corresponds to an undefined key code.

 

set Layout
{
item ResizeHorz;
item ResizeVert;
item AlignToLeft;
item AlignToRight;
item AlignToTop;
item AlignToBottom;
}

The definition Core::Layout determines the set of available arrangement constraints to apply on views during the automatic GUI arrangement. Each view can determine its own set of constraints how it want to behave when e.g. its owner changes the size.

The constraints ResizeVert and ResizeHorz e.g. determine the resize behavior of the view in response to the size modification of its owner. Views with these constraints disabled always will keep their size unchanged. In conflict cases when the alignment and resize constraints do contradict, the view will maintain its size and will be pulled into the middle area resulting by the alignment constraints.

In case of views automatically arranged in rows or columns within a Core::Outline, the alignment constraints determine the vertical or horizontal alignment of the view within the corresponding row or column. The resize constraints in this case enable the view to fill the entire height of a column or the entire width of a row.

Items Description
AlignToBottom The constraint 'AlignToBottom' determines whether the view should try to keep a constant distance to the lower edge of its owner. If not active, the distance changes proportionally to the size modifications of its owner. In the case the view belongs to a column formation of a Core::Outline, the constraint determine whether the view should be bottom aligned within the column. To align the view in the center of the column, both constraints AlignToBottom and AlignToTop should be deactivated.
AlignToLeft The constraint 'AlignToLeft' determines whether the view should try to keep a constant distance to the left edge of its owner. If not active, the distance changes proportionally to the size modifications of its owner. In the case the view belongs to a row formation of a Core::Outline, the constraint determine whether the view should be left aligned within the row. To align the view in the center of the row, both constraints AlignToRight and AlignToLeft should be deactivated.
AlignToRight The constraint 'AlignToRight' determines whether the view should try to keep a constant distance to the right edge of its owner. If not active, the distance changes proportionally to the size modifications of its owner. In the case the view belongs to a row formation of a Core::Outline, the constraint determine whether the view should be right aligned within the row. To align the view in the center of the row, both constraints AlignToRight and AlignToLeft should be deactivated.
AlignToTop The constraint 'AlignToTop' determines whether the view should try to keep a constant distance to the upper edge of its owner. If not active, the distance changes proportionally to the size modifications of its owner. In the case the view belongs to a column formation of a Core::Outline, the constraint determine whether the view should be top aligned within the column. To align the view in the center of the column, both constraints AlignToBottom and AlignToTop should be deactivated.
ResizeHorz The constraint 'ResizeHorz' determines whether the view can be resized horizontally. If not active, the view will always keep its width unchanged. In the case the view belongs to a row formation of a Core::Outline, the constraint determine whether the view may take the entire width of the row.
ResizeVert The constraint 'ResizeVert' determines whether the view can be resized vertically. If not active, the view will always keep its height unchanged. In the case the view belongs to a column formation of a Core::Outline, the constraint determine whether the view may take the entire height of the column.

 

set RetargetReason
{
item WipeUp;
item WipeDown;
item WipeLeft;
item WipeRight;
item LongPress;
item ForeignPress;
}

The definition Core::RetargetReason determines the set of possible reasons for a touch handler to resign and pass over the current event processing to another handler.

Items Description
ForeignPress The retarget reason is a new touch interaction processed by a foreign touch handler lying in front or behind the affected touch handler.
LongPress The retarget reason is a long touch interaction.
WipeDown The retarget reason is a simple 'wipe down' gesture.
WipeLeft The retarget reason is a simple 'wipe left' gesture.
WipeRight The retarget reason is a simple 'wipe right' gesture.
WipeUp The retarget reason is a simple 'wipe up' gesture.

 

set ViewState
{
item Visible;
item AlphaBlended;
item Focusable;
item Touchable;
item Enabled;
item Selected;
item Focused;
item Modal;
item FastReshape;
item IsOutline;
item Embedded;
item RequestLayout;
item UpdateLayout;
item UpdatingLayout;
item PendingLayout;
item PendingViewState;
item Dialog;
item PendingFader;
item RunningFader;
item DontClipViews;
item PreEnabled;
item DeriveEnabledState;
}

The definition Core::ViewState determines the set of possible states, a Core::View can assume at its lifetime. These states are used internally by all GUI components. They determine whether components are visible, able to react to user events, etc.

Items Description
AlphaBlended The state 'AlphaBlended' determines the drawing mode for the corresponding view. Views with disabled alpha-blending will override the affected screen areas. If this mode is enabled, the aspect of the view is combined with the origin screen content by alpha-blending.
Dialog The state 'Dialog' is set for every GUI component being explicitly presented by using the method Core::Group.PresentDialog() or Core::Group.SwitchToDialog().
Embedded The state 'Embedded' determines how the view should appear and behave within its superior owner. If this state is active, the affected view will be embedded (limited) to the boundary of a preceding Core::Outline sibling view. This is as if the view had been embedded within this outline. If this state is not active, the view is considered as a regular view of its owner - it doesn't belong to any outline.
Enabled The state 'Enabled' determines whether the view is able to react to user input events. Disabled views will never receive these events. Whether the can really react to events depends additionally on its other states Focusable and Touchable.
Focusable The state 'Focusable' determines whether the view is able to become focused and react to keyboard events. Non focusable views can not receive keyboard events.
Focused The state 'Focused' determines whether the view belongs to the focus path and thus is able to receive keyboard events.
Modal The state 'Modal' determines whether the view is currently modal.
Selected The state 'Selected' determines whether the view is currently selected within its owner. The selected view is stored in its owner Focus property.
Touchable The state 'Touchable' determines whether the view is able to receive cursor events. Non touchable views can not react to user touch screen taps.
Visible The state 'Visible' determines the visibility of the corresponding view. Invisible views will not appear on the screen. Whether a view is really visible depends on the visibility of its owner and the position of the view within the owners boundary area.