Main page

---

ExpElement.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 EXPELEMENT_H
#define EXPELEMENT_H

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

// required includes
#include "mc/Element.h"
#include "mc/Polynomial.h"
#include "mc/Text.h"


// this defines all the classes declared in this header file
mcDEFINE_HELPER_CLASSES(mcExpElement)





enum mcExpElemCursorLocation {

 mcECL_EXPONENTBEGIN,

 mcECL_INSIDEEXPONENT,
 
 mcECL_EXPONENTEND,

 mcECL_SUBSCRIPTBEGIN,

 mcECL_INSIDESUBSCRIPT,

 mcECL_SUBSCRIPTEND,

 mcECL_INSIDEBASE
};



#define mcECL_NOTINSIDEEXPONENT  0x77777777

#define mcECL_NOTINSIDESUBSCRIPT 0x88888888





inline int mcEP_HAS(bool exp)
{ return (exp ? mcEP_HASEXPONENT : mcEP_HASSUBSCRIPT); }

inline mcExpElemCursorLocation mcECL_BEGIN(bool exp)
{ return (exp ? mcECL_EXPONENTBEGIN : mcECL_SUBSCRIPTBEGIN); }

inline mcExpElemCursorLocation mcECL_INSIDE(bool exp)
{ return (exp ? mcECL_INSIDEEXPONENT : mcECL_INSIDESUBSCRIPT); }

inline mcExpElemCursorLocation mcECL_END(bool exp)
{ return (exp ? mcECL_EXPONENTEND : mcECL_SUBSCRIPTEND); }

inline mcKey *mcGetEditKey(bool exp)
{ return (exp ? mcMathCore::Get()->m_pEditExpKey : 
   mcMathCore::Get()->m_pEditSubscriptKey); }

inline int mcNotInside(bool exp)
{ return (exp ? mcECL_NOTINSIDEEXPONENT : mcECL_NOTINSIDESUBSCRIPT); }









class mcExpElementHelpers : public mcElementHelpers
{
#ifdef mcENABLE_DATA
protected:  // DATA variables

 mcElement mdata_pExp;

 mcElement mdata_pSub;

 bool mdata_bExpEnabled;

 bool mdata_bSubEnabled;

#endif


#ifdef mcENABLE_GUI
protected:  // GUI variables

 bool mgui_bExpRight;

 bool mgui_bSubRight;
 
 wxSize mgui_szBase;

 //int mgui_nCursorPos;
 mcExpElemCursorLocation mgui_nCursorLoc;

#endif


#ifdef mcENABLE_MATH
public:   // customizable variables

 static bool smath_bConvertToRadicalWhenPossible;

#endif


public:

 mcExpElementHelpers() : mdata_pExp(NULL), mdata_pSub(NULL) {  
  // exponent & subscribt do not exist yet...
  mdata_bExpEnabled = mdata_bSubEnabled = TRUE;
 }

 virtual ~mcExpElementHelpers() {
  data_DestroyExpSub(TRUE);
  data_DestroyExpSub(FALSE);
 }

protected:

 void gui_Init() {
  mcElementHelpers::gui_Init();

  // this value can be changed by derived classes' constructors
  mgui_nCursorLoc = mcECL_INSIDEBASE;  // default: not inside exponent nor subscript
  mgui_bExpRight = mgui_bSubRight = TRUE;
 }




#ifdef mcENABLE_DATA
public:

#ifdef __MCDEBUG__

 void data_Check() const;

 virtual wxString data_Debug(long flags) const;

 virtual wxString data_BaseDebug(long flags) const  { return wxT("invalid"); }
 
 wxString data_ExpDebug(long flags) const;

 wxString data_SubDebug(long flags) const;

#endif

 int data_GetChildrenCount() const {
  int b1 = data_GetExp() != NULL;
  int b2 = data_GetSub() != NULL;
  return mcElementHelpers::data_GetChildrenCount() + b1 + b2;
 }

 const mcElement &data_GetConstChild(int n) const {
  mcRETURN_ELEMENT_CHILD(n, mcElementHelpers);
  bool b1 = data_GetExp() != NULL;
  bool b2 = data_GetSub() != NULL;
  
  if (b1 && n == 0)
   return data_GetExp();
  if (b2 && (n == 0 || n == 1))
   return data_GetSub();

  return mcEmptyElement;
 }
 
 void data_SetChild(int n, const mcElement &newchild) {
  mcSET_ELEMENT_CHILD(n, mcElementHelpers, newchild);
  bool b1 = data_GetExp() != NULL;
  bool b2 = data_GetSub() != NULL;

  if (b1 && n == 0)
   data_SetExpSub(TRUE, newchild);
  if (b2 && (n == 0 || n == 1))
   data_SetExpSub(FALSE, newchild);
  }


 void data_DeepCopy(const mcElementHelpers *p);

