### ISetCanvas

  The ISetCanvas class provides a window that organizes the windows it contains in row or column decks.

  Deck is the direction-independent term for a line of child windows in a set canvas window. A horizontal deck is equivalent to a row and a vertical deck is equivalent to a column. An ISetCanvas object can hold more than one deck of child windows, but the decks must be either all horizontal or all vertical.

  This class best arranges fixed-size child windows of similar size, such as a row of push buttons or a group of radio buttons. ISetCanvas divides these child windows evenly among multiple decks by number rather than by size. ISetCanvas also sizes and positions its child windows based on their minimum sizes instead of the size of the canvas. ISetCanvas uses IWindow::minimumSize and IWindow::calcMinimumSize to size the windows.

  This class provides you with a number of alignment and packing options for positioning differently sized child windows.

### ISetCanvas - Member Functions and Data by Group

### Constructors & Destructor

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

~ISetCanvas

      public:
      virtual ~ISetCanvas()

Supported Platforms

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

ISetCanvas

  Overload 1

      public:
      ISetCanvas( unsigned long windowIdentifier,
                  IWindow* parent,
                  IWindow* owner,
                  const IRectangle& initial = 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.
  initial
    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 ISetCanvas::Style, ICanvas::Style, and IWindow::Style objects. Optional.

Exception

  IInvalidParameter | style contains an invalid combination of styles. style cannot contain more than one deck orientation style (ISetCanvas::horizontalDecks and ISetCanvas::verticalDecks), more than one pack style (ISetCanvas::packTight, ISetCanvas::packEven, and ISetCanvas::packExpanded), more than one horizontal alignment style (ISetCanvas::leftAlign, ISetCanvas::centerAlign, and ISetCanvas::rightAlign), or more than one vertical alignment style (ISetCanvas::topAlign, ISetCanvas::centerVerticalAlign, and ISetCanvas::bottomAlign).

Supported Platforms

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

  Overload 2

      protected:
      ISetCanvas()

  Derived classes that create their own windows should call this ISetCanvas constructor. If you use this constructor, you can call ISetCanvas::initialize to create a canvas window.

Supported Platforms

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

initialize

      protected:
      ISetCanvas&
        initialize( unsigned long windowIdentifier,
                    IWindow* parent,
                    IWindow* owner,
                    const IRectangle& initialRect,
                    unsigned long style,
                    unsigned long extendedStyle )

  Processes the style values, then calls ICanvas::initialize to create an underlying system window. Call this function from a constructor of a class derived from ISetCanvas if the constructor calls the protected ISetCanvas constructor.

Exception

  IInvalidParameter | style contains an invalid combination of styles. style cannot contain more than one deck orientation style (ISetCanvas::horizontalDecks and ISetCanvas::verticalDecks), more than one pack style (ISetCanvas::packTight, ISetCanvas::packEven, and ISetCanvas::packExpanded), more than one horizontal alignment style (ISetCanvas::leftAlign, ISetCanvas::centerAlign, and ISetCanvas::rightAlign), or more than one vertical alignment style (ISetCanvas::topAlign, ISetCanvas::centerVerticalAlign, and ISetCanvas::bottomAlign).

Supported Platforms

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

### Adding and Removing Child Windows

You can explicitly add and remove child windows to and from the set whose size and position the set canvas manages. As a result, the canvas can have child windows whose size and position it does not modify.

These functions can be used to add and remove child windows to and from canvases with or without the style, ISetCanvas::explicitAddsNeeded. The style explicitAddsNeeded is used to determine which child windows are to be managed during the canvas layout. When ISetCanvas::explicitAddsNeeded is not set, all child windows, except those that have been removed or replaced, will be managed during the canvas layout. When ISetCanvas::explicitAddsNeeded is set, only child windows that have been added will be managed during the canvas layout. See function isInLayout for more details.

add

      public:
      virtual ISetCanvas& add(IWindow* child)

  Adds the specified child window to the set canvas, causing the canvas to manage the size and position of the window. You do not need to call this function if you did not create the canvas using the style ISetCanvas::explicitAddsNeeded.

  This function also makes the child window visible. It does not change the sibling order of the child window, which determines where the set canvas positions it relative to its sibling windows.

Exception

  IInvalidParameter | The set canvas must be the parent window of child.

Supported Platforms

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

areExplicitAddsNeeded

      public:
      bool areExplicitAddsNeeded() const

  Returns if the canvas was created with the style ISetCanvas::explicitAddsNeeded. If true, you must call the ISetCanvas::add or ISetCanvas::replaceChildWith functions for the set canvas to manage the size and positions of its child windows.

Supported Platforms

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

isInLayout

      public:
      virtual bool isInLayout(IWindow* child) const

  Identifies if the set canvas manages the size and position of the specified child window. Otherwise you are responsible for sizing and positioning the child window.

  This function returns true if either of the following is true:

  - You created the canvas with the style ISetCanvas::explicitAddsNeeded and added the child window to the canvas by calling ISetCanvas::add or ISetCanvas::replaceChildWith, and did not remove or replace it afterwards by calling ISetCanvas::remove or ISetCanvas::replaceChildWith.
  - You created the canvas without the style ISetCanvas::explicitAddsNeeded, but never removed or replaced the child window using ISetCanvas::remove or ISetCanvas::replaceChildWith.

  This function returns false for a child window if:

  - You removed or replaced the child window by calling ISetCanvas::remove or ISetCanvas::replaceChildWith without later adding it back to the canvas.
  - You constructed the canvas with the style ISetCanvas::explicitAddsNeeded and never added the child window to the canvas using ISetCanvas::add or ISetCanvas::replaceChildWith.

Exception

  IInvalidParameter | The set canvas must be the parent window of child.

Supported Platforms

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

remove

      public:
      virtual ISetCanvas& remove(IWindow* child)

  Removes the specified child window from the set canvas, causing the canvas to no longer manage the size and position of the window.

  To remove the child window from view and minimize the user's ability to interact with the removed window, this function also does the following:

  - hides the child window
  - gives it a 0 size
  Note: The behavior of this function is the same for canvases with and without the ISetCanvas::explicitAddsNeeded style.

Exception

  IInvalidParameter | The set canvas must be the parent window of child.

Supported Platforms

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

Portability Considerations

  This function attempts to prevent the user from moving the input focus to the child window using the Tab key, arrow keys, and mnemonics, while not changing how the user can navigate between the remaining child windows using the keyboard. To fully prevent the user from accessing the child window with the arrow keys on the OS/2 and Windows operating systems, you are responsible for ensuring that the first child window in the sibling order has the group style.

replaceChildWith

      public:
      virtual ISetCanvas&
        replaceChildWith( IWindow* existingChild,
                          IWindow* newChild )

  Replaces one child window in the set canvas with another. This function removes the existing child window from the canvas (see ISetCanvas::remove for the changes made to the child window). Before the existing window is removed, the canvas applies the following changes to the new child window:

  - Moves the child window to the existing window's position in the sibling order
  - Assigns the settings of the tab-stop and group styles of the existing window to the new child window
  - Makes the new child window visible
  Note: The behavior of this function is the same for canvases with and without the ISetCanvas::explicitAddsNeeded style.

Exception

  IInvalidParameter | The set canvas must be the parent window of existingChild and newChild.

Supported Platforms

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

### Decks

Use these members to set and query whether child windows should be laid out horizontally in rows or vertically in columns.

deckCount

      public:
      unsigned long deckCount() const

  Returns the maximum number of decks used by the canvas.

  You can set the maximum number of decks by calling ISetCanvas::setDeckCount. If you do not call setDeckCount, this function returns 1 and the set canvas lays out its child windows into a single deck.

Supported Platforms

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

deckOrientation

      public:
      DeckOrientation deckOrientation() const

  Returns an enumerator for deck direction. The returned value is an enumerator provided by DeckOrientation.

Supported Platforms

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

setDeckCount

      public:
      virtual ISetCanvas& setDeckCount(unsigned long decks)

  Sets the maximum number of decks used by the canvas. This function has no effect if the ISetCanvas::decksByGroup style is being used.

Exception

  IInvalidParameter | decks must be nonzero.

Supported Platforms

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

setDeckOrientation

      public:
      virtual ISetCanvas&
        setDeckOrientation( DeckOrientation value )

  Sets the direction of the decks.

Exception

  IInvalidParameter | You specified an uninitialized ISetCanvas::DeckOrientation value.

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.

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 any of the following is true:

  - The canvas contains at least one child window and was not constructed with the style ISetCanvas::explicitAddsNeeded.
  - You explicitly added a child window to the canvas using the function ISetCanvas::add

  Otherwise it returns false.

Supported Platforms

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

setLayoutDistorted

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

  Treats the following as changing the layout of its child windows:

  - A minimum size change for a child window
  - A font change (if the set canvas has text assigned)
  - An added child window
  - A removed child window

Supported Platforms

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

layout

      protected:
      virtual ISetCanvas& layout()

  Positions and sizes child windows.

Supported Platforms

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

### Notification Members

ISetCanvas provides notifications that allow observers to process changes to the window.

deckOrientationId

      public:
      static INotificationId const deckOrientationId

  Notification identifier provided to observers when the deck orientation of the set canvas changes. ISetCanvas provides the new deck orientation value in the INotificationEvent::eventData field of the INotificationEvent. This value is one of the predefined DeckOrientation enumeration values.

Supported Platforms

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

### Spacing of Child Windows

Use these members to specify the spacing added around and between child windows.

alignDecksByGroup

      public:
      ISetCanvas&
        alignDecksByGroup( bool alignDecksByGroup = true )

  Turns the style ISetCanvas::decksByGroup on or off.

Supported Platforms

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

alignment

      public:
      Alignment alignment() const

  Returns the enumerator for deck alignment. The returned value is an enumerator provided by Alignment.

Supported Platforms

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

groupPad

      public:
      unsigned long groupPad() const

  Returns the pad width or height, which is the space before a child window in a deck with a style of IWindow::group.

Supported Platforms

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

hasDecksAlignedByGroup

      public:
      bool hasDecksAlignedByGroup() const

  Returns the current value of the ISetCanvas::decksByGroup style.

Supported Platforms

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

margin

      public:
      ISize margin() const

  Returns the margin width and height, which is the space between the edge of the canvas and the outermost child windows.

Supported Platforms

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

packType

      public:
      PackType packType() const

  Returns an enumerator for child window spacing in decks. The returned value is an enumerator provided by PackType.

Supported Platforms

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

pad

      public:
      ISize pad() const

  Returns the pad width and height, which is the space between child windows in a deck and between multiple decks.

Supported Platforms

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

setAlignment

      public:
      virtual ISetCanvas& setAlignment(Alignment value)

  Sets how child windows are aligned in decks.
  Note: If the canvas uses a pack type of expanded, this function has no effect.

Exception

  IInvalidParameter | You specified an uninitialized ISetCanvas::Alignment value.

Supported Platforms

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

setGroupPad

      public:
      virtual ISetCanvas& setGroupPad(unsigned long groupPad)

  Sets the pad width or height to use for controls with a style of IWindow::group. The default value is zero.

Supported Platforms

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

setMargin

      public:
      virtual ISetCanvas& setMargin(const ISize& margin)

  Sets the margin width and height, which is the space between the edge of the canvas and the outermost child windows.

Exception

  IInvalidParameter | The height and width of margin cannot be less than 0.

Supported Platforms

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

setPackType

      public:
      virtual ISetCanvas& setPackType(PackType value)

  Sets how child windows are spaced in decks.

Exception

  IInvalidParameter | You specified an uninitialized ISetCanvas::PackType value.

Supported Platforms

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

setPad

      public:
      virtual ISetCanvas& setPad(const ISize& pad)

  Sets the pad width and height, which is the space between child windows in a deck and between multiple decks.

Exception

  IInvalidParameter | The height and width of pad cannot be less than -1.

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 ISetCanvas object, you can use ISetCanvas, 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 set 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

bottomAlign

      public:
      static const Style bottomAlign

  Aligns child windows at the bottom edge of a horizontal deck or the bottom edge of a row between evenly packed vertical decks.
  Note: If you use this style with both packTight and verticalDecks, it is ignored. If you use this style with packExpanded, it is ignored. You cannot specify this style with topAlign or centerVerticalAlign.

Supported Platforms

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

centerAlign

      public:
      static const Style centerAlign

  Centers child windows horizontally within a vertical deck or within a column between evenly packed horizontal decks.
  Note: If you use this style with both packTight and horizontalDecks, it is ignored. If you use this style with packExpanded, it is ignored. You cannot specify this style with leftAlign or rightAlign.

Supported Platforms

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

centerVerticalAlign

      public:
      static const Style centerVerticalAlign

  Centers child windows vertically within a horizontal deck or within a row between evenly packed vertical decks.
  Note: If you use this style with both packTight and verticalDecks, it is ignored. If you use this style with packExpanded, it is ignored. You cannot specify this style with topAlign or bottomAlign.

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 ISetCanvas::horizontalDecks | ISetCanvas::packTight | ISetCanvas::leftAlign | ISetCanvas::topAlign | IWindow::visible.

Supported Platforms

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

decksByGroup

      public:
      static const Style decksByGroup

  Causes the number of decks in the set canvas to be determined by the number of child windows with the group style (IWindow::isGroup returns true). Each child window with the group style starts a new deck. If you specify this style, calls to setDeckCount are ignored.

Supported Platforms

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

explicitAddsNeeded

      public:
      static const Style explicitAddsNeeded

  Specifies that the set canvas manages the size and position of a child window only if you add that child window to the canvas using the ISetCanvas::add or ISetCanvas::replaceChildWith function.

  Not using this style causes the set canvas to treat all child windows as added, unless you explicitly remove a child window using ISetCanvas::remove or ISetCanvas::replaceChildWith.

  Whether you use this style or not, you can remove and replace child windows, and you can add back removed child windows. See the function isInLayout for more details on when ISetCanvas manages the size and position of a child window.

Supported Platforms

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

horizontalDecks

      public:
      static const Style horizontalDecks

  Organizes child windows in rows. Multiple rows are arranged from top to bottom.
  Note: You cannot specify this style with ISetCanvas::verticalDecks.

Supported Platforms

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

leftAlign

      public:
      static const Style leftAlign

  Aligns child windows at the left edge of a vertical deck or the left edge of a column between evenly packed horizontal decks.
  Note: If you use this style with both packTight and horizontalDecks, it is ignored. If you use this style with packExpanded, it is ignored. You cannot specify this style with rightAlign or centerAlign.

Supported Platforms

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

packEven

      public:
      static const Style packEven

  Sizes child windows to their minimum size and spaces them such that corresponding windows in each deck are aligned. This gives the child windows the appearance of being arranged in both rows and columns. As a result, child windows within a deck can be separated by more than the pad amount.
  Note: If the set canvas has only one deck, this style has no effect. You cannot specify this style with packTight or packExpanded.

Supported Platforms

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

packExpanded

      public:
      static const Style packExpanded

  Sizes child windows in a way similar to that of packEven, except the child windows are enlarged rather than spaced by more than the pad amount. All smaller child windows are enlarged to the same size as the largest child window.
  Note: You cannot specify this style with packTight or packEven.

Supported Platforms

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

packTight

      public:
      static const Style packTight

  Sizes child windows to their minimum size and separates them within a deck by the pad amount only.
  Note: You cannot specify this style with packEven or packExpanded.

Supported Platforms

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

rightAlign

      public:
      static const Style rightAlign

  Aligns child windows at the right edge of a vertical deck or the right edge of a column between evenly packed horizontal decks.
  Note: If you use this style with both packTight and horizontalDecks, it is ignored. If you use this style with packExpanded, it is ignored. You cannot specify this style with leftAlign or centerAlign.

Supported Platforms

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

topAlign

      public:
      static const Style topAlign

  Aligns child windows at the top edge of a horizontal deck or a row between evenly packed vertical decks.
  Note: If you use this style with both packTight and verticalDecks, it is ignored. If you use this style with packExpanded, it is ignored. You cannot specify this style with bottomAlign or centerVerticalAlign.

Supported Platforms

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

verticalDecks

      public:
      static const Style verticalDecks

  Organizes child windows in columns. Multiple columns are arranged from left to right.
  Note: You cannot specify this style with ISetCanvas::horizontalDecks.

Supported Platforms

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

### Text

Use these members to support drawing a border and border text around the contents of the canvas.

expandForText

      protected:
      virtual ISetCanvas& expandForText()

  Determines how much larger the canvas must be to include a border and the current border text.

  This protected function should be called from the calcMinimumSize function to account for the size of the border and border text. The layout size is adjusted by the calculated border and border text size.

Exception

  IAccessError | The call to determine the size required to display the text of the set canvas failed.

Supported Platforms

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

### ISetCanvas - Enumerations

Alignment

      enum Alignment { topLeft,
                       topCenter,
                       topRight,
                       centerLeft,
                       centerCenter,
                       centerRight,
                       bottomLeft,
                       bottomCenter,
                       bottomRight }

  Use the following enumerators to specify the alignment of child windows in a deck.

  topLeft
    Aligns the child windows in the canvas to the top and left edge in the deck:
  topCenter
    Aligns the child windows in the canvas to the top edge, centered horizontally in the deck.
  topRight
    Aligns the child windows in the canvas to the top and right edge in the deck.
  centerLeft
    Aligns the child windows in the canvas to the left edge, centered vertically in the deck.
  centerCenter
    Aligns the child windows in the canvas to the center of the deck.
  centerRight
    Aligns the child windows in the canvas to the right edge, centered vertically in the deck.
  bottomLeft
    Aligns the child windows in the canvas to the bottom and left edge in the deck.
  bottomCenter
    Aligns the child windows in the canvas to the bottom edge, centered vertically in the deck.
  bottomRight
    Aligns the child windows in the canvas to the bottom and right edge in the deck.

Supported Platforms

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

DeckOrientation

      enum DeckOrientation { horizontal,
                             vertical }

  Use the following enumerators to specify the direction in which to orient the deck of child windows:

  horizontal
    Arranges the child windows in the canvas horizontally in rows from left to right. Decks of rows are arranged from top to bottom.
  vertical
    Arranges the child windows in the canvas vertically in columns from top to bottom. Decks of columns are arranged from left to right.

Supported Platforms

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

PackType

      enum PackType { tight,
                      even,
                      expanded }

  Use these enumerators to specify the spacing between child windows in decks.

  tight
    Sizes the child windows to their minimum size and separates them within a deck by the pad amount only.
  even
    Sizes child windows to their minimum size and spaces them so that corresponding windows in each deck are aligned. This gives the appearance of their being arranged in both rows and columns. As a result, child windows within a deck can be separated by more than the pad amount. This option has no effect if the set canvas has only one deck.
  expanded
    Similar to the enumerator even, except the child windows are expanded, rather than spaced by more than the pad amount. Child windows are expanded to the same size as the largest child window.

Supported Platforms

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

### ISetCanvas - 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( 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
          color( unsigned long colorArea,
                 const IColor& defaultColor ) 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,
                  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,
                  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,
                  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 )

  -     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