Main page

---

Element.cpp

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



// optimization for GCC compiler
#ifdef __GNUG__
#pragma implementation "Element.cpp"
#endif

// includes
#include "mc/mcprec.h"
#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef mcPRECOMP
    #include <wx/dcscreen.h>

 #include "mc/EmptyBox.h"
 #include "mc/Number.h"
 #include "mc/Bracket.h"
 #include "mc/Fraction.h"
 #include "mc/Function.h"
 #include "mc/Radical.h"
 #include "mc/Text.h"
 #include "mc/Symbol.h"
 #include "mc/Operator.h"
 #include "mc/AddSubOp.h" 
 #include "mc/MultDivOp.h" 
 #include "mc/Monomial.h"
 #include "mc/Parenthesis.h"
#endif


// setup customizable variables
wxBrush *mcElementHelpers::sgui_pSelectionBrush = NULL;
wxBrush *mcElementHelpers::sgui_pActivationBrush = NULL;
mcStyleArray *mcElementHelpers::sgui_pDefaultStyles = NULL;
int mcElementHelpers::sgui_nAdditionalActivationSpaceLeftRight = 2;
mcElement *mcElementHelpers::sdata_pElem[];

// global objects
mcElement mcEmptyElement;





// -------------------------
// mcELEMENTHELPERS
// -------------------------

#ifdef __MCDEBUG__

void mcElementHelpers::data_Check() const
{
 //mcASSERT(m_nExpDepth >= 0, "Not valid");
 mcASSERT(mdata_nProperties >= 0, wxT("Not valid"));
 mcASSERT(mdata_nID >= 0, wxT("Not valid"));

 // now check childrens (recursive check)...
 for (int i=0,max=data_GetChildrenCount(); i < max; i++) {

  const mcElement &tocheck = data_GetConstChild(i);

  // be sure that this child has set this element as its parent
  /*mcASSERT(tocheck.GetParent() == this, 
   wxT("One of our children is out of sync"));*/

  // recurse
  tocheck.data_Check();
 }
}

wxString mcElementHelpers::data_GetDebug(int indent, long flags) const
{
 wxString str, tmp;

 // get debug info from this element
 //tmp = data_Debug();
 //tmp = Indent(tmp, indent); // indent it

 // leave some spaces
 str += wxString(wxT(' '), indent);

 // include some additional info if required
 if (flags & mcELEMENT_DBG_EXPDEPTH)
  str += wxString::Format(wxT("EXPDEPTH: %2d  "), gui_GetExpDepth());

 if (flags & mcELEMENT_DBG_SELECTION &&
  mcMathCore::Get()->isGUIEnabled())
  str += wxString::Format(wxT("SELECTED: %s  "), 
    (gui_isSelected() ? wxT("YES") : wxT("NO ")));

 if (flags & mcELEMENT_DBG_ID)
  str += wxString::Format(wxT("ID: %2d  "), data_GetID());

 // add the string
 str += data_Debug(flags);
 str = wxIndent(str, indent);

 // return the result 
 return str;
}

void mcElement::data_CheckContainer() const
{
 // first of all, check if this is a valid container for the
 // current shared data
 if (data_GetRefData()) {
  mcElementHelpers *helpers = (mcElementHelpers *)data_GetRefData();
  mcUNUSED(helpers);  // just to avoid a stupid warning
 
  // we cannot mix helpers of some type with elements of another
  // type: mcNumber cannot reference a mcBracketHelper class...
  mcASSERT(data_isValidContainerFor(helpers->data_GetType()), 
   wxT("Invalid container (this is a ") +
   data_GetDebugName() + 
   wxT(") for the given helper class (") + 
   helpers->data_GetDebugName() +
   wxT("Helpers) !!"));
 }
}

void mcElement::data_Check() const
{
 // check if we contain valid data
 data_CheckContainer();

 // then, check the helper (if present) & its children
 if (chlp()) chlp()->data_Check();
}

#endif  // __MCDEBUG__


mcElementHelpers::mcElementHelpers()
{
 // this variable should be decided by derived classes
 //mdata_nType = mcET_INVALID;
 
 // create the ID for this element
 mdata_nID = mcElementHelpers::data_GenID();
 
 // set up flags and member variables
 mdata_nProperties = mcEP_NOPROPERTIES;
 mgui_nExpDepth = 0;
}

void mcElementHelpers::data_Init()
{
 // init only required sections
 if (mcMathCore::Get()->isGUIEnabled()) gui_Init();
 if (mcMathCore::Get()->isMathEnabled()) math_Init();
 if (mcMathCore::Get()->isIOEnabled()) io_Init();
}

bool mcElementHelpers::io_Init(const wxString &str)
{
 wxString err;
 int n;
 
 // just check the string begins with the begin-char for this class
 if (!mcMathCore::Get()->isIOEnabled())
  return FALSE;
 if (io_isBeginChar(str) == FALSE)
  return FALSE;
 return io_ImportInlinedExpr(str, &n, err);
}

void mcElementHelpers::gui_OnRecalcSize(wxSize old)
{
 // if there were no changes, do nothing...
 if (old == mgui_sz)
  return;
 
 // if this object's size has changed, notify children 
 // with the correct properties...
 //for (int i=0; i < data_GetChildrenCount(); i++)
 // data_GetChild(i).gui_OnParentSizeChange();
} 

void mcElementHelpers::gui_SetStyleArray(const mcStyleArray *p)
{
 // change the style for this class
 if (!mcMathCore::Get()->isGUIEnabled())
  return;
 
 mgui_pStyleArray = p;
 
 // and its children...
 for (int i=0; i < data_GetChildrenCount(); i++)
  data_GetChild(i).gui_SetStyleArray(p);
}

mcElement &mcElementHelpers::data_GetElemFromID(int id) const 
{
 // do not check for ourselves (since this is a CONST function)
 
 // search among children
 for (int i=0; i < data_GetChildrenCount(); i++) {
  mcElement &p = data_GetConstChild(i).data_GetElemFromID(id);
  if (p != mcEmptyElement)
   return p;
 }
 
 return mcEmptyElement;
}


void mcElementHelpers::data_AddRecursiveProperty(mcElementType t, int p, void *val1, void *val2)
{
 if (data_GetType() == t)
  data_AddProperty(p, val1, val2);
 
 // add this property to all the childrens...
 for (int i=0; i < data_GetChildrenCount(); i++)
  data_GetChild(i).data_AddRecursiveProperty(t, p, val1, val2);
}

bool mcElementHelpers::data_hasRecursiveProperty(mcElementType t, int p) const
{
 if (data_GetType() == t)
  return ((mdata_nProperties & p) != 0);
 
 // check if at least one of the children has the property...
 for (int i=0; i < data_GetChildrenCount(); i++)
  if (data_GetConstChild(i).data_hasRecursiveProperty(t, p))
   return TRUE;
  return FALSE;
}

void mcElementHelpers::data_RemoveRecursiveProperty(mcElementType t, int p)
{
 if (data_GetType() == t)
  mdata_nProperties &= ~p;
 
 // remove this property from all the childrens...
 for (int i=0; i < data_GetChildrenCount(); i++)
  data_GetChild(i).data_RemoveRecursiveProperty(t, p);
}

