Main page

---

ElementArray.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 ELEMENTARRAY_H
#define ELEMENTARRAY_H

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

// required includes
#include "mc/Element.h"
#include "mc/MathCore.h"
#include "mc/Operator.h"


// defined later
class mcElementArrayHelpers;
class mcMonomial;
class mcFraction;
class mcBracket;
class mcNumber;


#define mcELEMENTARRAY_DEFAULT_ROOM   4

#define mcELEMENTARRAY_EMPTYENTRY   ((mcElement )0xFFFFFFFF)

#define mcEP_ELEMENTARRAY_FILTER   mcEP_NONSTANDARD_BASE*2

#define mcFILTER_NO_INSTANCES_LIMIT   -1




class mcArrayEntry : public mcDataHelper 
{
public:

 int mdata_idx;

 const mcElementArrayHelpers *mdata_arr;

public:

 mcArrayEntry(const mcElementArrayHelpers *owner = NULL, int idx = -1) 
  : mdata_arr(owner) { mdata_idx=idx; }

 virtual ~mcArrayEntry() {}



 
 mcElement &data_GetRef() const;

 int data_GetIdx() const;
 int math_GetIdx() const;

 mcBracket &data_GetBracket() const  { return (mcBracket &)data_GetRef(); }
 mcFraction &data_GetFraction() const { return (mcFraction &)data_GetRef(); } 

 bool data_isValid() const
  { return (mdata_arr != NULL) && (mdata_idx != -1); }




 void data_SetOwner(mcElementArrayHelpers *ref) { mdata_arr = ref; }
 void data_SetIdx(int idx)      { mdata_idx = idx; }

};


// a global instance of the mcArrayEntry class
extern mcArrayEntry mcEmptyArrayEntry;


class mcFilter : public mcDataHelper
{
protected:

 mcFilterType m_nType;

 int m_nMaxInstances[mcNUM_ELEMENT_TYPES];

public:

 mcFilter(mcFilterType type = mcFILTER_INCLUDE_ELEMENT_LIST, 
  mcElementType t1 = mcET_INVALID, int count1 = -1);
 virtual ~mcFilter() {}

 void DeepCopy(const mcFilter *f) {
  for (int i=0; i < mcNUM_ELEMENT_TYPES; i++)   
   m_nMaxInstances[i] = f->m_nMaxInstances[i];  

  m_nType = f->m_nType;
 }




 void SetMaxInstancesFor(mcElementType t, 
  int count = mcFILTER_NO_INSTANCES_LIMIT);

 void math_AddAllowedMathData() {}

 void SetFilterType(mcFilterType type) {
  m_nType = type;
 }





 bool isElementTypeAllowed(mcElementType t, int num);

};





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





class mcElementArrayHelpers : public mcElementHelpers
{
 friend class mcArrayEntry;

#ifdef mcENABLE_DATA
private:  // DATA variables

 mcElement *mdata_pElemArray;
 
 int mdata_nUpperBound;
 
protected:

 int mdata_nElements;

 mcFilter *mdata_pFilter;

#endif




#ifdef mcENABLE_GUI
protected:  // GUI variables

 int mgui_nCursorPos; 


public:    // customizable variables getters

 static wxPen *sgui_pSelectionPen;

 static bool sgui_bDrawSelectionInverting;

 virtual int gui_GetSpaceBetweenRatio() const 
  { return 0; }

#ifdef mcELEMENTARRAY_DRAW_DECORATIONS

 static wxBitmap *pBeginTriBmp, *pEndTriBmp;
#endif

#endif




public:

 mcElementArrayHelpers() {

  // array is empty and still not allocated
  mdata_nElements = mdata_nUpperBound = 0; 
  mdata_pElemArray = NULL;
  mdata_pFilter = NULL;
  mgui_nCursorPos = 0;
 }

 virtual ~mcElementArrayHelpers() {
  data_DeleteAll();
  mcSAFE_DELETE_ARRAY(mdata_pElemArray);  
  mcSAFE_DELETE(mdata_pFilter);
 }


protected:
 
 void gui_Init()  { mcElementHelpers::gui_Init(); mgui_nCursorPos = 0; }



#ifdef mcENABLE_DATA
protected:

 virtual int data_GetIdxFromEntry(const mcArrayEntry *p) const = 0;
 virtual mcElement &data_GetRefFromEntry(const mcArrayEntry *p) = 0;
 
public:


#ifdef __MCDEBUG__

 void data_Check() const;

 wxString data_Debug(long flags) const;

 wxString data_GetDebugName() const
  { return wxT("mcElementArray"); }

#endif

 void data_DeepCopy(const mcElementHelpers *p);

 void data_AddProperty(int p, void *val1 = NULL, void *val2 = NULL) {
  if (p == mcEP_ELEMENTARRAY_FILTER)
   data_ChangeFilter((const mcFilter *)val1);
 }

 int data_GetChildrenCount() const {
  return mcElementHelpers::data_GetChildrenCount()+data_GetCount();
 }

 const mcElement &data_GetConstChild(int n) const {
  mcRETURN_ELEMENT_CHILD(n, mcElementHelpers);
  return data_Get(n);
 }
 
 void data_SetChild(int n, const mcElement &newchild) {
  mcSET_ELEMENT_CHILD(n, mcElementHelpers, newchild);
  data_Delete(n);
  data_Set(n, newchild);
  }

 
 void data_CheckArrayLimit();

