Ultimate Page Control Suite™ Win32 | Delphi™ | C++Builder™; D.13. TADVANCE_PMInterface, FocusedPageIndex PROPERTY EDITOR

TADVANCE_PMInterface is the nucleus of UPC™ paging functionality. Each PMInterface manages one internalized paging region. Every TADVANCE_PMInterface is a direct member of the root module.

Expanded node of a PMInterface in the Object Inspector.

PMInterfaces, PM1_Main...PM6_Status, of a PM04_DataMaster UPC™ module in the Object Inspector, with the PM1_Main node expanded. Naming conventions list TADVANCE_PMInterfaces according the top-downward physical order of their FocusControls, as drawn by the page control.

EVENTS

property BeforeChangeFocus : TNotifyEvent read FBeforeChangeFocus write FBeforeChangeFocus;
__property Classes::TNotifyEvent BeforeChangeFocus = {read=FBeforeChangeFocus, write=FBeforeChangeFocus};

Called before focusing a different page.

property OnChangeFocus : TNotifyEvent read FOnChangeFocus write FOnChangeFocus;
__property Classes::TNotifyEvent OnChangeFocus = {read=FOnChangeFocus, write=FOnChangeFocus};

Called after focusing a different page. Individual pages also publish an OnFocus event.

property OnHideAllPages : TNotifyEvent read FOnHideAllPages write FOnHideAllPages;
__property Classes::TNotifyEvent OnHideAllPages = {read=FOnHideAllPages, write=FOnHideAllPages};

Called by the HideAllPages method. The alternative FocusNone method (internally called by HideAllPages) can be called to avoid invoking the OnHideAllPages event.

property OnWrap : TNotifyEvent read FOnWrap write FOnWrap;
__property Classes::TNotifyEvent OnWrap = {read=FOnWrap, write=FOnWrap};

OnWrap is fired only after wrapping is performed. When resizing occurs, if no tools require relocation, OnWrap is not called.

SIZING EVENTS

Sizing events in the Object Inspector.

property Sizing_HeightMaximizeMethod : TNotifyEvent read FSizing_HeightMaximizeMethod write SetSizing_HeightMaximizeMethod;
__property Classes::TNotifyEvent Sizing_HeightMaximizeMethod = {read=FSizing_HeightMaximizeMethod, write=SetSizing_HeightMaximizeMethod};

property Sizing_HeightMinimizeMethod : TNotifyEvent read FSizing_HeightMinimizeMethod write SetSizing_HeightMinimizeMethod;
__property Classes::TNotifyEvent Sizing_HeightMinimizeMethod = {read=FSizing_HeightMinimizeMethod, write=SetSizing_HeightMinimizeMethod};

property Sizing_HeightNormalizeMethod : TNotifyEvent read FSizing_HeightNormalizeMethod write SetSizing_HeightNormalizeMethod;
__property Classes::TNotifyEvent Sizing_HeightNormalizeMethod = {read=FSizing_HeightNormalizeMethod, write=SetSizing_HeightNormalizeMethod};

property Sizing_WidthAndHeightMaximizeMethod : TNotifyEvent read FSizing_WidthAndHeightMaximizeMethod write SetSizing_WidthAndHeightMaximizeMethod;
__property Classes::TNotifyEvent Sizing_WidthAndHeightMaximizeMethod = {read=FSizing_WidthAndHeightMaximizeMethod, write=SetSizing_WidthAndHeightMaximizeMethod};

property Sizing_WidthAndHeightMinimizeMethod : TNotifyEvent read FSizing_WidthAndHeightMinimizeMethod write SetSizing_WidthAndHeightMinimizeMethod;
__property Classes::TNotifyEvent Sizing_WidthAndHeightMinimizeMethod = {read=FSizing_WidthAndHeightMinimizeMethod, write=SetSizing_WidthAndHeightMinimizeMethod};

