Main page

---

Element.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 ELEMENT_H
#define ELEMENT_H


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

// required includes
#include <wx/memory.h>
#include "mc/Setup.h"
#include "mc/Styles.h"
#include "mc/MathUtils.h"
#include "mc/MathHelpers.h"
#include "wx/xml2.h"

#include "mc/Object.h"


#define mcELEMENTMATH_MAX_EXPDEPTH       4

#define mcELEMENTMATH_MAX_PROCESS_CYCLES     100


#define mcELEMENT_DBG_EXPDEPTH  1  
#define mcELEMENT_DBG_SELECTION  2  
#define mcELEMENT_DBG_ID   4  


#define mcFIND_NOFLAGS    0

#define mcFIND_STRICT    1

#define mcFIND_PARENT    2


#define mcMCF_NOMODIFIERS   0

#define mcMCF_EXTEND_SELECTION  1


// compiler needs to know that mcElementGUI, mcElementMath, mcElementIO
// and mcElement classes exist, before we define the mcElementData class.
mcDEFINE_HELPER_CLASSES(mcElement);


// defined later
class mcPolynomial;
class mcMonomial;
extern mcElement mcEmptyElement;
extern mcPolynomial mcEmptyPolynomial;




class mcElementHelpers : public mcObjectRefData
{
 friend class mcElement;


#ifdef mcENABLE_DATA
public:

 static mcElement *sdata_pElem[mcNUM_ELEMENT_TYPES];




 static mcElementType gui_isKeyBeginKey(const mcKey &ev);
 static mcElementType io_isCharBeginChar(const wxString &str);
 static mcElementType io_isTagBeginTag(const wxXml2Node &tag);

 static mcElement data_NewElem(mcElementType type, 
        const mcElementHelpers *towrap = NULL);

 static mcElement *data_GetInstanceOf(mcElementType type)
  { return sdata_pElem[type]; }

 static wxString data_GetGlobalMemoryInfo();

 static void data_UpdateElemArray();

 static int data_GenID(bool bFirstMember = TRUE);

 static void Init();

 static void Cleanup();



protected:   // DATA variables

 int mdata_nID;

 int mdata_nProperties;

#endif



#ifdef mcENABLE_GUI
protected:   // GUI variables

 const mcStyleArray *mgui_pStyleArray;

 bool mgui_bSelected;

 wxSize mgui_sz;

 int mgui_nExpDepth;

public:   // customizable variables

 static wxBrush *sgui_pSelectionBrush;

 static wxBrush *sgui_pActivationBrush;

 static mcStyleArray *sgui_pDefaultStyles;

 static int sgui_nAdditionalActivationSpaceLeftRight;

#endif


public:
  


 // properties which are set by the element itself and are handled by the parent

 #define mcEP_NOPROPERTIES       0

 #define mcEP_NOTIFY_PARENTSIZE_CHANGE   1

 #define mcEP_NOTIFY_NEIGHBOR_CHANGE    2

 #define mcEP_FACTOREOUT_ALLOWED     4

 #define mcEP_INITIALIZED      8


 // properties which can be set by mcElement-external functions but which must be
 // handled by the element.

 #define mcEP_HASEXPONENT       16

 #define mcEP_HASSUBSCRIPT       32

 #define mcEP_NONSTANDARD_BASE      64

 // END OF mcELEMENT PROPERTIES SECTION



public:

 mcElementHelpers();

 virtual ~mcElementHelpers() {}



 
#ifdef mcENABLE_DATA
public:


 virtual void data_AddProperty(int p, void *val1 = NULL, void *val2 = NULL) {

  // m_nProperties stores info as bit array; use OR op
  // to add properties, AND op to check if a property is set
  mdata_nProperties |= p;
 }

 virtual void data_RemoveProperty(int p) {
  mdata_nProperties &= ~p;
 }

 virtual bool data_hasProperty(int p) const {
  return ((mdata_nProperties & p) != 0);
 }





 virtual void data_AddRecursiveProperty(mcElementType t, int p, void *val1 = NULL, void *val2 = NULL);

 virtual void data_RemoveRecursiveProperty(mcElementType t, int p);

 virtual bool data_hasRecursiveProperty(mcElementType t, int p) const;



 

 virtual mcElementHelpers *data_Clone() const = 0; 

 virtual int data_GetMemoryInfo() const = 0;

 virtual mcElementType data_GetType() const = 0;





 virtual void data_DeepCopy(const mcElementHelpers *p);

 virtual bool data_isSameAs(const mcElementHelpers *) const;
 
 virtual bool data_isAllowedBefore(mcElementType type) const   { return TRUE; }
 
 virtual bool data_isAllowedAfter(mcElementType type) const   { return TRUE; }

 virtual mcElement &data_GetElemFromID(int id) const;

 virtual void data_OnNeighborChange() {
  // default implementation does nothing
 }

 virtual void data_Update();

#ifdef __MCDEBUG__
 virtual wxString data_Debug(long flags) const
  { return wxT("mcElement\n"); }
 