 void data_ChangeFilter(const mcFilter *p);

 void data_UpdateFilterFor(mcElement &p, const mcFilter *f);

 bool data_isElementAllowed(mcElementType type) const;

 bool data_isSameAs(const mcElementHelpers *p) const;


 
 

 virtual bool data_ScanArray(bool (*func)(const mcElement &), bool odd) const;

 virtual int data_AddElements(const mcElement *p, int num, int pos = -1, 
       bool bOverwrite = FALSE, bool bForceCopy = FALSE);

 virtual mcElement &data_AddNewElement(mcElementType t, bool bOverwrite = FALSE, int pos = -1);

 virtual mcElement &data_AddNewWrappedElement(mcElementType t, 
        bool bOverwrite = FALSE, int pos = -1) 
  { return data_AddNewElement(t, bOverwrite, pos); }

 void data_Merge(const mcElementArray &p, int n = 0, bool bAddToEnd = TRUE);

 virtual void data_AddNewOp(mcElementType type, int pos = -1);

 virtual void data_AddNewEmptyBox(int pos = -1);
 
 virtual void data_UpdateNeighbor(int n);
 
 virtual void data_Delete(int entry);

 virtual bool data_Delete(const mcElement &elem);

 virtual void data_DeleteLast(int num);

 virtual void data_DeleteFirst(int num);

 virtual void data_DeleteAllElemType(mcElementType);

 mcElement data_Detach(int n);

 mcElement data_DetachLastElem(int num);

 mcElement data_DetachAll();
 
 void data_DeleteAll();
 
 void data_MoveElemRight(int start);
 
 void data_MoveElemLeft(int start);

 void data_Move(int n, int k);

 int data_MoveAllElemType(mcElementType t, mcElementArray &m);
 
 void data_Swap(int index1, int index2);

 int data_QueueElemType(mcElementType t, int firstpos);

 virtual void data_Repair() {}

 virtual bool data_isWrappingOnly(mcElementType t) const;

 virtual const mcElement &data_GetWrapped(mcElementType t) const;

 
 
 
 
 
 inline void data_CheckIndex(int entry) const {
  // in release mode, for perfomance reasons, don't test
  mcASSERT(mdata_pElemArray != NULL, wxT("Array not allocated yet"));
  mcASSERT(entry >= 0 && entry <= mdata_nUpperBound, wxT("Invalid index"));
 }
 
 inline const mcElement &data_GetConst(int entry) const {
  data_CheckIndex(entry);
  return mdata_pElemArray[entry];
 }

 inline const mcElement &data_Get(int entry) const 
  { return data_GetConst(entry); }

 inline mcElement &data_Get(int entry) {
  data_CheckIndex(entry);
  return mdata_pElemArray[entry];
 }
 
 int data_GetIndexOf(const mcElement &p) const;

 inline const mcElement &data_GetLast() const 
  { return data_Get(data_GetCount()-1); }

 inline mcElement &data_GetLast()
  { return data_Get(data_GetCount()-1); }
 
 inline mcElement *data_GetArray(int n = 0) const {
  data_CheckIndex(n);
  return &mdata_pElemArray[n];
 }

 inline int data_GetIndex(int id) const {
  for (int i=0; i < data_GetCount(); i++)
   if (data_Get(i).data_GetID() == id)
    return i;
   return -1;
 }
 
 inline int data_GetCount() const { 
  return mdata_nElements; 
 }
 
 inline int data_GetAvailableEntryCount() const {
  return mdata_nUpperBound;
 }
 
 int data_GetNumOfElemType(mcElementType t) const;
 
 int data_GetOpCount() const;
 
 mcElement &data_GetElemOfType(int n, mcElementType t) const;
 
 int data_GetElemIndexOfType(int n, mcElementType t) const;

 mcElement &data_GetNonOpElem(int n) const;

 int data_GetNonOpElemIndex(int n) const;
 
 mcOperator &data_GetOp(int n) const;
 
 int data_GetOpIndex(int n) const;

 mcElementType data_GetOpTypeBetween(int n1, int n2) const;

 mcElementType data_GetOpTypePreceding(int n) const;

 mcOperator &data_GetOpPreceding(int n) const
  { return (mcOperator &)*data_GetInstanceOf(data_GetOpTypePreceding(n)); }

 const mcElement &data_GetElemAtLeftOf(const mcElement &p) const {
  int n = data_GetIndexOf(p);
  return (n < 1) ? mcEmptyElement : data_Get(n-1);
 }
 
 const mcElement &data_GetElemAtRightOf(const mcElement &p) const { 
  int n = data_GetIndexOf(p);
  return (n == -1 || n >= mdata_nElements-1) ? mcEmptyElement : data_Get(n+1);
 }

 
 
 
 
 
 
 bool data_isOp(int entry) const;
 
 inline bool data_isEmptyBox(int entry) const {
  data_CheckIndex(entry);
  return (mdata_pElemArray[entry].data_GetType() == mcET_EMPTYBOX); 
 }
 
 inline bool data_isEmptyEntry(int entry) const {
  data_CheckIndex(entry);
  return (data_Get(entry) == mcEmptyElement);
 }
 