property Sizing_WidthAndHeightNormalizeMethod : TNotifyEvent read FSizing_WidthAndHeightNormalizeMethod write SetSizing_WidthAndHeightNormalizeMethod;
__property Classes::TNotifyEvent Sizing_WidthAndHeightNormalizeMethod = {read=FSizing_WidthAndHeightNormalizeMethod, write=SetSizing_WidthAndHeightNormalizeMethod};

property Sizing_WidthMaximizeMethod : TNotifyEvent read FSizing_WidthMaximizeMethod write SetSizing_WidthMaximizeMethod;
__property Classes::TNotifyEvent Sizing_WidthMaximizeMethod = {read=FSizing_WidthMaximizeMethod, write=SetSizing_WidthMaximizeMethod};

property Sizing_WidthMinimizeMethod : TNotifyEvent read FSizing_WidthMinimizeMethod write SetSizing_WidthMinimizeMethod;
__property Classes::TNotifyEvent Sizing_WidthMinimizeMethod = {read=FSizing_WidthMinimizeMethod, write=SetSizing_WidthMinimizeMethod};

property Sizing_WidthNormalizeMethod : TNotifyEvent read FSizing_WidthNormalizeMethod write SetSizing_WidthNormalizeMethod;
__property Classes::TNotifyEvent Sizing_WidthNormalizeMethod = {read=FSizing_WidthNormalizeMethod, write=SetSizing_WidthNormalizeMethod};

The SizingWindow™. From left to right, sizing tools are Sizing_WidthMinimize, Sizing_WidthNormalize, Sizing_WidthMaximize, Sizing_HeightMinimize, Sizing_HeightNormalize, Sizing_HeightMaximize, Sizing_WidthAndHeightMinimize, Sizing_WidthAndHeightNormalize, Sizing_WidthAndHeightMaximize, and Closure.

The SizingWindow™ is invoked by right MouseDown of the FocusButton™. Handlers are dynamically wired to tools at run time, and may size a region by any legitimate direct or indirect means. Handler existence automatically configures the FocusButton.Hint, response to right mouse-down, and displayed sizing tools. All you have to do is write handlers. Example source is found in the UPC™ Demos.

METHODS

HOW PAGEGROUPS WORK, AND HOW PAGEGROUP MEMBERSHIP IS HANDLED BY PAGE PROPAGATION METHODS

To maintain intended PageGroup™ membership with methods which affect the organization or population of the Pages[] array, we have to understand how PageGroup™ membership is implemented.

A page declares membership to a PageGroup™ if the value of its PageGroup_PID property is greater than -1 and matches the PID of a TADVANCE_PageGroup_Item belonging to its PMInterface. In order to support developer processes which might not at every moment maintain valid associations, invalid membership values are tolerated.
- Succeeding pages are interpreted to belong to a declared PageGroup™ until a subsequent page declares membership to a different PageGroup™.
- A PageGroup_PID value of -1 is interpreted simply to not explicitly declare membership.
  - However, implicit membership is inherited from any preceding page.

Any system you deploy therefore can implement either explicit or implicit membership.

HOW PAGE DELETION METHODS MANAGE PAGEGROUP MEMBERSHIP FOR YOU

When propagating pages, PageGroup™ membership is explicitly indicated by AddPageAt() arguments. The DeleteFocusedPage() and DeletePageAtIndex(Index) page deletion methods however can interpret how to handle page membership issues, and require no arguments to accurately do so:

When the succeeding page does not declare PageGroup™ membership, the membership of the deleted page (if any) is assigned to the succeeding, resulting in an explicit declaration equivalent to the implicit membership which already existed.

The comprehensive behavior or these methods mean that you do not have to address membership issues when destroying pages, because the integrity of your explicit or implicit membership system is maintained.

PAGE PROPAGATION

function AddPageAt(TargetIndex: Integer; Focus: Boolean; GroupWith: TADVANCE_GroupWith): Integer;
int __fastcall AddPageAt(int TargetIndex, bool Focus, TADVANCE_GroupWith GroupWith);