void mcElementHelpers::data_Update()
{
 // nothing to do....

 // just update children
 for (int i=0; i < data_GetChildrenCount(); i++)
  data_GetChild(i).data_Update(); 
}

bool mcElementHelpers::data_AddChildrenTo(mcElement p)
{
 if (p.data_GetType() != data_GetType())
  return FALSE;
  
 for (int i=0, max=data_GetChildrenCount(); i < max; i++)
  p.data_SetChild(i, data_GetChild(i));
 return TRUE; // non container elements should have no child to add...
}

int mcElementHelpers::data_GetChildIdx(const mcElement &p) const
{  
 for (int i=0,max=data_GetChildrenCount(); i < max; i++)
  if (data_GetConstChild(i) == p)
   return i; // found...
  
 return -1;
}

mcElement &mcElementHelpers::data_GetChild(int n)
{ return (mcElement &)data_GetConstChild(n);}

const mcElement &mcElementHelpers::data_GetConstChild(int) const
{ return mcEmptyElement;}





// ----------------------------------------
// mcELEMENT - various
// ----------------------------------------

mcElement::mcElement(const mcElementHelpers *helpers)
{ 
 //mcLOG("mcElementHelpers::mcElement - wrapping"); 
 data_SetRefData((mcObjectRefData *)helpers);
 
 // increment the reference count since we've now wrapped the given class
 if (data_GetRefData())
  data_GetRefData()->data_IncRefCount();
#ifndef mcENABLE_COW
 if (data_GetRefData())
  data_MakePrivateCopy();  // no sharing allowed
#endif
}

mcElement::~mcElement()
{ 
#ifdef mcENABLE_COW_DEBUG
 if (data_GetRefData() && mcMathCore::isOk())
  mcMathCore::Get()->m_nMaxSharing = 
  mcMAX(mcMathCore::Get()->m_nMaxSharing, chlp()->data_GetRefCount());
#endif
}

void mcElement::data_Ref(const mcObject &toclone)
{
 mcObject::data_Ref(toclone);

 // check this is a valid container for the just
 // referenced data.... we can do it here because
 // this function is called when the element
 // has been completely built and thus, if present,
 // the overloaded version of CheckContainer will be
 // called...
#ifdef __MCDEBUG__
 wxLogNull logNo;
 data_CheckContainer();
#endif
}

void mcElementHelpers::Init()
{
 for (int t=0; t < mcNUM_ELEMENT_TYPES; t++)
  sdata_pElem[t] = NULL;

 // this will create an instance for each registered MathCore element
 data_UpdateElemArray();
}

void mcElementHelpers::Cleanup()
{  
 for (int t=0; t < mcNUM_ELEMENT_TYPES; t++)
  mcSAFE_DELETE(sdata_pElem[t]);
}

void mcElementHelpers::data_UpdateElemArray()
{
 // create one instance of each class; required by the
 // mcElementHelpers::isCharBeginChar & mcElementHelpers::isTagBeginTag
 // functions...
 for (int t=0; t < mcNUM_ELEMENT_TYPES; t++) {
  mcSAFE_DELETE(sdata_pElem[t]);

  // if at least one of the mcElement sections is enabled,
  // build this element
  sdata_pElem[t] = new mcElement(data_NewElem((mcElementType)t));
 }
}


#define mcDEFINE_ALLOCATOR(x)       \
 if (towrap)           \
  return x(towrap);        \
 else            \
  return x(); 

#define mcDEFINE_SPECIAL_ALLOCATOR(x, param1)   \
 if (towrap)           \
  return x(towrap);        \
 else            \
  return x(param1); 

mcElement mcElementHelpers::data_NewElem(mcElementType type, const mcElementHelpers *towrap)
{
 //mcElement pnew = mcEmptyElement;

 // create a new MathCore class; the following switch should contain
 // one case label for each value declared in mcElementType
 switch (type) {
 case mcET_NUMBER:
  mcDEFINE_ALLOCATOR(mcNumber)
 case mcET_PARENTHESIS:
  mcDEFINE_ALLOCATOR(mcParenthesis)
 case mcET_BRACKET:
  mcDEFINE_ALLOCATOR(mcBracket)
 case mcET_RADICAL:
  mcDEFINE_ALLOCATOR(mcRadical)
 case mcET_FRACTION:
  mcDEFINE_ALLOCATOR(mcFraction)
 case mcET_SYMBOL:
  mcDEFINE_ALLOCATOR(mcSymbol)
 case mcET_FUNCTION:
  mcDEFINE_ALLOCATOR(mcFunction)
 case mcET_TEXT:
  mcDEFINE_ALLOCATOR(mcText)
 case mcET_EMPTYBOX:
  mcDEFINE_ALLOCATOR(mcEmptyBox)
 case mcET_ADDOP:
  mcDEFINE_SPECIAL_ALLOCATOR(mcAddSubOp, mcET_ADDOP);
 case mcET_SUBOP:
  mcDEFINE_SPECIAL_ALLOCATOR(mcAddSubOp, mcET_SUBOP);
 case mcET_MULTOP:
  mcDEFINE_SPECIAL_ALLOCATOR(mcMultDivOp, mcET_MULTOP);
 case mcET_DIVOP:
  mcDEFINE_SPECIAL_ALLOCATOR(mcMultDivOp, mcET_DIVOP);
 case mcET_POLYNOMIAL:
  mcDEFINE_ALLOCATOR(mcPolynomial)
 case mcET_MONOMIAL:
  mcDEFINE_ALLOCATOR(mcMonomial)
 default:
  mcASSERT(0, wxT("The allocation of an undefined class was requested"));
 }

 return NULL;
}

// a macro used to avoid the repetion of specialized code in the
// following functions
#define SCAN_REGISTERED_CLASSES(fnc, params)     \
 /* for each MathCore registered element class */   \
 for (int i=0; i < mcNUM_ELEMENT_TYPES; i++) {  \
  if (sdata_pElem[i]->fnc(params) != FALSE) {    \
                \
   /* found the class we were searching for */   \
   return (mcElementType)i;       \
  }              \
 }               \
                \
 /* there is no class with that char as begin char */  \
 return mcET_INVALID;



mcElementType mcElementHelpers::gui_isKeyBeginKey(const mcKey &key) {
 SCAN_REGISTERED_CLASSES(gui_isBeginKey, key);
}

mcElementType mcElementHelpers::io_isCharBeginChar(const wxString &str) {
 SCAN_REGISTERED_CLASSES(io_isBeginChar, str);
}

mcElementType mcElementHelpers::io_isTagBeginTag(const wxXml2Node &tag) {
 SCAN_REGISTERED_CLASSES(io_isBeginTag, tag);
}

wxString mcElementHelpers::data_GetGlobalMemoryInfo()
{
 wxString res;

 for (int i=0; i < mcNUM_ELEMENT_TYPES; i++) {

  res += wxString::Format(wxT("Class number #%d: %d\n"), 
   i,//GetClassInfo()->GetClassName(),
   sdata_pElem[i]->data_GetMemoryInfo());
 }

 return res;
}

int mcElementHelpers::data_GenID(bool bFirstMember)
{
 // use both time and random generator to compute our ID
 static int l=0, r=0xFFFF;
 if (bFirstMember)
  return l++;
 return r++;//(rand()+wxGetLocalTime())/rand();
}