 virtual wxString data_GetDebugName() const
  { return wxT("mcElement"); }

#else
 // this function should be removed by the linker...
 inline wxString data_Debug(long) const 
  { return wxEmptyString; }
 inline wxString data_GetDebugName() const 
  { return wxEmptyString; }
#endif 






#ifdef __MCDEBUG__
 virtual void data_Check() const;
#else
 // this function should be removed by the linker...
 inline wxString data_Check() const { return wxEmptyString; }
#endif

 virtual int data_GetChildrenCount() const  { return 0; }

 virtual const mcElement &data_GetConstChild(int n) const;
 
 virtual mcElement &data_GetChild(int n);
 
 virtual void data_SetChild(int idx, const mcElement &newchild) {
  // non-container elements should just do nothing...
  }

 virtual int data_GetChildIdx(const mcElement &p) const;
 
 virtual bool data_AddChildrenTo(mcElement p);

 // Called by mcElement's standard functions to update the parent-child
 // relationships of member classes.
 // Override this function if you need to change parent-relationships.
 // virtual void data_UpdateParent()
 //
 // WARNING: THIS FUNCTION IS USELESS: WHEN AN OBJECT HAS MEMBER CLASSES
 //          WHICH ARE TIED TO THE ELEMENT ITSELF AS SIBLINGS OR CHILDREN,
 //          IT'S NOT REQUIRED TO UPDATE THEM... see also #m_nExpDepth






 int data_GetID() const   { return mdata_nID; }

 void data_Init();

#ifdef __MCDEBUG__
 wxString data_GetDebug(int indent, long flags) const;
#else
 // this function should be removed by the linker
 inline wxString data_GetDebug(int, long) const 
  { return wxEmptyString; }
#endif


#endif  // mcENABLE_DATA





#ifdef mcENABLE_GUI
protected:

 virtual void gui_Init();

public:


 virtual bool gui_isBeginKey(const mcKey &ev) const = 0;

 virtual bool gui_isEndKey(const mcKey &ev) const = 0;






 // functions grouped under this section belong to the
 // USER INPUT SYSTEM group

    virtual int gui_Draw(wxDC &dc, int x, int y, long flags, const wxPoint &pt) const = 0;

 virtual void gui_DoRecalcSize() = 0;

 virtual int gui_GetRelCursorPos(wxDC &dc, wxPoint *pt) const = 0;

 virtual mcMoveCursorRes gui_MoveCursor(mcMoveCursorFlag flag, long modifiers) = 0;

 virtual int gui_MoveCursorUsingPoint(wxDC &dc, const wxPoint &p) = 0;

 virtual void gui_GetCursorPos(mcCursorPos &) const = 0;

 virtual mcCursorPos gui_GetCursorPos() const
  { mcCursorPos ret; gui_GetCursorPos(ret); return ret; }

 virtual void gui_SetCursorPos(const mcCursorPos &code) = 0;

 virtual mcInputRes gui_Input(const mcKey &ev, mcElement *newelem) = 0;

 virtual mcInsertRes gui_Insert(const mcElement &toinsert, mcElement *newelem) = 0;







 virtual void gui_OnSelect(wxDC &, wxRect &rc) {
  gui_Select();
 }

 virtual mcElement gui_GetSelection() const;

 virtual void gui_DeleteSelection();

 virtual mcElement &gui_GetActiveElem(int x, int y, const wxPoint &pt) const;






 virtual void gui_SetStyleArray(const mcStyleArray *p);

 virtual void gui_OnRecalcSize(wxSize old);

 virtual void gui_OnParentSizeChange() {
  // default implementation does nothing
 }

 virtual void gui_DeepRecalcSize();

 virtual bool gui_isAllSelected() const;

 virtual void gui_SelectAll();

 virtual void gui_DeSelect();

 virtual bool gui_Split(mcElement *p)  { return FALSE; }

 virtual bool gui_MergeWith(const mcElement &) {
  return FALSE; // default implementation does nothing
 }

 virtual bool gui_isSplittable() const {
  return FALSE;
 }

 virtual void gui_Select() {

  // we don't need to do anything else: size hasn't changed
  mgui_bSelected = TRUE;
 }

 virtual bool gui_isSelected() const {
  return mgui_bSelected;
 }

 virtual bool gui_LetInCursor(mcCursorPos code) {
  gui_SetCursorPos(code);
  return TRUE;
 }

 virtual void gui_RecalcSize();

 int gui_GetExpDepth() const    { return mgui_nExpDepth; }

 virtual wxSize gui_GetSize() const  { return mgui_sz; }

 virtual int gui_GetWidth() const  { return mgui_sz.GetWidth(); }

 virtual int gui_GetHeight() const  { return mgui_sz.GetHeight(); }

 virtual wxSize gui_GetSize() {
  if (mgui_sz.GetWidth() == mgui_sz.GetHeight() && 
   mgui_sz.GetWidth() == -1)
   gui_RecalcSize();
  return mgui_sz;
 }

 virtual int gui_GetWidth() {
  if (mgui_sz.GetWidth() == -1)
   gui_RecalcSize();
  return mgui_sz.GetWidth();
 }