TADVANCE_GroupWith = (gwPrec, gwNext, gwNone);
enum TADVANCE_GroupWith {gwPrec, gwNext, gwNone};

Creates a new page at a rectified TargetIndex of the Pages[] array and returns the index of the result page, or -1 if unsuccessful.

TargetIndex is rectified to a legal range for potential indexes of 0...PageCount, enabling AddPageAt to append pages to the Pages[] array (TList).
- A TargetIndex of (PageCount + 10) for instance will be rectified to PageCount.
- A TargetIndex of -100 is rectified to zero, resulting in insertion of a first page.
Focus indicates whether to focus the resultant page.
GroupWith indicates whether to assign the PageGroup membership of the preceding page, next page (formerly occupying TargetIndex), or none to the resultant page.

DELPHI AddPageAt EXAMPLES

procedure TForm1.SpeedButton_AddAndFocusLastPageClick(Sender: TObject);
     var
     ReturnedIndex       : integer;
     TEMPGlyph           : TBitmap;
     TEMPLabel           : TLabel;

begin
     TEMPGlyph := TBitmap.Create;
     TEMPGlyph.LoadFromResourceName( HImages, 'R2CLPLIM' );

ReturnedIndex := T1.PM1_Main.AddPageAt(T1.PM1_Main.PageCount, True, gwPrec); // EQUIVALENT TO APPEND.

if T1.PM1_Main.Pages[ReturnedIndex] is TADVANCE_Page
     then with TADVANCE_Page(T1.PM1_Main.Pages[ReturnedIndex]).Navigation
          do begin
             Glyph := TempGlyph;
             NumGlyphs := 2;

TEMPLabel := TMyLabel.Create(Self);
                  TEMPLabel.Caption := 'TADVANCE_Page_MainDataMaster '#151#32 + TADVANCE_Page(T1.PM1_Main.Pages[ReturnedIndex]).Name;
                  TEMPLabel.Parent := TADVANCE_Page(T1.PM1_Main.Pages[ReturnedIndex]);
             end;
     end;

// HOW SUPERSEDED METHODS ARE IMPLEMENTED WITH AddPageAt:

function  TADVANCE_PMInterface.
                    AddAndFocusLastPage: Integer;
                              begin
                              Result := AddPageAt(PageCount, True, gwPrec);
                              end;

function  TADVANCE_PMInterface.
                    AddLastPage_ReturnIndex: Integer;
                              begin
                              Result := AddPageAt(PageCount, False, gwPrec);
                              end;

function  TADVANCE_PMInterface.
                    InsertAndFocusFirstPage: Integer;
                              begin
                              Result := AddPageAt(0, True, gwNext);
                              end;

function  TADVANCE_PMInterface.
                    InsertAndFocusPageAfterCurrentIndex: Integer;
                              begin
                              Result := -1;

if FocusedPageIsAssignedAndNotNil
                              then try
                                        FocusedPage := FPages.Items[AddPageAt(Succ(FPages.IndexOf(FFocusedPage)), True, gwPrec)];
                                        Result := FPages.IndexOf(FFocusedPage);
                                        except
                                             //
                                             end;
                              end;

function  TADVANCE_PMInterface.
                    InsertAndFocusPageAtCurrentIndex: Integer;
                              var
                                   LGroupWith          : TADVANCE_GroupWith;

begin
                              Result := -1;

if FocusedPageIsAssignedAndNotNil
                              then try
                                        LGroupWith := gwPrec;

if FPages.IndexOf(FFocusedPage) = 0
                                        then LGroupWith := gwNext;

Result := AddPageAt(Succ(FPages.IndexOf(FFocusedPage)), True, LGroupWith);
                                        except
                                             //
                                             end;
                              end;

function  TADVANCE_PMInterface.
                    InsertPageAtIndex_ReturnIndex(TargetIndex: Integer): Integer;
                              var
                                   RectifiedTargetIndex     : Integer;
                                   LGroupWith               : TADVANCE_GroupWith;

begin
                              RectifiedTargetIndex := RectifyIndexArgToPotentialInsert(TargetIndex);