 inline bool data_isAddSubOp(int entry) const {
  data_CheckIndex(entry);
  return (data_Get(entry).data_GetType() == mcET_ADDOP || 
   data_Get(entry).data_GetType() == mcET_SUBOP);
 }
 
 inline bool data_isMultDivOp(int entry) const {
  data_CheckIndex(entry);
  return (data_Get(entry).data_GetType() == mcET_MULTOP || 
   data_Get(entry).data_GetType() == mcET_DIVOP);
 }
 
 inline bool data_isArrayEmpty() const {
  return (mdata_nElements == 0);
 }
 
 static inline bool data_isValidElem(const mcElement &p) {
  return p != mcEmptyElement;  
 }
 
 inline bool data_isValidElem(int entry) const {
  data_CheckIndex(entry);
  return data_isValidElem(mdata_pElemArray[entry]);
 }
 
 
 
 
 
 void data_Set(int i, const mcElement &value);
 
 inline void data_SetAsEmptyEntry(int entry) {
  data_CheckIndex(entry);
  mdata_pElemArray[entry] = mcEmptyElement;
 }
 



 void data_SetFilter(const mcFilter *p);

 mcFilter *data_GetFilter()     { return mdata_pFilter; }

 const mcFilter *data_GetFilter() const  { return mdata_pFilter; }

 bool data_isUsingFilter() const    { return (mdata_pFilter != NULL); }


#endif  // mcENABLE_DATA





#ifdef mcENABLE_GUI
public:
 

 virtual int gui_AddNewElement(mcElementType type, const mcKey &key, int pos = -1);
 
 void gui_AddNewEmptyBox(int pos = -1);

 void gui_AddNewOp(mcElementType nOpType, int pos = -1);

 void gui_SetCursorOnElemBegin(int n) {  
  mgui_nCursorPos = n;
  data_Get(n).gui_SetCursorPos(mcCP_BEGIN);
  gui_CheckCursorPos();
 }

 void gui_SetCursorOnElemEnd(int n) {  
  mgui_nCursorPos = n;
  data_Get(n).gui_SetCursorPos(mcCP_END);
  gui_CheckCursorPos();
 }

 bool gui_isCursorOn(const mcElement &p) const {
  int idx = data_GetIndexOf(p);
  if (idx != -1)
   return (idx == mgui_nCursorPos);
  return FALSE;
 }

 int gui_GetSelElemCount() const {
  return gui_GetSelEnd()-gui_GetSelStart();
 }

 int gui_GetSelElemCountOfType(mcElementType t) const {
  int count = 0;

  for (int i=gui_GetSelStart(), max=gui_GetSelEnd(); i < max; i++)
   if (data_Get(i).data_GetType() == t)
    count++;

  return count;
 }
 
 int gui_GetSelElemIndex(int n) const {
  int m = -1; // PLEASE NOTE THAT WE MUST ALWAYS START FROM -1:
     // IN THIS WAY THE PARAMETER n MUST BE EXPRESSED
     // AS ZERO-BASED
  
  for (int i=0; i < data_GetCount(); i++) {
   if (data_Get(i).gui_isSelected()) {
    m++;
    // found ?
    if (m == n) return i;
   }
  }
  
  // no enough selected elements
  return -1;
 }

 int gui_GetSelElemIndexOfType(int n, mcElementType t) const {
  int m = -1;
  
  for (int i=0, max=gui_GetSelElemCount(); i < max; i++) {
   if (gui_GetSelElem(i).data_GetType() == t) {
    m++;
    // found ?
    if (n == m) return gui_GetSelElemIndex(i);
   }
  }
  
  // the n-th occurrence of t doens't exist
  return -1;
 }
 
 const mcElement &gui_GetSelElem(int n) const {
  int m = gui_GetSelElemIndex(n);
  
  if (m > -1)
   return data_Get(m);
  
  // not enough selected elements
  return mcEmptyElement;
 }

 const mcElement &gui_GetSelElemOfType(int n, mcElementType t) const {
  int m = gui_GetSelElemIndexOfType(n, t);
  
  if (m > -1)
   return data_Get(m);
  
  // not enough selected elements
  return mcEmptyElement;
 }
 
 int gui_GetSelStart() const {
  for (int i=0; i < data_GetCount(); i++)
   if (data_Get(i).gui_isSelected())
    return i;
  return -1;
 }
 
 int gui_GetSelEnd() const {
  for (int i=data_GetCount()-1; i >= 0; i--)
   if (data_Get(i).gui_isSelected())
    return i+1;
  return -1;
 }

 void gui_DeleteSelection();
 
 mcElement &gui_ExGetActiveElem(int x, int y, const wxPoint &pt, int cl) {
  int n = gui_GetActiveElemIndex(x, y, pt, cl);
  if (n != mcDRW_NOACTIVEELEM && n != mcDRW_ONSELECTION)
   return data_Get(n).gui_GetActiveElem(x, y, pt);
  return mcEmptyElement;
 }

 void gui_DeleteNextOp();

 void gui_DeletePreviousOp();

 void gui_MoveCursorRight();
 void gui_MoveCursorLeft();

 void gui_UpdateExpDepth();

 bool gui_Insert(const mcElement &toinsert);







