### ISplitCanvas

  The ISplitCanvas class provides a way to split a window into two or more window panes by creating and adding controls. The number of controls you add determines the number of panes in the split canvas.

  You can separate the window panes using split bars (the default style). By dragging the split bars, a user can dynamically change the visible amount of each pane. The split canvas manages the position and size of its child windows, so that together with the split bars, they occupy the entire area of the canvas.

  You can stack the controls vertically (the default) or horizontally.

  Typically, you create a split canvas control with a frame window or another split canvas window as its parent and owner. Any window can serve this purpose. In addition, you might want to call IFrameWindow::setClient to make the split canvas control the client window of a frame window. Then you can add other controls, such as list boxes, push buttons, or even another split canvas by creating each control with the split canvas for its parent.
  Note: You can make an IFrameWindow the child window of a split canvas only if it is the only child window of the canvas. However, it is better to add a multicell canvas between the split canvas and the IFrameWindow. Make the IFrameWindow the only child window of the multicell canvas by placing it in a single expandable row and column and make the multicell canvas a child window of the split canvas.

  Do not change the Z-order of the child windows of a split canvas without refreshing the canvas. Doing so results in unpredictable behavior.

  Controls are positioned in the window panes of a split canvas in the order you create them in, from left to right in a vertically split canvas and from top to bottom in a horizontally split canvas. Tabbing order is based on the order in which you create controls having the style IWindow::tabStop.

  To specify what percentage of the split canvas a control occupies when the split canvas is initially displayed, use ISplitCanvas::setSplitWindowPercentage. The percentages you set determine the size of the window panes containing the controls, not the size of the controls themselves. Some testing might be necessary to determine the proper percentages to specify for each control to obtain the optimal initial appearance of the split canvas.
  Note: If the split canvas has split bars and the user drags the split bars, the percentages you set will change. Your percentage values determine the initial appearance of the split canvas and the controls it contains. The minimum size to which a user can size a pane is the width of the split bar.

  You can create a split canvas without split bars by using the style ISplitCanvas::noSplitBars. When you use this style, each pane maintains its size ratio to the other panes when users size the canvas. However, users cannot modify the percentage of the canvas occupied by a pane as they can when split bars are available.

  When the sum of the controls' percentages is equal to 100, each window pane is given its requested percentage of the split canvas. However, when the sum of the controls' percentages is less than or greater than 100, the percentages are converted to ratios.

  Controls that do not have a percentage are assigned a percentage by the class library proportional to the number of controls in the split canvas. For example, if your split canvas has three controls and you specify no percentages, each window pane gets one-third of the window.

  If you set percentages for some or all of your controls, the window panes containing these controls are given a ratio determined by the percentages that you set. For example, suppose you have three controls, as in the preceding example, but this time you set the second control to 10 percent and the third control to 30 percent. The first pane gets one-third of the window since you did not specify a percentage. However, in this case, the second and third panes are given a ratio of 10:30 of the remaining space. The second pane gets 1/6 of the window (10/40 of the remaining space), and the third pane gets 1/2 of the window (30/40 of the remaining space).

  If a user changes the size of a split canvas, its window panes are sized to fill the split canvas by default. Each pane maintains its size ratio to the other panes in the canvas when this occurs.

#### AIX Considerations

  Motif does not support the enumeration SplitBarEdge. The value of the edge is always zero. The enumerator splitBarMiddle specifies the thickness of the split bar.

### ISplitCanvas - Member Functions and Data by Group

### Constructors & Destructor

You can construct and destruct objects of this class. You cannot copy or assign ISplitCanvas objects because both the copy constructor and assignment operator are private functions.

~ISplitCanvas

      public:
      virtual ~ISplitCanvas()

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