if RectifiedTargetIndex = 0
                              then LGroupWith := gwNext // IF YOU INSERT AT INDEX 0, THE PAGEGROUP OF THE SUCCEEDING PAGE (IF ANY) IS ASSIGNED TO THE NEW.
                              else LGroupWith := gwPrec;

Result := AddPageAt(RectifiedTargetIndex, False, LGroupWith);
                              end;

function  TADVANCE_PMInterface.
                    InsertPageAtIndexWOInheritingPageGroup_ReturnIndex(TargetIndex: Integer): Integer;
                              begin
                              Result := AddPageAt(TargetIndex, False, gwNone);
                              end;

C++ AddPageAt EXAMPLES

void __fastcall TForm1 :: SpeedButton_AddAndFocusLastPageClick(TObject * Sender)
     {
     Graphics :: TBitmap * TEMPGlyph = new Graphics :: TBitmap ;
     	TEMPGlyph->LoadFromResourceName(((unsigned int)HImages), "R2CLPLIM");

signed int ReturnedIndex = T1->PM1_Main->AddPageAt(T1.PM1_Main.PageCount, True, gwPrec); // EQUIVALENT TO APPEND.

TADVANCE_Page * pPage = dynamic_cast <TADVANCE_Page *> (1->PM1_Main->Pages[ReturnedIndex]);

if (pPage)
          {
          pPage->Navigation->Glyph = TEMPGlyph;
          pPage->Navigation->NumGlyphs = 2;

TLabel * TEMPLabel = new TMyLabel(this);
               TEMPLabel->Caption = "TADVANCE_Page_MainDataMaster \x97 " + pPage->Name;
               TEMPLabel->Parent = T1->PM1_Main->Pages[ReturnedIndex];
          }
     }

// HOW SUPERSEDED METHODS ARE IMPLEMENTED WITH AddPageAt:

int __fastcall TADVANCE_PMInterface :: AddAndFocusLastPage(void)
                              {
                              return AddPageAt(PageCount, True, gwPrec);
                              }

int __fastcall TADVANCE_PMInterface :: AddLastPage_ReturnIndex(void)
                              {
                              return AddPageAt(PageCount, False, gwPrec);
                              }

int __fastcall TADVANCE_PMInterface :: InsertAndFocusFirstPage(void)
                              {
                              return AddPageAt(0, True, gwNext);
                              }

int __fastcall TADVANCE_PMInterface :: InsertAndFocusPageAfterCurrentIndex(void)
                              {
                              int Result = -1;

if (FocusedPageIsAssignedAndNotNil())
                                   try
                                        {
                                        FocusedPage = FPages->Items[AddPageAt(((FPages->IndexOf(FFocusedPage)) + 1)), True, gwPrec)];
                                        Result = FPages->IndexOf(FFocusedPage);
                                        }
                                   catch(...)
                                        {
                                        }

return Result;
                              }

int __fastcall TADVANCE_PMInterface :: InsertAndFocusPageAtCurrentIndex(void)
                              {
                              int Result = -1;

if (FocusedPageIsAssignedAndNotNil())
                              then try
                                        {
                                        TADVANCE_GroupWith LGroupWith = gwPrec;

if FPages->IndexOf(FFocusedPage) == 0
                                             LGroupWith = gwNext;

Result = AddPageAt(Succ(FPages->IndexOf(FFocusedPage)), True, LGroupWith);
                                        }
                                   catch(...)
                                        {
                                        }

return Result;
                              }

int __fastcall TADVANCE_PMInterface :: InsertPageAtIndex_ReturnIndex(int TargetIndex)
                              {
                              TADVANCE_GroupWith LGroupWith = gwNone;
                              int RectifiedTargetIndex = RectifyIndexArgToPotentialInsert(TargetIndex);

if RectifiedTargetIndex == 0
                                   LGroupWith = gwNext // IF YOU INSERT AT INDEX 0, THE PAGEGROUP OF THE SUCCEEDING PAGE (IF ANY) IS ASSIGNED TO THE NEW.
                              else LGroupWith = gwPrec;

Result = AddPageAt(RectifiedTargetIndex, False, LGroupWith);

return Result;
                              }

