### IMultiCellCanvas

  The IMultiCellCanvas class manages a collection of child windows in a way similar to that of data stored in a spreadsheet. A multicell canvas is a two-dimensional array of cells with an origin of (1,1) in the upper-left corner. Windows are added to a multicell canvas by specifying a starting cell and, optionally, a number of contiguous columns, rows, or a combination thereof.

  This class bases the initial cell sizes on the minimum sizes returned by each child window of the canvas. You can override the minimum sizes provided by the Open Class Library by doing either of the following:

  - Calling setMinimumSize
  - Creating a derived class and implementing a calcMinimumSize function

  Changing the size of a multicell canvas causes only expandable rows and columns to be resized. The user can cause any occupied cells to be resized by doing either of the following:

  - Changing the size of the child window which occupies the cell
  - Calling the setColumnWidth or setRowHeight functions for the cell

  Undesirable movement of the windows might result when a multicell canvas updates its child windows. In the case where the canvas contains IStaticText windows, you can avoid this by calling IStaticText::setLimit so that the static text bases its minimum size on an expected number of characters rather than its actual text string.

  The following figure illustrates the positioning of four static text controls, three entry fields, and two push buttons:

  Sample Multicell Canvas

  Because there is no text in either row 1 or column 1, row 1 and column 1 take the default cell size, which is 10 pixels. As you can see in the figure, the default cell size is relatively small and, therefore, preserves screen space. Also, using the default cell size for column 1 and row 1 creates some padding, or margin, around the child windows that you place in the multicell canvas.

  Positioning Static Text Controls Example

  The first static text control has a starting cell of (2,2). The child static text control window exists in one row, row 2, and extends from column 2 through column 7. It occupies six columns (2, 3, 4, 5, 6, and 7). The following addToCell call was used to produce it, where myClient is the client window multicell canvas:

      myClient.addToCell(&prompt, 2, 2, 6, 1);

  The name of the child static text control window is prompt. The two numbers that follow the name specify the starting column and row, (2,2). The last two numbers, (6,1), specify that the control extends through six columns and occupies one row.

  The other static text controls, which contain the text strings "Name," "Serial number," and "Password," have starting cells of (3,4), (3,6), and (3,8), respectively. The following addToCell calls were used to produce them:

      myClient.addToCell(&namePrompt, 3, 4);
      myClient.addToCell(&numberPrompt, 3, 6);
      myClient.addToCell(&passwordPrompt, 3, 8);

  Notice that we did not specify the number of columns and rows for these text controls to occupy. This means the columns and rows take the default, which is one column and one row. The width of column 3 is based on the static text control that contains "Serial number."

  Positioning Entry Fields Example

  The first entry field has a starting cell of (5,4) and extends through three columns (columns 5, 6, and 7) while occupying one row. The first static text control has already determined the width of these columns, so this entry field is stretched to the right edge of column 7.

  The second entry field has a starting cell of (5,6) and occupies the default of one column and one row. This means that the width of column 5 is based on the width of the second entry field because it only occupies one column.

  The third entry field has a starting cell of (5,8), spanning two columns and one row. Here are the addToCell calls for the entry fields:

      myClient.addToCell(&name, 5, 4, 3, 1);
      myClient.addToCell(&number, 5, 6);
      myClient.addToCell(&password, 5, 8, 2, 1);

  Using Expandable Rows and Columns Example

  In the figure, column 7 is much wider than you might expect. You might think that it should be the same size as all of the other columns except 3 and 5, which are sized to fit particular controls. Also, the height of row 9 is much greater than that of the other rows. The reason column 7 is so much wider and that the height of row 9 is so much greater is that we made them expandable. Columns and rows that are expandable grow when the window's size increases or shrink when the window's size decreases.

  When the space allotted to the canvas is larger than the size needed to contain the canvas, expandable rows and columns are given more space relative to each other. For example, if one expandable row is twice the size of another expandable row, the ratio is maintained after increasing the size of the canvas. Rows and columns that are not specified as expandable maintain their fixed size.

  The setColumnWidth and setRowHeight functions have an expandable parameter whose default is false. However, we set them to true for column 7 and row 9. Here is the setColumnWidth function call for column 7:

      myClient.setColumnWidth(7, 0, true);

  On the setColumnWidth function call, the first number represents column 7. The second number specifies the amount that the width of the column is to increase beyond the minimum size required for the window or windows contained in the column. We set this to 0 so that the column would not take up screen space unless the canvas is wide enough that it has space not needed by the nonexpandable columns. The final value, true, indicates that this column is expandable.

  Positioning Push Buttons Example

  The last part of this multicell canvas is actually another multicell canvas. The two push buttons, OK and Cancel, are contained in a multicell canvas that is nested inside the multicell canvas that contains the other controls. To do this, we first defined a nested multicell canvas called myButtons and added it to the bottom of the myClient multicell canvas:

      myClient.addToCell(&myButtons, 2, 10, 6, 1);

  The myButtons canvas begins in column 2, row 10, and spans six columns and one row. Next, we used the addToCell function to put the two push buttons in the myButtons canvas, as follows:

      myButtons.addToCell(&ok, 1, 1);
      myButtons.addToCell(&cancel, 3, 1);

  The OK push button begins in column 1, row 1 of the nested canvas and occupies one column. In the figure, the white numbers in black boxes indicate the columns and rows in the nested canvas. The Cancel push button begins in column 3, row 1 of the nested canvas and also spans one column. The width of the columns is determined by the size of the text in the push buttons together with the margin around the text (the space between the text and the border of the push buttons).

  You must specify the last row and column of a multicell canvas on either an addToCell call or on setRowHeight and setColumnWidth calls. This is done to provide a padding, or margin, for the right and bottom sides of the canvas, similar to the margin provided by taking the default cell size for column 1 and row 1. The following are the calls used in the example to set the last column and row, column 8 and row 11, to the default column width and row height:

      myClient.setColumnWidth(8, IMultiCellCanvas::defaultCell().width());
      myClient.setRowHeight(11, IMultiCellCanvas::defaultCell().height());

  The following points are from the preceding example:

  - It is not necessary to have a window in every cell.
  - You can use empty columns and empty rows to provide padding around the windows.
  - The canvas can have more rows or columns than needed to hold the windows. For example, columns 1 and 8, as well as rows 1, 3, and 5, are empty. They will be sized either to a default value, or they can be sized explicitly by the application.
  - Windows can occupy multiple columns, rows, or both. The first entry field, for example, begins in cell (5,4) and occupies columns 5 through 7. The number of columns or rows occupied includes the originating column or row.
  - A window's range can overlap cells that contain other windows. However, two windows cannot have the same starting cell.