ISplitCanvas

      public:
      ISplitCanvas( unsigned long windowIdentifier,
                    IWindow* parent,
                    IWindow* owner,
                    const IRectangle& initialSize = IRectangle ( ),
                    const Style& style = defaultStyle ( ) )

  windowIdentifier
    The window identifier of the canvas you are constructing.

    We recommend that you do the following:

    - For portability, use a value in the range 0 to 65535.
    - Give unique identifiers to all windows in the same frame window. Two windows are in the same frame window if the first frame window in each of its parent window chains is the same window.
    - Give the client window a window identifier of IC_FRAME_CLIENT_ID, which is defined in the file icconst.h.
    Presentation Manager Notes Do not use FID_xxx values defined in pmwin.h, other than FID_CLIENT (which is equivalent to IC_FRAME_CLIENT_ID).
  parent
    The parent window of the canvas you are constructing. You must specify a parent window. The parent window is primarily used for visible relationships.
  owner
    The owner window of the canvas you are constructing. The owner window is primarily used for routing notification events and unprocessed messages. A window also inherits colors from its owner window.
    Motif Notes The owner window is only used for routing unprocessed messages. There is no concept of an owner in Motif.
  initialSize
    The initial position and size of the canvas you are constructing. The position is relative to the origin of the parent window. See ICoordinateSystem for additional information. Optional.
  style
    The window's characteristics. This value can be a combination of ISplitCanvas::Style, ICanvas::Style, and IWindow::Style objects. Optional.

Exception

  IInvalidParameter | style contains an invalid combination of styles. style cannot contain both the ISplitCanvas::horizontal and ISplitCanvas::vertical styles.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

### Child Window Sizing

Use these members to control the size of the child windows of the split canvas through percentages (ratios).

setSplitWindowPercentage

      public:
      virtual ISplitCanvas&
        setSplitWindowPercentage( IWindow* window,
                                  unsigned long percentage )

  Sets the percentage of the canvas occupied by the specified window.
  Note: If the split canvas is already shown, this function does not update it immediately. You must call IWindow::refresh to update the appearance of the canvas.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

splitWindowPercentage

      public:
      unsigned long splitWindowPercentage(IWindow* window)

  Returns the percentage of the width or height of the canvas currently occupied by the specified window.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

### Colors

Use these members to set and query the color of the middle or edge of a split bar.

resetSplitBarEdgeColor

      public:
      virtual ISplitCanvas& resetSplitBarEdgeColor()

  Resets the color of the edges of the canvas' split bars, so the default edge color is used.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Ignored

resetSplitBarMiddleColor

      public:
      virtual ISplitCanvas& resetSplitBarMiddleColor()

  Resets the color of the interior of the canvas' split bars, so that the default color is used.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Ignored

setSplitBarEdgeColor

      public:
      virtual ISplitCanvas&
        setSplitBarEdgeColor( const IColor& color )

  Sets the color for the edges of the canvas' split bars.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Ignored

setSplitBarMiddleColor

      public:
      virtual ISplitCanvas&
        setSplitBarMiddleColor( const IColor& color )

  Sets the color for the interior of the canvas' split bars.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

splitBarEdgeColor

      public:
      virtual IColor splitBarEdgeColor() const

  Returns the color of the edges of the canvas' split bars.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Ignored

splitBarMiddleColor

      public:
      virtual IColor splitBarMiddleColor() const

  Returns the color of the interior of the canvas' split bars.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

### Layout Support

Layout members determine how this class sizes and positions its child windows or how this window will be laid out on another canvas.

setLayoutDistorted

      public:
      virtual ISplitCanvas&
        setLayoutDistorted( unsigned long layoutAttributesOn,
                            unsigned long layoutAttributesOff )

  Treats the following as changes to the layout of its child windows:

  - Changing the size of the canvas
  - Adding a child window
  - Removing a child window

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

layout

      protected:
      virtual ISplitCanvas& layout()

  Computes the position and size of all child controls.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

### Notification Members

These members allow observers to process changes to the window.

orientationId

      public:
      static INotificationId const orientationId

  Notification identifier provided to observers when the orientation of the split canvas changes. ISplitCanvas provides the new split canvas orientation value in the INotificationEvent::eventData field of the INotificationEvent. as an Orientation enumeration.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