mcObjectRefData *mcElement::data_MakePrivateCopy()  // implements COW
{
 const mcElementHelpers *h = chlp();

 // if the mcElement-derived class we reference is owned only
 // by this mcElement, then we can just return it
 if (h->data_GetRefCount() == 1)
  return (mcElementHelpers *)h;

 // we need to unshare: unreference the old data
#ifdef mcENABLE_COW_DEEPDEBUG
 mcLOG(wxT("mcElementHelpers::data_MakePrivateCopy"));
#endif
 data_UnRef();

 // set as reference data a clone of current referenced data 
 data_SetRefData(h->data_Clone());

 // return our brand-new referenced data
 return (mcElementHelpers *)data_GetRefData(); 
}

void mcElementHelpers::gui_UpdateExpDepth()
{
 // DO NOT UPDATE CHILDREN:
 //   for (int i=0; i < data_GetChildrenCount(); i++)
 //      data_GetChild(i).gui_UpdateExpDepth();
 // default implementation does nothing because it doesn't know
 // anything about the relationships between this object and
 // its children... plus, the overloaded versions of this function
 // should have already updated (maybe calling the #gui_SetAsExpOf
 // or #gui_SetAtSameLevelOf functions) the expdepth of our
 // children; so, also UPDATE IS NOT NECESSARY !
 
 // we can just recalc our size: all the exponent updates
 // should have been already done !!
 gui_RecalcSize();
}

/*
void mcElementHelpers::SetExpDepth(int n)
{
 hlp()->m_nExpDepth = n;
 
 // update derived class variables
 data_UpdateExpDepth();
 
 // size should be changed because the style is chosen
 // basing on exponent depth and, if exponent depth has
 // changed, also style has changed...
 // the following piece of code is used to avoid that
 // this function, called during the mcElement creation,
 // calls the pure virtual mcElement function #gui_RecalcSize()...
 // mcElement uses m_nType variable to check whether this
 // mcElement class has already been constructed.. so it's
 // essential to change the value of that variable as
 // the first thing in derived classes' constructors...
 if (data_GetType() != mcET_INVALID && mcMathCore::Get()->isGUIEnabled())
  gui_RecalcSize();
}
*/






// ----------------------------------------
// mcELEMENTDATA
// ----------------------------------------

bool mcElementHelpers::data_isSameAs(const mcElementHelpers *p) const
{
 bool b = TRUE;

 // The ID must *not* be checked...
 // b &= (mdata_nID == p->mdata_nID);

 // check basic data
 b &= (data_GetType() == p->data_GetType());
 b &= (mdata_nProperties == p->mdata_nProperties);
 if (!b) return FALSE;

 // check also the children, recursively
 for (int i=0; i < data_GetChildrenCount(); i++)
  if (!data_GetConstChild(i).data_isSameAs(p->data_GetConstChild(i)))
   return FALSE;

 return TRUE;
}

//bool mcElementHelpers::data_hasSameChildren(c

void mcElementHelpers::data_DeepCopy(const mcElementHelpers *p)
{
 // types should already be the same (anyway, we could not copy them, since 
 // they are not stored in mcElementHelpers)
 mcASSERT(data_GetType() == p->data_GetType(), wxT("Cannot perform deep copy !!"));

 // copy basic data (except for ID !)
 mdata_nProperties = p->mdata_nProperties;
 
 mgui_bSelected = p->mgui_bSelected;
 mgui_sz = p->mgui_sz;
 mgui_pStyleArray = p->mgui_pStyleArray;
 mgui_nExpDepth = p->mgui_nExpDepth;
}






// ----------------------------------------
// mcELEMENTGUI
// ----------------------------------------

void mcElementHelpers::gui_Init() 
{
 // mark the size as dirty: it will be recalculated as soon as
 // gui_GetSize() or directly gui_RecalcSize() is called
 mgui_sz.Set(-1, -1);
 
 // as default, the element is not selected
 mgui_bSelected = FALSE;
 
 // set the style array (if gui is enabled)...
 if (!mcMathCore::Get()->isGUIEnabled())
  return;
 
 // We cannot check our parent for a valid style since we are still
 // in mcElementGUI constructor (and accessing helper classes is
 // *not* allowed during construction), so we choose default styles, by now.
 // Anyway, our parent can call SyncStyleWithParent() once construction has been
 // completed...
 mcASSERT(sgui_pDefaultStyles != NULL,
  wxT("pDefaultStyles must always be a valid array !!!"));
 
 // the style array *must* always be valid: mcElementGUI holds a static
 // array of styles which is the default for ALL elements...
 mgui_pStyleArray = sgui_pDefaultStyles;

 gui_RecalcSize();
}
/*
bool mcElementHelpers::gui_SyncStyleWithParent()
{
 const mcStyleArray *old = mgui_pStyleArray;

 // climb the tree searching for a valid style...
 const mcElement &p = hlp()->GetConstParent();
 if (p) {
  
  // set this element's style to be the same of the parent's
  // NOTE: maybe that the caller of this constructor is
  //       a mcElementData-derived class: in this case,
  //       the parent GUI pointer could be not set yet...
  //       but we need to set the style anyway, so we go
  //       on searching for a valid GUI parent...
  while (p) {
  
   if (p.gui()) {

    // ok, we have found a valid pointer to a style array;
    // stop here; climbing further the tree is not useful...
    mgui_pStyleArray = p.gui_mgui_pStyleArray;
    if (mgui_pStyleArray)
     break;
   }

   // go up one level...
   p = p.GetConstParent();
  }
 }
 mcASSERT(0, wxT(""));

 // if current style is different from the old one which was set
 // at the beginning of this function, then we managed to find a
 // valid style among parent's styles...
 return (old != mgui_pStyleArray);
}*/

mcElement mcElementHelpers::gui_GetSelection() const
{
 // return a copy of the element which is assumed to be entirely selected:
 // this should work for all non-container classes
 return mcElement(this);
}

mcElement &mcElementHelpers::gui_GetActiveElem(int x, int y, const wxPoint &pt) const
{
 wxScreenDC tmp;

 // use the gui_Draw() function to do the most important part of the work... 
 int n = gui_Draw(tmp, x, y, mcDRW_USEPOINT, pt);

 // and then, just convert the result of the gui_Draw() call to an element
 // pointer using the mcElementHelpers::data_GetElemFromID()
 if (n != mcDRW_NOACTIVEELEM && n != mcDRW_ONSELECTION)
  return data_GetElemFromID(n);
 return mcEmptyElement;
}

void mcElementHelpers::gui_RecalcSize()
{
 wxSize old = mgui_sz;
 gui_DoRecalcSize();

 // notify the element section...
 gui_OnRecalcSize(old);
}

void mcElementHelpers::gui_DeepRecalcSize()
{
 mcGUILOG(wxT("mcElementHelpers::gui_DeepRecalcSize [%s]"), mcTXTTHIS);

 // recalc children sizes...
 for (int i=0; i < data_GetChildrenCount(); i++)
  data_GetChild(i).gui_DeepRecalcSize();

 // finally recalc also our size....
 gui_RecalcSize();
}

