Main page

---

OptDlg.cpp

Go to the documentation of this file.

// MathGUI = a WYSIWYG equation editor + a powerful math engine      //
// Copyright (C) 2003 by Francesco Montorsi                          //
//                                                                   //
// This library is free software; you can redistribute it and/or     //
// modify it under the terms of the GNU Lesser General Public        //
// License as published by the Free Software Foundation; either      //
// version 2.1 of the License, or (at your option) any later         //
// version.                                                          //
//                                                                   //
// This library is distributed in the hope that it will be useful,   //
// but WITHOUT ANY WARRANTY; without even the implied warranty of    //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the      //
// GNU Lesser General Public License for more details.               //
//                                                                   //
// You should have received a copy of the GNU Lesser General Public  //
// License along with this program; if not, write to the Free        //
// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,   //
// MA 02111-1307, USA.                                               //
//                                                                   //
// For any comment, suggestion or feature request, please contact    //
// the administrator of the project at frm@users.sourceforge.net     //
//                                                                   //



// optimization for GCC compiler
#if defined(__GNUG__) && !defined(__APPLE__)
  #pragma implementation "OptDlg.h"
#endif


// includes
#include "mg/mgprec.h"

#ifndef mgPRECOMP
   #include "mg/OptDlg.h"
   #include "mg/OptBtnPanel.h"
   #include "mg/OptTreeCtrl.h"

   // the panels which can be displayed by this dialog...
   #include "mg/OptBasePanel.h"
   #include "mg/OptGeneral.h"
   #include "mg/OptKeyBindings.h"
   #include "mg/OptFontSettings.h"
#endif



// event table for mgOptDlg
IMPLEMENT_CLASS(mgOptDlg, wxDialog )
BEGIN_EVENT_TABLE(mgOptDlg,wxDialog)
  EVT_BUTTON( OPTIONSDLG_BTN_OK, mgOptDlg::OnOkButton )
  EVT_BUTTON( OPTIONSDLG_BTN_CANCEL, mgOptDlg::OnCancelButton )
  EVT_BUTTON( OPTIONSDLG_BTN_APPLY, mgOptDlg::OnApplyButton )
  EVT_TREE_SEL_CHANGED( OPTIONSDLG_TREELIST, mgOptDlg::OnItemSelected )
END_EVENT_TABLE()

// defines the custom command event sent to the app object when options change
DEFINE_EVENT_TYPE( mgEVT_OPTIONS_CHANGED )




// --------------------------------------------
// mcOPTIONSDLG
// --------------------------------------------

mgOptDlg::mgOptDlg( wxWindow* parent, wxWindowID id, wxConfig* config )
: wxDialog( parent, id, wxT("MathStudio Options"),
         wxDefaultPosition, wxSize( 660, 500),
         wxCAPTION | wxSYSTEM_MENU | wxRESIZE_BORDER )
{
   // inits the option's panel actually displayed
   m_actualPanel = 0;
   // m_emptyPanel  = 0;

   // set the event handler which will receive our custom events
   SetClientEvtHandler(parent);

   // creates the button panel and the treelist control
   m_treeWnd   = new mgOptionsTreeCtrl( this );
   m_buttonWnd = new mgOptionsBtnPanel( this );

   CreateLayout( this );      // creates the layout objects for the tree child windows
   //DisplayPanel( Id_mgOptBasePanel );       // creates and displays the empy panel

   // selects the first children of the root node: THIS DOESN'T WORK
   // on wxGTK: it provokes a segmentation fault !!!!
   //long tmp;
   //wxTreeItemId n = m_treeWnd->GetRootItem();
   //m_treeWnd->SelectItem(m_treeWnd->GetItemData(m_treeWnd->GetFirstChild(n, tmp)));
}

mgOptDlg::~mgOptDlg()
{
}