int __fastcall TADVANCE_PMInterface :: InsertPageAtIndexWOInheritingPageGroup_ReturnIndex(int TargetIndex)
                              {
                              return AddPageAt(TargetIndex, False, gwNone);
                              }

procedure DeleteFocusedPage;
void __fastcall DeleteFocusedPage(void);

Deletes and destroys the focused page (if any) and focuses a secure alternative. Also see How Page Deletion Methods Manage PageGroup Membership for You.

DELPHI EXAMPLE

C++ EXAMPLE

procedure DeletePageAtIndex(Index: Integer);
void __fastcall DeletePageAtIndex(int Index);

Deletes and destroys the page at Index (if any).

If Pages[Index] is focused, a secure alternative is focused.
- To control resultant focus, explicitly focus before calling DeletePageAtIndex().

Also see How Page Deletion Methods Manage PageGroup Membership for You.

DELPHI EXAMPLE

C++ EXAMPLE

void __fastcall TForm1 :: SpeedButton_DeletePageAtIndexClick ( TObject * Sender )
     {
     if ( ( ComboBox_DeletePageAtIndex->ItemIndex < T1->PM1_Main->PageCount )
     && ( -1 < ComboBox_DeletePageAtIndex->ItemIndex ) )
     	{
          TADVANCE_Page * pPage = dynamic_cast < TADVANCE_Page * > ( T1->PM1_Main->Pages[ ComboBox_DeletePageAtIndex->ItemIndex ] ) ;

if ( pPage )
          	{
               AnsiString LString =
               	"Delete page " +
                    pPage->Name +
                    " at index position " +
                    IntToStr ( ComboBox_DeletePageAtIndex->ItemIndex ) +
                    " or page number " + IntToStr ( ComboBox_DeletePageAtIndex->ItemIndex + 1 ) +
                    "?\n\nThis process will automatically focus an alternate focusable page (if any)." ;

if ( mrYes == MessageDlg ( LString, mtConfirmation, ( TMsgDlgButtons() << mbNo << mbYes ), 0 ) )
                    T1->PM1_Main->DeletePageAtIndex ( ComboBox_DeletePageAtIndex->ItemIndex ) ;
          	}
     	}
     else
          ShowMessage ( "No page exists at the selected index." ) ;
     }

FocusedPageIsAssignedAndNotNil: Boolean;
bool __fastcall FocusedPageIsAssignedAndNotNil(void);

Validates that a FocusedPage can be processed in terms of:

A page is focused.
The page pointer is assigned valid values of a page.
- If you need also to verify that the page belongs to a specific class, your code must perform this validation.

DELPHI EXAMPLE

C++ EXAMPLE

NAVIGATION — SECURITY, DETERMINATION OF ALTERNATE FOCUSABLE PAGES

HOW PAGE SECURITY IS TREATED BY NAVIGATION METHODS AND THE NAVIGATION WINDOW

Alternate secure and general navigation methods allow implementations to respect page security settings or to provide general navigation to all pages as is required at design time in the IDE. Pages feature two boolean security properties. Secure navigation methods will not focus pages having either property set to False, and seek secure alternatives to the excluded pages.

NavigationWindow processes treat these properties as follows:

If Page.Navigation.CanFocus is False, the PageNavigationButton is disabled.
If Page.Navigation.NavWinCanDisplay is False, the PageNavigationButton is not displayed.

Consequently, the NavigationWindow automatically provides secure navigation, and no concern exists but setting page security properties as intended.

HOW ALTERNATE FOCUSABLE PAGES ARE SOUGHT BY SECURE NAVIGATION METHODS

Next and Last navigation methods seek first toward the end of Pages[].
- If unsuccessful, they then seek toward the beginning.
  The Next or Last methods therefore will result in focusing the same page if it is the last focusable page.
