Foundation
Introducing Rogue Wave Views Foundation
Application Programming Interface (API)
Libraries
Class Hierarchy
Using Rogue Wave Views
Windows and Views
What is a View?
Looking at a View Window
Containers: Controlling the View
Introducing Graphic Objects
Displaying Graphic Objects
Interactors
Drawing Attributes and Palettes
Color
Line Style and Width
Patterns
Font
Basic Drawing Types
Lines
Regions
Strings
Graphic Objects
IlvGraphic: The Graphic Objects Class
Member Functions
Callbacks
The IlvSimpleGraphic Class
Member Functions
Graphic Attributes
Predefined Graphic Objects
IlvArc
IlvFilledArc
IlvEllipse
IlvFilledEllipse
IlvIcon
IlvZoomableIcon
IlvTransparentIcon
IlvZoomableTransparentIcon
IlvLabel
IlvFilledLabel
IlvListLabel
IlvZoomableLabel
IlvLine
IlvArrowLine
IlvReliefLine
IlvMarker
IlvZoomableMarker
IlvPolyPoints
IlvPolySelection
IlvPolyline
IlvArrowPolyline
IlvPolygon
IlvOutlinePolygon
IlvRectangle
IlvFilledRectangle
IlvRoundRectangle
IlvFilledRoundRectangle
IlvShadowRectangle
IlvShadowLabel
IlvGridRectangle
IlvReliefRectangle
IlvReliefLabel
IlvReliefDiamond
IlvSpline
IlvClosedSpline
IlvFilledSpline
Composite Graphic Objects
Filling Polygons: IlvGraphicPath
Grouping Objects: IlvGraphicSet
Referencing Objects: IlvGraphicHandle
Other Base Classes
IlvGauge
IlvScale
IlvGadget
IlvGroupGraphic
IlvMapxx
Creating a New Graphic Object Class
The Example: ShadowEllipse
Basic Steps to Subtype a Graphic Object
Redefining IlvGraphic Member Functions
Creating the Header File
Implementing the Object Functions
Updating the Palettes
Saving and Loading the Object Description
Graphic Resources
IlvResource: The Resource Object Base Class
Predefined Graphic Resources
Named Resources
Resource Creation and Destruction: lock and unLock
IlvColor: The Color Class
Color Models
Using the IlvColor Class
Converting between Color Models
Computing Shadow Colors
IlvLineStyle: The Line Style Class
New Line Styles
IlvPattern and IlvColorPattern: The Pattern Classes
Monochrome Patterns
Colored Patterns
IlvGradientPattern: The Pattern Class Dedicated to Gradients
The IlvLinearGradientGeometry class
The IlvRadialGradientGeometry class
The IlvGradientGeometry class
Gradient Patterns Sharing
IlvFont: The Font Class
New Fonts
Font Names
IlvCursor: The Cursor Class
Other Drawing Parameters
Line Width
Fill Style
Fill Rule
Arc Mode
Draw Mode
Alpha Value
Anti-Aliasing Mode
IlvPalette: Drawing Using a Group of Resources
Locking and Unlocking Resources
Clipping Area
Creating a Non-shared Palette
Creating a Shared Palette
Naming Palettes
IlvQuantizer: The Image Color Quantization Class
Graphic Formats
Graphic Formats Supported
Bitmaps
IlvBitmap: The Bitmap Image Class
Bitmap-Related Member Functions
Bitmap Formats
Loading Bitmaps: Streamers
Loading Transparent Bitmaps
IlvBitmapData: The Portable Bitmap Data Management Class
The IlvBitmapData Class
The IlvIndexedBitmapData Class
The IlvRGBBitmapData Class
The IlvBWBitmapData Class
Image Processing Filters
IlvBitmapFilter: The Image Processing Class
The IlvBlendFilter Class
The IlvColorMatrixFilter Class
The IlvComponentTransferFilter Class
The IlvComposeFilter Class
The IlvConvolutionFilter Class
The IlvDisplaceFilter Class
The IlvFloodFilter Class
The IlvGaussianBlurFilter Class
The IlvImageFilter Class
The IlvLightingFilter Class
The IlvLightSource Class
The IlvMergeFilter Class
The IlvMorphologyFilter Class
The IlvOffsetFilter Class
The IlvTileFilter Class
The IlvTurbulenceFilter Class
The IlvFilterFlow Class
Using IlvFilteredGraphic to Apply Filter Flows to Graphic Objects
The Display System
IlvDisplay: The Display System Class
Connecting to the Display Server
Opening a Connection and Checking the Display
Closing a Connection and Ending a Session
Display System Resources
The getResource Method
How Display System Resources are Stored
Default Display System Resources
Environment Variables and Resource Names
Display System Resources on Windows
Home
The Display Path
Setting the Display Path
The Path Resource
The ILVPATH Environment Variable
Querying or Modifying the Display Path
Example: Add a Directory to the Display Path
Views
View Hierarchies: Two Perspectives
Window-Oriented View Hierarchy
Class-Oriented View Hierarchy
IlvAbstractView: The Base Class
IlvView: The Drawing Class
IlvView Subclasses
The IlvElasticView Class
The IlvDrawingView Class
The IlvContainer Class
The IlvScrollView Class
Drawing Ports
IlvPort: The Drawing Port Class
Derived Classes of IlvPort
The IlvSystemPort Class
The IlvPSDevice Class
Containers
IlvContainer: The Graphic Placeholder Class
General-Purpose Member Functions
Applying Functions to Objects
Tagged Objects
Object Properties
Displaying Containers
Drawing Member Functions
Geometric Transformations
Managing Double Buffering
Reading Objects from Disk
Managing Events: Accelerators
Member Functions
Implementing Accelerators: IlvContainerAccelerator
Predefined Container Accelerators
Managing Events: Object Interactors
Using Object Interactors
Predefined Object Interactors
Example: Linking an Interactor and an Accelerator
Creating Objects with Complex Behavior
Example: Creating a Slider
Associating a Behavior with Your Device
Building and Extending your Device
Dynamic Modules
IlvModule: The Dynamic Module Class
Dynamic Module Code Skeleton
Building a Dynamic Module
Loading a Dynamic Module
Implicit Mode
Explicit Mode
An Example: Dynamic Access
Writing the Sample Module Definition File
Implementing the New Class
Loading and Registration of the Example
Registration Macros
Adding the Sample Class to a Dynamic Module
Events
IlvEvent: The Event Handler Class
Recording and Playing Back Event Sequences: IlvEventPlayer
Functions Handling Event Recording
The IlvTimer Class
External Input Sources (UNIX only)
Idle Procedures
Low-level Event Handling
Main Loop Definition: An Example
Touch Screen Support
IlvNamedProperty: The Persistent Properties Class
Associating Named Properties with Objects
Extension of Named Properties
Example: Creating a Named Property
Printing in Rogue Wave Views
The IlvPrintableDocument Class
Iterators
Example
The IlvPrintable Class
The IlvPrintableLayout Class
The IlvPrinter Class
The IlvPrintUnit Class
The IlvPaperFormat Class
Dialogs
Rogue Wave Script Programming
Rogue Wave Script for Rogue Wave Views
Making Rogue Wave Views Applications Scriptable
Including the Header File
Linking with Rogue Wave Script for Rogue Wave Views Libraries
Binding Rogue Wave Views Objects
Getting the Global Rogue Wave Script Context
Binding Rogue Wave Views Objects
Loading Rogue Wave Script Modules
Inline Scripts
Default Rogue Wave Script Files
Independent Rogue Wave Script Files
Rogue Wave Script Static Functions
Using Rogue Wave Script Callbacks
Writing a Callback
Setting a Rogue Wave Script Callback
Handling Panel Events
The OnLoad Function
The onShow Property
The onHide Property
The onClose Property
Creating Rogue Wave Views Objects at Run Time
Common Properties of Rogue Wave Views Objects
className
name
help
Using Resources in Rogue Wave Script for Rogue Wave Views
Using Resource Names with Rogue Wave Script for Rogue Wave Views
Using Bitmaps with Rogue Wave Script for Rogue Wave Views
Using Fonts with Rogue Wave Script for Rogue Wave Views
Guidelines for Developing Scriptable Applications
Resource Names
Internationalization
What is i18n?
Checklist for Localized Environments
Creating a Program to Run in a Localized Environment
Locale Requirements
Checking Your System’s Locale Requirements
Locale Name Format
Current Default Locale
Changing the Current Default Locale
X Library Support (UNIX only)
Rogue Wave Views Locale Support
Rogue Wave Views Locale Names
Determining Rogue Wave Views Support for the Locale
Required Fonts
Localized Message Database Files in Rogue Wave Views
The IlvMessageDatabase Class
Language of the Message Database Files
Location of the Message Database Files
Determining Parameters of the Message Database Files
Loading the Message Database
.dbm File Format
How to Dynamically Change Your Display Language
Using Rogue Wave Views with Far Eastern Languages
Data Input Requirements
Input Method (IM)
Far Eastern Input Method Servers Tested with Rogue Wave Views
How to Control the Language Used for Data Input
Limitations of Internationalization Features
Troubleshooting
Reference: Encoding Listings
Reference: Supported Locales on Different Platforms
Packaging Rogue Wave Views Applications
Launching ilv2data
The ilv2data Panel
Launching ilv2data with a Batch Command
Adding a Resource File to a UNIX Library
Adding a Resource File to a Windows DLL
Using Rogue Wave Views on Microsoft Windows
Creating a New Rogue Wave Views Application on Microsoft Windows
Incorporating Windows Code into a Rogue Wave Views Application
Integrating Rogue Wave Views Code into a Windows Application
Exiting an Application Running on Microsoft Windows
Windows-specific Devices
Printing
Selecting a Printer
Using GDI+ Features with Rogue Wave Views
What is GDI+
GDI+ and Rogue Wave Views
Controlling GDI+ Features at Run Time
Limitations
Using Multiple Display Monitors with Rogue Wave Views
Using Rogue Wave Views on X Window Systems
Libraries
Using the Xlib Version, libxviews
Using the Motif Version, libmviews
Adding New Sources of Input
Integrating Rogue Wave Views with a Motif Application using libmviews
Initializing Your Application
Standard Rogue Wave Views Initialization Procedure
Motif Application Initialization Procedure
Retrieving Connection Information
Using an Existing Widget
Running the Main Loop
Sample Program Using Motif and Rogue Wave Views
Integrating Rogue Wave Views with an X Application Using libxviews
Integration Steps
Complete Template
Complete Example with Motif
Using Cairo Features with Rogue Wave Views
Cairo Features in Rogue Wave Views
Controlling Cairo Features at Run Time
Limitations
Text anti-aliasing and scalable fonts with Xft on X Windows
Portability Limitations
Non-Supported or Limited Features
The Main Event Loop
Error Messages
The IlvError Class
Fatal Errors
Warnings
Rogue Wave Script Language Reference
Syntax
Rogue Wave Script Program Syntax
Compound Statements
Comments
Identifier Syntax
Expressions
Rogue Wave Script Expressions
Literals
Variable Reference
Property Access
Assignment Operators
Function Call
Special Keywords
Special Operators
Other Operators
Statements
Conditional Statement
Loops
Variable Declaration
Function Definition
Default Value
Numbers
Number Literal Syntax
Special Numbers
Automatic Conversion to a Number
Number Methods
Numeric Functions
Numeric Constants
Numeric Operators
Strings
String Literal Syntax
Automatic Conversion to a String
String Properties
String Methods
String Functions
String Operators
Booleans
Boolean Literal Syntax
Automatic Conversion to a Boolean
Boolean methods
Logical Operators
Arrays
Rogue Wave Script Arrays
Array Constructor
Array Properties
Array Methods
Objects
Rogue Wave Script Objects
Defining Methods
The this Keyword
Object Constructor
User-defined Constructors
Built-in Methods
Dates
Rogue Wave Script Date Values
Date Constructor
Date Methods
Date Functions
Date Operators
The null Value
The Rogue Wave Script null Value
Methods of null
The undefined Value
The Rogue Wave Script undefined Value
Methods of undefined
Functions
Rogue Wave Script Functions
Function Methods
Miscellaneous
Studio
Introducing Rogue Wave Views Studio
What is Foundation Studio?
Setting Up and Running Rogue Wave Views Studio on UNIX Systems
Setting the ILVHOME Environment Variable
Running Rogue Wave Views Foundation Studio
Loading Plug-Ins
Common Plug-Ins for Rogue Wave Views Studio
Building Other Executables of Rogue Wave Views Studio
Setting Up and Running Rogue Wave Views Studio on Microsoft Windows Systems
Setting the ILVHOME Environment Variable
Running Rogue Wave Views Studio
Loading Plug-Ins
Common Plug-Ins for Rogue Wave Views Studio
Building Other Executables of Rogue Wave Views Studio
A Quick Look at the Interface
Using Rogue Wave Views Studio
Creating Objects
Selecting Objects
Editing the Basic Properties of an Object
Specifying Resources for Objects
Inspecting an Object
Aligning Objects
Using the Editing Modes of Rogue Wave Views Studio
Using Marking Menus
Working with Description Files
Printing
How to Edit a Document
The Main Dialog
Adding a New Chapter
Removing a Chapter
Modifying the Properties of a Printable Object
Replacing the Default Layout
Replacing or Specifying the Layout of a Chapter
Modifying the Properties of a Layout
Print or Preview the Document
Cancel the Print or the Preview
The Rogue Wave Views Studio Interface
Main Window
The Menu Bar
The Action Toolbar
The Editing Modes Toolbar
The Buffer Windows
The Generic Inspector
The Resource Editor
The Message Area
Palettes Panel
Graphics Palette
Icons Palette
Gauges Palette
More Palette
Using Rogue Wave Script
Using Rogue Wave Script for Rogue Wave Views in your Application
Callbacks
Writing and Playing Scripts
Application and Scripts
Syntax Errors
Commands Specific to the Rogue Wave Script Extension
LoadScript
ShowScriptErrorList
ShowScriptDebugger
ShowScriptEditor
Commands
Introduction
Predefined Commands
AddIcon
AddTransparentIcon
AddZoomableIcon
AddZoomableTransparentIcon
AlignBottom
AlignHorizontal
AlignLeft
AlignRight
AlignTop
AlignVertical
CascadeWindows
ClipboardCopy
ClipboardCut
ClipboardPaste
CloseAllBuffers
CloseBuffer
CloseDocument
Delete
DoubleBuffering
Duplicate
EditOptions
EditGroup
FitToContents
FitViewToContents
FlipHorizontal
FlipVertical
GenerateStringData
Group
GroupIntoGraphicSet
GroupIntoSelector
GroupIntoSmartSet
HelpMainPanel
HorizontalSpaces
InspectPanel
LoadMessageDatabase
LockInspector
MakeFilteredGraphic
MinimizeAllWindows
MotifLook
NewGraphicBuffer
NudgeDown
NudgeLeft
NudgeRight
NudgeUp
OpaqueMoving
OpenBuffer
OpenDocument
PlayerOpen
PlayerPlay
PlayerSaveAs
PlayerSpeed
PlayerStart
PlayerStop
Pop
Print
PrinterPreview
PrintCurrentBuffer
PrintPreviewCurrentBuffer
Push
Quit
Redo
Repeat
Refresh
ResetView
ResizePanel
RestoreAllWindows
RevertBuffer
RevertDocument
Rotate90
Rotatem90
SameHeight
SameWidth
SaveBuffer
SaveBufferAs
SaveAll
SaveDocument
SaveDocumentAs
SelectActiveMode
SelectAll
SelectArcMode
SelectArrowLineMode
SelectBuffer
SelectClosedSplineMode
SelectFilledArcMode
SelectFilledSplineMode
SelectGadgetContainerRectangleMode
SelectLabelListMode
SelectLabelMode
SelectLineMode
SelectObject
SelectPlug-Ins
SelectPolySelectionMode
SelectPolygonMode
SelectPolylineMode
SelectPreviousBuffer
SelectRectangularObjectCreationMode
SelectReliefLineMode
SelectRotateMode
SelectSCGadgetContainerRectangleMode
SelectSCGrapherRectangleMode
SelectSCManagerRectangleMode
SelectSelectionMode
SelectSplineMode
SelectTranslateMode
SelectUnZoomMode
SelectZoomMode
SetLanguage_en_US
SetLanguage_fr_FR
SetLayer
SetName
SetObjectInteractor
SetThickness
SetToolTip
ShowAlignPanel
ShowAttachPanel
ShowCommandPanel
ShowErrorPanel
ShowGenericInspector
ShowGridPanel
ShowGridOptionsPanel
ShowGroupOptionsPanel
ShowInfoPanel
ShowInspector
ShowLayerPanel
ShowMessagePanel
ShowPalettePanel
ShowPropertiesPanel
ShowPrinterDialog
TestDocument
TestPanel
TileHorizontally
TileVertically
ToggleActiveGrid
ToggleForegroundGrid
ToggleGrid
ToggleState
ToggleTransformed
UnDo
UnGroup
VerticalSpaces
ViewsX Look
Windows Look
Windows95Look
ZoomIn
ZoomOut
Panels
Commands Panel
View Inspector (View Options) Panel
Alignment Panel
Message Editor Panel
Grid Options Panel
Layers Editor
Errors Panel
Preferences Panel
Customizing Rogue Wave Views Studio
Configuration Files
The Option File
Rogue Wave Views Studio Command File
Rogue Wave Views Studio Panel Description File
Resource and Environment Variables
Gadgets
Creating GUI Applications with Rogue Wave Views Studio
Introducing the Gadgets Extension of Rogue Wave Views Studio
Loading the GUI Application and GUI Generation Plug-In
The Main Window
Buffer Windows
The Menu Bar
The Action Toolbar
The Editing Modes Toolbar
The Palettes Panel
Gadgets Palette
Menus Palette
Matrix Palette
Miscellaneous Palette
View Rectangles Palette
Gadgets Extension Commands
AddPanel
EditApplication
Generate
GenerateAll
GenerateApplication
GenerateMakeFile
GeneratePanelClass
GeneratePanelSubClass
InspectPanel
KillTestPanels
MakeDefaultApplication
NewApplication
NewGadgetBuffer
NewPanelClass
OpenApplication
RemoveAllAttachments
RemoveAttachments
RemovePanel
RemovePanelClass
SaveApplication
SaveApplicationAs
SelectAttachmentsMode
SelectFocusMode
SelectMatrixMode
SelectMenuMode
ShowAllTestPanels
ShowApplicationInspector
ShowClassPalette
ShowPanelClassInspector
TestApplication
TestDocument
TestPanel
Gadgets Extension Panels
Application Inspector
The Panel Class Inspector
The Panel Instance Inspector
Editing Gadget Panels
Creating a New Panel
Creating Gadget Objects
Inspecting an Object
Testing a Panel
Using Active Mode
Setting the Keyboard Focus in Panels
Using the Attachments Mode
Setting the Guides
Attaching Objects to Guides
Attachment Operations
Editing Menus
Menu Bars
Pop-up Menus
Toolbars
Using Matrices
Setting Up Matrix Items
Extracting Matrix Items
Inspecting Matrix Items
Editing Spin Boxes
Inserting a Spin Box
Setting the Type of Spin Box Item
Editing Applications
The Application Buffer
Application Description File
Other Generated Files
The Application Inspector
The General Page
The Options Page
The Header and Source Pages
The Script Page
The Application Inspector Buttons
Editing an Application
The Panel Class Palette
Panel Classes
The Panel Class Inspector
Panel Instances
Testing an Application
Using the Generated Code
Building the Application
Setting Up the Application Class
Creating the First Panel Class
Creating the Second Panel Class
Generating the C++ Code
FirstPanelClass Header File
FirstPanelClass Source File
MyApplication Header File
MyApplication Source File
Testing the Generated Application
Extending the Generated Code
Defining a Derived Class
Using the Derived Class
Defining Callbacks without Deriving Classes
Customizing the Gadgets Extension of Rogue Wave Views Studio
Configuration Options for the Gadgets Extension
Extending Rogue Wave Views Studio
Extending Rogue Wave Views Studio Components
Defining a New Command
Defining a New Panel
Rogue Wave Views Studio Messages
Defining a New Buffer
Defining a New Editing Mode
The Class IlvStExtension
Integrating your Own Graphic Objects
Defining a New Command to Add an Object
Adding the Include File and Library File of a New Class to the Generated Code
Customizing the Palettes Panel
Defining and Integrating an Inspector Panel
Extending Rogue Wave Views Studio: An Example
Defining a New Buffer Class
Defining a New Command
Defining a New Panel
Providing Container Information
Registering Callbacks
Using Inspector Classes
What Is an Inspector?
Components of an Inspector Panel
Preconditions and Validators
Editors
Defining a New Inspector Panel
Example
Creating the Color Combo Box Inspector Panel
Rogue Wave Views Gadgets
Introducing Rogue Wave Views Gadgets
Gadgets Main Features
Gadgets in a Snapshot
Menus
Common Gadgets
Matrices
Gadgets Libraries
Code Sample
Understanding Gadgets
Gadget Holders
List of Available Gadget Holders
Handling Events
Focus Management
Gadgets Attachments
Common Gadget Properties
Gadget Appearance
Associating a Callback with a Gadget
Localizing a Gadget
Associating a Mnemonic with a Gadget Label
Setting Tooltips
Gadget Resources
Gadgets Look and Feel
Using the Default Look and Feel
Using Several Look and Feel
Dynamic Loading of Look and Feel
Changing the Look and Feel Dynamically
Using the Windows XP Look and Feel
Dialogs
Predefined Dialog Boxes
IlvIMessageDialog
IlvIQuestionDialog
IlvIErrorDialog
IlvIWarner
IlvIInformationDialog
IlvIFileSelector
IlvFileChooser
IlvIPromptString
IlvFontSelector
IlvColorSelector
IlvGradientSelector
Customizing Predefined Dialog Boxes
IlvFileChooser
Creating Your Own Dialog Box
Showing and Hiding Dialog Boxes
Setting a Default Button
Using Common Gadgets
Using IlvArrowButton
Using IlvButton
Displaying a Bitmap in a Button
Displaying the Button Frame
Associating a Mnemonic with a Button
Event Handling and Callbacks
Using IlvComboBox and IlvScrolledComboBox
Setting a Combo Box as Noneditable
Setting and Retrieving Items
Changing or Retrieving the Selection
Using Large Lists
Setting the Number of Visible Items
Localizing Combo Boxes
Event Handling and Callbacks
Using IlvDateField
Formatting a Date
Setting and Retrieving a Date Value
Year 2000 Management
Using IlvFrame
Associating a Mnemonic with a Frame
Using IlvMessageLabel
Associating a Bitmap with a Message Label
Making the Message Label Opaque
Laying Out the Message Label
Localizing a Message Label
Associating a Mnemonic
Using IlvNotebook
Customizing Notebook Tabs
Handling Notebook Pages
Event Handling and Callbacks
Using IlvNumberField
Selecting an Editing Mode
Choosing a Format
Defining a Range of Values
Setting and Retrieving a Value
Specifying the Thousand Separator
Specifying the Decimal Point Character
Event Handling and Callbacks
Using IlvOptionMenu
Setting and Retrieving Items
Changing and Retrieving the Selected Item
Localizing Option Menus
Event Handling and Callbacks
Using IlvPasswordTextField
Using IlvScrollBar
Setting the Scrollbar Values
Setting the Scrollbar Orientation
Event Handling and Callbacks
Using IlvSlider
Setting the Slider Values
Setting the Slider Orientation
Setting the Thumb Orientation
Event Handling and Callbacks
Using IlvSpinBox
Adding and Removing Fields to a Spin Box
Working with Text Fields
Working with Numeric Fields
Event Handling and Callbacks
Using IlvStringList
Manipulating String List Items
Customizing the Appearance of String List Items
Displaying Tooltips
Localizing String List Items
Handling Events and Callbacks
Using IlvText
Setting and Retrieving Text
Event Handling
Using IlvTextField
Aligning Text
Setting and Retrieving Text
Localizing a Text Field
Limiting the Number of Characters
Event Handling and Callbacks
Keyboard Shortcuts
Using IlvToggle
Changing the State and Color of a Toggle Button
Toggle and Radio Button Styles
Displaying a Bitmap on a Toggle Button
Aligning and Positioning the Label
Changing the Size of the State Marker
Localizing a Toggle Button
Associating a Mnemonic with a Toggle Button
Handling Events and Callbacks
Grouping Toggle Buttons in a Selector
Using IlvTreeGadget
Changing the Tree Hierarchy
Navigating Through a Tree Hierarchy
Changing the Characteristic of an Item
Expanding and Collapsing a Gadget Item
Changing the Look of the Tree Gadget Hierarchy
Event Handling and Callbacks
Gadget Items
Introducing Gadget Items
Using Gadget Items
Creating a Gadget Item
Setting a Label
Setting a Picture
Specifying the Layout of a Gadget Item
Nonsensitive Gadget Items
Dynamic Types
Using Palettes with Gadget Items
Drawing a Gadget Item
Gadget Item Holders
Gadget Item Features
Finding Gadget Items
Redrawing Gadget Items
Creating Gadget Items
Editing Gadget Items
Dragging and Dropping Gadget Items
List Gadget Item Holders
Modifying a List
Accessing Items
Sorting a List
Menus, Menu Bars, and Toolbars
Introducing Menus, Menu Bars, and Toolbars
Menus and Menu Items
Using IlvAbstractMenu
Using IlvMenuItem
Pop-up Menus
Aligning Item Labels in a Pop-up Menu
Using Tear-Off Menus
Using the Open Menu Callback
Using Checked Menu Items
Using Stand-alone Menus
Using Tooltips in a Pop-Up Menu
Menu Bars and Toolbars
Using IlvAbstractBar
Using IlvMenuBar and IlvToolBar
Matrices
Introducing Matrices
Using IlvAbstractMatrix
Subclassing IlvAbstractMatrix
Drawing Items Over Multiple Cells
Setting Fixed Rows and Columns
Handling Events
Using IlvMatrix
Handling Columns and Rows
Handling Matrix Items
Handling Events
Using Gadget Items in a Matrix
Using IlvSheet
Using IlvHierarchicalSheet
Changing the Tree Hierarchy
Navigating through a Tree Hierarchy
Changing the Characteristic of a Tree Item
Expanding and Collapsing a Gadget Item
Changing the Look of the Tree Gadget Hierarchy
Event Handling and Callbacks
Panes
Introducing Panes
Creating Panes
Creating a Graphic Pane
Creating a View Pane
Showing or Hiding a Pane
Adding Panes to Paned Containers
Creating a Paned Container
Modifying the Layout of a Paned Container
Retrieving Panes
Encapsulating a Paned Container in a View Pane
Resizing Panes
Setting the Resize Mode and the Minimum Size of a Pane
Resizing Panes With Sliders
Docking Panes and Containers
Introducing Docking Panes and Dockable Containers
Creating Docking Panes
Creating Orthogonal Dockable Containers
Controlling Docking Operations
Connecting an Instance of the IlvDockable Class to a Pane
Docking and Undocking a Pane
Filtering Docking Operations
Using Docking Bars
Using the IlvAbstractBarPane Class
Customizing Docking Bars
Building a Standard Application With Docking Panes
Defining a Standard Layout
Using the IlvDockableMainWindow Class
View Frames
Introducing View Frames
Creating a Desktop with View Frames
Creating a Desktop
Creating View Frames
Managing View Frames
Creating a Client View
Changing the Title Bar
Changing the View Frame Menu
Minimizing, Maximizing, and Restoring View Frames
Normal View Frames
Minimized View Frames
Maximized View Frames
Closing View Frames
Changing the Current View Frame
Customizing the Look and Feel
Understanding the Architecture
IlvLookFeelHandler
IlvObjectLFHandler
Class Diagram
Making a User-Defined Component Look-and-Feel Dependant
Creating a New Component
Defining the Object Look-and-Feel Handler API
Subclassing the Object Look-and-Feel Handler
Installing the Object Look-and-Feel Handlers
Changing the Look and Feel of an Existing Component
Subclassing the Component Object Look-and-Feel Handler
Replacing an Object Look-and-Feel Handler
Creating a New Look-and-Feel Handler
Registering a New Look-and-Feel Handler
Registering Object Look-and-Feel Handlers Into a New Look-and-Feel Handler
Styling
Model
Mechanism
CSS Styling
Syntax
CSS Selectors
CSS declaration
Rogue Wave Views Application Framework
Introducing Rogue Wave Views Application Framework
What is Application Framework
The Document/View Architecture
Using the Application Framework Editor
Starting Up the Application Framework Editor
Application Framework Editor Main Window
Components Palette
Workspace
Creating a New Application
Selecting a Document Type
Creating and Configuring an Options File (.odv file)
Setting Application Parameters
Adding Menu Items
Adding Toolbar Items
Setting Document Parameters
Setting General Document Parameters
Setting Parameters for a Selected Document
Setting Window Parameters
Setting Toolbar Parameters for a Document Type
Setting Action Parameters
Action Definition
Creating an Action
Setting Popup Menu Parameters
Popup Definition
Creating a Popup Menu
Adding a Popup Item
Adding a New Popup Submenu
Setting Dialog Parameters
Dialog Definition
Creating a Dialog Box
Setting Data Parameters
Data Definition
Generating Parameters
Parameters Command
GUI Action Summary
Implementing an Application
How Application Framework Functions
Option Files
Main File
Implementation of a Document Class
New Document
Serialization
Commands
Undo / Redo / Repeat Actions
Reflecting Changes Made In the Data to Associated Views
Implementation of a Document View Class
Interactions
Application Framework Interfaces
The Interface Mechanism
Declaring an Interface
Naming Convention for Macros
Actions
Activating an Action Event
Processing an Action Event
Editing States
Creating a Simple Application
Creating the First Panel
Creating the Second Panel
States Panels
Editing the Show State
Chaining States
Changing the Label and the Callback of the Show Button
Creating a Substate: the Edit State
The State File
2D Graphics
Managers
Basic Manager Features
Introducing Managers
Layers
Views
View Transformer
Event Handling
Main Features of IlvManager
Manager Views
View Transformations
Double-buffering
Manager Layers
Layer Index
Layer Selectability
Layer Visibility
Layer Rendering
Managing Objects
Modifying the Geometry of Graphic Objects
Selecting Objects
Selection Procedures
Managing Selected Objects
Managing Object Properties
Arranging Objects
Drawing and Redrawing
Optimizing Drawing Tasks
Saving and Reading
Manager Event Handling
The Event Handling Mechanism
Event Hooks
View Interactors
Predefined View Interactors
Example: Implementing the IlvDragRectangleInteractor Class
Example of an Extension: IlvMoveInteractor
Object Interactors
Accelerators
Example: Changing the Key Assigned to an Accelerator
Predefined Manager Accelerators
Advanced Manager Features
Observers
General Notifications
Manager View Notifications
Manager Layer Notifications
Manager Contents Notifications
Graphic Object Geometry Notifications
Example
View Hooks
Manager View Hooks
Example: Monitoring the Number of Objects in a Manager
Example: Maintaining a Scale Displayed With No Transformation
Manager Grid
Example: Using a Grid
Undoing and Redoing Actions
Command Class
Managing Undo
Example: Using the IlvManagerCommand Class to Undo/Repeat
Managing Modifications
Grapher
Introducing the Grapher Extension of Rogue Wave Views Studio
The Main Window
Buffer Windows
The Menu Bar
The Action Toolbar
The Editing Modes Toolbar
The Palettes Panel
The Grapher Palettes
Grapher Extension Commands
MakeNode
NewGrapherBuffer
SelectArcLinkImageMode
SelectDoubleLinkImageMode
SelectDoubleSplineLinkImageMode
SelectLinkImageMode
SelectOneLinkImageMode
SelectOneSplineLinkImageMode
SelectOrientedArcLinkImageMode
SelectOrientedDoubleLinkImageMode
SelectOrientedDoubleSplineLinkImageMode
SelectOrientedLinkImageMode
SelectOrientedOneLinkImageMode
SelectOrientedOneSplineLinkImageMode
SelectOrientedPolylineLinkImageMode
SelectPinEditorMode
SelectPolylineLinkImageMode
Features of the Grapher Package
Graph Management
Description of the IlvGrapher Class
Loading and Saving Graph Descriptions
Grapher Links
Base Class for Links
Predefined Grapher Links
Creating a Custom Grapher link
Connection Pins
Grapher Interactors
Selection Interactor
Creating Nodes
Creating Links
Editing Connection Pins
Editing Links
Prototypes
Introducing the Prototypes Package
An Overview of the Prototypes Package
Business Graphic Objects
Creating BGOs Using the Prototypes Extension of Rogue Wave Views Studio
Using Prototypes in Applications
When Should You Use Prototypes?
The Prototype Design Pattern
Specifying Graphic and Interactive Behavior Using Accessors
Using Rogue Wave Views Studio to Create BGOs
Creating and Using Prototypes
Creating a Prototype Library
Creating a Prototype
Defining the Attributes
Drawing the Prototype
Defining Graphic Behaviors
Defining Interactive Behaviors
Editing a Prototype
Testing Your Prototype
Saving a Prototype
Loading and Saving Prototype Libraries
Creating and Editing Prototype Instances in Panels
Choosing a Buffer Type
Creating a Prototype Instance
Editing Prototype Instances
Loading and Saving Panels
Connecting Prototype Instances
The User Interface and Commands
Overview
Launching Rogue Wave Views Studio With the Prototypes Extension
The Main Window
Buffer Windows
The Menu Bar
The Action Toolbar
The Editing Modes Toolbar
The Palettes Panel
Group Inspector Panel
Prototypes Extension Commands
CloseProtoLibrary
ConvertProtoManager
DeletePrototype
EditPrototype
GroupIntoGroup
NewProtoLibrary
NewPrototype
NewPrototypeEditionBuffer
NewPrototypeGrapherBuffer
OpenProtoLibrary
SaveProtoLibraryAs
SelectGroupConnectionMode
SelectGroupSelectionMode
SelectNodeSelectionMode
ShowGroupEditor
ToggleTimers
UngroupIlvGroups
Using Prototypes in C++ Applications
Architecture
Groups
Attributes and Accessor Objects
Accessor Parameters
Prototypes and Instances
Displaying Groups and Instances in Managers and Containers
Connecting Attributes
Linking Application Objects to Prototypes
Writing C++ Applications Using Prototypes
Header Files
Loading a Panel Containing Prototype Instances
Loading Prototypes
Creating Prototype Instances
Deleting Prototype Instances
Retrieving Groups and Prototype Instances
Getting and Setting Attributes
User-Defined and Predefined Attributes
Linking Prototypes to Application Objects
Setting Values Directly
Using Group Mediators
Using Proto Mediators
Advanced Uses of Prototypes
Writing New Accessor Classes
Creating Prototypes by Coding
Customizing Rogue Wave Views Studio With the Prototypes Extension
Predefined Accessors
Overview
Graphic Representation of the Behavior of a Prototype
Data Accessors
Value
Reference
Group
Script
Control Accessors
Assign
Condition
Format
Increment
Min/Max
Multiple
Notify
Script
Switch
Toggle
Display Accessors
Fill
MultiRep
Rotation
ScaleX
ScaleY
TranslateX
TranslateY
Animation Accessors
Blink
Invert
Rotate
Trigger Accessors
Callback
Clock
Watch
Event
Miscellaneous Accessors
Debug
Prototype
Gantt
Gantt Chart Functionalities
High Level Gantt Chart Classes
User Interfaces
Manager Views
Grapher Views
Scales
Gantt Abstract Data Classes
Populating Gantt Charts
Gantt Graphic Models
Specifying Graphic Models
Gantt Grid Objects
Predefined Grid Classes
Gantt Interactors
Select and Move Interactors
Creation Interactors
Zoom Interactors
Time Scales and IlvGanttChartForm
Positioning the Time Scales
Using Time Converters
Using the Gantt Chart Through Examples
The Entry Point of the Sample
Subclassing IlvGanttChart
Customizing Gantt Scales
Modifying the Start and End Times
Automatically Updating Scales
Customizing Gantt Chart Grids
Defining Graphic Models for Lines and Nodes
Defining a Graphic Model for Links
Registering Gantt Data Change Hooks
Name Property
Name Property Change Hook
Registering Name Property Hooks
Using the Handle
Mono View Gantt Chart
Hiding the Handle
Overview of Gantt Samples
The Simple Sample
The Load Sample
The Month Sample
The Calendar Sample
BIDI
Introduction
Target Systems
Arabic Version of Windows Server 2003/Server 2008/XP/7/8
Limitations
Compatibility with the Standard Version of Rogue Wave Views
Support of Bidirectional and Contextual Languages
Supported Languages
Initializing Rogue Wave Views Bidi
Setting the Language
Setting Bidirectional Features
Limitation
Bidirectional Attributes
The IlvLayoutDirection Attribute
The IlvNumerals Attribute
The IlvShaping Attribute
The IlvSwapping Attribute
The IlvWordBreak Attribute
Default Bidirectional Attributes of the IlvDisplay
Controlling Default Bidirectional Attributes Through the API
Controlling Default Bidirectional Attributes Through Resources
The Class IlvBidiString
Functions Using the IlvBidiString Class
IlvPort Methods Using the IlvBidiString Class
IlvFont Methods Using the IlvBidiString Class
The Class IlvBidiInterface
Bidirectional Attributes and the Class IlvGraphic
Get Functions
Set Functions
Orientation of Gadget Holders
IlvText and IlvTextField
Bidirectional Rogue Wave Studio
Foundation
Bidirectional Rogue Wave Studio
NEWFEATURES