Main page

---

MathBox.h

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     //
//                                                                   //



#ifndef MATHBOX_H
#define MATHBOX_H

// includes
#include "mc/Element.h"
#include "mc/Text.h"
#include "mc/MathLine.h"
#include "mc/MathOrSystem.h"
#include <wx/caret.h>

// required because mgMathBox uses a WX extension written by Markus Greither
#include "wx/resizec.h"
#include "wx/keybinder.h"


// optimization for GCC compiler
#ifdef __GNUG__
#pragma interface "MathBox.h"
#endif




#define mgMATHBOX_CONTEXTMENU_BASEID         mgMATHBOX_BASEID

#define mgMATHBOX_CONTEXTMENU_MATHCMD_BASEID mgMATHBOX_CONTEXTMENU_BASEID+20

#define mgMATHBOX_CONTEXTMENU_FINALID        mgMATHBOX_CONTEXTMENU_BASEID+32




// the mgMathBox class is able to send to the wxEvtHandler attached through
// the mgMathBox::SetClientHandler, some specific events:
BEGIN_DECLARE_EVENT_TYPES()
   DECLARE_EVENT_TYPE( mgEVT_ACTIVE_ELEM_CHANGED, mgMATHBOX_EVENTS_BASEID )
END_DECLARE_EVENT_TYPES()


#define EVT_ACTIVE_ELEM_CHANGED(winid, fn)                     \
   DECLARE_EVENT_TABLE_ENTRY( mgEVT_ACTIVE_ELEM_CHANGED, winid,   \
      wxID_ANY, (wxObjectEventFunction) (wxEventFunction)         \
      wxStaticCastEvent( wxCommandEventFunction, & fn ),       \
      (wxObject *) NULL ),



class mgCaret : public wxCaret
{
public:
   mgCaret(wxWindow *window, int w, int h)
      : wxCaret(window, w, h) {}

   void ForceShow()  { DoShow(); m_countVisible=1; } 

   void ForceHide()  { DoHide(); m_countVisible=0; } 
};



enum mgMathBoxCmdID {

   // standard edit commands
   mgMBC_CUT = 0,
   mgMBC_COPY_ASPLAIN,
   mgMBC_COPY_ASMATHML,
   mgMBC_PASTE,
   mgMBC_SELECTALL,

   mgMBC_CREATENEW_ANDLINE,
   mgMBC_CREATENEW_ORLINE,
   mgMBC_SIMPLEEND,

   // advanced edit commands
   mgMBC_EMBED_NUMFRACTION,
   mgMBC_EMBED_DENFRACTION,
   mgMBC_EMBED_RADICAL,
   mgMBC_EMBED_BRACKET,
   mgMBC_ADVEND,

#ifdef __MGDEBUG__
   mgMBC_DEBUG,
#endif

   mgMBC_LAST
};

struct mgMathBoxCmd {
   mgMathBoxCmdID m_nID;
   const wxChar *m_strDescription;
};




class mgMathBox : public wxWindow
{
protected:     // member variables
   
   mcMathOrSystem m_mathContent;

   wxPoint m_ptPos;

   //wxCursor *m_pCursor;

   wxRect m_rcSelection;

   mcElement m_eSelection;

   //mcMathMngCmdID m_nCmdID[mgMATHBOX_MAXMENU_ITEMS];

   wxEvtHandler *m_pClient;


protected:

   bool m_bProcSpecialChar;

   bool m_bAutoExpand;


   bool m_bInputEnabled;

   bool m_bSelectionEnabled;

   bool m_bContextMenuEnabled;

   // This enables/disables preprocessing of 
   bool m_bPreProcessingEnabled;


protected:        // internal utilities

   void Init();

#ifdef __WXMSW__     // WXMSG is not defined in all ports

   // In the wxMSW port, this function determines if the messages
   // should be preprocessed (by acceleration tables, for example) or
   // they should just be sent to the the event handler of this window
   // "as is": by default, wxWindow::MSWShouldPreProcessMessage returns
   // TRUE but mgMathBox and 
   virtual bool MSWShouldPreProcessMessage(WXMSG* pMsg) {
      return m_bPreProcessingEnabled;
   }

#endif

   mgCaret *GetCaret() const     { return (mgCaret *)wxWindow::GetCaret(); }

public:           // customizable variables