#### Portability Considerations

  You can create child windows of an IMultiCellCanvas which are not added to any cells of the IMultiCellCanvas. The IMultiCellCanvas, however, will only perform positioning of child controls that are added to the canvas. Therefore, the positioning of child controls that are not added to the canvas may vary from platform to platform because coordinate system differences are not handled automatically.

  You can avoid this problem by ensuring that all visible child controls are added to the canvas.

### IMultiCellCanvas - Member Functions and Data by Group

### Constructors & Destructor

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

~IMultiCellCanvas

      public:
      virtual ~IMultiCellCanvas()

Supported Platforms

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

IMultiCellCanvas

      public:
      IMultiCellCanvas( 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 IMultiCellCanvas::Style, ICanvas::Style, and IWindow::Style objects. Optional.

Supported Platforms

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

### Cell Contents

Use these members to position child windows of the canvas relative to one another, in cells.

addToCell

      public:
      virtual IMultiCellCanvas&
        addToCell( IWindow* childWindow,
                   unsigned long startingColumn,
                   unsigned long startingRow,
                   unsigned long numberOfColumns = 1,
                   unsigned long numberOfRows = 1 )

  Specifies the starting cell into which a window is placed. Optionally, you can specify the number of columns or rows that the window occupies. By default, a multicell canvas has no windows. Windows added to the multicell canvas must be parented to the multicell canvas or an InvalidParameter exception is thrown.
  Note: If the multicell canvas is already shown, this function does not cause it to update the canvas itself immediately. You must call IWindow::refresh to update the appearance of the canvas.

  You do not specify how many rows and columns a multicell canvas contains. IMultiCellCanvas determines the maximum number of rows and columns from addToCell, setColumnWidth, and setRowHeight.

Exception

  IInvalidRequest | The canvas already contains a child window that begins in the cell identified by startingColumn and startingRow.
  IInvalidParameter | childWindow must be a nonzero pointer.
  IInvalidParameter | childWindow must be a child window of the multicell canvas.
  IInvalidParameter | startingColumn, startingRow, numberOfColumns, and numberofRows must be nonzero.

Supported Platforms

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

removeFromCell

  Removes a window from the canvas. If you specify a cell, the window that occupies that cell is removed. If you specify a window, the window is removed.

  This function returns the window removed from the canvas. It does not delete the child window. If the specified window is not found, 0 is returned.

  You must call this function if you delete the child window or change its parent window.
  Note: If the multicell canvas is already shown, this function does not cause it to update immediately. You must call IWindow::refresh to update the appearance of the canvas.

  Overload 1

      public:
      virtual IWindow* removeFromCell(IWindow* childWindow)

  childWindow
    The child window to remove from the multicell canvas.

Supported Platforms

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

  Overload 2

      public:
      virtual IWindow*
        removeFromCell( unsigned long column,
                        unsigned long row )

  column
    The starting column of the child window being removed. Columns are numbered beginning with 1. This is the starting column you specified in the addToCell call that added the child window to the canvas.
  row
    The starting row of the child window being removed. Rows are numbered beginning with 1. This is the starting row you specified in the addToCell call that added the child window to the canvas.

Supported Platforms

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

windowInCell

      public:
      virtual IWindow*
        windowInCell( unsigned long startingColumn,
                      unsigned long startingRow ) const

  Returns the child window occupying the specified cell.

Supported Platforms

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

### Grid and Drag Lines

These members provide visual debugging aids for you to use in your IMultiCellCanvas objects.

disableDragLines

      public:
      virtual IMultiCellCanvas& disableDragLines()

  Removes the style IMultiCellCanvas::dragLines from a multicell canvas.

Supported Platforms

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

disableGridLines

      public:
      virtual IMultiCellCanvas& disableGridLines()

  Removes the style IMultiCellCanvas::gridLines from a multicell canvas.

Supported Platforms

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

enableDragLines

      public:
      virtual IMultiCellCanvas&
        enableDragLines( bool enable = true )

  Sets the style IMultiCellCanvas::dragLines for a multicell canvas.

Supported Platforms

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

enableGridLines

      public:
      virtual IMultiCellCanvas&
        enableGridLines( bool enable = true )

  Sets the style IMultiCellCanvas::gridLines for a multicell canvas.

Supported Platforms

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

hasDragLines

      public:
      bool hasDragLines() const

  Queries whether a multicell canvas has the style IMultiCellCanvas::dragLines set.

Supported Platforms

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

hasGridLines

      public:
      bool hasGridLines() const

  Queries whether a multicell canvas has the style IMultiCellCanvas::gridLines set.

Supported Platforms

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

### Layout Support

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

hasChildrenToLayout

      public:
      virtual bool hasChildrenToLayout() const

  Indicates whether the canvas is managing the size and position of any child windows.

  This function returns true if the canvas contains at least one child window that you have specified on a call to addToCell. Otherwise it returns false.

Supported Platforms

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

setLayoutDistorted

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

  Adds the IWindow::layoutDistorted flag to its internal state if it receives a value of IWindow::childWindowCreated or IWindow::childWindowDestroyed and calls IWindow::setLayoutDistorted. If the IWindow::immediateUpdate flag is on, the canvas runs its layout routine.

  The internal state of a window is indicated by the Layout enumeration.

  A window treats the following events as changes to the layout of its child windows:

  - Changing the size
  - Changing the size of a child window
  - Adding another child window
  - Deleting a child window

Supported Platforms

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

layout

      protected:
      virtual IMultiCellCanvas& layout()

  Computes the child windows' positions and sizes based on the following:

  - The contents of the cells
  - The minimum size of rows and columns
  - The expandability of rows and columns

  Then positions and sizes each child according to the results.

Supported Platforms

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

### Row and Column Sizing

Use these members to query and set the width of columns and the height of rows in the canvas, as well as to set their ability to expand with the canvas.

columnWidth

      public:
      unsigned long columnWidth(unsigned long column) const

  Returns the current width of the specified column in pixels.

Supported Platforms

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

defaultCell

      public:
      static ISize defaultCell()

  Queries the current default cell size. The initial default size is 10 pixels by 10 pixels. You can change it by calling the function setDefaultCell.

Supported Platforms

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

isColumnExpandable

      public:
      bool isColumnExpandable(unsigned long column) const

  If the specified column can be expanded when the canvas is larger than its minimum size, true is returned. You can use setColumnWidth to make a column expandable.

Supported Platforms

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

isRowExpandable

      public:
      bool isRowExpandable(unsigned long row) const

  If the specified row can be expanded when the canvas is larger than its minimum size, true is returned. You can use setRowHeight to make a row expandable.

Supported Platforms

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

rowHeight

      public:
      unsigned long rowHeight(unsigned long row) const

  Returns the current height of the specified row in pixels.

Supported Platforms

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

setColumnWidth

      public:
      virtual IMultiCellCanvas&
        setColumnWidth( unsigned long column,
                        unsigned long widthInPixels,
                        bool expandable = false )

  Defines the smallest width that the column will have and indicates whether the column is expandable. The minimum sizes of the child windows in this column might cause the actual width of this column to be larger than this value.

  If you do not call this function, the column will have a minimum width of 0 unless the column contains no child windows. In that case, the canvas sizes the column to the default cell width.

  You do not specify how many rows and columns a multicell canvas contains. IMultiCellCanvas determines the maximum number of rows and columns from addToCell, setColumnWidth, and setRowHeight.
  Note: If the multicell canvas is already shown, this function does not cause it to update itself immediately. You must call IWindow::refresh to update the appearance of the canvas.

Supported Platforms

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

setDefaultCell

      public:
      static void setDefaultCell(const ISize& widthAndHeight)

  Sets the default width for a column and height for a row of a cell that does not have a child window. The initial default size for both rows and columns is 10 pixels.
  Note: This function does not cause the layout of a multicell canvas to update itself immediately. To force a multicell canvas to update after calling this function, call setLayoutDistorted, as follows:

      setLayoutDistorted(IWindow::layoutChanged |
                              IWindow::immediateUpdate, 0);

Supported Platforms

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

setRowHeight

      public:
      virtual IMultiCellCanvas&
        setRowHeight( unsigned long row,
                      unsigned long heightInPixels,
                      bool expandable = false )

  Defines the smallest height that the row will have and indicates whether the row is expandable. The minimum sizes of the child windows in this row can cause the actual height of the row to be larger than this value.

  If you do not call this function, the row will have a minimum height of 0 unless the row contains no child windows. In that case, the canvas sizes the row to the default cell height.

  You do not specify how many rows and columns a multicell canvas contains. IMultiCellCanvas determines the maximum number of rows and columns from addToCell, setColumnWidth, and setRowHeight.
  Note: If a multicell canvas is already shown, this function does not cause it to update itself immediately. You must call IWindow::refresh to update the appearance of the canvas.

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 IMultiCellCanvas object, you can use IMultiCellCanvas, 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 multicell 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 IWindow::visible.

Supported Platforms

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

dragLines

      public:
      static const Style dragLines

  Causes the multicell canvas to have draggable grid lines between the rows and columns of the canvas. Dragging and dropping grid lines will dynamically cause the functions setColumnWidth and setRowHeight to be called, adjusting the size of bounding rows and columns. This is a visual enhancement that is intended to be used for testing or debugging purposes only.

Supported Platforms

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

gridLines

      public:
      static const Style gridLines

  Causes the multicell canvas to have grid lines between the rows and columns of the canvas.

Supported Platforms

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

spaceAddedToLast

      public:
      static const Style spaceAddedToLast

  Causes the multicell canvas to size its columns and rows in an alternate manner.

  This style affects child windows that occupy more than one column or row, of which none are expandable. If the sum of the columns occupied by the child window is less than the minimum width of the child window, or the sum of the rows is less than the minimum height of the child window, then the multicell canvas must grow one of the columns or rows. By default, IMultiCellCanvas grows the first column and row occupied by the child window. If you use this style, the canvas instead grows the last column or row occupied by the child window. In some cases, this results in more predictable layouts.

Supported Platforms

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

### IMultiCellCanvas - 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

  -     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(const IEvent& event) const

  -     virtual const IWindow&
          postEvent( EventType eventType,
                     const IEventParameter1& parm1 = 0,
                     const IEventParameter2& parm2 = 0 ) 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,
                  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,
                  IXmCreateFunction createFunction,
                  const IWindow* parent,
                  const IWindow* owner,
                  const IRectangle& initRect,
                  IWindow::SiblingOrder ordering = defaultOrdering ( ) )

  -     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,
                  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 ( ) )

  -     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) = 0

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

  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