 virtual bool gui_isEndKey(const mcKey &ev) const;
 //virtual void DeepCopy(const mcElementGUI *p);
 virtual void gui_SetCursorPos(const mcCursorPos &code);
 virtual mcInputRes gui_Input(const mcKey &ev, mcElement *newelem);
 virtual mcMoveCursorRes gui_MoveCursor(mcMoveCursorFlag flag, long modifiers);
 virtual mcElement gui_GetSelection() const;
 virtual void gui_DoRecalcSize();
 virtual void gui_GetCursorPos(mcCursorPos &) const;
 virtual mcCursorPos gui_GetCursorPos() const
  { return mcElementHelpers::gui_GetCursorPos(); }

 virtual int gui_GetYAnchor() const {
  return gui_GetCenterLine();
 }

 void gui_OnSelect(wxDC &dc, wxRect &rc) {
  // call the overloaded version;
  gui_ExOnSelect(dc, rc, -1);
 }

 int gui_Draw(wxDC &dc, int x, int y, long flags, const wxPoint &pt) const {
  // call the overloaded version
  return gui_ExDraw(dc, x, y, flags, pt, -1);
 }

 int gui_GetRelCursorPos(wxDC &dc, wxPoint *pt) const {
  // call the overloaded version
  return gui_ExGetRelCursorPos(dc, pt, -1);
 }

 int gui_MoveCursorUsingPoint(wxDC &dc, const wxPoint &pt) {
  // call the overloaded version
  return gui_ExMoveCursorUsingPoint(dc, pt, -1);
 }

 mcElement &gui_GetActiveElem(int x, int y, const wxPoint &pt) {
  // call the overloaded version
  return gui_ExGetActiveElem(x, y, pt, -1);
 }






 virtual mcInputRes gui_BackInput(const mcKey &key, mcElement *pnewelem, int n) = 0;

 virtual bool gui_isArrEndKey(const mcKey &ev) const = 0;
  
 virtual void gui_CheckCursorPos() const = 0;

 virtual void gui_DoSplit(mcElementType type, const mcKey &ev) = 0;








 virtual int gui_GetSpaceBetween() const;

 virtual int gui_GetCenterLine() const;

  virtual int gui_ExDraw(wxDC &dc, int x, int y, long flags, const wxPoint &pt, int cl = -1, 
     int begin = 0, int end = -1, bool bgui_DrawSelected = FALSE) const;

  virtual int gui_DrawSelectedElements(wxDC &dc, int x, int y, long flags, 
         const wxPoint &pt, int cl = -1) const;

 virtual int gui_DrawSelection(wxDC &hDC, int x, int y, long flags, const wxPoint &pt, int cl = -1) const;

 virtual void gui_ExOnSelect(wxDC &dc, wxRect &rc, int cl = -1);

 virtual wxSize gui_CalcSizeOfFirst(int n, int cl = -1) const;

 virtual wxSize gui_CalcSizeOfRange(int begin, int end, int cl = -1) const;

 virtual wxRect gui_GetSelectionRect(wxDC &dc, int x, int y, int cl = -1) const;

 virtual wxPoint gui_GetOriginOfElem(int n, int cl = -1) const;
 
 virtual int gui_GetBB(int n, wxRect *rc, int yCenter = 0, int w = 0) const;

 virtual int gui_ExGetRelCursorPos(wxDC &hDC, wxPoint *pt, int cl = -1) const;
 
 virtual int gui_ExMoveCursorUsingPoint(wxDC &hDC, const wxPoint &pt, int cl = -1);

 virtual int gui_GetActiveElemIndex(int x, int y, const wxPoint &pt, int cl = -1);

#endif  // mcENABLE_GUI




#ifdef mcENABLE_MATH



protected:

 virtual mcExpSimRes math_HandleExpSimFlag(mcExpSimRes r, mcElement *newelem, int i);

 virtual void math_HandleBasicOpRes(mcBasicOpRes res, mcElement r, int ridx);

 virtual int math_ReorderElements(mcElement *arr, int sz, int start = 0, int toskip = 1);


 virtual mcExpSimRes math_ExpandAll(long flags, mcElement *pp);


 virtual mcExpSimRes math_SimplifyAll(long flags, mcElement *pp);

 virtual mcExpSimRes math_SimplifyExp(long flags, mcElement *pp);

 virtual mcExpSimRes math_SimplifyRemoveNeutrals(long flags);

 virtual mcExpSimRes math_SimplifySolveOp(long flags);

 virtual mcExpSimRes math_Reorder() = 0;

 virtual bool math_SimplifyNeedExp(long flags, int n) const;

 virtual mcExpSimRes math_BeginSimSteps()  { return mcESR_DONE; }
 virtual mcExpSimRes math_FinalSimSteps()  { return mcESR_DONE; }

 virtual void math_EndSimSteps() {}

 virtual void math_EndExpSteps() {}

public:


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

  mcExpSimRes math_Simplify(long flags) { return math_Simplify(flags, NULL); }
  mcExpSimRes math_Expand(long flags)  { return math_Expand(flags, NULL); }

 mcMathType math_GetMathType() const;

 bool math_CanBeAddedWith(const mcElement &p) const;
 bool math_CanBeDivBy(const mcElement &p) const;
 bool math_CanBeMultWith(const mcElement &p) const;

 //void math_SetExp(const mcPolynomial &p);
 mcBasicOpRes math_MakeReciprocal(mcElement *);

 virtual mcRealValue math_Evaluate() const;
 