void mgOptDlg::CreateLayout( wxWindow* parent )
{
#ifdef OPTIONSDLG_USE_LAYOUTCONSTRAINTS
   // Set constraints for the tree list control: same as the parent window
   // with a 10 pixel margin and an absolute width of 160 pixels
   wxLayoutConstraints* treeLayout = new wxLayoutConstraints;
   wxASSERT( treeLayout );

   treeLayout->left.SameAs (parent, wxLeft, 10 );
   treeLayout->top.SameAs (parent, wxTop, 10 );
   treeLayout->width.Absolute ( 160 );
   treeLayout->bottom.SameAs( parent, wxBottom, 10);
   m_treeWnd->SetConstraints( treeLayout );

   // Set constraints for the button panel window:
   // The button panel is located just left of the tree list control, at the
   // bottom of parent window and it has an absolute height of 70 pixels
   // Its width is strechable to the right end of the parent
   wxLayoutConstraints* buttonLayout = new wxLayoutConstraints;
   wxASSERT( buttonLayout );

   buttonLayout->left.RightOf ( m_treeWnd, 10 );
   buttonLayout->height.Absolute ( 70 );
   buttonLayout->right.SameAs ( parent, wxRight, 10 );
   buttonLayout->bottom.SameAs( parent, wxBottom, 10);
   m_buttonWnd->SetConstraints( buttonLayout );

   // creates the layout for the option's panels
   // but since no windows are yet created, it does not call SetConstraints for
   // this object, instead it is stored in a data members and when option's panels
   // will be created, a newly created copy of this object is set as constraints
   // for the panel
   m_optionLayout = new wxLayoutConstraints;
   wxASSERT( m_optionLayout );

   m_optionLayout->left.RightOf ( m_treeWnd, 10 );
   m_optionLayout->top.SameAs( parent, wxTop, 10 );
   m_optionLayout->right.SameAs ( parent, wxRight, 10 );
   m_optionLayout->bottom.Above( m_buttonWnd, 10);

   // forces layout to be handled automatically by wxWidgets in OnSize() handlers
   SetAutoLayout( TRUE );

#else

   // use sizers...
   m_mainSizer = new wxBoxSizer(wxHORIZONTAL);
   m_optionSizer = new wxBoxSizer(wxVERTICAL);

   // DisplayPanel() will prepend to this sizer the actual panel
   m_optionSizer->Add(m_buttonWnd, 1, wxGROW);

   // place in the m_mainSizer sizer of the dialog both the treectrl,
   // the actual panel and the OK, CANCEL, APPLY buttons
   m_mainSizer->Add(m_treeWnd, 2, wxGROW | wxALL, 10);
   m_mainSizer->Add(m_optionSizer, 5, wxGROW | wxALL, 5);

   SetSizer(m_mainSizer);
   m_mainSizer->SetSizeHints(this);

#endif // OPTIONSDLG_USE_LAYOUTCONSTRAINTS

   // this doesn't work     :-(
   /*long tmp;
   wxTreeItemId n = m_treeWnd->GetRootItem();
   m_treeWnd->SelectItem(m_treeWnd->GetItemData(m_treeWnd->GetFirstChild(n, tmp)));*/
}