### Orientation

These members control the orientation of the canvas' split bars.

orientation

      public:
      Orientation orientation() const

  Returns an enumerator Orientation for the orientation of the canvas' split bars.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

setOrientation

      public:
      virtual ISplitCanvas& setOrientation(Orientation value)

  Sets the direction in which the canvas' split bars are drawn.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

### Split Bar Thickness

Use these members to customize the thickness of the split bar.

setSplitBarThickness

      public:
      virtual ISplitCanvas&
        setSplitBarThickness( SplitBarArea area,
                              unsigned long thickness )

  Sets the thickness of the specified area of the split bar.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

splitBarThickness

      public:
      unsigned long splitBarThickness(SplitBarArea area)

  Returns the thickness of the specified area of the split bar.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

### Styles

Use these style members to customize a window at the time you construct it. Most styles have equivalent member functions, which allow you to similarly modify a window after creating it. You can use these styles with the styles defined by the following nested classes:

- ICanvas::Style
- IWindow::Style

Once you have constructed an ISplitCanvas object, you can use ISplitCanvas, ICanvas, and IWindow member functions to query and change individual styles.

convertToGUIStyle

      public:
      virtual unsigned long
        convertToGUIStyle( const IBitFlag& style,
                           bool extendedOnly = false ) const

  Converts a style object into a value appropriate for the underlying system. The default action is to return the base GUI styles for the platform. Extended styles, those defined by the application and the Open Class Library, will be returned if you set extendedOnly to true.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

defaultStyle

      public:
      static Style defaultStyle()

  Returns the default style. The default style is classDefaultStyle unless you have changed the style using setDefaultStyle.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

setDefaultStyle

      public:
      static void setDefaultStyle(const Style& style)

  Sets the default style for all subsequent split canvases.

  This member function is not thread safe. In a multithreaded application, it should only be called when a conflict is not possible. A conflict can arise if you set the default style on one thread at the same time that it is being queried on another. In this situation, the query would take place while the style is in an unknown state.

  When you create a window class and do not specifically specify window styles in the constructor, the Open Class Library queries the default style. Therefore, the only safe place to call this member function is when no other application threads that create windows are active.

  Another way to avoid a conflict in a multithreaded application is to specifically specify window styles on window construction, rather than calling this member function.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

classDefaultStyle

      public:
      static const Style classDefaultStyle

  Specifies the original default style for this class, which is ISplitCanvas::vertical | IWindow::visible.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

horizontal

      public:
      static const Style horizontal

  Draws split bars horizontally, placing the panes top to bottom.
  Note: You cannot specify this style with ISplitCanvas::vertical.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

noSplitBars

      public:
      static const Style noSplitBars

  Specifies no split bars are used to separate panes.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

vertical

      public:
      static const Style vertical

  Draws split bars vertically, placing the panes left to right. This style is the default.
  Note: You cannot specify this style with ISplitCanvas::horizontal.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

### ISplitCanvas - Enumerations

Orientation

      enum Orientation { horizontalSplit,
                         verticalSplit }

  Use these enumerators to specify the direction of the canvas's split bars:

  horizontalSplit
    Draws split bars horizontally, placing the panes top to bottom.
  verticalSplit
    Draws split bars vertically, placing the panes left to right.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

SplitBarArea

      enum SplitBarArea { splitBarEdge,
                          splitBarMiddle }

  Use these enumerators to specify different areas of a split bar:

  splitBarEdge
    Specifies the top and bottom edges of a horizontal split bar or the left and right edges of a vertical split bar.
  splitBarMiddle
    Specifies the interior of a split bar.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

### ISplitCanvas - Inherited Member Functions and Data