 virtual mcRealValue math_GetLenght() const  { return 0.5; }






 const mcElement &math_Get(int n) const 
  { return data_Get(math_MathToDataIdx(n)); }
 mcElement &math_Get(int n) 
  { return data_Get(math_MathToDataIdx(n)); }

 virtual int math_GetCount() const 
  { return data_GetCount() - data_GetOpCount(); }

 int math_GetIndexOf(int occ, const mcElement &tofind) const;  

 mcElementType math_GetOpTypeBetween(int n1, int n2) const 
  { return data_GetOpTypeBetween(math_MathToDataIdx(n1), math_MathToDataIdx(n2)); }

 mcElementType math_GetOpTypePreceding(int n) const 
  { return data_GetOpTypePreceding(math_MathToDataIdx(n)); }

 mcOperator &math_GetOpBetween(int n1, int n2) const;
 mcOperator &math_GetOpPreceding(int n) const;




 
 bool math_Remove(int n, bool bAddZero = TRUE);

 bool math_RemoveFactor(const mcArrayEntry &toremove);

 virtual bool math_Delete(int n, const mcElement &elem, bool bAddZero = TRUE);

 //virtual void Move(int n, int k);

 void math_ApplyOp(mcElementType optype, mcElement res, const mcElement &factor, mcElement *);

 void math_ApplyOpSimple(mcElementType optype, mcElement res, const mcElement &factor);

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

 virtual bool math_isWrappingOnly(mcElementType t) const;

 virtual const mcElement &math_GetWrapped(mcElementType t) const;

 virtual mcArrayEntry math_WrapMonomial(const mcMonomial &) = 0;
 virtual mcArrayEntry math_WrapSimple(const mcElement &) = 0;

 virtual mcArrayEntry math_WrapSymbol(const mcSymbolProperties *sym);
 virtual mcArrayEntry math_WrapNumber(const mcRealValue &val);

 bool math_isWrappingNumOnly() const  { return math_isWrappingOnly(mcET_NUMBER); }

 bool math_isWrappingSymOnly() const  { return math_isWrappingOnly(mcET_SYMBOL); }

 mcRealValue math_GetWrappedNumber() const;

 const mcSymbolProperties *math_GetWrappedSymbol() const;

 bool math_isWrappingOnly(const mcSymbolProperties *sym) const
  { return math_GetWrappedSymbol() == sym; }
 bool math_isWrappingOnly(const mcRealValue &val) const
  { return math_GetWrappedNumber() == val; }

 virtual void math_ResetToOne();
 virtual void math_ResetToZero();

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

 mcArrayEntry math_EmbedInFraction(bool bAsDenominator = FALSE); 
 mcArrayEntry math_EmbedInBracket();
 mcArrayEntry math_EmbedInRadical();





 virtual int math_DataToMathIdx(int dataindex) const = 0;

 virtual int math_MathToDataIdx(int mathindex) const = 0;

 virtual void math_PrepareForComparison(mcElementArray &p) const;
 virtual void math_PrepareForMathOperations(mcElementArray &p) const;

 virtual mcElementType math_GetNeutralOpType() const = 0;
 virtual double math_GetNeutralValue() const = 0;
 
 virtual mcPolynomial math_GetPolynomialWrapper() const = 0;

 virtual mcElementArray math_CreateWrapperFor(const mcElement &p) const;

 virtual mcMonomial math_GetFactors() const;

 //virtual void math_FactoreOut() = 0;

 //virtual void math_RaiseChildrenTo(const mcRealValue &n) = 0;
 //virtual void math_RaiseChildrenTo(const mcPolynomial &p) = 0;

 void math_EmbedInBracketAndRaiseTo(const mcRealValue &n);  
 void math_EmbedInBracketAndRaiseTo(const mcPolynomial &p);
 void math_EmbedInRadicalAndRaiseTo(const mcPolynomial &p);


#endif  // mcENABLE_MATH



#ifdef mcENABLE_IO
public:

 bool io_isBeginTag(const wxXml2Node &tag) const { 
  if (tag.GetName() == wxT("mrow"))
   return TRUE;
  return FALSE;
 }

 bool io_isBeginChar(const wxString &str) const {
  return FALSE;
 }

 wxString io_GetInlinedExpr() const;

#endif  // mcENABLE_IO
};





class mcElementArray : public mcElement
{
 mcDEFINE_ABSTRACT_CLASS(ElementArray, mcElement);
 
public:

 bool data_isValidContainerFor(mcElementType t) const
  { return t == mcET_MONOMIAL || t == mcET_POLYNOMIAL; }


#ifdef mcENABLE_DATA
public:

 mcWRAPPER void data_CheckIndex(int entry) const
  { hlp()->data_CheckIndex(entry); }
 mcWRAPPER void data_CheckArrayLimit()
  { hlp()->data_CheckArrayLimit(); }
 mcWRAPPER void data_ChangeFilter(const mcFilter *p)
  { hlp()->data_ChangeFilter(p); }

 mcWRAPPER void data_UpdateFilterFor(mcElement &p, const mcFilter *f)
  { hlp()->data_UpdateFilterFor(p, f); }

 mcWRAPPER bool data_isElementAllowed(mcElementType type) const
  { return hlp()->data_isElementAllowed(type); }