mgOptBasePanel *mgOptDlg::CreatePanel(  mgOptTreeCtrlItemData *itemData, const wxString &itemLabel )
{
   mgLogDebug( wxT("mgOptDlg::CreatePanel() itemData=%p"), itemData );
   wxASSERT( itemData );

#ifdef OPTIONSDLG_USE_LAYOUTCONSTRAINTS
   // the copy of the constraints object
   wxLayoutConstraints* c = new wxLayoutConstraints( *m_optionLayout );
   wxASSERT( c );
#endif

   mgOptBasePanel* panel = 0;

#ifdef NOT_DEFINED
   // this piece of code constructs a mgOptBasePanel-derived class from its
   // classname using wxWidgets's RTTI feature and the 'wxCreateDynamicObject()'
   // function.
   // It seems that not all platforms supports the dynamic creation of objects
   // so I have stripped out this code fragment
   // but I still leave the possibility of using this feature in the future
   wxString className = itemData->m_className;
   panel = ( mgOptBasePanel*) ::wxCreateDynamicObject( className );
#endif

   // gets the ID of the class
   IdOptionsPanel id = itemData->m_classID;

   switch ( id )  {
   case Id_mgOptGeneralPanel :
      panel = new mgOptGeneralPanel();
      break;
   case Id_mgOptKeyBindingsPanel :
      panel = new mgOptKeyBindingsPanel();
      break;
   case Id_mgOptFontSettingsPanel:
      panel = new mgOptFontSettingsPanel();
      break;
   default :
      panel = NULL;
      break;
   }

   wxASSERT( panel );


   // two step creation because dynamic creation only accepts default ctor
   // the problem is that in the default ctor we cannot set much (for
   // example ew cannot call SetBackgroundColor() becasue the object is
   // not yet created.
   // We have to set backgrounds and children only when the Create function
   // is called.
   panel->Create( this, -1 );

   // after the windows substystem has fully created the underlaying structures
   // we can call the virtual Setup() function in order to let the derived
   // panel initialize itself
   panel->Setup( itemLabel );

#ifdef OPTIONSDLG_USE_LAYOUTCONSTRAINTS
   // use constraints
   panel->SetConstraints( c );
#endif

   mgLogDebug( wxT("mgOptDlg::CreatePanel() . panel created") );

   return panel;
}

void mgOptDlg::DisplayPanel( wxTreeItemId itemId )
{
   mgLogDebug( wxT("mgOptDlg::DisplayPanel() - start\n") );
   wxASSERT( itemId.IsOk() );

   // gets the item-data structure associated with the treelist item
   mgOptTreeCtrlItemData *itemData =
      ( mgOptTreeCtrlItemData* ) m_treeWnd->GetItemData( itemId );

   // gets the item label
   wxString itemLabel = m_treeWnd->GetItemText( itemId );

   mgLogDebug( wxT("mgOptDlg::Display Panel() label=%s, item-data=%p"),
      itemLabel.c_str(), itemData );

   wxASSERT( itemData != 0 );

   // gets the panel pointer (NULL if not yet created)
   mgOptBasePanel*   newPanel = itemData->m_panel;
   mgLogDebug( wxT("mgOptDlg::DisplayPanel() - itemData=%p panel=%p classname=%s"),
      itemData, itemData->m_panel, (itemData->m_className).c_str() );


   // if newPanel == ZERO no instance of the specialized class was yet created
   // so creates it and stores the pointer in the item-data structure
   if ( newPanel == 0 )  {
      newPanel = CreatePanel( itemData, itemLabel );
      itemData->m_panel = newPanel;
   }

   // if the selected panel is the already displayed one (the user just
   // clicks twice upon a tree-list item), does nothing
   if ( m_actualPanel == newPanel )
      return;

   // hides the previously displayed panel and shows the actual one
   if ( m_actualPanel != 0 )
      m_actualPanel->Show( FALSE );

#ifndef OPTIONSDLG_USE_LAYOUTCONSTRAINTS

   // remove old panel from sizer
   if (m_actualPanel)
      m_optionSizer->Remove(m_actualPanel);

   // prepend the new one
   m_optionSizer->Prepend(newPanel, 7, wxALL | wxGROW, 5);
   m_optionSizer->Layout();
   m_mainSizer->Layout();

   // this call is very important because it sets the minimum size
   // which is allowed for the options dlg: it's surely changed
   // if we changed the currently displayed panel...
   m_mainSizer->SetSizeHints(this);

   mgLogDebug( wxT("mgOptDlg::DisplayPanel() - sizer has been prepended") );

#endif

   wxASSERT( newPanel != 0 );

   mgLogDebug( wxT("mgOptDlg::DisplayPanel() - showing the panel") );

   // refresh and center the dialog
   CenterOnScreen();
   newPanel->Show( TRUE );
   m_actualPanel = newPanel;
   Refresh();
}