The First and Preceding navigation methods seek first toward the beginning of Pages[].
- If unsuccessful, they then seek toward the end.
  The First or Preceding methods therefore will result in focusing the same page if it is the first focusable page.

GENERAL NAVIGATION

procedure FocusFirstPage;
void __fastcall FocusFirstPage(void);

procedure FocusPrecedingPage;
void __fastcall FocusPrecedingPage(void);

procedure FocusNextPage;
void __fastcall FocusNextPage(void);

procedure FocusLastPage;
void __fastcall FocusLastPage(void);

General navigation methods do not respect page security properties. They will focus every page.

DELPHI EXAMPLES

C++ EXAMPLES

SECURE NAVIGATION

procedure FocusFirstPage_SECURE;
void __fastcall FocusFirstPage_SECURE(void);

procedure FocusPrecedingPage_SECURE;
void __fastcall FocusPrecedingPage_SECURE(void);

procedure FocusNextPage_SECURE;
void __fastcall FocusNextPage_SECURE(void);

procedure FocusLastPage_SECURE;
void __fastcall FocusLastPage_SECURE(void);

Secure navigation methods respect page security properties.

DELPHI EXAMPLES

C++ EXAMPLES

function FocusSECUREAlternativeToPage_ReturnIndex(APage: TADVANCE_Page): Integer;
int __fastcall FocusSECUREAlternativeToPage_ReturnIndex(TADVANCE_Page* APage);

Focuses a secure alternative to APage.

First seeks toward the end of Pages[].
If unsuccessful, seeks toward the beginning of Pages[].
If no page can be focused, -1 is returned.

DELPHI EXAMPLE

C++ EXAMPLE

METHODS CONTINUED...

procedure FocusNone;
void __fastcall FocusNone(void);

Defocuses all pages without firing the OnHideAllPages event.

Call HideAllPages to fire your OnHideAllPages event handler.

DELPHI EXAMPLE

C++ EXAMPLE

procedure HideAllPages;
void __fastcall HideAllPages(void);

Calls FocusNone and fires the OnHideAllPages event.

Call FocusNone to avoid firing the OnHideAllPages event.

DELPHI EXAMPLE

C++ EXAMPLE

function IsMemberOfPages(const ProspectiveMember: TADVANCE_Page): Boolean;
bool __fastcall IsMemberOfPages(const TADVANCE_Page* ProspectiveMember);

Determines if ProspectiveMember is a member of the Pages[] TList.

DELPHI EXAMPLE

C++ EXAMPLE

function RectifyIndexArg(var IndexArgument: Integer): Integer;
int __fastcall RectifyIndexArg(int &IndexArgument);

Rectifies IndexArgument to the legitimate index range of Pages[] (TList).

If the Pages[] array is not populated, RectifyIndexArg() returns -1.
If the Pages[] array is populated,
- The least value returned will be 0.
- The greatest value returned will be PageCount - 1.

DELPHI EXAMPLE

C++ EXAMPLE

function RectifyIndexArgToPotentialInsert(var IndexArgument: Integer): Integer;
int __fastcall RectifyIndexArgToPotentialInsert(int &IndexArgument);

Rectifies IndexArgument to a value of 0...PageCount.

PageCount is a valid argument for AddPageAt(), and will be validated by RectifyIndexArgToPotentialInsert().
- Passing PageCount to AddPageAt(TargetIndex) results in appending a page.
The greatest valid index for an existing page is PageCount - 1.
- If your return value must be a valid existing index, call RectifyIndexArg() instead.

DELPHI EXAMPLE

C++ EXAMPLE

PROPERTIES

property FocusedPage : TADVANCE_Page read FFocusedPage write SetFocusedPage;
__property TADVANCE_Page* FocusedPage = {read=FFocusedPage, write=SetFocusedPage, stored=false};

Not published. At run time, you may assign a pointer to a member of Pages[] to FocusedPage to focus the page. See FocusedPageIndex for related information.