 virtual int gui_GetHeight() {
  if (mgui_sz.GetHeight() == -1)
   gui_RecalcSize();
  return mgui_sz.GetHeight();
 }

 virtual int gui_GetYAnchor() const {
  return gui_GetSize().GetHeight()/2;
 }





 //static int gui_GetExpDepthFromDrawFlags()  
 // { return flags & mcDRW_FLAGS_STARTBIT; }

 static void gui_InitDefaultStyles();

 static void gui_DeleteDefaultStyles();

 //static void gui_SetGlobalStyleArray(const mcStyleArray *);

 //bool SyncStyleWithParent();

 //| [...]   mcElementHelpers::sgui_GetStyle(0).[...]
 static const mcStyle *gui_GetDefaultStyle(int n);

 static double gui_GetPointSize();

 static double gui_PointSize2Pixels(double pointsize);

 static double gui_Pixels2PointSize(double pointsize);

 static wxSize gui_GetSizeOf(wxDC *dc, const wxString &str);

 static int gui_GetHeightOf(wxDC *, const wxString &); 
 static int gui_GetWidthOf(wxDC *, const wxString &);   





 virtual void gui_UpdateExpDepth();

 void gui_SetAsExpOf(const mcElement &p);

 void gui_SetAtSameLevelOf(const mcElement &p);

 void gui_SetExpDepth(int n)
  { mgui_nExpDepth = n; gui_UpdateExpDepth(); }

 const mcStyle *gui_GetStyle(int n) const;

 const mcStyleArray *gui_GetStyleArray() const
  { return mgui_pStyleArray; }

 wxSize gui_GetSizeOfChar(wxDC *dc = NULL, const mcElement &p = mcEmptyElement) const;

 int gui_GetHeightOfChar(wxDC *, const mcElement &) const; 
 int gui_GetWidthOfChar(wxDC *, const mcElement &) const;    

 const mcStyle *gui_GetStyleForThis() const;

 void gui_SelectStyle(wxDC &dc) const;

 int gui_GetThickness(wxDC *dc) const;

 int gui_GetBaseOffsety(int h) const;

 int gui_GetSubscriptOffsety(int h) const;


#endif  // mcENABLE_GUI







#ifdef mcENABLE_MATH
protected:  // utils

 virtual void math_Init() {}

 virtual mcElement math_RecursiveFind(int &n, 
    const mcElement &p, long flags) const; 

 virtual mcElement math_RecursiveFindInChildrenOnly(int &n, 
    const mcElement &p, long flags) const;


public:



 mcElement math_Find(int n, const mcElement &p, long flags = mcFIND_NOFLAGS) const;

 mcElement math_FindInChildrenOnly(int n, const mcElement &p, long flags = mcFIND_NOFLAGS) const;

 int math_NonRecursiveFindInChildren(int n, const mcElement &p, long flags = mcFIND_NOFLAGS) const;

 virtual int math_GetCountOf(const mcElement &p, long flags = mcFIND_NOFLAGS) const;

 virtual int math_GetCountOfChildrenOnly(const mcElement &p, long flags = mcFIND_NOFLAGS) const;

 virtual int math_GetCountOf(const mcSymbolProperties *sym, long flags = mcFIND_NOFLAGS) const;

 virtual int math_GetCountOf(const mcSymbolArray *arr, long flags = mcFIND_NOFLAGS) const;

 virtual int math_GetCountOfSymbolsType(const mcSymbolArray *arr, long flags = mcFIND_NOFLAGS) const;

 virtual int math_Replace(const mcElement &tofind, int n, long flags,
      const mcElement &replacement, bool bAttachChildren);

 virtual bool math_Contains(const mcElement &p, long flags = mcFIND_NOFLAGS) const;  

 //bool math_Contains(const mcElement &p, long flags = mcFIND_NOFLAGS) const;  

 bool math_ContainsOneOf(const mcSymbolArray *) const;

 virtual bool math_ContainsSymbol(const mcSymbolProperties *s, 
      const mcPolynomial &exp = mcEmptyPolynomial) const;
 virtual bool math_ContainsNumber(const mcRealValue &n, 
      const mcPolynomial &exp = mcEmptyPolynomial) const;

 virtual bool math_ContainsUnknowns() const;

 virtual bool math_ContainsConstants() const;

 virtual bool math_ContainsParameters() const;

 virtual bool math_ContainsSymbols() const;

 virtual bool math_ContainsInvalidSymbols() const;



 

 static bool math_isExpAllowed(mcElement p);
 static bool math_isSubAllowed(mcElement p);   

 virtual mcExpSimRes math_MaxSimplify(long flags);

 virtual bool math_isMaxSimplified(long flags) const;

 virtual int math_GetSymbolList(mcSymbol **, int size, const mcSymbol &tofind) const;
 virtual int math_GetSymbolList(mcSymbol **, int size, mcSymbolProperties &tofind) const;

 virtual bool math_isConstant() const;

 virtual bool math_EvaluatesTo(const mcRealValue &val) const
  { return math_Evaluate() == val; }