void mcElementHelpers::gui_SelectAll()
{
 // select our children
 for (int i=0; i < data_GetChildrenCount(); i++)
  data_GetChild(i).gui_SelectAll();

 // select ourselves
 gui_Select();
}

void mcElementHelpers::gui_DeSelect()
{
 // deselect children
 for (int i=0; i < data_GetChildrenCount(); i++)
  data_GetChild(i).gui_DeSelect();

 // change also our selection state !!!
 mgui_bSelected = FALSE;
}

bool mcElementHelpers::gui_isAllSelected() const
{
 // are all our children selected ?
 for (int i=0; i < data_GetChildrenCount(); i++)
  if (!data_GetConstChild(i).gui_isAllSelected())
   return FALSE;

 // yes, they are... just check we are selected too...
 return gui_isSelected();
}

void mcElementHelpers::gui_DeleteSelection()
{
 mcASSERT(!gui_isAllSelected(), 
  wxT("This element is completely selected: it should be removed by the caller"));

 // delete the selection inside our children
 for (int i=0; i < data_GetChildrenCount(); i++)
  data_GetChild(i).gui_DeleteSelection();

 // size should have changed...
 gui_RecalcSize();
}





// ----------------------------------------
// mcELEMENTGUI - styles functions
// ----------------------------------------

void mcElementHelpers::gui_SetAsExpOf(const mcElement &p)
{
 if (p != mcEmptyElement)
  mgui_nExpDepth = p.gui_GetExpDepth()+1;

 // update exponent depth of the children
 gui_UpdateExpDepth();
}

void mcElementHelpers::gui_SetAtSameLevelOf(const mcElement &p)
{
 if (p != mcEmptyElement)
  mgui_nExpDepth = p.gui_GetExpDepth();

 // update exponent depth of the children
 gui_UpdateExpDepth();
}

void mcElementHelpers::gui_InitDefaultStyles()
{
 mcGUILOG(wxT("mcElementHelpers::gui_InitDefaultStyles"));

 // remove the previous existing styles (if present)
 gui_DeleteDefaultStyles();
 
 // create the style array
 sgui_pDefaultStyles = new mcStyleArray();
 mcStyle *p = new mcStyle();

 // and init it
 for (int j=0; j < sgui_pDefaultStyles->GetCount(); j++) {
  
  
  // choose different facenames on different platforms
  //
  // VERY IMPORTANT: all the facenames should be chosen among
  //                 the facenames which are installed by default
  //                 on that plaftform. Otherwise a default (ugly)
  //                 font will be chosen...
  //
  // NOTE: these fontfaces are NOT the font faces you will see if
  //       your program is using MathGUI library: it automatically
  //       change them...
  //
#if defined(__WXMSW__)
  
  
  wxString face1 = wxT("Lucida Sans Unicode");  //Trebuchet MS
  wxString face2 = wxT("Tahoma");
  wxString face3 = wxT("Verdana");
  const int size = 25;
  const int size2 = 20;
  /*wxString face1 = wxT("Times New Roman");  //Trebuchet MS
  wxString face2 = wxT("Tahoma");
  wxString face3 = wxT("Verdana");
  const int size = 12;
  const int size2 = 14;*/
  
#else
  
  wxString face1 = wxT("Lucida");
  wxString face2 = wxT("Lucida");
  wxString face3 = wxT("Lucida");//"Helvetica";
  const int size = 25;
  const int size2 = 25;
  
#endif
  
  // set up the font strings
  wxString num = wxString::Format(wxT("%d-%s-%d-%d-%d"), wxSWISS,
   face1.c_str(), size/(j+1), wxNORMAL, wxNORMAL);
  
  wxString fnc = wxString::Format(wxT("%d-%s-%d-%d-%d"), wxSWISS,
   face2.c_str(), size/(j+1), wxNORMAL, wxITALIC);
  
  wxString sym = wxString::Format(wxT("%d-%s-%d-%d-%d"), wxROMAN,
   face3.c_str(), size/(j+1), wxNORMAL, wxITALIC);
  
  wxString text = wxString::Format(wxT("%d-%s-%d-%d-%d"), wxSWISS,
   face2.c_str(), size2/(j+1), wxBOLD, wxNORMAL);
  
  wxString spec = wxString::Format(wxT("%d-%s-%d-%d-%d"), wxSWISS,
   wxT("MathStudio Special"), size/(j+1), wxBOLD, wxNORMAL);
  
  // sets the textsettings
  p->SetTextSettingsFor(mcET_NUMBER, mcINITWX(0xFF0000), *wxWHITE, num);
  p->SetTextSettingsFor(mcET_FUNCTION, mcINITWX(0x4080FF), *wxWHITE, fnc);
  p->SetTextSettingsFor(mcET_SYMBOL, mcINITWX(0x14A03C), *wxWHITE, sym);
  p->SetTextSettingsFor(mcET_TEXT, mcINITWX(0x329C7A), *wxWHITE, text);
  
  // mcET_ADDOP and all other operators use the same style, so we can
  // avoid to call SetTextSettingsFor(mcET_SUBOP, ....
  p->SetTextSettingsFor(mcET_ADDOP, mcINITWX(0x0), *wxWHITE, num);
  
  // these special settings are used to draw some special symbols...
  p->SetSpecialTextSettings(mcINITWX(0x0), *wxWHITE, spec);
  
  // be sure we built correctly everything
  mcASSERT(p->Ok(), wxT("Problems in style creation"));
  
  // store the style which has been just built
  sgui_pDefaultStyles->Set(p, j); // mcStyleArray::Set will *copy* the given style
 }

 // now, we can delete the temporary class we created to make
 // styles initialization easier...
 delete p;
}

double mcElementHelpers::gui_GetPointSize()
{
 // pxperpoint contains the point size in pixels; this variable is
 // calculated only once, the first time it's required.
 static double pxperpoint = 0;

 if (pxperpoint == 0) {

  wxScreenDC dc;

  // get the same result we would obtain calling GetDeviceCaps(),
  // using cross platform functions
  dc.SetMapMode(wxMM_POINTS);
  pxperpoint = dc.LogicalToDeviceYRel(72);
 }

 return pxperpoint;
}

void mcElementHelpers::gui_DeleteDefaultStyles()
{
 // this is an useful macro...
 mcSAFE_DELETE(sgui_pDefaultStyles);
}

double mcElementHelpers::gui_PointSize2Pixels(double pointsize)
{
 // use the formula taken from Win32 Platform SDK under CreateFont help:
 // nHeight = -MulDiv(PointSize, GetDeviceCaps(hDC, LOGPIXELSY), 72);
 //
 // here, we do not use the MulDiv & GetDeviceCaps functions because
 // they are Win32-specific; we need cross-platformness ... :-)
 return (pointsize * gui_GetPointSize());
}

double mcElementHelpers::gui_Pixels2PointSize(double pixels)
{
 // see #gui_PointSize2Pixels for more info about the formula used here
 return (72.0 * pixels / gui_GetPointSize());
}

int mcElementHelpers::gui_GetBaseOffsety(int exph) const
{
 // force the exponent to overlap the base (only on y axis) by half the
 // height of a character in exp style
 return (int)((exph/100.0)*50.);
}