 void data_DeepCopyExpSub(bool exp, const mcExpElementHelpers *);
 
 virtual void data_CreateExpSub(bool exp);
 
 virtual void data_DestroyExpSub(bool exp);

 mcElement &data_GetExp()        { return mdata_pExp; }
 const mcElement &data_GetExp() const     { return mdata_pExp; }

 mcElement &data_GetSub()        { return mdata_pSub; } 
 const mcElement &data_GetSub() const     { return mdata_pSub; } 

 mcElement &data_Get(bool bExp)
  { return (bExp ? mdata_pExp : mdata_pSub); }
 const mcElement &data_Get(bool bExp) const
  { return (bExp ? mdata_pExp : mdata_pSub); }

 virtual void data_SetExpSub(bool exp, const mcElement &p);

#endif  // mcENABLE_DATA





#ifdef mcENABLE_GUI
public:


 bool gui_isExpSubEndKey(bool, const mcKey &) const;
 //bool gui_isSubEndKey(const mcKey &) const;  //!< See #gui_isExpEndKey

 bool gui_isExpSubEndKeyHelper(bool exp, const mcKey &ev) const;
 
 int gui_ExpSubDraw(bool, wxDC &, int, int, long flags, const wxPoint &) const;
 //int gui_DrawSub(wxDC &, int, int, long flags, const wxPoint &) const;  //!< See #gui_DrawExp.
 
 /*wxSize gui_GetExpSize();
 wxSize gui_GetSubSize();   //!< See #gui_GetExpSize.
 wxSize gui_GetExpSize() const;
 wxSize gui_GetSubSize() const;*/
 wxSize gui_GetExpSubSize(bool);
 wxSize gui_GetExpSubSize(bool) const;
 
 void gui_RecalcExpSubSize(bool);
 //void gui_RecalcSubSize();     //!< See #gui_RecalcExpSize.
 
 virtual int gui_GetExpSubOffsety(bool) const;
 
 //virtual int gui_GetSubOffsety() const;

 virtual int gui_GetExpSubOffsetx(bool) const;
 //virtual int gui_GetSubOffsetx() const;     //!< See #gui_GetExpOffsetx.
 
 virtual int gui_GetExpSubRelCursorPos(bool, wxDC &, wxPoint *) const;
 //virtual int gui_GetSubRelCursorPos(wxDC &, wxPoint *) const;  //!< See #gui_GetExpRelCursorPos.
 
 virtual mcMoveCursorRes gui_ExpSubMoveCursor(bool, mcMoveCursorFlag, long);
 //virtual mcMoveCursorRes gui_SubMoveCursor(mcMoveCursorFlag, long); //!< See #gui_ExpMoveCursor.

 int gui_ExpSubMoveCursorUsingPoint(bool, wxDC &dc, const wxPoint &p);
 //int gui_SubMoveCursorUsingPoint(wxDC &dc, const wxPoint &p);
 
 void gui_GetExpSubCursorPos(bool, mcCursorPos &) const; 
 //void gui_GetSubCursorPos(mcCursorPos &) const;   //!< See #gui_GetExpCursorPos.
 
 void gui_SetExpSubCursorPos(bool, const mcCursorPos &code);

 //void gui_SetSubCursorPos(mcCursorPos code);
 
 virtual mcInputRes gui_ExpSubInput(bool, const mcKey &ev, mcElement *pnew);
 //virtual mcInputRes gui_SubInput(const mcKey &ev, mcElement *pnew); //!< See #gui_ExpInput.
 
 void gui_EditExpSub(bool);
 //void gui_EditSub();    //!< See #gui_EditExp().
 
 void gui_DeleteExpSub(bool);
 //void gui_DeleteSub();   //!< See #gui_DeleteExp.
 
 virtual void gui_CheckExpSub(bool);
 //virtual void gui_CheckSub();   //!< See #gui_CheckExp.

 virtual void gui_CreateExpSub(bool);
 




 
 virtual bool gui_isBaseEndKey(const mcKey &ev) const = 0;
 
 virtual int gui_DrawBase(wxDC &dc, int x, int y, long flags, 
        const wxPoint &pt) const = 0;
 
 virtual void gui_DoRecalcBaseSize() = 0;
 
 virtual void gui_SetBaseCursorPos(const mcCursorPos &) = 0;
 
 virtual void gui_EditBase() = 0;
 
 virtual void gui_EditBaseAndSetPos(const mcCursorPos &cp);
 
 virtual void gui_GetBaseCursorPos(mcCursorPos &) const = 0;

 virtual mcCursorPos gui_GetBaseCursorPos() const
  { mcCursorPos ret; gui_GetBaseCursorPos(ret); return ret; }
 
 virtual mcInputRes gui_BaseInput(const mcKey &ev, mcElement *pnew) = 0;
 