 virtual mcRealValue math_EvaluateAt(const mcSymbolProperties *sym, 
          const mcRealValue &symval) const;

 virtual bool math_isFinite() const;
 
 virtual mcRealValue math_GetTotalLenght() const;

 virtual void math_SimpleAdd(const mcElement &p, bool add = TRUE);
 virtual void math_SimpleSubtract(const mcElement &p) { math_SimpleAdd(p, FALSE); }
 virtual void math_SimpleMultiplyBy(const mcElement &p);
 virtual void math_SimpleDivideBy(const mcElement &p);

 void math_SimpleRaiseTo(const mcPolynomial &);

 bool math_isValidMath() const;

 virtual bool math_isListedBeforeOf(const mcElement &p) const;






 virtual mcMathType math_GetMathType() const = 0;
  
 virtual mcRealValue math_GetLenght() const = 0;
 
 virtual mcExpSimRes math_Simplify(long flags, mcElement *newelem) = 0;

 virtual mcExpSimRes math_Expand(long flags, mcElement *newelem) = 0;

 virtual bool math_Compare(const mcElement &p, long flags) const = 0;

 virtual bool math_CompareThisOnly(const mcElement &p, long flags) const;

 virtual mcRealValue math_Evaluate() const = 0;

 virtual int math_GetOrderPos() const = 0;

 virtual mcMonomial math_GetFactors() const;




 virtual bool math_CanBeAddedWith(const mcElement &p) const = 0;

 virtual bool math_CanBeMultWith(const mcElement &p) const = 0;

 virtual bool math_CanBeDivBy(const mcElement &p) const = 0;

 virtual mcBasicOpRes math_Add(const mcElement &e, mcElement *pp, bool add = TRUE) = 0;

 mcBasicOpRes math_Subtract(const mcElement &e, mcElement *pp)
  { return math_Add(e, pp, FALSE); }

 virtual mcBasicOpRes math_MultiplyBy(const mcElement &e, mcElement *pp) = 0;

 virtual mcBasicOpRes math_DivideBy(const mcElement &e, mcElement *pp) = 0;

 virtual mcMonomial math_GetLCM(const mcElement &) const = 0;
 virtual mcMonomial math_GetGCD(const mcElement &) const = 0;





 virtual mcBasicOpRes math_RaiseTo(const mcPolynomial &) = 0;

 virtual mcBasicOpRes math_MakeReciprocal(mcElement *replacement);

 virtual void math_SetExp(const mcPolynomial &); 



#endif  // mcENABLE_MATH







#ifdef mcENABLE_IO
protected:

 virtual void io_Init() {}

 virtual void io_PostProcess() {}

 virtual void io_PostProcessChildren();

public:

 virtual bool io_Init(const wxString &str);


 virtual bool io_isBeginTag(const wxXml2Node &tag) const = 0;

 virtual bool io_isBeginChar(const wxString &str) const = 0;

 virtual wxXml2Node io_GetMathML(bool bGetPresentation) const = 0;

 virtual wxString io_GetInlinedExpr() const = 0;


 virtual bool io_ImportPresentationMathML(wxXml2Node tag, wxString &pErr) = 0;

 virtual bool io_ImportInlinedExpr(const wxString &str, int *count, wxString &pErr) = 0; 


#endif  // mcENABLE_IO
};



class mcElement : public mcObject
{
protected:

 //void SetExpDepth(int n);
 
public:
   

 mcObjectRefData *data_MakePrivateCopy();

 void data_Ref(const mcObject &toclone);

 mcElementHelpers *phlp()    { return (mcElementHelpers *)data_MakePrivateCopy(); }

 const mcElementHelpers *chlp() const { return (mcElementHelpers *)data_GetRefData(); }

    bool data_isOk() const     { return (mdata_refData != NULL); }




public:

 mcElement() {}

 mcElement(const mcElementHelpers *helpers);

 virtual ~mcElement();


 // as for all mcElement-derived classes, we define through
 // macros the following functions:
 // - hlp() const      which uses chlp()
 // - hlp() non-const  which uses phlp()
 // - operator==
 // - operator!=
 mcDEFINE_HLP_GETTER(mcElement)
 mcDEFINE_COMPARISON_OPERATORS(mcElement) 


 
#ifdef mcENABLE_DATA
public:

 virtual mcElement data_Clone() const
  { return mcElement(chlp()); }
 
 virtual void data_DeepCopy(const mcElement &p) 
  { hlp()->data_DeepCopy(p.hlp()); }

 virtual mcElement data_GetNewElemLikeThis() const 
  { return mcElementHelpers::data_NewElem(data_GetType()); }

 virtual bool data_isValidContainerFor(mcElementType t) const
  { return TRUE; }

#ifdef __MCDEBUG__

 void data_CheckContainer() const;

 void data_Check() const;

 virtual wxString data_GetDebugName() const
  { return wxT("mcElement"); }

 // the wrapper for the data_GetDebug function (which 
 // is implemented by the helpers section)
 mcWRAPPER wxString data_GetDebug(int n, long f) const
  { return hlp()->data_GetDebug(n, f); } 

#else