   static int nSpaceAround;

   static int nCursorWidth;

   static bool bUseNativeNewLines;

   static mgMathBoxCmd cmd[mgMBC_LAST+1];

public:

   mgMathBox(wxWindow *parent,
      wxWindowID id = -1,
      const wxPoint &pos = wxDefaultPosition,
      const wxSize &size = wxDefaultSize,
      long style = wxSUNKEN_BORDER 
      | wxNO_FULL_REPAINT_ON_RESIZE, 
      const wxString &name = wxT("mgMathBox"))
      : wxWindow(parent, id, pos,  size, style, name) {
         Init();
   }

   mgMathBox(const mgMathBox &tocopy) { DeepCopy(tocopy); }

   virtual ~mgMathBox() {
      // the SetCaret() function will delete the caret, if it exists...
      SetCaret(NULL);
   }


public:


   void DeepCopy(const mgMathBox &);

   mcMathOrSystem &GetMathObj()              { return m_mathContent; }
   const mcMathOrSystem &GetMathObj() const     { return m_mathContent; }

   void EnableInput(bool bEnable = TRUE);

   void EnableSelection(bool bEnable = TRUE) {
      m_bSelectionEnabled = bEnable;
   }

   void EnableContextMenu(bool bEnable = TRUE) {
      m_bContextMenuEnabled = bEnable;
   }

   void EnablePreProcessing(bool bEnable = TRUE) {
      m_bPreProcessingEnabled = bEnable;
   }

   void DisableInput() { EnableInput(FALSE); }
   void DisableSelection() { EnableSelection(FALSE); }
   void DisableContextMenu() { EnableContextMenu(FALSE); }
   void DisablePreProcessing() { EnablePreProcessing(FALSE); }

   void SetClientEvtHandler(wxEvtHandler *p) {
      m_pClient = p;
   }

   mcElement GetActiveElem(const wxPoint &pos, const wxPoint &pt) const {
      return m_mathContent.gui_GetActiveElem(pos.x, pos.y, pt);
   }

   mcElement GetElemFromID(int id) const {
      return m_mathContent.data_GetElemFromID(id);
   }

   wxString GetDebug() const;





   void FitContents();

   void SetSizeHintsToFitContents();

   wxSize GetContentSize() const;

   void Clean();

   int GetXPos() const     { return m_ptPos.x; }

   int GetYPos() const     { return m_ptPos.y; }

   wxRect GetRectOfContents()
      { return wxRect(wxPoint(GetXPos(), GetYPos()), GetContentSize()); }





   int UpdateMathBmp(long flags, const wxPoint &p = wxDefaultPosition);

   void UpdateContentPos();

   void UpdateCaretPos();

   void UpdateCaret();

   void UpdateMathBmpWithCurrentPos();

   void ForceBmpUpdate();


   



   void RedrawMath(wxDC &dc, int x, int y);

   void GetContextMenu(wxMenu &, const mcElement &selected) const;

   void CheckReturnFlag(int res);

   void ResetGUI();

   bool isSelecting() const
      { return m_rcSelection.width != -1; }

   void ResetSelectionRect() {
      m_rcSelection.x = m_rcSelection.y = -1;
      m_rcSelection.width = m_rcSelection.height = -1;
   }

   void DeSelect()   
      { m_mathContent.gui_DeSelect();  }

   void SetStyleArray(mcStyleArray *p) {
      m_mathContent.gui_SetStyleArray(p);
      m_mathContent.gui_DeepRecalcSize();
      ResetGUI();
   }






   void InsertFraction();
   void InsertRadical();
   void InsertFunction();
   void EditExponent();
   void EditSubscript();

   void Cut(const mcElement &sel = mcEmptyElement);
   void CopyAsPlainText(const mcElement &sel = mcEmptyElement);
   void CopyAsMathML(const mcElement &sel = mcEmptyElement);
   void Paste(const mcElement &sel = mcEmptyElement);

   void EmbedAsFractionNum(const mcElement &sel = mcEmptyElement);
   void EmbedAsFractionDen(const mcElement &sel = mcEmptyElement);
   void EmbedAsRadical(const mcElement &sel = mcEmptyElement);






   void OnSetFocus(wxFocusEvent &);    // focus events
   void OnFocusLost(wxFocusEvent &);