 mcWRAPPER int data_AddElements(const mcElement *p, int num, int pos = -1, 
      bool bOverwrite = FALSE, bool bForceCopy = FALSE)
  { return hlp()->data_AddElements(p, num, pos, bOverwrite, bForceCopy); }

 mcWRAPPER mcElement &data_AddNewElement(mcElementType t, bool bOverwrite = FALSE, int pos = -1)
  { return hlp()->data_AddNewElement(t, bOverwrite, pos); }

 mcWRAPPER mcElement &data_AddNewWrappedElement(mcElementType t, 
         bool bOverwrite = FALSE, int pos = -1) 
  { return hlp()->data_AddNewWrappedElement(t, bOverwrite, pos); }

 mcWRAPPER void data_Merge(const mcElementArray &p, int n, bool bmath_AddToEnd = TRUE)
  { hlp()->data_Merge(p, n, bmath_AddToEnd); }

 mcWRAPPER void data_AddNewOp(mcElementType type, int pos = -1)
  { hlp()->data_AddNewOp(type, pos); }

 mcWRAPPER void data_AddNewEmptyBox(int pos = -1)
  { hlp()->data_AddNewEmptyBox(pos); }


 mcWRAPPER bool data_Delete(const mcElement &elem)
  { return hlp()->data_Delete(elem); }
 mcWRAPPER void data_Delete(int entry)
  { hlp()->data_Delete(entry); }
 mcWRAPPER void data_DeleteLast(int num)
  { hlp()->data_DeleteLast(num); }
 mcWRAPPER void data_DeleteFirst(int num)
  { hlp()->data_DeleteFirst(num); }
 mcWRAPPER void data_DeleteAllElemType(mcElementType t)
  { hlp()->data_DeleteAllElemType(t); }
 mcWRAPPER void data_DeleteAll()
  { hlp()->data_DeleteAll(); }

 mcWRAPPER mcElement data_Detach(int n)
  { return hlp()->data_Detach(n); }
 mcWRAPPER mcElement data_DetachLastElem(int num)
  { return hlp()->data_DetachLastElem(num); }
 mcWRAPPER mcElement data_DetachAll()
  { return hlp()->data_DetachAll(); }

 mcWRAPPER void data_MoveElemRight(int start)
  { hlp()->data_MoveElemRight(start); }
 mcWRAPPER void data_MoveElemLeft(int start)
  { hlp()->data_MoveElemLeft(start); }
 mcWRAPPER void data_Move(int n, int k)
  { hlp()->data_Move(n, k); }
 mcWRAPPER int data_MoveAllElemType(mcElementType t, mcElementArray &m)
  { return hlp()->data_MoveAllElemType(t, m); }

 mcWRAPPER void data_Swap(int index1, int index2)
  { hlp()->data_Swap(index1, index2); }

 mcWRAPPER int data_QueueElemType(mcElementType t, int firstpos)
  { return hlp()->data_QueueElemType(t, firstpos); }

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



 mcWRAPPER bool data_isWrappingOnly(mcElementType t) const
  { return hlp()->data_isWrappingOnly(t); }

 mcWRAPPER const mcElement &data_GetWrapped(mcElementType t) const
  { return hlp()->data_GetWrapped(t); }


 mcWRAPPER const mcElement &data_Get(int entry) const 
  { return hlp()->data_Get(entry); }
 mcWRAPPER mcElement &data_Get(int entry)
  { return hlp()->data_Get(entry); }


 mcWRAPPER int data_GetIndexOf(const mcElement &p) const
  { return hlp()->data_GetIndexOf(p); }

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


 mcWRAPPER mcElement *data_GetArray(int n = 0) const
  { return hlp()->data_GetArray(n); }

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

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

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

 mcWRAPPER int data_GetNumOfElemType(mcElementType t) const
  { return hlp()->data_GetNumOfElemType(t); }

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

 mcWRAPPER mcElement &data_GetElemOfType(int n, mcElementType t) const
  { return hlp()->data_GetElemOfType(n, t); }

 mcWRAPPER int data_GetElemIndexOfType(int n, mcElementType t) const
  { return hlp()->data_GetElemIndexOfType(n, t); }

 mcWRAPPER mcElement &data_GetNonOpElem(int n) const
  { return hlp()->data_GetNonOpElem(n); }

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

 mcWRAPPER mcOperator &data_GetOp(int n) const
  { return hlp()->data_GetOp(n); }

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

 mcWRAPPER mcElementType data_GetOpTypeBetween(int n1, int n2) const
  { return hlp()->data_GetOpTypeBetween(n1, n2); }

 mcWRAPPER mcElementType data_GetOpTypePreceding(int n) const
  { return hlp()->data_GetOpTypePreceding(n); }

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

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

 mcWRAPPER bool data_isOp(int entry) const
  { return hlp()->data_isOp(entry); }
 mcWRAPPER bool data_isEmptyBox(int entry) const
  { return hlp()->data_isEmptyBox(entry); }
 mcWRAPPER bool data_isEmptyEntry(int entry) const
  { return hlp()->data_isEmptyEntry(entry); }
 mcWRAPPER bool data_isAddSubOp(int entry) const
  { return hlp()->data_isAddSubOp(entry); }
 mcWRAPPER bool data_isMultDivOp(int entry) const
  { return hlp()->data_isMultDivOp(entry); }