int mcElementHelpers::gui_GetSubscriptOffsety(int baseh) const
{
 // force the exponent to overlap the base (only on y axis) by half the
 // height of a character in exp style
 return (int)((baseh/100.0)*60.);
}

const mcStyle *mcElementHelpers::gui_GetStyleForThis() const {
 // just to avoid the following line repeated one million times...
 return mgui_pStyleArray->gui_GetStyleFor(this);
}

const mcStyle *mcElementHelpers::gui_GetDefaultStyle(int n) {  // static
 return sgui_pDefaultStyles->Get(n);
}

const mcStyle *mcElementHelpers::gui_GetStyle(int n) const {
 // just to hide mgui_pStyleArray variable...
 return mgui_pStyleArray->Get(n);
}
/*
void mcElementHelpers::gui_SetGlobalStyleArray(const mcStyleArray *p) {
 // just to hide mgui_pStyleArray variable...
 mgui_pStyleArray = p;
}*/

void mcElementHelpers::gui_SelectStyle(wxDC &hDC) const {
 const mcStyle *p = gui_GetStyleForThis();

 // in this function it doesn't make sense to use a
 // wxScreenDC to select the style; it would be destroyed
 // when this function returns and it could not be used
 mcASSERT(hDC.Ok(), wxT("Invalid DC"));

 // select text fg/bk colors basing on element type
 p->gui_Select(hDC, this);
}

int mcElementHelpers::gui_GetThickness(wxDC *dc) const {
 mcGUILOG(wxT("mcElementHelpers::gui_GetThickness"));
 bool bClean = FALSE;

 if (dc == NULL) {
  dc = new wxScreenDC();
  bClean = TRUE;
 }

 // select the style for the given element and retrieve its attributes
 gui_SelectStyle(*dc);
 int nWeight = dc->GetFont().GetWeight();
 int nHeight = dc->GetFont().GetPointSize();

 // clean up
 if (bClean)
  delete dc;

 // empirical formula; it works good with "normal" fonts such as
 // Tahoma, Times New Roman...
 return (int)(nWeight/527.5 + nHeight/12.8);
}

wxSize mcElementHelpers::gui_GetSizeOf(wxDC *hDC, const wxString &str) {
 mcGUILOG(wxT("mcElementHelpers::gui_GetSizeOf [%s]"), str.c_str());
 bool bClean=FALSE;
 int w=0, h=0;
 
 // if user doesn't provide a valid DC, use MathCore default one
 if (hDC == NULL) {
  hDC = new wxScreenDC();
  bClean = TRUE;
 }

 // if user provided an empty string, no problem
 if (str.IsEmpty()) return wxSize(0,0);

 // be sure to get right size
#ifdef __WXGTK20__
 mcGUILOG(wxT("------------------ Using the buggy wxScreenDC function -----------------"));
 hDC->GetTextExtent(str, &w, &h);//, NULL, NULL, &current);
#else
 hDC->GetTextExtent(str, &w, &h);
#endif
 mcASSERT(w != 0 && h != 0, wxT("Cannot retrieve character size"));

 // clean up
 if (bClean)
  delete hDC; 

 // and return
 return wxSize(w, h);
}

int mcElementHelpers::gui_GetWidthOf(wxDC *h, const wxString &str) {
 return gui_GetSizeOf(h, str).GetWidth();
}

int mcElementHelpers::gui_GetHeightOf(wxDC *h, const wxString &str) {
 return gui_GetSizeOf(h, str).GetHeight();
}

wxSize mcElementHelpers::gui_GetSizeOfChar(wxDC *hDC, const mcElement &p) const {
 return wxSize(mcElementHelpers::gui_GetWidthOfChar(hDC, p),
      mcElementHelpers::gui_GetHeightOfChar(hDC, p));
}

int mcElementHelpers::gui_GetWidthOfChar(wxDC *hDC, const mcElement &p) const {
 mcGUILOG(wxT("mcElementHelpers::gui_GetWidthOfChar"));
 bool bClean=FALSE;
 int w;

 // if user doesn't provide a valid DC, use MathCore default one
 if (hDC == NULL) {
  hDC = new wxScreenDC();
  bClean = TRUE;
 }

 // if the given pointer is NULL, use the font which is
 // already selected in the DC
 if (p != NULL)
  p.gui_SelectStyle(*hDC);

 // be sure to get right size
 w = hDC->GetCharWidth();
 mcASSERT(w != 0, wxT("Cannot retrieve character size"));

 // clean up
 if (bClean)
  delete hDC;

 // and return
 return w;
}

int mcElementHelpers::gui_GetHeightOfChar(wxDC *hDC, const mcElement &p) const {
 mcGUILOG(wxT("mcElementHelpers::sgui_GetHeightOfChar"));
 bool bClean=FALSE;
 int h;

 // if user doesn't provide a valid DC, use MathCore default one
 if (hDC == NULL) {
  hDC = new wxScreenDC();
  bClean = TRUE;
 }

 // if the given pointer is NULL, use the font which is
 // already selected in the DC
 if (p != NULL)
  p.gui_SelectStyle(*hDC);

 // be sure to get right size
 h = hDC->GetCharHeight();
 mcASSERT(h != 0, wxT("Cannot retrieve character size"));

 // clean up
 if (bClean)
  delete hDC;

 // and return
 return h;
}





// ----------------------------------------
// mcELEMENTIO - miscellaneous
// ----------------------------------------

void mcElementHelpers::io_PostProcessChildren()
{
 for (int i=0; i < data_GetChildrenCount(); i++)
  data_GetChild(i).hlp()->io_PostProcess();
}





// ----------------------------------------
// mcELEMENTMATH - basic functions
// ----------------------------------------

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

void mcElementHelpers::math_SimpleAdd(const mcElement &p, bool add)
{
 mcMATHLOG(wxT("mcElementHelpers::math_SimpleAdd [%s] - simple adding with [%s]"),
    mcTXTTHIS, mcTXT(p));
 mcBasicOpRes r = math_Add(p, NULL, add);
 mcASSERT(r == mcBOR_REMOVE_OPERAND, 
   wxT("The operation could not be completely performed: ")
   wxT("the given operand has not been completely merged in *this"));
 mcUNUSED(r);  // avoid dummy warnings
}

void mcElementHelpers::math_SimpleMultiplyBy(const mcElement &p)
{
 mcMATHLOG(wxT("mcElementHelpers::math_SimpleMultiplyBy [%s] - simple multiplying by [%s]"),
    mcTXTTHIS, mcTXT(p));
 mcBasicOpRes r = math_MultiplyBy(p, NULL);
 mcASSERT(r == mcBOR_REMOVE_OPERAND, 
   wxT("The operation could not be completely performed: ")
   wxT("the given operand has not been completely merged in *this"));
 mcUNUSED(r);  // avoid dummy warnings
}

void mcElementHelpers::math_SimpleDivideBy(const mcElement &p)
{
 mcMATHLOG(wxT("mcElementHelpers::math_SimpleDivideBy [%s] - simple dividing by [%s]"),
    mcTXTTHIS, mcTXT(p));
 mcBasicOpRes r = math_DivideBy(p, NULL);
 mcASSERT(r == mcBOR_REMOVE_OPERAND, 
   wxT("The operation could not be completely performed: ")
   wxT("the given operand has not been completely merged in *this"));
 mcUNUSED(r);  // avoid dummy warnings
}