#### Inherited Public Functions

  ICanvas

  -     virtual ~ICanvas()

  -     virtual ICanvas& addBorder()

  -     virtual IColor backgroundColor() const

  -     virtual IColor borderColor() const

  -     IText borderText() const

  -     IPoint bottomRightLayoutOffset() const

  -     virtual IFont font() const

  -     virtual bool hasBorder() const

  -     virtual bool hasChildrenToLayout() const

  -     ICanvas( unsigned long windowIdentifier,
                 IWindow* parent,
                 IWindow* owner,
                 const IRectangle& initial = IRectangle ( ),
                 const Style& style = defaultStyle ( ) )

  -     virtual bool isTabStop() const

  -     virtual IWindowHandle
          matchForMnemonic( unsigned short character ) const

  -     virtual ICanvas& removeBorder()

  -     virtual ICanvas& resetBorderColor()

  -     virtual ICanvas& resetFont()

  -     virtual ICanvas& setBorderColor(const IColor& borderColor)

  -     virtual ICanvas&
          setBorderText( const IText& borderText,
                         bool showBorder = true )

  -     virtual ICanvas&
          setBorderText( const IResourceId& borderText,
                         bool showBorder = true )

  -     virtual ICanvas& setFont(const IFont& font)

  -     virtual ICanvas&
          setLayoutDistorted( unsigned long layoutAttributesOn,
                              unsigned long layoutAttributesOff )

  -     IPoint topLeftLayoutOffset() const

  IControl

  -     virtual ~IControl()

  INotifier

  -     virtual ~INotifier()

  -     virtual INotifier& disableNotification() = 0

  -     virtual INotifier&
          enableNotification( bool enable = true ) = 0

  -     INotifier()

  -     virtual bool isEnabledForNotification() const = 0

  -     virtual INotifier&
          notifyObservers( const INotificationEvent& event ) = 0

  -     virtual INotifier&
          notifyObserversAsync( const INotificationEvent& event )

  -     const IThreadId& threadId() const

  IWindow

  -     virtual ~IWindow()

  -     IAccelTblHandle acceleratorHandle() const

  -     IAcceleratorTable acceleratorTable() const

  -     virtual IColor activeColor() const

  -     IWindow&
          addOrReplaceAttribute( const IAttributeName& name,
                                 const IAttribute& attribute )

  -     IWindow&
          adoptWindowData( const DataHandle& typeToken,
                           IWindowData* windowData )

  -     virtual IString asDebugInfo() const

  -     virtual IString asString() const

  -     IAttributeName
          attributeNameAt( const AttributeCursor& cursor ) const

  -     const IAttribute*
          attributeWithName( const IAttributeName& name,
                             ESearchType search = kWindowOnly ) const

  -     virtual IWindow& capturePointer(bool capture = true)

  -     ISize characterSize() const

  -     IWindowHandle childAt(const ChildCursor& cursor) const

  -     IWindow* childWindowAt(const ChildCursor& cursor) const

  -     virtual IArgList
          convertToArgList( const IBitFlag& style ) const

  -     static DataHandle
          dataHandleWithKey( const char* dataKeyName )

  -     virtual IWindowHandle defaultEmphasisButton() const

  -     static SiblingOrder defaultOrdering()

  -     static IWindow* desktopWindow()

  -     virtual IWindow& disable()

  -     virtual IColor disabledBackgroundColor() const

  -     virtual IColor disabledForegroundColor() const

  -     virtual IWindow& disableGroup()

  -     IWindow& disableMinimumSizeCaching()

  -     virtual IWindow& disableNotification()

  -     virtual IWindow& disableTabStop()

  -     virtual IWindow& disableUpdate()

  -     bool
          dispatchRemainingHandlers( IEvent& event,
                                     bool callDefProc = true )

  -     virtual IWindow& enable(bool enableWindow = true)

  -     virtual IWindow& enableGroup(bool enable = true)

  -     IWindow&
          enableMinimumSizeCaching( bool enableCaching = true )

  -     virtual IWindow& enableNotification(bool enable = true)

  -     virtual IWindow& enableTabStop(bool enable = true)

  -     virtual IWindow& enableUpdate(bool enableWindow = true)

  -     static IWindow::ExceptionFn* exceptionFunction()

  -     virtual IColor foregroundColor() const

  -     virtual IWindowHandle handle() const

  -     virtual bool
          handleException( IException& dispatcherException,
                           IEvent& exceptionEvent )

  -     virtual IWindowHandle handleForChildCreation() const

  -     static IWindowHandle
          handleWithParent( unsigned long identifier,
                            const IWindowHandle& parent )

  -     static IWindowHandle handleWithPointerCaptured()

  -     virtual bool hasFocus() const

  -     virtual bool hasPointerCaptured() const

  -     unsigned long helpId() const

  -     virtual IWindow& hide()

  -     virtual IWindow& hideSourceEmphasis()

  -     virtual IColor hiliteBackgroundColor() const

  -     virtual IColor hiliteForegroundColor() const

  -     virtual unsigned long id() const

  -     virtual IColor inactiveColor() const

  -     virtual IRectangle invalidatedRect() const

  -     virtual IRegionHandle invalidatedRegion() const

  -     bool isAutoDeleteObject() const

  -     bool isAutoDestroyWindow() const

  -     bool isEnabled() const

  -     virtual bool isEnabledForNotification() const

  -     virtual bool isFrameWindow() const

  -     virtual bool isGroup() const

  -     bool isHandling(const EventMask& events) const

  -     virtual bool
          isLayoutDistorted( unsigned long layoutAttribute ) const

  -     bool isMinimumSizeCachingEnabled() const

  -     bool isShowing() const

  -     bool isUpdateEnabled() const

  -     virtual bool isValid() const

  -     bool isVisible() const

  -     static bool isWindowValid(const IWindow* window)

  -     IDMItemProvider* itemProvider() const

  -     IWindow(const IWindowHandle& handle)

  -     IWindow(unsigned long identifier, IWindow* parent)

  -     virtual IRectangle layoutAdjustment() const

  -     static IPoint
          mapPoint( const IPoint& point,
                    const IWindowHandle& from,
                    const IWindowHandle& to )

  -     IMessageQueueHandle messageQueue() const

  -     ISize minimumSize(bool windowCalculatedSize = false) const

  -     virtual IPointerHandle mousePointer() const

  -     static void movePointerTo(const IPoint& position)

  -     virtual IWindow&
          moveSizeTo( const IRectangle& newSizeAndPosition )

  -     virtual IWindow& moveTo(const IPoint& newPosition)

  -     virtual IRectangle nativeRect() const

  -     virtual INotifierAddress notifierAddress() const

  -     virtual IWindow&
          notifyObservers( const INotificationEvent& event )

  -     virtual IWindow&
          notifyObserversAsync( const INotificationEvent& event )

  -     static IWindow* objectWindow()

  -     virtual IWindow* owner() const

  -     IWindow* parent() const

  -     virtual ISize parentSize() const

  -     static ISize parentSize(const IWindowHandle& windowHandle)

  -     static IPoint pointerPosition()

  -     virtual IPoint position() const

  -     virtual IWindow&
          positionBehindSibling( const IWindowHandle& siblingWindow )

  -     virtual IWindow& positionBehindSiblings()

  -     virtual IWindow& positionOnSiblings()

  -     virtual const IWindow&
          postEvent( unsigned long eventId,
                     const IEventParameter1& parm1 = 0,
                     const IEventParameter2& parm2 = 0 ) const

  -     virtual const IWindow&
          postEvent( EventType eventType,
                     const IEventParameter1& parm1 = 0,
                     const IEventParameter2& parm2 = 0 ) const

  -     virtual const IWindow& postEvent(const IEvent& event) const

  -     virtual IPresSpaceHandle presSpace() const

  -     virtual IRectangle rect() const

  -     virtual IWindow&
          refresh( const IRectangle& invalidRectangle,
                   bool immediate = false )

  -     virtual IWindow& refresh(RefreshType type = paintAll)

  -     virtual IWindow& releasePointer()

  -     virtual void
          releasePresSpace( const IPresSpaceHandle& presentationSpaceHandle ) const

  -     IWindow& removeAllAttributes()

  -     IWindow& removeAttribute(const IAttributeName& name)

  -     virtual IWindow& resetActiveColor()

  -     virtual IWindow& resetBackgroundColor()

  -     virtual IWindow& resetDisabledBackgroundColor()

  -     virtual IWindow& resetDisabledForegroundColor()

  -     virtual IWindow& resetFont()

  -     virtual IWindow& resetForegroundColor()

  -     virtual IWindow& resetHiliteBackgroundColor()

  -     virtual IWindow& resetHiliteForegroundColor()

  -     virtual IWindow& resetInactiveColor()

  -     IWindow& resetMinimumSize()

  -     virtual IWindow& resetShadowColor()

  -     virtual IEventResult sendEvent(const IEvent& event) const

  -     virtual IEventResult
          sendEvent( unsigned long eventId,
                     const IEventParameter1& parm1 = 0,
                     const IEventParameter2& parm2 = 0 ) const

  -     virtual IEventResult
          sendEvent( EventType eventType,
                     const IEventParameter1& parm1 = 0,
                     const IEventParameter2& parm2 = 0 ) const

  -     IWindow&
          setAcceleratorHandle( const IAccelTblHandle& handle )

  -     IWindow&
          setAcceleratorTable( const IAcceleratorTable* acceleratorTable )

  -     virtual IWindow& setActiveColor(const IColor& color)

  -     IWindow& setAutoDeleteObject(bool autoDelete = true)

  -     IWindow& setAutoDestroyWindow(bool autoDestroy = false)

  -     virtual IWindow& setBackgroundColor(const IColor& color)

  -     static void setDefaultOrdering(SiblingOrder order)

  -     virtual IWindow&
          setDisabledBackgroundColor( const IColor& color )

  -     virtual IWindow&
          setDisabledForegroundColor( const IColor& color )

  -     static IWindow::ExceptionFn*
          setExceptionFunction( IWindow::ExceptionFn* exceptionFunction )

  -     virtual IWindow& setFocus()

  -     virtual IWindow& setFont(const IFont& font)

  -     virtual IWindow& setForegroundColor(const IColor& color)

  -     IWindow& setHelpId(unsigned long helpTopicId)

  -     virtual IWindow&
          setHiliteBackgroundColor( const IColor& color )

  -     virtual IWindow&
          setHiliteForegroundColor( const IColor& color )

  -     virtual IWindow& setId(unsigned long newIdentifier)

  -     virtual IWindow& setInactiveColor(const IColor& color)

  -     IWindow& setItemProvider(IDMItemProvider* dragProvider)

  -     virtual IWindow&
          setLayoutDistorted( unsigned long layoutAttributesOn,
                              unsigned long layoutAttributesOff )

  -     IWindow& setMinimumSize(const ISize& size)

  -     virtual IWindow&
          setMousePointer( const IPointerHandle& mousePointer )

  -     virtual IWindow& setOwner(const IWindow* newOwner)

  -     virtual IWindow& setParent(const IWindow* newParent)

  -     virtual IWindow& setShadowColor(const IColor& color)

  -     virtual IColor shadowColor() const

  -     virtual IWindow& show(bool showWindow = true)

  -     virtual IWindow& showSourceEmphasis(bool show = true)

  -     virtual ISize size() const

  -     virtual IWindow& sizeTo(const ISize& newSize)

  -     IWindow& startHandling(const EventMask& events)

  -     IWindow& stopHandling(const EventMask& events)

  -     virtual IWindow&
          validateRect( const IRectangle& validatedRectangle )

  -     virtual IWindow&
          validateRegion( const IRegionHandle& validatedRegion )

  -     virtual IRectangle visibleRectangle() const

  -     IWindowData* windowData(const DataHandle& typeToken) const

  -     static IWindow*
          windowWithHandle( const IWindowHandle& windowHandle,
                            bool allThreads = true )

  -     static IWindow*
          windowWithOwner( unsigned long identifier,
                           const IWindow* owner,
                           bool allThreads = true )

  -     static IWindow*
          windowWithParent( unsigned long identifier,
                            const IWindow* parent,
                            bool allThreads = true )