 mcWRAPPER bool data_isArrayEmpty() const
  { return hlp()->data_isArrayEmpty(); }
 mcWRAPPER bool data_isValidElem(int entry) const
  { return hlp()->data_isValidElem(entry); }

 mcWRAPPER void data_Set(int i, const mcElement &value)
  { hlp()->data_Set(i, value); }

 mcWRAPPER void data_SetAsEmptyEntry(int entry)
  { hlp()->data_SetAsEmptyEntry(entry); }

 mcWRAPPER void data_SetFilter(const mcFilter *p)
  { hlp()->data_SetFilter(p); }

 mcWRAPPER mcFilter *data_GetFilter()
  { return hlp()->data_GetFilter(); }

 mcWRAPPER const mcFilter *data_GetFilter() const  
  { return hlp()->data_GetFilter(); }

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

#endif  // mcENABLE_DATA




#ifdef mcENABLE_GUI
public:

 mcWRAPPER int gui_AddNewElement(mcElementType type, const mcKey &key, int pos = -1)
  { return hlp()->gui_AddNewElement(type, key, pos); }
 mcWRAPPER void gui_AddNewEmptyBox(int pos = -1)
  { hlp()->gui_AddNewEmptyBox(pos); }
 mcWRAPPER void gui_AddNewOp(mcElementType nOpType, int pos = -1)
  { hlp()->gui_AddNewOp(nOpType, pos); }

 mcWRAPPER void gui_SetCursorOnElemBegin(int n)  
  { hlp()->gui_SetCursorOnElemBegin(n); }
 mcWRAPPER void gui_SetCursorOnElemEnd(int n)  
  { hlp()->gui_SetCursorOnElemEnd(n); }

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

 mcWRAPPER int gui_GetSelElemCount() const
  { return hlp()->gui_GetSelElemCount(); }
 mcWRAPPER int gui_GetSelElemCountOfType(mcElementType t) const
  { return hlp()->gui_GetSelElemCountOfType(t); }
 mcWRAPPER int gui_GetSelElemIndex(int n) const
  { return hlp()->gui_GetSelElemIndex(n); }
 mcWRAPPER int gui_GetSelElemIndexOfType(int n, mcElementType t) const
  { return hlp()->gui_GetSelElemIndexOfType(n, t); }

 mcWRAPPER const mcElement &gui_GetSelElem(int n) const
  { return hlp()->gui_GetSelElem(n); }
 mcWRAPPER const mcElement &gui_GetSelElemOfType(int n, mcElementType t) const
  { return hlp()->gui_GetSelElemOfType(n, t); }

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

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

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

 mcWRAPPER void gui_DeleteNextOp()
  { hlp()->gui_DeleteNextOp(); }
 mcWRAPPER void gui_DeletePreviousOp()
  { hlp()->gui_DeletePreviousOp(); }

 mcWRAPPER void gui_MoveCursorRight()
  { hlp()->gui_MoveCursorRight(); }
 mcWRAPPER void gui_MoveCursorLeft()
  { hlp()->gui_MoveCursorLeft(); }

/*
 mcWRAPPER mcInputRes gui_BackInput(const mcKey &key, mcElement *pnewelem, int n)

 mcWRAPPER bool gui_isArrEndKey(const mcKey &ev) const

 mcWRAPPER void gui_CheckCursorPos() const

 mcWRAPPER void gui_DoSplit(mcElementType type, const mcKey &ev)

 mcWRAPPER int gui_GetSpaceBetween() const
*/
 mcWRAPPER int gui_GetCenterLine() const
  { return hlp()->gui_GetCenterLine(); }

 mcWRAPPER int gui_ExDraw(wxDC &dc, int x, int y, long flags, const wxPoint &pt, int cl = -1, 
     int begin = 0, int end = -1, bool bDrawSelected = FALSE) const
  { return hlp()->gui_ExDraw(dc, x, y, flags, pt, cl, begin, end, bDrawSelected); }
/*
  mcWRAPPER int gui_DrawSelectedElements(wxDC &dc, int x, int y, long flags, 
         mcWRAPPER const wxPoint &pt, int cl = -1) const

 mcWRAPPER int gui_DrawSelection(wxDC &hDC, int x, int y, long flags, const wxPoint &pt, int cl = -1) const

 mcWRAPPER void gui_ExOnSelect(wxDC &dc, int x, int y, wxRect &rc, int cl = -1)

 mcWRAPPER wxSize gui_CalcSizeOfFirst(int n, int cl = -1) const

 mcWRAPPER wxSize gui_CalcSizeOfRange(int begin, int end, int cl = -1) const

 mcWRAPPER wxRect gui_GetSelectionRect(wxDC &dc, int x, int y, int cl = -1) const

 mcWRAPPER wxPoint gui_GetOriginOfElem(int n, int cl = -1) const

 mcWRAPPER int gui_GetBB(int n, wxRect *rc, int yCenter, int w) const
*/
 mcWRAPPER int gui_ExGetRelCursorPos(wxDC &dc, wxPoint *pt, int cl = -1) const
  { return hlp()->gui_ExGetRelCursorPos(dc, pt, cl); }
/*
 mcWRAPPER int gui_ExMoveCursorUsingPoint(wxDC &hDC, const wxPoint &pt, int cl = -1)

 mcWRAPPER int gui_GetActiveElemIndex(int x, int y, const wxPoint &pt, int cl = -1)
*/
#endif  // mcENABLE_GUI


#ifdef mcENABLE_MATH
public:

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