   void OnTimer(wxTimerEvent &);       // miscellaneous events
   void OnPaint(wxPaintEvent &);
   void OnSize(wxSizeEvent &);

   void OnLDown(wxMouseEvent &);       // mouse events
   void OnLUp(wxMouseEvent &);
   void OnRUp(wxMouseEvent &);
   void OnMouseMove(wxMouseEvent &);
   void OnSetCursor(wxSetCursorEvent &);
   void OnLeaveWindow(wxMouseEvent &);

   void OnCtxMenuItem(wxCommandEvent &);  // menu events

   void OnChar(wxKeyEvent &);          // keyboard events
   void OnSpecialChar(wxKeyEvent &);






/* //! Adds one "line" to the mcMathOrSystem contained.
   void AddLine(bool bCopyLast);

   void DeleteLine(int n);

   void SelectLine(int n)  { m_mathContent.gui_SelectLine(n); }

   int GetSelLineId();*/

   void AppendEditCommands(wxMenu &);






   bool Export(bool bXHTML, const wxString &filename, const wxString &title,
      bool bUpperTag = FALSE, bool bMPSupp = FALSE, bool bUseNS = FALSE,
      const wxString &ns = wxEmptyString, const wxString &href = wxEmptyString,
      int indstep = 2) const;

   bool Export(bool bXHTML, wxOutputStream &str, const wxString &title,
      bool bUpperTag = FALSE, bool bMPSupp = FALSE, bool bUseNS = FALSE,
      const wxString &ns = wxEmptyString, const wxString &href = wxEmptyString,
      int indstep = 2) const;

   wxString GetExportPreview(bool bXHTML, const wxString &title,
      bool bUpperTag = FALSE, bool bMathPlayerSupport = FALSE,
      bool bUseNS = FALSE, const wxString &ns = wxEmptyString,
      const wxString &href = wxEmptyString, int indentstep = 2) const;

   wxXml2Node GetMathML(bool bGetPresentation) const {
      return m_mathContent.io_GetMathML(bGetPresentation);
   }

   wxString GetInlinedExpr() const {
      return m_mathContent.io_GetInlinedExpr();
   }

   bool Import(int type, const wxString &filename, wxString *pDesc = NULL);

   bool ImportMathML(wxXml2Node pDoc, wxString *pErr) {
      return m_mathContent.io_ImportPresentationMathML(pDoc, *pErr);
   }

   bool ImportInlinedExpr(const wxString &str);

   wxString ConvertString(const wxString &str) const;



private:
   DECLARE_CLASS(mgMathBox)
   DECLARE_EVENT_TABLE()
};




#if 1

class mgResizeableBox : public wxResizeableControl
{
protected:

   int m_nMinBorder;

   //bool m_bFocus, m_bChildFocus;

public:
   mgResizeableBox(wxWindow *parent,
      wxWindowID id = -1,
      const wxPoint &pos = wxDefaultPosition,
      const wxSize &size = wxDefaultSize);

   mgResizeableBox() {
      m_nMinBorder = 0;
   }

   mgResizeableBox(const mgResizeableBox &tocopy);

   virtual ~mgResizeableBox() {
      //GetParent()->GetParent()->SetFocus();
   }

   void DeepCopy(const mgResizeableBox &);

   void SetMinBorder(int n);

   int GetBorder();

   //void SetFocus();
   //void Refresh(bool eraseBackground = TRUE, const wxRect* rect = NULL);

   virtual wxString GetDebug();



   virtual wxWindow *GetChild()        { return NULL; }


   // event handlers
   virtual void OnSize(wxSizeEvent &);
   virtual void OnSetFocus(wxFocusEvent &);
   virtual void OnKillFocus(wxFocusEvent &);
   virtual void OnSetCursor(wxSetCursorEvent &ev);
   virtual void OnPaint(wxPaintEvent &ev);
   virtual void OnMove(wxMoveEvent &ev);