 virtual mcInsertRes gui_BaseInsert(const mcElement &, mcElement *) = 0;

 virtual mcMoveCursorRes gui_BaseMoveCursor(mcMoveCursorFlag, long modifiers) = 0; 

 virtual int gui_BaseMoveCursorUsingPoint(wxDC &, const wxPoint &) = 0;
 
 virtual int gui_GetBaseRelCursorPos(wxDC &, wxPoint *) const = 0;

 virtual bool gui_DrawAsActiveOverBase() const = 0;

 virtual int gui_GetBaseOffsety() const;

 virtual int gui_GetBaseOffsetx() const;
  
 virtual wxSize gui_GetBaseSize() { 
  if (mgui_szBase.GetWidth() == 0)
   gui_DoRecalcBaseSize();
  return mgui_szBase;
 }

 virtual wxSize gui_GetBaseSize() const  { return mgui_szBase; }

 virtual void gui_OnBaseSelect(wxDC &dc, wxRect &rc) {
  gui_SelectAll();
 }

 virtual bool gui_hasBaseSthOnRightSide() const;

 virtual bool gui_hasBaseSthOnLeftSide() const;

 virtual bool gui_isOnRight(bool exp) const
  { return (exp ? mgui_bExpRight : mgui_bSubRight); }

 virtual mcElement gui_GetBaseSelection() const
  { return mcEmptyElement; }

 





 int gui_HandleSubExpEditKeys(const mcKey &ev);

 wxSize gui_GetBaseAndSubSize() const;
 
 virtual void gui_DrawNonActive(wxDC &dc, wxPoint &base, 
         wxPoint &exp, wxPoint &sub) const;
 
 virtual void gui_DrawActivationRect(wxDC &dc, int x, int y) const;

 virtual void gui_DrawAllActive(wxDC &dc, wxPoint &orig, wxPoint &base, 
  wxPoint &exp, wxPoint &sub) const;
 
 bool gui_isCursorInExpSub(bool, bool bCheckBeginEndExp = TRUE) const;

 //bool gui_isCursorInSub(bool bCheckBeginEndExp = TRUE) const;

 bool gui_isCursorInBase() const;







 virtual mcMoveCursorRes gui_MoveCursor(mcMoveCursorFlag flag, long modifiers);
 virtual mcInputRes gui_Input(const mcKey &ev, mcElement *newelem);
 virtual mcInsertRes gui_Insert(const mcElement &, mcElement *);
 virtual void gui_GetCursorPos(mcCursorPos &) const;

 virtual void gui_OnSelect(wxDC &dc, wxRect &rc); 
 virtual void gui_SetCursorPos(const mcCursorPos &code);
 virtual void gui_DoRecalcSize();
 virtual void gui_UpdateExpDepth();

 virtual int gui_Draw(wxDC &dc, int x, int y, long flags, const wxPoint &pt) const;
 virtual int gui_GetRelCursorPos(wxDC &dc, wxPoint *pt) const;
 virtual int gui_MoveCursorUsingPoint(wxDC &dc, const wxPoint &p);
 virtual int gui_GetYAnchor() const;

 virtual bool gui_isEndKey(const mcKey &ev) const;
 virtual mcElement gui_GetSelection() const;


#endif  // mcENABLE_GUI





#ifdef mcENABLE_MATH
protected:

 mcExpSimRes math_SimplifyExp(long flags, mcElement *);

public:

 bool math_hasExp() const;
 bool math_hasSub() const;



 const mcPolynomial &math_GetConstExp() const;
 mcPolynomial &math_GetExp();
 const mcPolynomial &math_GetExp() const
  { return math_GetConstExp(); } 

 
 mcText &math_GetSub() const
  { return (mcText &)(data_GetSub()); }
 const mcText &math_GetConstSub() const;  


 void math_SetExp(const mcPolynomial &pol)
  { data_SetExpSub(TRUE, pol); }

 mcBasicOpRes math_RaiseTo(const mcPolynomial &p);

 mcRealValue math_EvaluateExp() const;
 bool math_CompareExp(const mcExpElement &, long flags) const;
 bool math_CompareSub(const mcExpElement &, long flags) const;
 mcBasicOpRes math_MultOrDiv(const mcElement &, mcElement *, bool mult);
 
 


 //virtual //bool hasSameContentOf(const mcElement &) const;
 virtual bool math_Compare(const mcElement &p, long flags) const;
 
 mcRealValue math_GetLenght() const 
  { mcRealValue l=math_GetBaseLenght(); return (math_hasExp() ? l+0.5 : l); }
 
 virtual mcRealValue math_Evaluate() const;
 virtual mcBasicOpRes math_MakeReciprocal(mcElement *);

 virtual mcBasicOpRes math_MultiplyBy(const mcElement &, mcElement *);
 virtual mcBasicOpRes math_DivideBy(const mcElement &, mcElement *);
 