 mcWRAPPER const mcElement &math_Get(int n) const
  { return hlp()->math_Get(n); }
 mcWRAPPER mcElement &math_Get(int n)
  { return hlp()->math_Get(n); }
 mcWRAPPER int math_GetCount() const
  { return hlp()->math_GetCount(); }

 mcWRAPPER int math_GetIndexOf(int occ, const mcElement &tofind) const
  { return hlp()->math_GetIndexOf(occ, tofind); }

 mcWRAPPER mcElementType math_GetOpTypeBetween(int n1, int n2) const
  { return hlp()->math_GetOpTypeBetween(n1, n2); }
 mcWRAPPER mcElementType math_GetOpTypePreceding(int n) const
  { return hlp()->math_GetOpTypePreceding(n); }
 mcWRAPPER mcOperator &math_GetOpBetween(int n1, int n2) const
  { return hlp()->math_GetOpBetween(n1, n2); }
 mcWRAPPER mcOperator &math_GetOpPreceding(int n) const
  { return hlp()->math_GetOpPreceding(n); }

 mcWRAPPER bool math_Remove(int n, bool bAddZero = TRUE)
  { return hlp()->math_Remove(n, bAddZero); }
 mcWRAPPER bool math_Delete(int n, const mcElement &elem, bool bAddZero = TRUE)
  { return hlp()->math_Delete(n, elem, bAddZero); }
 mcWRAPPER void math_ApplyOp(mcElementType optype, mcElement res, const mcElement &factor, mcElement *pp)
  { hlp()->math_ApplyOp(optype, res, factor, pp); }
 mcWRAPPER void math_ApplyOpSimple(mcElementType optype, mcElement res, const mcElement &factor)
  { hlp()->math_ApplyOpSimple(optype, res, factor); }

 mcWRAPPER bool math_isWrappingOnly(mcElementType t) const
  { return hlp()->math_isWrappingOnly(t); }

 mcWRAPPER const mcElement &math_GetWrapped(mcElementType t) const
  { return hlp()->math_GetWrapped(t); }
 mcWRAPPER mcArrayEntry math_WrapMonomial(const mcMonomial &m)
  { return hlp()->math_WrapMonomial(m); }
 mcWRAPPER mcArrayEntry math_WrapSimple(const mcElement &e)
  { return hlp()->math_WrapSimple(e); }
 mcWRAPPER mcArrayEntry math_WrapSymbol(const mcSymbolProperties *sym)
  { return hlp()->math_WrapSymbol(sym); }
 mcWRAPPER mcArrayEntry math_WrapNumber(const mcRealValue &val)
  { return hlp()->math_WrapNumber(val); }

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

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

 mcWRAPPER const mcSymbolProperties *math_GetWrappedSymbol() const
  { return hlp()->math_GetWrappedSymbol(); }
 mcWRAPPER bool math_isWrappingOnly(const mcSymbolProperties *sym) const
  { return hlp()->math_isWrappingOnly(sym); }
 mcWRAPPER bool math_isWrappingOnly(const mcRealValue &val) const
  { return hlp()->math_isWrappingOnly(val); }

 mcWRAPPER void math_ResetToOne()
  { hlp()->math_ResetToOne(); }
 mcWRAPPER void math_ResetToZero()
  { hlp()->math_ResetToZero(); }

 mcWRAPPER mcArrayEntry math_EmbedInFraction(bool bAsDenominator = FALSE) 
  { return hlp()->math_EmbedInFraction(bAsDenominator); }
 mcWRAPPER mcArrayEntry math_EmbedInBracket()
  { return hlp()->math_EmbedInBracket(); }
 mcWRAPPER mcArrayEntry math_EmbedInRadical()
  { return hlp()->math_EmbedInRadical(); }

 mcWRAPPER int math_DataToMathIdx(int dataindex) const
  { return hlp()->math_DataToMathIdx(dataindex); }
 mcWRAPPER int math_MathToDataIdx(int mathindex) const
  { return hlp()->math_MathToDataIdx(mathindex); }

/* mcElementType math_GetNeutralOpType() const
 mcWRAPPER double math_GetNeutralValue() const

 mcWRAPPER mcPolynomial math_GetPolynomialWrapper() const

 mcWRAPPER mcElementArray math_CreateWrapperFor(const mcElement &p) const

 mcWRAPPER mcPolynomial math_GetFactors() const*/
/*
 mcWRAPPER void math_RaiseChildrenTo(const mcPolynomial &p)
  { hlp()->math_RaiseChildrenTo(p); }
 mcWRAPPER void math_RaiseChildrenTo(const mcRealValue &p)
  { hlp()->math_RaiseChildrenTo(p); }
*/
 mcWRAPPER void math_EmbedInBracketAndRaiseTo(const mcRealValue &n)
  { hlp()->math_EmbedInBracketAndRaiseTo(n); }
 mcWRAPPER void math_EmbedInBracketAndRaiseTo(const mcPolynomial &p)
  { hlp()->math_EmbedInBracketAndRaiseTo(p); }

#endif  // mcENABLE_MATH
};


#endif // ELEMENTARRAY_H

---

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

[ Top ]