 // these functions should be removed by the linker
 inline void data_Check() const    {}
 inline void data_CheckContainer() const  {}
 inline wxString data_GetDebug(int, long) const 
  { return wxEmptyString; }
 inline wxString data_GetDebugName(int, long) const 
  { return wxEmptyString; }

#endif  // __MCDEBUG__


 mcWRAPPER void data_AddProperty(int p, void *val1 = NULL, void *val2 = NULL) 
  { hlp()->data_AddProperty(p, val1, val2); }
 mcWRAPPER void data_RemoveProperty(int p) 
  { hlp()->data_RemoveProperty(p); }
 mcWRAPPER bool data_hasProperty(int p) const
  { return hlp()->data_hasProperty(p); }

 mcWRAPPER void data_AddRecursiveProperty(mcElementType t, int p, 
  void *val1 = NULL, void *val2 = NULL)
  { hlp()->data_AddRecursiveProperty(t, p, val1, val2); }
 mcWRAPPER void data_RemoveRecursiveProperty(mcElementType t, int p)
  { hlp()->data_RemoveRecursiveProperty(t, p); }
 mcWRAPPER bool data_hasRecursiveProperty(mcElementType t, int p) const
  { return hlp()->data_hasRecursiveProperty(t, p); } 

 mcWRAPPER int data_GetChildrenCount() const 
  { return hlp()->data_GetChildrenCount(); }
 mcWRAPPER const mcElement &data_GetConstChild(int n) const 
  { return hlp()->data_GetConstChild(n); }
 mcWRAPPER mcElement &data_GetChild(int n)
  { return hlp()->data_GetChild(n); }
 mcWRAPPER void data_SetChild(int idx, const mcElement &newchild)
  { hlp()->data_SetChild(idx, newchild); }
 mcWRAPPER int data_GetChildIdx(const mcElement &p) const
  { return hlp()->data_GetChildIdx(p); }
  mcWRAPPER bool data_AddChildrenTo(mcElement p)
  { return hlp()->data_AddChildrenTo(p); }

 mcWRAPPER bool data_isSameAs(const mcElement &p) const
  { return hlp()->data_isSameAs(p.hlp()); }
 mcWRAPPER void gui_UpdateExpDepth() 
  { hlp()->gui_UpdateExpDepth(); }

 mcWRAPPER mcElementType data_GetType() const
  { return hlp()->data_GetType(); }
 mcWRAPPER int data_GetID() const
  { return hlp()->data_GetID(); }
 mcWRAPPER int data_GetMemoryInfo() const
  { return hlp()->data_GetMemoryInfo(); }

 mcWRAPPER mcElement &data_GetElemFromID(int id) const
  { return hlp()->data_GetElemFromID(id); }

 mcWRAPPER void data_Update()
  { hlp()->data_Update(); }
 mcWRAPPER bool data_isAllowedBefore(mcElementType type) const 
   { return hlp()->data_isAllowedBefore(type); }
 mcWRAPPER bool data_isAllowedAfter(mcElementType type) const
   { return hlp()->data_isAllowedAfter(type); } 

#endif  // mcENABLE_DATA




#ifdef mcENABLE_GUI

 mcWRAPPER void gui_SetAsExpOf(const mcElement &p)
  { hlp()->gui_SetAsExpOf(p); }
 mcWRAPPER void gui_SetAtSameLevelOf(const mcElement &p)
  { hlp()->gui_SetAtSameLevelOf(p); }
 mcWRAPPER void gui_SetExpDepth(int n)
  { hlp()->gui_SetExpDepth(n); }

 mcWRAPPER bool gui_isBeginKey(const mcKey &ev) const
  { return hlp()->gui_isBeginKey(ev); } 
 mcWRAPPER bool gui_isEndKey(const mcKey &ev) const
  { return hlp()->gui_isEndKey(ev); } 
    mcWRAPPER int gui_Draw(wxDC &dc, int x, int y, long flags, const wxPoint &pt) const
  { return hlp()->gui_Draw(dc, x, y, flags, pt); } 
 mcWRAPPER int gui_GetRelCursorPos(wxDC &dc, wxPoint *pt) const
  { return hlp()->gui_GetRelCursorPos(dc, pt); } 
 mcWRAPPER void gui_GetCursorPos(mcCursorPos &cp) const
  { hlp()->gui_GetCursorPos(cp); }
 mcWRAPPER mcCursorPos gui_GetCursorPos() const
  { return hlp()->gui_GetCursorPos(); }
 mcWRAPPER mcElement gui_GetSelection() const
  { return hlp()->gui_GetSelection(); }
 mcWRAPPER bool gui_isAllSelected() const
  { return hlp()->gui_isAllSelected(); }
 mcWRAPPER bool gui_isSplittable() const
  { return hlp()->gui_isSplittable(); }
 mcWRAPPER bool gui_isSelected() const
  { return hlp()->gui_isSelected(); }