#### Inherited Public Data

  IWindow

  -     static INotificationId const activeColorId

  -     static const EventMask allMouseMoves

  -     static INotificationId const
          attributeAddReplaceId

  -     static INotificationId const attributeRemoveId

  -     static INotificationId const backgroundColorId

  -     static INotificationId const borderColorId

  -     static const Style clipChildren

  -     static const Style clipSiblings

  -     static const Style clipToParent

  -     static INotificationId const commandId

  -     static const Style disabled

  -     static INotificationId const
          disabledBackgroundColorId

  -     static INotificationId const
          disabledForegroundColorId

  -     static INotificationId const enableId

  -     static INotificationId const focusId

  -     static INotificationId const fontId

  -     static INotificationId const foregroundColorId

  -     static const Style group

  -     static INotificationId const
          hiliteBackgroundColorId

  -     static INotificationId const
          hiliteForegroundColorId

  -     static INotificationId const inactiveColorId

  -     static const Style leftToRight

  -     static const EventMask mouseEntersLeaves

  -     static const Style noStyle

  -     static INotificationId const positionId

  -     static const Style rightToLeft

  -     static const Style saveBits

  -     static INotificationId const shadowColorId

  -     static INotificationId const sizeId

  -     static const EventMask someMouseMoves

  -     static const Style synchPaint

  -     static INotificationId const systemCommandId

  -     static const Style tabStop

  -     static const Style visible

  -     static INotificationId const visibleId

  INotifier

  -     static INotificationId const allChangesId

  -     static INotificationId const deleteId

  ICanvas

  -     static const Style border

  -     static INotificationId const textId