void mcElementHelpers::math_SimpleRaiseTo(const mcPolynomial &p)
{
 mcMATHLOG(wxT("mcElementHelpers::math_SimpleRaiseTo [%s] - simple raising by [%s]"),
    mcTXTTHIS, mcTXT(p));
 mcBasicOpRes r = math_RaiseTo(p);
 mcASSERT(r == mcBOR_REMOVE_OPERAND, 
   wxT("The operation could not be completely performed: ")
   wxT("the given operand has not been completely merged in *this"));
 mcUNUSED(r);  // avoid dummy warnings
}

bool mcElementHelpers::math_isExpAllowed(mcElement p) 
{
 // check if the exponent level is under the limit
 //if (p.GetExpDepth()+1 < mcELEMENTMATH_MAX_EXPDEPTH)
  return TRUE;
 //return FALSE;
}

bool mcElementHelpers::math_isSubAllowed(mcElement )
{
 // allow nested subscripts to a undefined depth...
 return TRUE;
}

void mcElementHelpers::math_SetExp(const mcPolynomial &pol)
{
 // just call recursively the math_SetExp on our children...
 // this behaviour is right for those elements not-derived
 // from mcExpElement and which does not own an exponent
 // and thus are obliged to set the exponents of their children
 for (int i=0; i<data_GetChildrenCount(); i++)
  data_GetChild(i).math_SetExp(pol);
}

mcBasicOpRes mcElementHelpers::math_MakeReciprocal(mcElement *replacement)
{
 mcFraction f;
 f.data_GetNum().math_WrapNumber(1);
 f.data_GetDen().math_WrapSimple(mcElement(this));
 *replacement = f;

 return mcBOR_REPLACE_BOTH;
}

mcExpSimRes mcElementHelpers::math_MaxSimplify(long flags)
{
 mcExpSimRes retflag = mcESR_NOTFINISHED;
 int cycles=0;

 // call mcElementHelpers::math_Simplify(long flags) until everything is completely
 // simplified....
 while (retflag != mcESR_DONE) {
  retflag = math_Simplify(flags, NULL);  // NULL is just to compile but it's wrong
  cycles++;
  
  if (cycles >= mcELEMENTMATH_MAX_PROCESS_CYCLES)  // avoid to block the program
   return mcESR_NOTFINISHED;  // cannot finish !!!
 }

 return mcESR_DONE;
}

bool mcElementHelpers::math_isMaxSimplified(long flags) const
{
 mcExpSimRes retflag = mcESR_NOTFINISHED;
 int cycles=0;

 // work on a backup copy
 mcElementHelpers *backup = data_Clone();

 // call mcElementHelpers::math_Simplify(long flags) until everything is completely
 // simplified....
 while (retflag != mcESR_DONE) {
  retflag = backup->math_Simplify(flags, NULL);  // NULL is just to compile but it's wrong
  cycles++;

  if (cycles >= mcELEMENTMATH_MAX_PROCESS_CYCLES)  // avoid to block the program
   break;
 }

 // if the function returned mcESR_DONE at the first math_Simplify call, then
 // it should be completely simplified...
 return (cycles == 1);
}

mcRealValue mcElementHelpers::math_GetTotalLenght() const
{
 // to compute the lenght of this element we must take in count:
 // 1) the lenght of the children
 // 2) the lenght of this element itself (without its children)
 //    using the #math_GetLenght() function
 mcRealValue l = math_GetLenght();
 
 for (int i=0; i < data_GetChildrenCount(); i++)
  l += data_GetConstChild(i).math_GetTotalLenght();
  
 return l;
}

bool mcElementHelpers::math_isFinite() const
{
 mcRealValue res = math_Evaluate();
 if (res.math_isFinite())
  return TRUE;
 return FALSE;
}

bool mcElementHelpers::math_isValidMath() const
{
 switch (data_GetType()) {
 case mcET_INVALID:
 case mcET_PARENTHESIS:
 case mcET_EMPTYBOX:
/* case mcET_ADDOP:
 case mcET_SUBOP:
 case mcET_MULTOP:
 case mcET_DIVOP:*/
 case mcET_TEXT:
  return FALSE;  // a mcDecoration-derived class

 default:
  break;
 }

 // we are valid but we have to check our children...
 for (int i=0; i < data_GetChildrenCount(); i++)
  if (!data_GetConstChild(i).math_isValidMath())
   return FALSE;

 // ok; we are fully valid
 return TRUE;
}

bool mcElementHelpers::math_isListedBeforeOf(const mcElement &p) const
{
 if (math_GetOrderPos() < p.math_GetOrderPos())
  return TRUE;
 return FALSE;
}

mcMonomial mcElementHelpers::math_GetFactors() const
{
 mcMonomial pol;
 pol.math_WrapSimple(this);

 return pol;
}




// -------------------------------------------------------------------
// mcELEMENTMATH - search, comparison & replace functions
// -------------------------------------------------------------------

bool mcElementHelpers::math_Contains(const mcElement &p, long flags) const
{ return math_Find(0, p, flags) != mcEmptyElement; }

bool mcElementHelpers::math_ContainsNumber(const mcRealValue &num,
             const mcPolynomial &exp) const
{
 mcNumber n(num);

 // use the given polynomial as exponent, if required
 if (exp != mcEmptyPolynomial)
  n.data_SetExpSub(TRUE, exp);

 return math_Contains(n);
}

bool mcElementHelpers::math_ContainsSymbol(const mcSymbolProperties *prop,
             const mcPolynomial &exp) const
{
 mcSymbol safe(prop->data_GetSafeLinkedSym());
 mcASSERT(safe.data_isOk(), wxT("Invalid safe symbol ?"));

 // use the given polynomial as exponent, if required
 if (exp != mcEmptyPolynomial)
  safe.data_SetExpSub(TRUE, exp);

 return math_Contains(safe);
}

bool mcElementHelpers::math_ContainsOneOf(const mcSymbolArray *arr) const
{
 int max = arr->data_GetCount();
 for (int i=0; i < max; i++) {

  // this element will be used to contain the properties of
  // the symbol we are searching for in this element
  //mcSymbol sym;

  // try to search all the symbols in the given array...
  const mcSymbolProperties *curr = arr->data_GetSymbol(i);

  // BAD CAST FROM CONST TO NON-CONST !!!!
  //sym.data_LinkWith((mcSymbolProperties *)curr);

  if (math_Contains(curr->data_GetSafeLinkedSym())) {

   // ok; we contain one of the array's symbol
   return TRUE;
  }
 }

 // we do not contain any of the symbol listed in arrUnknowns
 return FALSE;
}

bool mcElementHelpers::math_ContainsUnknowns() const
{ return math_ContainsOneOf(&mcSymbol::arrUnknowns); }

bool mcElementHelpers::math_ContainsConstants() const
{ return math_ContainsOneOf(&mcSymbol::arrConstants); }

bool mcElementHelpers::math_ContainsParameters() const
{ return math_ContainsOneOf(&mcSymbol::arrParameters); }