 mcWRAPPER void gui_SetStyleArray(const mcStyleArray *p)
  { hlp()->gui_SetStyleArray(p); }
 mcWRAPPER void gui_OnRecalcSize(wxSize old)
  { hlp()->gui_OnRecalcSize(old); }
 mcWRAPPER void gui_DoRecalcSize()
  { hlp()->gui_DoRecalcSize(); }
 mcWRAPPER mcInputRes gui_Input(const mcKey &ev, mcElement *newelem)
  { return hlp()->gui_Input(ev, newelem); }
 mcWRAPPER mcInsertRes gui_Insert(const mcElement &toinsert, mcElement *newelem)
  { return hlp()->gui_Insert(toinsert, newelem); }
 mcWRAPPER int gui_MoveCursorUsingPoint(wxDC &dc, const wxPoint &p)
  { return hlp()->gui_MoveCursorUsingPoint(dc, p); } 
 mcWRAPPER mcMoveCursorRes gui_MoveCursor(mcMoveCursorFlag flag, long modifiers)
  { return hlp()->gui_MoveCursor(flag, modifiers); } 
 mcWRAPPER void gui_SetCursorPos(const mcCursorPos &code)
  { hlp()->gui_SetCursorPos(code); } 


 mcWRAPPER void gui_DeleteSelection()
  { hlp()->gui_DeleteSelection(); }

 mcWRAPPER mcElement &gui_GetActiveElem(int x, int y, const wxPoint &pt) const
  { return hlp()->gui_GetActiveElem(x, y, pt); }

 mcWRAPPER void gui_DeepRecalcSize()
  { hlp()->gui_DeepRecalcSize(); }

 mcWRAPPER void gui_SelectAll()
  { hlp()->gui_SelectAll(); }
 mcWRAPPER void gui_DeSelect()
  { hlp()->gui_DeSelect(); }
 mcWRAPPER void gui_Select()
  { hlp()->gui_Select(); }
 mcWRAPPER void gui_OnSelect(wxDC &dc, wxRect &rc)
  { hlp()->gui_OnSelect(dc, rc); }

 mcWRAPPER bool gui_Split(mcElement *p)  
  { return hlp()->gui_Split(p); }
 mcWRAPPER bool gui_MergeWith(const mcElement &p)
  { return hlp()->gui_MergeWith(p); }

 mcWRAPPER bool gui_LetInCursor(mcCursorPos code)
  { return hlp()->gui_LetInCursor(code); }

 mcWRAPPER void gui_RecalcSize()
  { hlp()->gui_RecalcSize(); }
 mcWRAPPER wxSize gui_GetSize() const  
  { return hlp()->gui_GetSize(); }
 mcWRAPPER int gui_GetWidth() const  
  { return hlp()->gui_GetWidth(); }
 mcWRAPPER int gui_GetHeight() const  
  { return hlp()->gui_GetHeight(); }

 /*wxSize gui_GetSize()
 mcWRAPPER int gui_GetWidth()
 mcWRAPPER int gui_GetHeight()*/
 mcWRAPPER int gui_GetExpDepth() const
  { return hlp()->gui_GetExpDepth(); }

 mcWRAPPER int gui_GetYAnchor() const
  { return hlp()->gui_GetYAnchor(); }

 mcWRAPPER const mcStyle *gui_GetStyle(int n) const
  { return hlp()->gui_GetStyle(n); }

 mcWRAPPER wxSize gui_GetSizeOfChar(wxDC *dc = NULL, 
   const mcElement &p = mcEmptyElement) const
  { return hlp()->gui_GetSizeOfChar(dc, p); }

 mcWRAPPER int gui_GetHeightOfChar(wxDC *dc, const mcElement &p) const 
  { return hlp()->gui_GetHeightOfChar(dc, p); }
 mcWRAPPER int gui_GetWidthOfChar(wxDC *dc, const mcElement &p) const    
  { return hlp()->gui_GetWidthOfChar(dc, p); }

 mcWRAPPER const mcStyle *gui_GetStyleForThis() const
  { return hlp()->gui_GetStyleForThis(); }

 mcWRAPPER void gui_SelectStyle(wxDC &dc) const
  { hlp()->gui_SelectStyle(dc); }
 mcWRAPPER int gui_GetThickness(wxDC *dc) const
  { return hlp()->gui_GetThickness(dc); }
 mcWRAPPER int gui_GetBaseOffsety(int h) const
  { return hlp()->gui_GetBaseOffsety(h); }
 mcWRAPPER int gui_GetSubscriptOffsety(int h) const
  { return hlp()->gui_GetSubscriptOffsety(h); }

#endif  // mcENABLE_GUI




#ifdef mcENABLE_MATH
public:

 mcWRAPPER mcElement math_Find(int n, const mcElement &p, long flags = mcFIND_NOFLAGS) const
  { return hlp()->math_Find(n, p, flags); }
 mcWRAPPER mcElement math_FindInChildrenOnly(int n, const mcElement &p, long flags = mcFIND_NOFLAGS) const
  { return hlp()->math_FindInChildrenOnly(n, p, flags); }
 mcWRAPPER int math_NonRecursiveFindInChildren(int n, const mcElement &p, long flags = mcFIND_NOFLAGS) const
  { return hlp()->math_NonRecursiveFindInChildren(n, p, flags); }
 mcWRAPPER int math_GetCountOf(const mcElement &p, long flags = mcFIND_NOFLAGS) const
  { return hlp()->math_GetCountOf(p, flags); }
 mcWRAPPER int math_GetCountOfChildrenOnly(const mcElement &p, long flags = mcFIND_NOFLAGS) const
  { return hlp()->math_GetCountOfChildrenOnly(p, flags); }
 mcWRAPPER int math_Replace(const mcElement &tofind, int n, long flags,
      const mcElement &replacement, bool bAttachChildren)
  { return hlp()->math_Replace(tofind, n, flags, replacement, bAttachChildren); }

 mcWRAPPER int math_GetCountOf(const mcSymbolProperties *sym, long flags = mcFIND_NOFLAGS) const
  { return hlp()->math_GetCountOf(sym, flags); }
 mcWRAPPER int math_GetCountOf(const mcSymbolArray *arr, long flags = mcFIND_NOFLAGS) const
  { return hlp()->math_GetCountOf(arr, flags); }
 mcWRAPPER int math_GetCountOfSymbolsType(const mcSymbolArray *arr, long flags = mcFIND_NOFLAGS) const
  { return hlp()->math_GetCountOfSymbolsType(arr, flags); }


 mcWRAPPER bool math_Contains(const mcElement &p, long flags = mcFIND_NOFLAGS) const  
  { return hlp()->math_Contains(p, flags); }
 mcWRAPPER bool math_ContainsOneOf(const mcSymbolArray *arr) const
  { return hlp()->math_ContainsOneOf(arr); }

 mcWRAPPER bool math_ContainsSymbol(const mcSymbolProperties *p, 
       const mcPolynomial &exp = mcEmptyPolynomial) const
  { return hlp()->math_ContainsSymbol(p, exp); }
 mcWRAPPER bool math_ContainsNumber(const mcRealValue &n, 
       const mcPolynomial &exp = mcEmptyPolynomial) const
  { return hlp()->math_ContainsNumber(n, exp); }

 mcWRAPPER bool math_ContainsUnknowns() const
  { return hlp()->math_ContainsUnknowns(); }
 mcWRAPPER bool math_ContainsConstants() const
  { return hlp()->math_ContainsConstants(); }
 mcWRAPPER bool math_ContainsParameters() const
  { return hlp()->math_ContainsParameters(); }
 mcWRAPPER bool math_ContainsSymbols() const
  { return hlp()->math_ContainsSymbols(); }
 mcWRAPPER bool math_ContainsInvalidSymbols() const
  { return hlp()->math_ContainsInvalidSymbols(); }

 mcWRAPPER mcExpSimRes math_MaxSimplify(long flags)
  { return hlp()->math_MaxSimplify(flags); }

 mcWRAPPER bool math_isMaxSimplified(long flags) const
  { return hlp()->math_isMaxSimplified(flags); }

 mcWRAPPER int math_GetSymbolList(mcSymbol **arr, int size, const mcSymbol &tofind) const
  { return hlp()->math_GetSymbolList(arr, size, tofind); }
 mcWRAPPER int math_GetSymbolList(mcSymbol **arr, int size, mcSymbolProperties &tofind) const
  { return hlp()->math_GetSymbolList(arr, size, tofind); }

 mcWRAPPER bool math_isConstant() const
  { return hlp()->math_isConstant(); }

 mcWRAPPER bool math_EvaluatesTo(const mcRealValue &val) const  
  { return hlp()->math_EvaluatesTo(val); }

 mcWRAPPER bool math_isFinite() const
  { return hlp()->math_isFinite(); }

 mcWRAPPER mcBasicOpRes math_RaiseTo(const mcPolynomial &p)
  { return hlp()->math_RaiseTo(p); }
 mcWRAPPER mcBasicOpRes math_MakeReciprocal(mcElement *p)
  { return hlp()->math_MakeReciprocal(p); }
 mcWRAPPER void math_SetExp(const mcPolynomial &p)
  { hlp()->math_SetExp(p); }


 mcWRAPPER mcRealValue math_GetTotalLenght() const
  { return hlp()->math_GetTotalLenght(); }

 mcWRAPPER void math_SimpleAdd(const mcElement &p, bool add = TRUE)
  { hlp()->math_SimpleAdd(p, add); }
 mcWRAPPER void math_SimpleSubtract(const mcElement &p)  
  { hlp()->math_SimpleSubtract(p); }
 mcWRAPPER void math_SimpleMultiplyBy(const mcElement &p)
  { hlp()->math_SimpleMultiplyBy(p); }
 mcWRAPPER void math_SimpleDivideBy(const mcElement &p)
  { hlp()->math_SimpleDivideBy(p); }
 mcWRAPPER void math_SimpleRaiseTo(const mcPolynomial &pol)
  { hlp()->math_SimpleRaiseTo(pol); }

