Main page

---

MathSystem.h

Go to the documentation of this file.

// MathCore = 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 MATHSYSTEM_H
#define MATHSYSTEM_H

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

// required includes
#include "mc/MathLine.h"


#define mcMATHSYSTEM_MAXLINES    32

// global objects
class mcMathSystem;
extern mcMathSystem mcEmptySystem;


class mcMathSystemHelpers : public mcAbstractArray, public mcElementHelpers,
       public mcDoubleBufferedElement
{
#ifdef mcENABLE_GUI
protected:  // member variables

 int mgui_nSel;

 int mgui_nLastActive;

 int mgui_nCurrentActive;

 wxSize mgui_szSymbol;


 wxFont mgui_fLastFont;

 int mgui_nLastWidth;

#endif


public:
 mcMathSystemHelpers() {}
 virtual ~mcMathSystemHelpers() {}

 void gui_Init() {
  mgui_nSel = mgui_nLastWidth = 0;
  mgui_nLastActive = -1;
  mgui_nCurrentActive = -1;
  mcElementHelpers::gui_Init();
 }



#ifdef mcENABLE_DATA
public:

#ifdef __MCDEBUG__

 void data_Check() const;

#else
 
 inline void data_Check() const {}

#endif  // __MCDEBUG__

 void data_DeepCopy(const mcElementHelpers *p);

 int data_GetChildrenCount() const
  { return mcAbstractArray::data_GetCount(); }
 const mcElement &data_GetConstChild(int n) const
  { return *((const mcElement *)(data_GetItem(n))); } 

 // these functions are used to link the children functions
 // defined above with the mcAbstractArray functions/terminology.
 mcElement &data_Get(int n)
  { return data_GetChild(n); }
 const mcElement &data_Get(int n) const
  { return data_GetConstChild(n); } 
 mcElement &data_GetLast()
  { return data_Get(data_GetCount()-1); }
 const mcElement &data_GetLast() const
  { return data_Get(data_GetCount()-1); }
 int data_GetCount() const
  { return data_GetChildrenCount(); }

#endif  // mcENABLE_DATA



#ifdef mcENABLE_GUI
protected:

 virtual bool gui_DrawHorizontally() const = 0;
 virtual bool gui_DrawVertically() const = 0;

 virtual int gui_GetSpaceAboveBelow() const = 0;
 virtual int gui_GetSpaceLeftRight() const = 0;
 virtual int gui_GetSpaceBetween() const = 0; 

public: 


 mcElement &gui_GetFocus()
  { return data_Get(mgui_nSel); }
 const mcElement &gui_GetFocus() const
  { return data_Get(mgui_nSel); }

 mcDoubleBufferedElement *gui_Get(int n)
  { return dynamic_cast<mcDoubleBufferedElement*>(data_Get(n).hlp()); }
 const mcDoubleBufferedElement *gui_Get(int n) const
  { return dynamic_cast<const mcDoubleBufferedElement*>(data_Get(n).chlp()); }




 
 int gui_UpdateBmp(int x, int y, long flags, const wxPoint &p);
 int gui_ForceBmpUpdate(int x, int y, long flags, const wxPoint &p);
 int gui_DrawBmp(wxDC &dc, int x, int y) const;

 void gui_SetMask(const wxColour &col);
 void gui_SetBmpBackgroundBrush(const wxBrush &);

 bool gui_NeedsRefresh() const;
 




 virtual void gui_DrawSystemSymbols(wxDC &dc, int x, int y, long flags) const = 0;

 virtual void gui_RecalcSymbolSize() = 0;





 virtual int gui_GetXOf(int n) const;

 virtual int gui_GetYOf(int n) const;

 virtual int gui_GetXOfSymbol(int n) const;

 virtual int gui_GetYOfSymbol(int n) const;

 wxRect gui_GetRectOf(int n) const;

 int gui_GetElemContaining(const wxPoint &pt) const;

 virtual wxSize gui_GetSymbolSize() const
  { return mgui_szSymbol; }

 wxPoint gui_GetRelCursorPos(wxDC &dc, int x, int y, int *height) const;

 void gui_CheckSelLineIdx();

 wxBitmap gui_GetBmp() const;

 int gui_GetFocusIdx() const 
  { return mgui_nSel; }

 void gui_SetFocusIdx(int n)
  { mgui_nSel = n; }

 bool gui_isSymbolToDraw() const 
 { return data_GetCount() >= 2; }





 
 // these does not apply to a mcMathSystem
 bool gui_isBeginKey(const mcKey &key) const 
  { return FALSE; }
 bool gui_isEndKey(const mcKey &key) const
  { return FALSE; }

 void gui_DoRecalcSize();
 void gui_SetCursorPos(const mcCursorPos &code);
 void gui_OnSelect(wxDC &dc, wxRect &rc);
 int gui_GetRelCursorPos(wxDC &dc, wxPoint *pt) const;
 int gui_MoveCursorUsingPoint(wxDC &dc, const wxPoint &pos);
 int gui_Draw(wxDC &dc, int x, int y, long flags, const wxPoint &pt) const; 
 void gui_GetCursorPos(mcCursorPos &) const;
 mcInputRes gui_Input(const mcKey &ev, mcElement *newelem);
 mcInsertRes gui_Insert(const mcElement &, mcElement *);
 mcMoveCursorRes gui_MoveCursor(mcMoveCursorFlag flag, long modifiers);
 
/*
 mcElement &gui_GetActiveElem(int x, int y, const wxPoint &pt);
 mcElement data_GetElemFromID(int id);
*/

 //void gui_DeleteSelection();

 void gui_UpdateExpDepth();





 /*void gui_MultiplyBySel() {
  gui_GetSelLine()->gui_MultiplyBySel();
 }

 void gui_MoveSel() {
  gui_GetSelLine()->gui_MoveSel();
 }

 wxArrayString gui_GetPossibleOpOnSel(mcMathMngCmd *pID) {
  return gui_GetSelLine()->gui_GetPossibleOpOnSel(pID);
 }

 wxArrayString math_GetPossibleOp(mcMathMngCmd *pID, int n = 0) {
  return data_GetLine(n)->gui_GetPossibleOp(pID);
 }

 void gui_ExecCmdOnSel(mcMathMngCmd n) {
  gui_GetSelLine()->gui_ExecCmdOnSel(n);
 }*/

 wxString gui_GetSelInlinedExpr() const;


#endif  // mcENABLE_GUI



#ifdef mcENABLE_MATH
protected:
  
 mcExpSimRes math_ExpSimAllLines(bool simp = TRUE);

public:


 mcBasicOpRes math_MultiplyBy(const mcElement &, mcElement *);

 mcBasicOpRes math_DivideBy(const mcElement &, mcElement *);
 mcBasicOpRes math_Add(const mcElement &, mcElement *, bool);
 mcBasicOpRes math_Subtract(const mcElement &, mcElement *);

 mcBasicOpRes math_RaiseTo(const mcPolynomial &);

 mcExpSimRes math_Simplify(long flags, mcElement *);
 mcExpSimRes math_Expand(long flags, mcElement *);

 mcRealValue math_Evaluate(int n = -1) const;

 bool math_isMaxSimplified() const;
 //bool math_isConstant() const;

/* mcElement math_Find(int n, const mcElement &tofind, long flags,
       int *pos = NULL, int *entry = NULL) const;
 int math_GetCountOf(const mcElement &tocount, long flags) const;
 int math_Replace(const mcElement &tofind, int n, long flags,
  const mcElement &rep, bool bAttachChildren);*/

 mcIntegerValue math_GetMathSystemDegreeFor(const mcSymbolProperties *unk) const;
 
 mcRealValue math_GetLenght() const;
 //mcRealValue math_GetTotalLenght() const;

 //bool math_isComplete() const;

 virtual mcMathSystemType math_GetMathSystemType() const = 0;

 mcMathType math_GetMathType() const;

 bool math_Compare(const mcElement &, long flags) const; 


 // these does not have sense for a mcMathSystem
 mcRealValue math_Evaluate() const  { return 0.0; }
 int math_GetOrderPos() const   { return 0; }

 bool math_CanBeAddedWith(const mcElement &p) const { return FALSE; }
 bool math_CanBeMultWith(const mcElement &p) const { return FALSE; }
 bool math_CanBeDivBy(const mcElement &p) const  { return FALSE; }

 mcMonomial math_GetLCM(const mcElement &) const  { return mcEmptyMonomial; }
 mcMonomial math_GetGCD(const mcElement &) const  { return mcEmptyMonomial; }


#endif  // mcENABLE_MATH



#ifdef mcENABLE_IO
protected:

 int io_FilterInlinedExpr(wxString &);

public:


 bool io_ImportInlinedExpr(const wxString &str, int *count, wxString &perr);

 bool io_ImportInlinedExpr(const wxString &str)
 { wxString tmp; return io_ImportInlinedExpr(str, NULL, tmp); }

 wxString io_GetInlinedExpr() const;

 wxXml2Node io_GetMathML(bool bGetPresentation) const;

 bool io_ImportPresentationMathML(wxXml2Node pDoc, wxString &pErr);

 virtual wxString io_GetInlinedExprOfLogicalOperator() const = 0;
 virtual bool io_ImportToken(const wxString &str, wxString *perr) = 0;


 // USELESS ??
 
 wxString io_GetInlinedExprOfLogicalOperator(mcLogicOperator op, 
         bool shortversion = FALSE) const;

 wxString io_GetInlinedExprOfAllLogicalOp() const;


 // these does not have sense for a mcMathSystem
 bool io_isBeginTag(const wxXml2Node &tag) const  { return FALSE; }
 bool io_isBeginChar(const wxString &str) const   { return FALSE; }


#endif  // mcENABLE_IO
};