   virtual void OnChildKillFocus(wxCommandEvent &);
   virtual void OnChildSetFocus(wxCommandEvent &);
   virtual void OnChildResize(wxCommandEvent &);


private:
   DECLARE_CLASS(mgResizeableBox)
   DECLARE_EVENT_TABLE()
};
/*
class mgResizeableBox2 : public wxResizeableHub
{
protected:

   int m_nMinBorder;

   //bool m_bFocus, m_bChildFocus;

public:
   mgResizeableBox(wxWindow *parent,
      wxWindowID id = -1,
      const wxPoint &pos = wxDefaultPosition,
      const wxSize &size = wxDefaultSize);

   mgResizeableBox(); {
      m_nMinBorder = 0;
   }

   mgResizeableBox(const mgResizeableBox &tocopy);

   virtual ~mgResizeableBox() {
      //GetParent()->GetParent()->SetFocus();
   }

   void DeepCopy(const mgResizeableBox &);

   void SetMinBorder(int n);

   int GetBorder();

   void SetFocus();
   //void Refresh(bool eraseBackground = TRUE, const wxRect* rect = NULL);

   virtual wxString GetDebug();



   virtual wxWindow *GetChild()        { return NULL; }


   // event handlers
   virtual void OnSize(wxSizeEvent &);
   virtual void OnSetFocus(wxFocusEvent &);
   virtual void OnKillFocus(wxFocusEvent &);
   virtual void OnSetCursor(wxSetCursorEvent &ev);
   virtual void OnPaint(wxPaintEvent &ev);

   virtual void OnChildKillFocus(wxCommandEvent &);
   virtual void OnChildSetFocus(wxCommandEvent &);
   virtual void OnChildResize(wxCommandEvent &);


private:
   DECLARE_CLASS(mgResizeableBox2)
   DECLARE_EVENT_TABLE()
};
*/
class mgResizeableMathBox : public mgResizeableBox
{
protected:

   mgMathBox *m_pMathBox;//m_mathBox;

public:
   mgResizeableMathBox(wxWindow *parent,
      wxWindowID id = -1,
      const wxPoint &pos = wxDefaultPosition,
      const wxSize &size = wxDefaultSize);

   mgResizeableMathBox() {};// : m_mathBox() {}

   mgResizeableMathBox(const mgResizeableMathBox &tocopy);

   virtual ~mgResizeableMathBox() {
      if (m_pMathBox) delete m_pMathBox;
   }

   void DeepCopy(const mgResizeableMathBox &);

   wxString GetDebug();

   virtual wxXml2Node GetMathML(bool bGetPresentation) {
      return m_pMathBox->GetMathML(bGetPresentation);
   }

   virtual bool ImportMathML(wxXml2Node pDoc, wxString *pErr) {
      return m_pMathBox->ImportMathML(pDoc, pErr);
   }


   wxWindow *GetChild()       { return m_pMathBox; }//&m_mathBox; }

/* void DeleteLine(int n)        { m_pMathBox->DeleteLine(n); }
   void SelectLine(int n)        { m_pMathBox->SelectLine(n); }
   void AddLine(bool bCopyLast)  { m_pMathBox->AddLine(bCopyLast); }
   int GetSelLineId()            { return m_pMathBox->GetSelLineId(); }*/

   // event handlers
   //virtual void OnSize(wxSizeEvent &);

private:
   DECLARE_CLASS(mgResizeableMathBox)
   DECLARE_EVENT_TABLE()
};



class mgResizeableTextBox : public /*wxTextCtrl, public*/ mgResizeableBox
{
protected:

   wxTextCtrl *m_pTextCtrl;
   //mcText m_text;

public:
   mgResizeableTextBox(wxWindow *parent,
      wxWindowID id = -1,
      const wxPoint &pos = wxDefaultPosition,
      const wxSize &size = wxDefaultSize);

   //mgResizeableTextBox() : m_pTextCtrl(NULL) {}

   //mgResizeableTextBox(const mgResizeableTextBox &tocopy);

   virtual ~mgResizeableTextBox() {
      //if (m_pTextCtrl) delete m_pTextCtrl;
   }

   //void DeepCopy(const mgResizeableTextBox &);

   wxString GetDebug();


   wxWindow *GetChild()       { return m_pTextCtrl; }

   // event handlers
   /*void OnSize(wxSizeEvent &);
   void OnSetFocus(wxFocusEvent &);
   void OnSetCursor(wxSetCursorEvent &ev);
   void OnChildResize(wxCommandEvent &);
   void OnPaint(wxPaintEvent &ev);*/

private:
   DECLARE_CLASS(mgResizeableTextBox)
   DECLARE_EVENT_TABLE()
};

#endif
#endif   // MATHBOX_H

---

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

[ Top ]