 mcWRAPPER bool math_isValidMath() const
  { return hlp()->math_isValidMath(); }

 mcWRAPPER bool math_isListedBeforeOf(const mcElement &p) const
  { return hlp()->math_isListedBeforeOf(p); }

 mcWRAPPER mcMathType math_GetMathType() const
  { return hlp()->math_GetMathType(); }
 mcWRAPPER mcRealValue math_GetLenght() const
  { return hlp()->math_GetLenght(); }

 mcWRAPPER mcExpSimRes math_Simplify(long flags, mcElement *newelem)
  { return hlp()->math_Simplify(flags, newelem); }
 mcWRAPPER mcExpSimRes math_Expand(long flags, mcElement *newelem)
  { return hlp()->math_Expand(flags, newelem); }

 mcWRAPPER bool math_Compare(const mcElement &p, long flags) const
  { return hlp()->math_Compare(p, flags); }
 mcWRAPPER bool math_CompareThisOnly(const mcElement &p, long flags) const
  { return hlp()->math_CompareThisOnly(p, flags); }

 mcWRAPPER mcRealValue math_Evaluate() const
  { return hlp()->math_Evaluate(); }
 mcWRAPPER mcRealValue math_EvaluateAt(const mcSymbolProperties *sym, 
           const mcRealValue &symvalue) const
  { return hlp()->math_EvaluateAt(sym, symvalue); }

 mcWRAPPER int math_GetOrderPos() const
  { return hlp()->math_GetOrderPos(); }

// mcPolynomial math_GetFactors() const
//  { return hlp()->math_GetFactors(); }

 mcWRAPPER bool math_CanBeAddedWith(const mcElement &p) const
  { return hlp()->math_CanBeAddedWith(p); }
 mcWRAPPER bool math_CanBeMultWith(const mcElement &p) const
  { return hlp()->math_CanBeMultWith(p); }
 mcWRAPPER bool math_CanBeDivBy(const mcElement &p) const
  { return hlp()->math_CanBeDivBy(p); }

 mcWRAPPER mcBasicOpRes math_Add(const mcElement &e, mcElement *pp, bool add = TRUE)
  { return hlp()->math_Add(e, pp, add); }
 mcWRAPPER mcBasicOpRes math_Subtract(const mcElement &e, mcElement *pp) 
  { return hlp()->math_Subtract(e, pp); }
 mcWRAPPER mcBasicOpRes math_MultiplyBy(const mcElement &e, mcElement *pp)
  { return hlp()->math_MultiplyBy(e, pp); }
 mcWRAPPER mcBasicOpRes math_DivideBy(const mcElement &e, mcElement *pp)
  { return hlp()->math_DivideBy(e, pp); }

 // the implementation of these two must be in the source file
 // and thus they cannot be inlined...
 mcMonomial math_GetLCM(const mcElement &p) const;
 mcMonomial math_GetGCD(const mcElement &p) const;
 mcMonomial math_GetFactors() const;

 mcElement operator*(const mcElement &m) const
 { mcElement ret(*this); ret.math_SimpleMultiplyBy(m); return ret; }
 mcElement operator/(const mcElement &m) const
 { mcElement ret(*this); ret.math_SimpleDivideBy(m); return ret; }
 mcElement operator-(const mcElement &m) const
 { mcElement ret(*this); ret.math_SimpleSubtract(m); return ret; }
 mcElement operator+(const mcElement &m) const
 { mcElement ret(*this); ret.math_SimpleAdd(m); return ret; }

 mcElement operator^(const mcPolynomial &m) const
 { mcElement ret(*this); ret.math_RaiseTo(m); return ret; }

 // this operator cannot be inlined...
 mcElement operator^(const mcRealValue &m) const;


 // these operators return references

 mcElement &operator^=(const mcPolynomial &m)
 { *this = (*this)^m;return *this; }
 mcElement &operator^=(const mcRealValue &m)
 { *this = (*this)^m;return *this; }

 mcElement &operator+=(const mcElement &m)  { *this = *this+m;return *this; }
 mcElement &operator-=(const mcElement &m)  { *this = *this-m;return *this; }
 mcElement &operator*=(const mcElement &m)  { *this = *this*m;return *this; }
 mcElement &operator/=(const mcElement &m)  { *this = *this/m;return *this; }

#endif  // mcENABLE_MATH


#ifdef mcENABLE_IO
public:

 mcWRAPPER bool io_isBeginTag(const wxXml2Node &tag) const
  { return hlp()->io_isBeginTag(tag); }
 mcWRAPPER bool io_isBeginChar(const wxString &str) const
  { return hlp()->io_isBeginChar(str); }

 mcWRAPPER wxXml2Node io_GetMathML(bool bGetPresentation) const
  { return hlp()->io_GetMathML(bGetPresentation); }

 mcWRAPPER wxString io_GetInlinedExpr() const
  { return hlp()->io_GetInlinedExpr(); }

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

#endif  // mcENABLE_IO
};


#endif // ELEMENT_H

---

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

[ Top ]