class mcMathSystem : public mcElement
{
 mcDEFINE_ABSTRACT_CLASS(MathSystem, mcElement);

public:

 bool data_isValidContainerFor(mcElementType t) const
  { return t == mcET_MATHORSYSTEM || t == mcET_MATHANDSYSTEM; }


#ifdef mcENABLE_DATA
public:

 mcWRAPPER mcElement &data_Get(int n)
  { return hlp()->data_Get(n); }
 mcWRAPPER const mcElement &data_Get(int n) const
  { return hlp()->data_Get(n); }
 mcWRAPPER mcElement &data_GetLast()
  { return hlp()->data_GetLast(); }
 mcWRAPPER const mcElement &data_GetLast() const
  { return hlp()->data_GetLast(); }
 
 mcWRAPPER int data_GetCount() const
  { return hlp()->data_GetCount(); } 
 mcWRAPPER void data_Insert(mcAbstractItem *pointer, int n)
  { hlp()->data_Insert(pointer, n); }
 mcWRAPPER void data_SetItem(mcAbstractItem *pointer, int n)
  { hlp()->data_SetItem(pointer, n); }
 mcWRAPPER void data_RemoveAt(int idx, int count = 1)
  { hlp()->data_RemoveAt(idx, count); }
 mcWRAPPER void data_Remove(const mcAbstractItem *p)
  { hlp()->data_Remove(p); }
 mcWRAPPER void data_Clear()
  { hlp()->data_Clear(); }
 mcWRAPPER bool data_isEmpty() const 
  { return hlp()->data_isEmpty(); } 
 mcWRAPPER int data_Find(const mcAbstractItem *pointer) const
  { return hlp()->data_Find(pointer); } 
 mcWRAPPER mcAbstractItem *data_Detach(int idx)
  { return hlp()->data_Detach(idx); } 

#endif  // mcENABLE_DATA


#ifdef mcENABLE_GUI
public:

 mcWRAPPER int gui_UpdateBmp(int x, int y, long flags, const wxPoint &p)
  { return hlp()->gui_UpdateBmp(x, y, flags, p); } 
 mcWRAPPER int gui_ForceBmpUpdate(int x, int y, long flags, const wxPoint &p)
  { return hlp()->gui_ForceBmpUpdate(x, y, flags, p); } 
 mcWRAPPER int gui_DrawBmp(wxDC &dc, int x, int y) const
  { return hlp()->gui_DrawBmp(dc, x, y); }

 mcWRAPPER bool gui_NeedsRefresh() const
  { return hlp()->gui_NeedsRefresh(); }
 mcWRAPPER void gui_SetMask(const wxColour &c)
  { hlp()->gui_SetMask(c); }
 mcWRAPPER void gui_SetBmpBackgroundBrush(const wxBrush &c)
  { hlp()->gui_SetBmpBackgroundBrush(c); }

 mcWRAPPER void gui_SetFocusIdx(int n)
  { hlp()->gui_SetFocusIdx(n); }
 mcWRAPPER int gui_GetFocusIdx() const
  { return hlp()->gui_GetFocusIdx(); }

 mcWRAPPER wxPoint gui_GetRelCursorPos(wxDC &dc, int x, int y, int *height) const
  { return hlp()->gui_GetRelCursorPos(dc, x, y, height); }
 
 mcWRAPPER wxBitmap gui_GetBmp() const
  { return hlp()->gui_GetBmp(); }
 
 mcWRAPPER wxString gui_GetSelInlinedExpr() const
  { return hlp()->gui_GetSelInlinedExpr(); }

#endif  // mcENABLE_GUI


#ifdef mcENABLE_IO
public:

 mcWRAPPER bool io_ImportInlinedExpr(const wxString &str)
  { return hlp()->io_ImportInlinedExpr(str); }
 mcWRAPPER bool io_ImportInlinedExpr(const wxString &str, int *count, wxString &err)
  { return hlp()->io_ImportInlinedExpr(str, count, err); }

#endif  // mcENABLE_IO


#ifdef mcENABLE_MATH
public:

 mcWRAPPER mcMathSystemType math_GetMathSystemType() const
  { return hlp()->math_GetMathSystemType(); }

#endif  // mcENABLE_MATH
};


#endif  // MATHSYSTEM_H

---

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

[ Top ]