bool mcElementHelpers::math_ContainsSymbols() const
{
 // just check if contains any of the three supported type of symbols...
 return math_ContainsUnknowns() || 
   math_ContainsConstants() ||
   math_ContainsParameters();
}

bool mcElementHelpers::math_ContainsInvalidSymbols() const
{
 // just scan for unregistered symbols...
 return math_ContainsOneOf(&mcSymbol::arrUnregistered);
}

bool mcElementHelpers::math_isConstant() const
{
 // since the only non-container elements are mcSymbols and mcNumbers
 // we just need to check them; since mcNumbers are allowed in any
 // case, we just have to check mcSymbols...
 return !math_ContainsParameters() && !math_ContainsUnknowns();
}

int mcElementHelpers::math_GetSymbolList(mcSymbol **arr, int size, const mcSymbol &tofind) const
{
 int n = 0;
 //if (arr == NULL) return -math_GetCountOf(&tofind);

 // start to search the first symbol...
 const mcElement p = math_Find(n, tofind);
/*
 while (p) {

  if (size <= n) return -math_GetCountOf(&tofind);

  // store this entry
  arr[n] = (mcSymbol *)p;

  // and search the next...
  p = math_Find(++n, tofind);
 }*/

 return n;
}

int mcElementHelpers::math_GetSymbolList(mcSymbol **arr, int size, mcSymbolProperties &tofind) const
{
 mcSymbol tmp;
 tmp.data_LinkWith(&tofind);

 return math_GetSymbolList(arr, size, tmp);
}

bool mcElementHelpers::math_CompareThisOnly(const mcElement &p, long) const
{
 // we just need to compare types for simple elements
 // which are just containers of other elements (like
 // mcFraction)
 return (data_GetType() == p.data_GetType());
}

mcElement mcElementHelpers::math_Find(int n, const mcElement &p, long flags) const
{
 mcASSERT(n >= 0, wxT("Invalid occurrence to find"));
 int k = n;

 // search recursively
 return math_RecursiveFind(k, p, flags);
}

mcElement mcElementHelpers::math_FindInChildrenOnly(int n, const mcElement &p, long flags) const
{
 mcASSERT(n >= 0, wxT("Invalid occurrence to find"));
 int k = n;

 // search recursively
 return math_RecursiveFindInChildrenOnly(k, p, flags);
}

int mcElementHelpers::math_NonRecursiveFindInChildren(int n, 
     const mcElement &p, long flags) const
{
 mcASSERT(n >= 0, wxT("Invalid occurrence to find"));

 // scan all the children
 for (int i=0,max=data_GetChildrenCount(); i<max; i++) {
    
  if (data_GetConstChild(i).math_Compare(p, flags)) {
   
   // did we find it ?  
   if (--n == -1)
    return i;

   // wait for next
  }
 }
 
 // could not find anything
 return -1;
}

mcElement mcElementHelpers::math_RecursiveFindInChildrenOnly(int &n, 
        const mcElement &p, long flags) const
{
 mcASSERT(n >= 0, wxT("Invalid occurrence to find"));

 // scan all the children
 for (int i=0,max=data_GetChildrenCount(); i<max; i++) {

  // and recursively search in each of them the element p
  const mcElement &res = data_GetConstChild(i).chlp()->math_RecursiveFind(n, p, flags);

  // did we find it ?
  // NOTE: since we passed a reference of n, something like
  //            if (res != mcEmptyElement) n--;
  //       is not necessary 
  if (n == -1) {

   // if the given pointer is valid...
   if (res != mcEmptyElement) 
    return res;

   // if it's not it must be because the data_GetConstChild(i)
   // is the parent of the element to find and "flags" contain
   // the mcFIND_PARENT flag...
   mcASSERT(flags & mcFIND_PARENT, wxT("Something wrong"));

   // NOTE: perform this check
   //       1) without the mcFIND_PARENT flag since we don't need it
   //       2) with "n+1" since n is now -1 and thus it's invalid.
   mcASSERT(math_NonRecursiveFindInChildren(n+1, p, flags & ~mcFIND_PARENT) != -1,
    wxT("Cannot find the element tofind in the children of *this..."));
   return mcElement(this);
  }
 }

 return mcEmptyElement;
}
/*
mcElement mcElementHelpers::math_FindParent(const mcElement &p, long flags) const
{

}*/

mcElement mcElementHelpers::math_RecursiveFind(int &n, 
        const mcElement &p, long flags) const
{
 mcASSERT(n >= 0, wxT("Invalid occurrence to find"));

 // if we are of the same type of p and we have enough children,
 // the it maybe that we are identic to "p"...
 if (math_CompareThisOnly(p, flags) &&
  data_GetChildrenCount() >= p.data_GetChildrenCount()) {

  // to be sure that this element matches "p", we must
  // compare all p's children with our children in the right
  // order: if one or more child is different from the relative
  // p's child, then we can just try to search "p" in our children
  // recursively...
  for (int i=0,max=p.data_GetChildrenCount(); i<max; i++)
   if (!data_GetConstChild(i).math_Compare(p.data_GetConstChild(i), flags))
    return math_RecursiveFindInChildrenOnly(n, p, flags); // we don't match p

  // we are identic to p and this is true also for ours
  // first p.data_GetChildrenCount() children; we can thus
  // return ourselves as result or just decrement 'n' (it's a
  // reference, so the caller's "n" is automatically sync)
  // if this is not the occurrence we are searching for...
  if (--n == -1) {

   // if we have to return not the element itself but its parent,
   // then we have to return with "n" set to -1 and with a NULL element:
   // math_RecursiveFindInChildrenOnly will then understand what
   // happened and will return the parent of "p" (which we do not hold
   // and thus we cannot return it directly).
   if (flags & mcFIND_PARENT)
    return mcEmptyElement;

   return mcElement(this);
  }
 }

 // *this does not match "p"; just search in our children
 return math_RecursiveFindInChildrenOnly(n, p, flags);
}

int mcElementHelpers::math_GetCountOfChildrenOnly(const mcElement &p, long flags) const
{
 int total = 0;

 for (int i=0,max=data_GetChildrenCount(); i<max; i++)
  total += data_GetConstChild(i).math_GetCountOf(p, flags);

 return total;
}

int mcElementHelpers::math_GetCountOf(const mcElement &p, long flags) const
{
 int total = 0;

 if (math_CompareThisOnly(p, flags) &&
  data_GetChildrenCount() >= p.data_GetChildrenCount()) {     

  for (int i=0,max=p.data_GetChildrenCount(); i<max; i++)
   if (!data_GetConstChild(i).math_Compare(p.data_GetConstChild(i), flags))
    return math_GetCountOfChildrenOnly(p, flags);

  total++;
 }

 return total+math_GetCountOfChildrenOnly(p, flags);
}

int mcElementHelpers::math_GetCountOf(const mcSymbolProperties *p, long flags) const
{
 mcSymbol safe(p->data_GetSafeLinkedSym());
 mcASSERT(safe.data_isOk(), wxT("Invalid safe symbol ?"));

 return math_GetCountOf(safe, flags);
}