property FocusControl : TADVANCE_FocusControlInterface read IFocusControl write IFocusControl;
__property TADVANCE_FocusControlInterface* FocusControl = {read=IFocusControl, write=IFocusControl};

Interface to the FocusControl. See TADVANCE_FocusControlInterface for further information.

FocusedPageIndex PROPERTY EDITOR, PROPERTY EDITOR FUNCTIONS

The FocusedPageIndex property ellipsis invokes the FocusedPageIndex property editor.

FocusedPageIndex property editor.

FUNCTIONS

Add appends a new page to Pages[].
Delete destroys the selected page, subject to confirmation.
Dec(Index) decrements the index property of the selected page.
Inc(Index) increments the index property of the selected page.
Edit assigns editable fields of the selected page to the editing controls. To post work to the page, you must click Post.
Post assigns edited values to the page.
Assign Selected to Property makes the selected page the FocusedPage of the page module by assigning its Index value to FocusedPageIndex.
To operate on the FocusedPage in the Object Inspector, close the property editor and click the page.

property FocusedPageIndex : Integer read FFocusedPageIndex write SetFocusedPageIndex stored True;
__property int FocusedPageIndex = {read=FFocusedPageIndex, write=SetFocusedPageIndex, stored=true, nodefault};

The FocusedPageIndex property is the primary mechanism for focusing pages, and for administering the page population at design time.

Assigning the index value of a member page to FocusedPageIndex focuses the page.
To focus no page, assign -1 to FocusedPageIndex, call FocusNone, or call HideAllPages to further invoke the OnHideAllPages event.

Also see FocusedPage above.

property NavigationWindowPrescription : TADVANCE_NavigationWindowPrescription read FNavigationWindowPrescription write FNavigationWindowPrescription;
__property TADVANCE_NavigationWindowPrescription* NavigationWindowPrescription = {read=FNavigationWindowPrescription, write=FNavigationWindowPrescription};

Configures the NavigationWindow. See TADVANCE_NavigationWindowPrescription for further information.

property PageCount : Integer read GetPageCount;
__property int PageCount = {read=GetPageCount, nodefault};

Count of the Pages[] property.

DELPHI EXAMPLE

C++ EXAMPLE