void mgOptDlg::CommitChanges()
{
   mgLogDebug( wxT("Edit - Options dialog box: Committing changes") );
   //return;   // for now,

   // iterate through m_treeWnd treelist's items and obtain
   // the m_panel data member of itemdata structure
   // then calls the CommitChanges() function of every panel which
   // returns the type of changes the panel is responsible of.
   // The type returned from the panel's CommitChanges function
   // is OR'ed with the previuos returned one.
   // After all panel's CommitChanges() function were called, the
   // cumulative type of changes is stored in the m_clientData
   // member of the custom event
   //mgOptChangedType t = OptChanged_None;
   //mgOptBasePanel *panel = 0;
   wxASSERT( m_treeWnd != 0 );

   int depthLevel = 0;

   long cookie[OPTIONSDLG_MAX_TREELIST_DEPTH];     // used for iteration
   wxTreeItemId rootID  = m_treeWnd->GetRootItem();
   wxTreeItemId childId[OPTIONSDLG_MAX_TREELIST_DEPTH];

   // obtains the first child of the root node and checks if
   // it is valid. if not, there are no items in the treelist
   childId[0] = m_treeWnd->GetFirstChild( rootID, cookie[0] );
   if ( !childId[0].IsOk() )  {
      mgLogDebug( wxT("mgOptDlg::CommitChanges() - no items in trelist\n") );
      return;
   }

   // iterates through items and sub-items.
   while ( 1 )  {
      // checks if the childId[0] is valid
      // otherwise, there are no more items
      // we checkk if the actual level child has children. Is yes,
      // we increse the depth level and obtain the children of the child
      if ( m_treeWnd->ItemHasChildren( childId[depthLevel] ))  {
         wxTreeItemId temp;   // the parent id
         ++depthLevel;
         wxASSERT( depthLevel < OPTIONSDLG_MAX_TREELIST_DEPTH );
         childId[depthLevel] = m_treeWnd->GetFirstChild( temp, cookie[depthLevel] );
      }
      else   {
         // the item has no children, so we do not go down the hierarchy
         // but we obtain the panel's pointer of the item and call its
         // CommitChanges function.
         mgOptTreeCtrlItemData *itemData =
            (mgOptTreeCtrlItemData*) m_treeWnd->GetItemData( childId[depthLevel] );
         wxASSERT( itemData != 0 );

         if ( itemData->m_panel != 0 )  {
            itemData->m_panel->CommitChanges( m_config );
         }

         // we get the next sibling of the item until no more
         // siblings are returned.
         // when no more siblings are returned we go up in the hierarchy
         // by decreasing the depthLevel
         childId[depthLevel] = m_treeWnd->GetNextSibling( childId[depthLevel]);
         if ( !childId[depthLevel].IsOk() )  {
            // no more siblings, we go up in the hierarchy
            --depthLevel;
            // the last sibling item is the child of the root node?
            // if yes, we are done
            if ( depthLevel < 0 )
               break;
         }
      }
   }

   // if event notification is enabled, send our custom event to the
   // client event handler...
   wxCommandEvent ev( mgEVT_OPTIONS_CHANGED );
   if (m_pClientEvtHandler)
      m_pClientEvtHandler->AddPendingEvent( ev );
}



void mgOptDlg::OnOkButton( wxCommandEvent &ev )
{
   CommitChanges();
   EndModal( wxID_OK );
}

void mgOptDlg::OnCancelButton( wxCommandEvent &ev )
{
   EndModal( wxID_CANCEL );
}

void mgOptDlg::OnApplyButton( wxCommandEvent &ev )
{
   CommitChanges();
}

void mgOptDlg::OnItemSelected( wxTreeEvent& ev )
{
   // gets the newly selected item ID
   wxTreeItemId id = ev.GetItem();

   // calls the DisplayPanel function in order to display the option's panel
   // relevant for the selected item.
   DisplayPanel( id );
}

---

Documentation generated with Doxygen on Sun Feb 6 17:19:26 2005 Visit MathStudio home page for more info

[ Top ]