 virtual mcExpSimRes math_Simplify(long flags, mcElement *newelem);
 virtual mcExpSimRes math_Expand(long flags, mcElement *newelem);

 virtual mcMathType math_GetMathType() const;




 
 virtual mcMathType math_GetBaseMathType() const = 0;

 virtual mcRealValue math_GetBaseLenght() const { return 0; }
 virtual mcRealValue math_EvaluateBase() const = 0;

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

 virtual mcExpSimRes math_SimplifyBase(long flags, mcElement *newelem) = 0;
 virtual mcExpSimRes math_SimplifyBaseExp(long flags, mcElement *pnew) { return mcESR_DONE; }

 virtual mcBasicOpRes math_MultiplyBaseOnlyBy(const mcElement &, mcElement *) = 0;
 virtual mcBasicOpRes math_DivideBaseOnlyBy(const mcElement &, mcElement *) = 0;

 virtual mcBasicOpRes math_MultiplyBaseBy(const mcElement &, mcElement *)
  { return mcBOR_REMOVE_OPERAND; }
 virtual mcBasicOpRes math_DivideBaseBy(const mcElement &, mcElement *) 
  { return mcBOR_REMOVE_OPERAND; }

 mcMonomial math_GetLCM(const mcElement &) const;
 mcMonomial math_GetGCD(const mcElement &) const;

 virtual mcMonomial math_GetBaseLCM(const mcElement &p) const;
 virtual mcMonomial math_GetBaseGCD(const mcElement &p) const;



#endif  // mcENABLE_MATH




#ifdef mcENABLE_IO
public:

 virtual wxXml2Node io_GetBaseMathML(bool bGetPresentation) const = 0;

 virtual wxXml2Node io_GetMathML(bool bGetPresentation) const;

 virtual wxString io_GetInlinedExpr() const;
 virtual wxString io_GetBaseInlinedExpr() const = 0;
 
 /*virtual void GetContentMathML(wxXml2Node *pTag) {
  
  // if an exponent is present, create a POWER section
  if (data_mdata_pExp != NULL && this->data_hasProperty(mcEP_HASEXPONENT)) {
   
   wxXml2Node *base = new wxXml2Node(), *exp = new wxXml2Node();
   
   // save base and exponent Math ML
   GetBaseContentMathML(base);
   data_mdata_pExp.io_GetMathML(exp);
   
   // concatenate all the string
   dest += wxString(wxT(' '), indent) + wxT("<apply>\n") + wxString(wxT(' '), indent+mcMathCore::Get()->m_nIndentationStep) + 
    wxT("<power/>\n") + base + exp + wxString(wxT(' '), indent) + wxT("</apply>\n");
   
   return dest;
  }
  
  // we don't need to create a MSUP tag
  return GetBaseContentMathML(indent);
 }*/
 static bool io_ImportExpSub(const wxString &str, int *count, wxString &pErr);

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

 static void io_GetExpSubInlinedToken(wxString &subexp);

#endif  // mcENABLE_IO
};


class mcExpElement : public mcElement
{
 mcDEFINE_ABSTRACT_CLASS(ExpElement, mcElement);

public:

 bool data_isValidContainerFor(mcElementType t) const
  { return t == mcET_SYMBOL || t == mcET_NUMBER ||
    t == mcET_FUNCTION || t == mcET_BRACKET ||
    t == mcET_RADICAL; }

#ifdef mcENABLE_DATA
public:

 mcWRAPPER mcElement &data_GetExp()     { return hlp()->data_GetExp(); }
 mcWRAPPER const mcElement &data_GetExp() const  { return hlp()->data_GetExp(); }

 mcWRAPPER mcElement &data_GetSub()     { return hlp()->data_GetSub(); } 
 mcWRAPPER const mcElement &data_GetSub() const  { return hlp()->data_GetSub(); } 
 
 mcWRAPPER void data_SetExpSub(bool exp, const mcElement &p)
  { hlp()->data_SetExpSub(exp, p); }
 mcWRAPPER void data_DestroyExpSub(bool exp)
  { hlp()->data_DestroyExpSub(exp); }
 mcWRAPPER void data_CreateExpSub(bool exp)
  { hlp()->data_CreateExpSub(exp); }

#endif


#ifdef mcENABLE_MATH
public:

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

 mcWRAPPER mcPolynomial &math_GetExp()
  { return hlp()->math_GetExp(); }
 mcWRAPPER const mcPolynomial &math_GetConstExp() const
  { return hlp()->math_GetConstExp(); }

 mcWRAPPER mcText &math_GetSub() 
  { return hlp()->math_GetSub(); }
 mcWRAPPER const mcText &math_GetSub() const 
  { return hlp()->math_GetSub(); }
#endif
};


#endif // EXPELEMENT_H

---

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

[ Top ]