#### Inherited Protected Functions

  IWindow

  -     IWindow& addHandler(IHandler* newHandler)

  -     virtual IWindow&
          addObserver( IObserver& observer,
                       const IInterest& interest )

  -     static void
          addToWindowSet( IWindow* window,
                          const IWindowHandle& windowHandle )

  -     IWindow& bindMessageQueue(bool bindToMessageQueue = true)

  -     IColor
          color( unsigned long colorArea,
                 const IColor& defaultColor ) const

  -     IColor color(unsigned long colorArea) const

  -     virtual IWindowHandle
          create( unsigned long id,
                  const char* text,
                  unsigned long style,
                  const char* windowClass,
                  const IWindowHandle& parent,
                  const IWindowHandle& owner,
                  const IRectangle& initRect,
                  const void* ctlData,
                  const void* presParams,
                  IWindow::SiblingOrder ordering = defaultOrdering ( ),
                  unsigned long extendedStyle = 0 )

  -     virtual IWindowHandle
          create( unsigned long id,
                  const char* text,
                  unsigned long style,
                  IXmCreateFunction createFunction,
                  const IWindowHandle& parent,
                  const IWindowHandle& owner,
                  const IRectangle& initRect,
                  const void* callerArgList,
                  unsigned int callerNumberArguments,
                  IWindow::SiblingOrder ordering = defaultOrdering ( ),
                  unsigned long extendedStyle = 0 )

  -     virtual IWindowHandle
          create( unsigned long id,
                  const char* text,
                  const IBitFlag& style,
                  const char* windowClass,
                  const IWindow* parent,
                  const IWindow* owner,
                  const IRectangle& initRect,
                  const void* ctlData,
                  const void* presParams,
                  IWindow::SiblingOrder ordering = defaultOrdering ( ) )

  -     virtual IWindowHandle
          create( unsigned long id,
                  const char* text,
                  const IBitFlag& style,
                  IXmCreateFunction createFunction,
                  const IWindow* parent,
                  const IWindow* owner,
                  const IRectangle& initRect,
                  IWindow::SiblingOrder ordering = defaultOrdering ( ) )

  -     IWindow& defaultProcedure(IEvent& event)

  -     bool deleteIsInProcess() const

  -     bool dispatch(IEvent& event)

  -     virtual unsigned long extendedStyle() const

  -     bool isBoundToMessageQueue() const

  -     virtual bool isDragStarting(IEvent& event)

  -     bool isPrimaryWindow() const

  -     bool isUserWindowWordReserved() const

  -     IWindow()

  -     IWindowNotifyHandler* notificationHandler() const

  -     virtual IWindow&
          notifyObservers( const INotificationId& notification )

  -     IObserverList&
          observerList( const IInterest* interest = 0 ) const

  -     virtual IWindow&
          prepareForUse( const IWindowHandle& windowHandle )

  -     virtual IWindow& removeAllObservers()

  -     static void removeFromWindowSet(IWindow* window)

  -     IWindow& removeHandler(IHandler* oldHandler)

  -     virtual IWindow& removeObserver(IObserver& observer)

  -     virtual IWindow&
          removeObserver( IObserver& observer,
                          const IInterest& interest )

  -     IWindow& reserveUserWindowWord(bool reserve = true)

  -     virtual IWindow& resetColor(unsigned long colorArea)

  -     ISize savedMinimumSize() const

  -     IWindow& saveMinimumSize(const ISize& size)

  -     virtual IWindow&
          setBidiSettings( const IBidiSettings& bidiSettings,
                           bool childInherit,
                           bool refresh )

  -     virtual IWindow&
          setColor( unsigned long colorArea,
                    const IColor& color )

  -     virtual IWindow&
          setDefaultEmphasisButton( const IWindowHandle& defaultEmphasisButton,
                                    bool enable )

  -     virtual IWindow&
          setDefaultPushButton( const IWindowHandle& defaultPushButton )

  -     virtual IWindow&
          setExtendedStyle( unsigned long extendedStyle )

  -     IWindow&
          setNotificationHandler( IWindowNotifyHandler* notifyHandler )

  -     virtual IWindow& setStyle(unsigned long style)

  -     IWindow&
          setWindowData( long index,
                         unsigned short dataValue )

  -     IWindow& setWindowData(long index, unsigned long dataValue)

  -     IWindow&
          startHandlingEventsFor( const IWindowHandle& windowHandle )

  -     IWindow&
          startHandlingEventsFor( unsigned long identifier,
                                  IWindow* parent )

  -     virtual unsigned long style() const

  -     IWindow& unbindMessageQueue()

  -     unsigned long windowULong(long index) const

  -     unsigned short windowUShort(long index) const

  INotifier

  -     virtual INotifier&
          addObserver( IObserver& observer,
                       const IInterest& interest )

  -     virtual INotifier&
          notifyObservers( const INotificationId& id ) = 0

  -     virtual IObserverList&
          observerList( const IInterest* anInterest = 0 ) const = 0

  -     virtual INotifier& removeAllObservers() = 0

  -     virtual INotifier&
          removeObserver( IObserver& observer,
                          const IInterest& interest )

  -     virtual INotifier& removeObserver(IObserver& observer) = 0

  ICanvas

  -     bool areChildrenReversed() const

  -     virtual ISize calcMinimumSize() const

  -     virtual IWindowPosBuffer fixupChildren()

  -     ICanvas()

  -     ICanvas&
          initialize( unsigned long windowIdentifier,
                      IWindow* parent,
                      IWindow* owner,
                      const IRectangle& initialRect,
                      unsigned long style,
                      unsigned long extendedStyle )

  -     virtual ICanvas& layout()

  -     ISize layoutSize() const

  -     virtual bool passEventToOwner(IEvent& event)

  -     IRectangle
          rectangleInsideBorder( const ISize& sizeWithBorder ) const

  -     virtual ICanvas&
          setBidiSettings( const IBidiSettings& bidiSettings,
                           bool childInherit,
                           bool refresh )

  -     ICanvas& setLayoutSize(const ISize& size)

  -     ISize sizeWithBorder(const ISize& sizeWithoutBorder) const

  IControl

  -     IControl()

#### Inherited Protected Data

  - None