void __fastcall TForm1 :: SpeedButton_DeletePageAtIndexClick(TObject * Sender)
     {
     if ( ( ComboBox_DeletePageAtIndex->ItemIndex < T1->PM1_Main->PageCount )
     && ( -1 < ComboBox_DeletePageAtIndex->ItemIndex ) )
     	{
          TADVANCE_Page * pPage = dynamic_cast < TADVANCE_Page * > ( T1->PM1_Main->Pages[ ComboBox_DeletePageAtIndex->ItemIndex ] ) ;

public PageCreationClass: TADVANCE_Page_ClassReference
public TMetaClass* PageCreationClass;

To propagate custom page classes, assign __classid(TYourClassName) (C++) or TYourClassName (Delphi) of your page descendant to PageCreationClass. Alternate class IDs may be assigned at run time to maintain unlimited page classes. See Subclassing TADVANCE_Page Descendants to Dynamically Populate Pages with Controls for further information.

DELPHI EXAMPLE

C++ EXAMPLE

property PageGroups : TADVANCE_PageGroup_Collection read FPageGroups write FPageGroups;
__property TADVANCE_PageGroup_Collection* PageGroups = {read=FPageGroups, write=FPageGroups};

Collection of PageGroup items to which a page may belong. At design time, PageGroups are maintained by the PageGroups property editor. See TADVANCE_PageGroup_Collection, TADVANCE_NavigationWindowPrescription, and How PageGroups Work, and How PageGroup Membership is Handled by Page Propagation Methods for related information.

property PageGroupsCount: Integer read GetPageGroupsCount;
__property int PageGroupsCount = {read=GetPageGroupsCount, nodefault};

Read-only count of the PageGroups collection property.

property PageNamingParams : TADVANCE_PageNamingParams read FPageNamingParams write FPageNamingParams;
__property TADVANCE_PageNamingParams* PageNamingParams = {read=FPageNamingParams, write=FPageNamingParams};

See TADVANCE_PageNamingParams.

property PageParent_Caption : String read FPageParent_Caption write SetPageParent_Caption;
__property AnsiString PageParent_Caption = {read=FPageParent_Caption, write=SetPageParent_Caption};

The PageParent region parents the pages of a module.

PageParent_Caption is the caption displayed in the PageParent region.
Original PageParent_Captions refer to the name of the PMInterface.
The PageParent region and PageParent_Caption are visible only when no pages are focused.
Pages fill the entire PageParent region.

property PageParent_Height : Integer read FPageParent_Height write SetPageParent_Height;
__property int PageParent_Height = {read=FPageParent_Height, write=SetPageParent_Height, nodefault};

In Related and Status modules, PageParent_Height sets the height of the PageParent region. See RenderToPageHeightOnFocusPage and TADVANCE_Page.PageHeightOnFocusPage for further information.

property Pages[Index: Integer] : TADVANCE_Page read GetPage;
__property TADVANCE_Page* Pages[int Index] = {read=GetPage};

Referring to Pages[Index] is the equivalent of a pointer to a page. Because pages are contained in a TList (dynamic array of pointers), the methods of TList can be applied to Pages[]. The following examples for instance call TList.Move() to move a page from its current index position to a target index position.

DELPHI MOVE PAGE EXAMPLE

C++ MOVE PAGE EXAMPLE

property RenderToPageHeightOnFocusPage : Boolean read FRenderToPageHeightOnFocusPage write SetRenderToPageHeightOnFocusPage default False;
__property bool RenderToPageHeightOnFocusPage = {read=FRenderToPageHeightOnFocusPage, write=SetRenderToPageHeightOnFocusPage, default=0};

RenderToPageHeightOnFocusPage causes the module to render intended page heights as pages are focused.

When True and the module is aligned alNone, alTop, or alBotton, if Page.PageHeightOnFocusPage > -1, then Page.PageHeightOnFocusPage is applied to the PageParent of the module when the page is focused.
When Page.PageHeightOnFocusPage = -1, no adjustment of PageParent.Height is made.

See PageParent_Height and TADVANCE_Page.PageHeightOnFocusPage for further information.

property ToolButton_ProportionalSpacerWidthPercent : TADVANCE_ToolButton_ProportionalSpacerWidthPercent read FToolButton_ProportionalSpacerWidthPercent write SetToolButton_ProportionalSpacerWidthPercent default pswp100;

__property TADVANCE_ToolButton_ProportionalSpacerWidthPercent ToolButton_ProportionalSpacerWidthPercent = {read=FToolButton_ProportionalSpacerWidthPercent, write=SetToolButton_ProportionalSpacerWidthPercent, default=0};

TADVANCE_ToolButton_ProportionalSpacerWidthPercent = (pswp100, pswp050, pswp025);
enum TADVANCE_ToolButton_ProportionalSpacerWidthPercent { pswp100, pswp050, pswp025 };

Prescribes button spacer width as a percentage of button width.

property Wrap : Boolean read FWrap write SetWrap default True;
__property bool Wrap = {read=FWrap, write=SetWrap, default=1};

Enables or disables Paged Toolbar™ wrapping.

property Wrap_OffAtWidthLessThan : Integer read FWrap_OffAtWidthLessThan write SetWrap_OffAtWidthLessThan default 10;// [Minimum = 25, Maximum = 25000]
__property int Wrap_OffAtWidthLessThan = {read=FWrap_OffAtWidthLessThan, write=SetWrap_OffAtWidthLessThan, default=10};

Disables Paged Toolbar™ wrapping when client width is less than Wrap_OffAtWidthLessThan.

• PRECEDING

D.12. TADVANCE_PM

NEXT •

A.01. INTRODUCTION TO ULTIMATE PAGE CONTROL SUITE™

Best viewed in Mozilla Firefox™.