MsgResult TEMPLATESGallery::Message(Msg* Message) { if (IS_OUR_DIALOG_MSG(Message)) { DialogMsg* Msg = (DialogMsg*)Message; switch (Msg->DlgMsg) { case DIM_CREATE: SGInit::UpdateGalleryButton(OPTOKEN_DISPLAYTEMPLATEGALLERY, TRUE); break; case DIM_CANCEL: SGInit::UpdateGalleryButton(OPTOKEN_DISPLAYTEMPLATEGALLERY, FALSE); break; } return(SuperGallery::Message(Message)); } // If we have no displaytree, then we have not been shown, or something terrible has // happened, so we don't bother handling any of these messages. if (DisplayTree == NULL) return(SuperGallery::Message(Message)); // **** TO DO **** // Just another note: Most galleries ignore most messages when closed (!IsVisible()) // This means that they must re-create themselves properly to get back up to date // when they are opened - this is done in the PostCreate handler. If you wish to // respond to messages to keep up to date while closed, you should address the // default code in the PostCreate handler as well. if (IsVisible() && MESSAGE_IS_A(Message, DocChangingMsg)) { DocChangingMsg *TheMsg = (DocChangingMsg *) Message; switch ( TheMsg->State ) { case DocChangingMsg::DocState::BORN: // New document - add to display tree { INT32 Extent = GetDisplayExtent(); // Remember previous list extent CreateNewSubtree(TheMsg->pChangingDoc); // Add a subtree for this doc ShadeGallery(FALSE); // Unshade the gallery InvalidateCachedFormat(); // And redraw what is necessary RedrawEverythingBelow(-Extent); } break; // Pass this message on to the base class as well } } return(SuperGallery::Message(Message)); }
MsgResult ArrangeAlignment::Message(Msg* Message) { if (IS_OUR_DIALOG_MSG(Message)) { DialogMsg* Msg=(DialogMsg*)Message; switch (Msg->DlgMsg) { case DIM_CREATE: // dialog created - restore its previous state BuildIDSDropList(_R(IDC_ALIGNDIALOG_HORIZONTAL), HAlignIDS, Align.h); BuildIDSDropList(_R(IDC_ALIGNDIALOG_VERTICAL), VAlignIDS, Align.v); SetRadioGroup(TargetArea, TargetArea[Align.target]); UpdateState(); break; case DIM_LFT_BN_CLICKED: // mouse clicks may change greyed state of buttons case DIM_SELECTION_CHANGED: // mouse clicks may change greyed state of buttons UpdateState(); break; case DIM_LFT_BN_DOWN: // Handle clicks in the diagram control if (Msg->GadgetID == _R(IDC_ALIGNDIALOG_DIAGRAM)) DiagramClicked((ReDrawInfoType*) Msg->DlgMsgParam); break; case DIM_REDRAW: // handle redraw request for diagram gadget if (Msg->GadgetID == _R(IDC_ALIGNDIALOG_DIAGRAM)) RedrawDiagram((ReDrawInfoType*)Msg->DlgMsgParam); break; case DIM_COMMIT: // handle left hand OK click DialogOKed(); break; case DIM_CANCEL: // handle cancel // Close(); // End(); // Do not call Close() and End(). The base class does this. break; default: break; } } else if (MESSAGE_IS_A(Message, SelChangingMsg)) { // if selection has changed, update state of dialog if ( ((SelChangingMsg*)Message)->State == SelChangingMsg::SELECTIONCHANGED ) UpdateState(); } // Pass all unhandled messages to base class for default processing! return DialogOp::Message(Message); }
MsgResult ExampleGallery::Message(Msg* Message) { // Note that all Dialogue messages should have been handled by the base class // message handler. Unless we're being antisocial, all we should have to // process here are the GalleryMsg messages. JCWTRACE( _T("\nExample gallery message handler\n")); #if FALSE if (MESSAGE_IS_A(Message, GalleryMsg)) { GalleryMsg *Msg = (GalleryMsg *) Message; switch(Msg->State) { } return(OK); // Don't try to go recursive with messages from the base class! } #endif return(Gallery::Message(Message)); }
MsgResult WebAddressDlg::Message( Msg* Message) { BOOL fEndDialog=FALSE; //If the message is a dialog message if (IS_OUR_DIALOG_MSG(Message)) { //Then work out what it says DialogMsg* pDialogMsg = ((DialogMsg*) Message); switch (pDialogMsg->DlgMsg) { case DIM_CREATE: OnCreate(); break; case DIM_COMMIT: OnAddButtonClicked(); break; case DIM_CANCEL: fEndDialog = TRUE; break; case DIM_TEXT_CHANGED: //This ensures that, when this code changes some text //in an edit field, we don't handle the "text changed" message if (WebAddressDlg::DontHandleNextTextMessage) { WebAddressDlg::DontHandleNextTextMessage=FALSE; } else OnDialogChange(); break; case DIM_LFT_BN_CLICKED: switch(pDialogMsg->GadgetID) { case _R(IDC_WEBADDRESS_REMOVE): OnRemoveButtonClicked(); break; case _R(IDC_WEBADDRESS_OBJECTSHAPE): case _R(IDC_WEBADDRESS_RECTANGLE): OnDialogChange(); break; case _R(IDC_WEBADDRESS_CORRECT): OnAutoCorrectClicked(); break; } break; //NB: This means someone has altered the combo box. It doesn't mean //the selection has changed! case DIM_SELECTION_CHANGED: OnDialogChange(); break; } } else if (MESSAGE_IS_A(Message, SelChangingMsg)) { if ( ((SelChangingMsg*)Message)->State == SelChangingMsg::SELECTIONCHANGED ) OnSelectionChange(); } if (fEndDialog) { Close(); End(); } return DialogOp::Message(Message); }
MsgResult CBaseBrushNameDlg::Message(Msg* pMessage) { // A message from the dialog or its gadgets? if (IS_OUR_DIALOG_MSG(pMessage)) { DialogMsg* pMsg = (DialogMsg*) pMessage; switch (pMsg->DlgMsg) { case DIM_CREATE: InitGadgetText(); break; case DIM_TEXT_CHANGED: // Disable the OK/Apply button if there's no document or entered text. EnableGadget(_R(IDOK), !GetStringGadgetValue(_R(IDC_EDITBRUSHNAME), 0).IsEmpty() && Document::GetSelected() != 0); break; case DIM_LFT_BN_CLICKED: // enter messages when the edit box has the focus get cast to this if (pMsg->GadgetID == _R(ID_CC_HELP_BUTTON)) break; case DIM_COMMIT: { // Check name for validity. String_256 strEnter = GetStringGadgetValue(_R(IDC_EDITBRUSHNAME), 0); UINT32 nErrID = IsValid(strEnter); if (nErrID != 0) { // Invalid, reinitialise. InformError(nErrID); if (nErrID == _R(IDS_BRUSHNAME_INVALID)) { String_32 s(strEnter); InitGadgetText(&s, FALSE); } else InitGadgetText(NULL); break; } else { // Entry is valid, try committing it. String_32 FinalString(strEnter); if (DoCommit(strEnter)) { // Don't close, reinitialise (dialog is modeless). InitGadgetText(); pMsg->DlgMsg = DIM_NONE; // stop base class closing it break; } else { // Close(); // End(); - base class will close break; } } } break; case DIM_CANCEL: HandleCancel(); // base class will close break; default: break; } } // Has the document been switched or closed? else if (MESSAGE_IS_A(pMessage, DocChangingMsg)) { DocChangingMsg* pMsg = (DocChangingMsg*) pMessage; if (pMsg->State == DocChangingMsg::SELCHANGED) EnableGadget(_R(IDOK), pMsg->pNewDoc != 0); } // Pass everything on to the base class . . . return DialogOp::Message(pMessage); }
MsgResult ToolbarDlg::Message(Msg* Message) { if (IS_OUR_DIALOG_MSG(Message)) { DialogMsg* Msg = (DialogMsg*)Message; BOOL EndDialog = FALSE; switch (Msg->DlgMsg) { case DIM_CANCEL: case DIM_COMMIT: // Cancel all changes the user wants to make to toolbars... EndDialog = TRUE; break; case DIM_SELECTION_CHANGED: case DIM_SELECTION_CHANGED_COMMIT: TakeToolbarDetails(); break; case DIM_LFT_BN_CLICKED: { // A control in the Toolbars... dialog has been clicked... CMainFrame* pFrame = GetMainFrame(); BOOL check; BOOL VV; switch (Msg->GadgetID) { case _R(IDC_BIGALL): // Select all the large buttons... SetLongGadgetValue(_R(IDC_BIGTOP),1); SetLongGadgetValue(_R(IDC_BIGLEFT),1); SetLongGadgetValue(_R(IDC_BIGRIGHT),1); SetLongGadgetValue(_R(IDC_BIGBOTTOM),1); SetLongGadgetValue(_R(IDC_BIGFLOAT),1); TakeToolbarDetails(); break; case _R(IDC_BIGNONE): // Deselect all the large buttons... SetLongGadgetValue(_R(IDC_BIGTOP),0); SetLongGadgetValue(_R(IDC_BIGLEFT),0); SetLongGadgetValue(_R(IDC_BIGRIGHT),0); SetLongGadgetValue(_R(IDC_BIGBOTTOM),0); SetLongGadgetValue(_R(IDC_BIGFLOAT),0); TakeToolbarDetails(); break; case _R(IDC_NEWBAR): NewToolbar(); break; case _R(IDC_BIGTOP): check = (BOOL)GetLongGadgetValue(_R(IDC_BIGTOP),0,1,_R(IDS_PHILS_EXAMPLE),&VV); pFrame->GetDockBar(DOCKBAR_TOP)->SetBigControlState(check); break; case _R(IDC_BIGLEFT): check = (BOOL)GetLongGadgetValue(_R(IDC_BIGLEFT),0,1,_R(IDS_PHILS_EXAMPLE),&VV); pFrame->GetDockBar(DOCKBAR_LEFT)->SetBigControlState(check); break; case _R(IDC_BIGRIGHT): check = (BOOL)GetLongGadgetValue(_R(IDC_BIGRIGHT),0,1,_R(IDS_PHILS_EXAMPLE),&VV); pFrame->GetDockBar(DOCKBAR_RIGHT)->SetBigControlState(check); break; case _R(IDC_BIGBOTTOM): check = (BOOL)GetLongGadgetValue(_R(IDC_BIGBOTTOM),0,1,_R(IDS_PHILS_EXAMPLE),&VV); pFrame->GetDockBar(DOCKBAR_BOTTOM)->SetBigControlState(check); break; case _R(IDC_BIGFLOAT): check = (BOOL)GetLongGadgetValue(_R(IDC_BIGFLOAT),0,1,_R(IDS_PHILS_EXAMPLE),&VV); pFrame->GetDockBar(DOCKBAR_FLOAT)->SetBigControlState(check); break; case _R(IDC_DELETEBAR): { String_32 BarName; GetSelectedBarName(&BarName); if (BarName != String_8(TEXT(""))) { // we can't delete the infoobar if(BarName == String_32(TEXT("Infobar"))) { InformWarning(_R(IDS_CANTDELETEINFOBAR),_R(IDS_OK)); break; } INT32 ButtonPressed = 1; ButtonPressed = InformWarning(_R(IDS_WARNDELETEBAR), _R(IDS_OK),_R(IDS_CANCEL)); Error::ClearError(); if (ButtonPressed == 1) DeleteSelectedBar(); } break; } case _R(IDC_RESETBARS): { INT32 ButtonPressed = 1; ButtonPressed = InformWarning(_R(IDS_WARNRESETBARS), _R(IDS_OK),_R(IDS_CANCEL)); Error::ClearError(); if(ButtonPressed == 1) { Progress::Start(FALSE); // lock the window to avoid untidy layout recalcs ::LockWindowUpdate(GetMainFrame()->GetSafeHwnd()); // tell the mainframe we are changing modes - this prevents // some unnecessary work GetMainFrame()->SetChangingMode(TRUE); // kill all bars ( except infobar at the mo..) BROADCAST_TO_CLASS(DialogMsg(NULL, DIM_BAR_DEATH, NULL ),DialogBarOp); // hide the info bar InformationBarOp::SetVisibility(FALSE,TRUE); DialogBarOp::WipeBarFiles(); DialogBarOp::LoadDefaultBars(); // force the info bar to the correct visible state InformationBarOp::SetVisibility(InformationBarOp::IsVisible(),TRUE); // All clear to Mainframe GetMainFrame()->SetChangingMode(FALSE); // Make sure everything is positioned correctly GetMainFrame()->RecalcLayout(); // Now handle the toolbar .... GetMainFrame ()->SetToolbarCreated (TRUE); GetMainFrame ()->RelocateToolbar (); // and unlock and show the window ::LockWindowUpdate(NULL); ShowToolbarList(); ShowToolbarSizes(); Progress::Stop(); } break; } } break; } } if (EndDialog) // Dialog communication over { Close(); // Close the dialog End(); // Destroy dialog return(OK); // After destroying this object, it's very dangerous to call base class! } } else if ( MESSAGE_IS_A(Message,BarMsg) ) { switch ( ((BarMsg*)Message)->Reason ) { case BAR_CHANGESTATE: // A bar simply became horizontal, vertical or floating and we don't care // about that so do nothing. break; default: // In most cases of BarMsg we want to show the user what happened... ShowToolbarList(); // Show changes in bars to user // Note: it would be more optimal to use the pointer // to the bar that comes with this message to just // alter that item in the list. break; } } return DialogOp::Message(Message); }
MsgResult ColourGallery::Message(Msg* Message) { // Note that all Dialogue messages should have been handled by the base class // message handler. Unless we're being antisocial, all we should have to // process here are list changing messages such as Doc- or Colour-ChangingMsg if (MESSAGE_IS_A(Message, ColourChangingMsg)) { ColourChangingMsg *Msg = (ColourChangingMsg *) Message; switch(Msg->State) { case ColourChangingMsg::LISTPAGED: SwitchTheDisplayList(Msg->ScopeDoc); if (GetCurrentDisplayList() != NULL && // cache exists, but not been filled in GetCurrentDisplayList()->GetCount() < 1) ReadNewColourList(); break; case ColourChangingMsg::COLOURUPDATED: case ColourChangingMsg::COLOURUPDATEDINVISIBLE: // If we weren't responsible for the colour being updated, then we must // re-read the colour list to ensure we've got it right. // **** This could be optimised by just re-sorting the displaylist... // if (!LockColourChange && GetCurrentDisplayList() != NULL) // ReadNewColourList(); ForceRedrawOfList(); // Cause list to be resorted & redisplayed break; #if FALSE /* // We NO LONGER process this message: The Colour Manager calls our special // ColourGallery::ColourListHasChanged() function in order to do this, so that we // have updated our DisplayList before others (the colour bar) start making // requests on it in response to the LISTUPDAETD message. case ColourChangingMsg::LISTUPDATED: UnshadeGallery(); if (GetCurrentDisplayList() != NULL) ReadNewColourList(); // Re-create the display list from the new list break; */ #endif case ColourChangingMsg::LISTDESELECTED: // Gallery should grey out - there is no current colour list ShadeGallery(); break; } // Drop through so the Gallery base class gets to see this message too } else if (MESSAGE_IS_A(Message, SelChangingMsg)) { SelChangingMsg *Msg = (SelChangingMsg *) Message; switch ( Msg->State ) { case SelChangingMsg::SelectionState::COLOURATTCHANGED: case SelChangingMsg::SelectionState::SELECTIONCHANGED: case SelChangingMsg::SelectionState::NODECHANGED: if (IsVisible() && !IsShaded) // If we're open & active, set listbox selection SetSelectionFromDocument(); break; } // Drop through so the Gallery base class gets to see this message too } else if (MESSAGE_IS_A(Message, DocChangingMsg)) { DocChangingMsg *Msg = (DocChangingMsg *) Message; switch (Msg->State) { case DocChangingMsg::BORN: if (Msg->pChangingDoc != NULL) CreateCachedDisplayList(Msg->pChangingDoc); break; } // Drop through so the Gallery base class gets to see this message too } return(Gallery::Message(Message)); }
MsgResult PrintPrefsDlg::Message(Msg* Message) { TRACEUSER( "Neville", _T("PrintPrefsDlg::Message\n")); ERROR3IF(Message == NULL,"PrintPrefsDlg::Message null message received"); // Jason - This is a message-loop lock which is used in the DIM_CREATE code to // allow the print marks manager cache print marks - this causes a lot of diocument // message broadcats and suchlike, which cause re-entrant messages to come in // here and trigger 3 billion ERROR3s. While caching the print marks, we lock this // message handler so that it just ignores all resultant broadcasts. static BOOL IgnoreAllMessages = FALSE; if (IgnoreAllMessages) return DialogTabOp::Message(Message); // Cope with messages for the dialog box if (MESSAGE_IS_A(Message,PrintMsg)) // Check for print messages { PrintMsg* pPrintMsg = (PrintMsg*)Message; if (pPrintMsg->Reason == PrintMsg::SETTINGSCHANGED) { // Tell the print layout tab about the print settings change OptionsTabs *pOptionsTabs = OptionsTabs::GetFirst(); while (pOptionsTabs != NULL) { if (pOptionsTabs->GetPageID() == _R(IDD_OPTSTAB_PRINTLAYOUT) || pOptionsTabs->GetPageID() == _R(IDD_OPTSTAB_PRINTGENERAL)) { PrintBaseTab* pBaseTab = (PrintBaseTab *) pOptionsTabs; pBaseTab->PrintSettingsChanged(); } // Get the next option's tab. pOptionsTabs = OptionsTabs::GetNext(pOptionsTabs); } } return DialogTabOp::Message(Message); } if (IS_OUR_DIALOG_MSG(Message)) { DialogMsg* Msg = (DialogMsg*)Message; MsgResult Result; // Main handler for dialog type messages BOOL EndDialog = FALSE; // TRUE if we should quit the dialog BOOL CommitValues = FALSE; // TRUE if we should commit the dialog values BOOL OldApplyNow = OptionsTabs::GetApplyNowState(); // Old ApplyNow button state // Make sure that we have set up our class variables so that the tabs know what // is the current document and spread to work on. Document *pDocument = Document::GetSelected(); OptionsTabs::SetCurrentDocAndSpread(pDocument); // Plus the current document units are correct OptionsTabs::SetUpDocUnits(); // Check if sending init/create message and if so set flag True. // If True then do not ungrey the ApplyNow button on changing messages if (Msg->DlgMsg == DIM_CREATE) { TRACEUSER( "Neville", _T("PrintPrefsDlg::Message DIM_CREATE\n")); OptionsTabs::SetInitMessageState(TRUE); } // If the message is not for the main options window then try the tab pages BOOL FoundPage = FALSE; TRACEUSER( "Neville", _T("PrintPrefsDlg::Message PageID = %d\n"),Msg->PageID); if (Msg->PageID != 0) { // Now go through all the tabs declared to the system // And see if the message is for that page or not. OptionsTabs *pOptionsTabs = OptionsTabs::GetFirst(); while (pOptionsTabs != NULL && !FoundPage) { CDlgResID PageId = pOptionsTabs->GetPageID(); if (PageId == Msg->PageID) { // Found the correct page so stop the search and send the message // to that page pOptionsTabs->HandleMsg(Msg); FoundPage = TRUE; } // Get the next option's tab. pOptionsTabs = OptionsTabs::GetNext(pOptionsTabs); } } else { // Main page window switch (Msg->DlgMsg) { case DIM_CREATE: // Creating the main dialog box { // grey out the apply now button as this should only become enabled when // we have made a change to the dialog box. OptionsTabs::SetInitMessageState(FALSE); IgnoreAllMessages = TRUE; // BLOCK { // Make sure the print marks are cached by the PMManager. This must be done now // because we want to demand-load the marks, but if we leave it any later we get // an awful lot of rather nasty problems with document messages flying around. PrintMarksMan* pMarksMan = GetApplication()->GetMarksManager(); if (pMarksMan) { pMarksMan->ConstructCache(); if (Document::GetSelected() != NULL) pMarksMan->AddDefaultMarksToDoc(Document::GetSelected()); } } IgnoreAllMessages = FALSE; OptionsTabs::SetApplyNowState(FALSE); OptionsTabs::GreyApplyNow(); // remove the apply now button as not required. CDlgResID PageID = GetCurrentPageID(); // Get currently selected Tab id TalkToPage(0); // Select the main tab HideGadget(_R(ID_APPLY_NOW), TRUE); // hide button on main tab TalkToPage(PageID); // Select the originally selected tab // Pass the message up to all the tabs in case it's of use to them OptionsTabs *pOptionsTabs = OptionsTabs::GetFirst(); while (pOptionsTabs != NULL) { if (pOptionsTabs->IsKindOf(CC_RUNTIME_CLASS(PrintSepsTab)) || // only these classes need this message pOptionsTabs->IsKindOf(CC_RUNTIME_CLASS(PrintImagesetterTab))) pOptionsTabs->HandleMsg(Msg); pOptionsTabs = OptionsTabs::GetNext(pOptionsTabs); } break; } case DIM_COMMIT: // Want to commit and quit { OptionsTabs *pOptionsTabs = OptionsTabs::GetFirst(); while (pOptionsTabs != NULL) { if (pOptionsTabs->IsKindOf(CC_RUNTIME_CLASS(PrintSepsTab)) || // only these classes need this message pOptionsTabs->IsKindOf(CC_RUNTIME_CLASS(PrintImagesetterTab))) pOptionsTabs->HandleMsg(Msg); // Get the next option's tab. pOptionsTabs = OptionsTabs::GetNext(pOptionsTabs); } OkUsed = TRUE; // Flag ok used EndDialog = TRUE; CommitValues = TRUE; } break; case DIM_SOFT_COMMIT: // Want to commit but leave the dialogue open { // Pass the message up to all the tabs in case it's of use to them OptionsTabs *pOptionsTabs = OptionsTabs::GetFirst(); while (pOptionsTabs != NULL) { if (pOptionsTabs->IsKindOf(CC_RUNTIME_CLASS(PrintSepsTab)) || // only these classes need this message pOptionsTabs->IsKindOf(CC_RUNTIME_CLASS(PrintImagesetterTab))) pOptionsTabs->HandleMsg(Msg); pOptionsTabs = OptionsTabs::GetNext(pOptionsTabs); } OkUsed = TRUE; // Flag ok used CommitValues = TRUE; } break; case DIM_CANCEL: // Want to quit { // Pass the message up to all the tabs in case it's of use to them OptionsTabs *pOptionsTabs = OptionsTabs::GetFirst(); while (pOptionsTabs != NULL) { if (pOptionsTabs->IsKindOf(CC_RUNTIME_CLASS(PrintSepsTab)) || // only these classes need this message pOptionsTabs->IsKindOf(CC_RUNTIME_CLASS(PrintImagesetterTab))) pOptionsTabs->HandleMsg(Msg); pOptionsTabs = OptionsTabs::GetNext(pOptionsTabs); } } OkUsed = FALSE; // Flag ok used EndDialog = TRUE; break; default: break; } } // Commit values here if (CommitValues) { BOOL ok = CommitDialogValues(); // Only unset EndDialog as in SOFT_COMMIT case we do not want to end the // Operation and hence close the dialog box if (!ok) { Msg->DlgMsg = DIM_NONE; // prevent baseclass from removing the dialog EndDialog = FALSE; // Values not correct so do not allow exit } } if ( !OldApplyNow && OptionsTabs::GetApplyNowState() && !EndDialog && !OptionsTabs::GetInitMessageState() ) { // Check for a change from apply now being False to it becoming // True as an item has been changed. OptionsTabs::UngreyApplyNow(); } if ( OptionsTabs::GetApplyNowState() && (Msg->DlgMsg == DIM_SOFT_COMMIT) && !EndDialog && !OptionsTabs::GetInitMessageState() ) { // Check for an apply now (DIM_SOFT_COMMIT) being used and the // apply being True, should always be the case, so that we can reset // the grey state to False as we are in an unchanged state. OptionsTabs::SetApplyNowState(FALSE); OptionsTabs::GreyApplyNow(); } // End dialog here if (EndDialog) { // Grey all the tabs to remove the Indexed colour in use error OptionsTabs::SetCurrentDocAndSpread(NULL); OptionsTabs *pOptionsTabs = OptionsTabs::GetFirst(); while (pOptionsTabs != NULL) { if (pOptionsTabs->IsPrintingOption()) pOptionsTabs->GreySection(); pOptionsTabs = OptionsTabs::GetNext(pOptionsTabs); } // Note this destroys "this". Hence don't call the base class Close(); // Hide the dialog box End(); // Finish the operation // Make sure that we remove our options tabs link to the dialog box class // as the dialog will now be destroyed OptionsTabs::pPrefsDlg = NULL; return OK; } // Allow the base class access to the message, it will do the // DLG_EAT_IF_HUNGRY(Msg) for us // Must do this before the Close and End Result = DialogTabOp::Message(Message); // Check if have been sending an init/create message and if so then set flag False. // Only do this in the init/create case as we might be sent one of these and then // be sent other messages whilst in the middle of the init/create message such as // text changing messages. if (Msg->DlgMsg == DIM_CREATE) OptionsTabs::SetInitMessageState(FALSE); // The message was for our dialog box so return that we have handled it, if necessary //return (DLG_EAT_IF_HUNGRY(Msg)); return Result; } // If nobody above has processed the message, then pass it around all the tabs in // case it's of use to them. OptionsTabs *pOptionsTabs = OptionsTabs::GetFirst(); while (pOptionsTabs != NULL) { pOptionsTabs->Message(Message); pOptionsTabs = OptionsTabs::GetNext(pOptionsTabs); } return DialogTabOp::Message(Message); }