int mcElementHelpers::math_GetCountOf(const mcSymbolArray *p, long flags) const
{
 int total = 0;

 // slow but easy to code... 
 for (int i=0; i<p->data_GetCount(); i++)
  total += math_GetCountOf(p->data_GetSymbol(i), flags);

 return total;
}

int mcElementHelpers::math_GetCountOfSymbolsType(const mcSymbolArray *p, long flags) const
{
 int total = 0;

 // unlike math_GetCountOf(const mcSymbolArray *p, ...) we don't
 // want to take the total number of symbols contained: we want
 // to know how many *types* of symbols of the given array are
 // contained...
 for (int i=0; i<p->data_GetCount(); i++)
  total += (int)math_ContainsSymbol(p->data_GetSymbol(i));

 return total;
}

int mcElementHelpers::math_Replace(const mcElement &tofind, int n, long flags,
       const mcElement &replacement, bool addchildren)
{
 mcMATHLOG(wxT("mcElementHelpers::math_Replace [%s] - going to replace [%s] with [%s]"),
    mcTXTTHIS, mcTXT(tofind), mcTXT(replacement));
 mcElement p(mcEmptyElement);
 int ntotal = 0;
 bool onlyone = (n != -1);
 int occ = (onlyone ? n : 0);

 // we have to find the first unshared parent of the element tofind
 mcElement parent = math_Find(occ, tofind, flags | mcFIND_PARENT);
 if (parent == mcEmptyElement) return 0;
 const mcElement *currtofind = &parent;

 mcElement currparent(mcEmptyElement);
 while (currtofind) {

  // calling the math_Find() function, we ask "parent" to share
  // the same reference data of the actually found element...  
  currparent = math_Find(0, *currtofind, flags | mcFIND_PARENT);
  if (currparent == mcEmptyElement) break;

  // ... thus, if that element is shared only by an element, then
  // it should have a reference count == 2
  if (currparent.data_GetRefData()->data_GetRefCount() > 2)
   currtofind = &currparent;
  else
   currtofind = NULL;
 }

 // "currparent" is not shared by anyone...
 /*while (currparent != parent) {
  currparent.math_Find(
 }
 
 // if we have to replace all the occurrences, start from the first
 int occ = (onlyone ? n : 0);
 
 // first of all, find the element
 mcElement p = math_Find(occ, tofind, flags);

 mcElement &parent = p;
 while (parent 
 mcElement parent = math_Find(occ, tofind, flags | mcFIND_PARENT);
 mcASSERT(parent != mcEmptyElement, 
   wxT("Cannot replace an element which does not have a parent"));
 while (parent != mcEmptyElement) {
  
  // now search in the parent we've just found, the element to find...
  int idx = parent.math_NonRecursiveFindInChildren(occ, tofind, flags);
  mcASSERT(idx != -1, wxT("We've found an invalid parent !")
       wxT("The parent does not have a pointer to its child ?"));
  p = parent.data_GetConstChild(idx);
  
  mcMATHLOG(wxT("mcElementHelpers::math_Replace - the parent of [%s] is [%s]"), 
   mcTXT(p), mcTXT(parent));
  
  // if we want to add the children of "p" to the replacement...
  mcElement rep(replacement);
  if (addchildren) {

   // create a new instance of the replacement
   // with the children attached...
   mcElement tmp(replacement);
   bool b = p.data_AddChildrenTo(tmp);
 
   // if we've been called with addchilren = TRUE, then this
   // operation should always work; otherwise, some elements
   // (the children of p) would be lost...
   mcASSERT(b, wxT("Cannot add children... check function call"));

   // don't use normal replacement for this replace operation;
   // use the replacement+children
   rep = tmp;
  }
  
  // then replace it (data_SetChild will make a copy)
     parent.data_SetChild(idx, rep);
  mcMATHLOG(wxT("mcElementHelpers::math_Replace - replaced occ #%d: [%s]"), 
   ntotal, mcTXT(parent));
  
  // another substitution has been done...
  ntotal++;  
  if (onlyone) break;

  // find next first occurrence of TOFIND...
  // we'll search the first occurrence since the one we've just
  // found has been replaced and thus does not exist anymore.
  parent = math_Find(0, tofind, flags | mcFIND_PARENT);

 }*/
 
 return ntotal;
}


// some wrappers which must be implemented in the source file...

mcMonomial mcElement::math_GetLCM(const mcElement &p) const
{ return hlp()->math_GetLCM(p); }

mcMonomial mcElement::math_GetGCD(const mcElement &p) const
{ return hlp()->math_GetGCD(p); }

mcMonomial mcElement::math_GetFactors() const
{ return hlp()->math_GetFactors(); }




mcRealValue mcElementHelpers::math_EvaluateAt(const mcSymbolProperties *sym,
            const mcRealValue &symvalue) const
{
 mcMATHLOG(wxT("mcElementHelpers::math_EvaluateAt [%s] - evaluating at [%s]=%s"),
    mcTXTTHIS, mcTXTP(sym), mcTXTV(symvalue));

#if 0
 mcSymbol symtorep;
 symtorep.data_LinkWith(&sym);
 mcNumber replacement;
 replacement.math_Set(symvalue);
 
 // or we should move sym to constants temporarily ?
 
 mcMathMng *clone = this->Clone();
 clone.math_Replace(&symtorep, -1, &replacement, TRUE);
 mcRealValue res = clone.math_Evaluate();
 delete clone;
#endif

 // FIXME: thread unsafe ???
/*
 int entry = -1;
 const mcSymbolProperties *sym = psym;

 // find the array containing the given symbol (should be arrParameters
 // or arrUnknowns)...
 mcSymbolArray *oldarr = mcSymbol::math_FindSymbol(mcSYMFIND_MATCH_ALL, *sym, 0, &entry);
 if (oldarr == NULL || entry == mcSYM_NOTFOUND) return *mcRealValue::pNAN;

 // save its old value
 mcRealValue old = sym->m_fValue;
 
 // temporary move it to mcSymbol::arrConstants
 mcSymbolProperties *newsym = oldarr->data_MoveSymbols(entry, &mcSymbol::arrConstants);
 if (newsym == NULL) return *mcRealValue::pNAN;

 // and sets a new value
 newsym->m_fValue = symvalue;

 // evaluate with the symbol's new value
 mcRealValue res = math_Evaluate();

 // now, undo what we did
 newsym->m_fValue = old;
 entry = mcSymbol::arrConstants.data_FindSymbol(mcSYMFIND_MATCH_ALL, *newsym);
 psym = mcSymbol::arrConstants.data_MoveSymbols(entry, oldarr); 
*/
 // NOTE: this should not be done, generally; however, here we can do
 //       it because we are going to modify the given mcSymbolProperties
 //       but we are also going to undo our changes... :-)
 mcSymbolProperties *psym = (mcSymbolProperties *)sym;

 // temporary set the "evaluation mode"
 psym->m_bEvaluating = TRUE;
 psym->m_fValue = symvalue;

 // evaluate ourselves
 mcRealValue res = math_Evaluate();

 // then revert everything to normal mode
 psym->m_bEvaluating = FALSE;
 psym->m_fValue = *mcRealValue::pNAN;

 mcMATHLOG(wxT("mcElementHelpers::math_EvaluateAt - result is %s"), mcTXTV(res));
 return res;
}

---

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

[ Top ]