Main page

---

ExpElement.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 "ExpElement.cpp"
#endif

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

#ifndef mcPRECOMP
//#include <math.h>
 #include "mc/ExpElement.h"
 #include "mc/Bracket.h"
 #include "mc/Number.h"
 #include "mc/Radical.h"
 #include "mc/Monomial.h"
#endif


mcIMPLEMENT_ABSTRACT_CLASS(mcExpElement, mcElement);


// setup customizable variables
bool mcExpElementHelpers::smath_bConvertToRadicalWhenPossible = FALSE;





// ----------------------------------------
// mcEXPELEMENT
// ----------------------------------------

#ifdef __MCDEBUG__

wxString mcExpElementHelpers::data_Debug(long flags) const
{
 wxString str = data_BaseDebug(flags);

 // if an exponent is present, add also exponent debug info
 // to check if an exponent is present, don't use such a line:
 //    if (this->data_hasProperty(mcEP_HASEXPONENT))
 // because math functions work modifying the exp without adding
 // this flag (sometimes)
 if (data_GetExp() != NULL)
  str += data_ExpDebug(flags);

 // do the same for the subscript
 if (this->data_hasProperty(mcEP_HASSUBSCRIPT))
  str += data_SubDebug(flags);

 // we don't need to add exp debug info
 return str;
}

void mcExpElementHelpers::data_Check() const
{
 // first basic checks
 mcElementHelpers::data_Check();

 // check if everything is okay with flags/variables
 mcASSERT((data_GetExp() != mcEmptyElement && data_hasProperty(mcEP_HASEXPONENT)) ||
  (data_GetExp() == mcEmptyElement && !data_hasProperty(mcEP_HASEXPONENT)), 
  wxT("The mcEP_HASEXPONENT flag is not synchronized with the exponent variable !"));

 // do we have to check the exponent ?
 const mcElement &e = data_GetExp();
 if (e == mcEmptyElement) return;

 // check the exponent type
 // NOTE: since it's one of our children, it should have
 //       been already data_Check()ed by mcElementHelpers::data_Check()
 mcASSERT(e.data_GetType() == mcET_POLYNOMIAL,
  wxT("mcExpElementMath can work only on mcPolynomials as exp")); 
}

#define mcEXPELEM_HEADER   0

wxString mcExpElementHelpers::data_ExpDebug(long flags) const
{
 int step = mcMathCore::Get()->m_nIndentationStep;

 // use the mcElement function data_GetDebug
 return wxString(wxT('*'), mcEXPELEM_HEADER) + wxT(" EXPONENT [\n") +
   data_GetExp().data_GetDebug(step, flags) +
   wxString(wxT('*'), mcEXPELEM_HEADER) + wxT(" EXPONENT ]");
}

wxString mcExpElementHelpers::data_SubDebug(long flags) const
{
 int step = mcMathCore::Get()->m_nIndentationStep;

 // use the mcElement function data_GetDebug
 return wxString(wxT('*'), mcEXPELEM_HEADER) + wxT(" SUBSCRIPT [\n") +
   data_GetSub().data_GetDebug(step, flags) +
   wxString(wxT('*'), mcEXPELEM_HEADER) + wxT(" SUBSCRIPT ]");
}

#endif  // __MCDEBUG__





// ----------------------------------------
// mcEXPELEMENTDATA
// ----------------------------------------

void mcExpElementHelpers::data_CreateExpSub(bool exp)
{
 data_DestroyExpSub(exp);

 if (exp) {
  
  // by default, the exponent is a mcPolynomial
  mcASSERT(mdata_bExpEnabled, wxT("Exponent creation is disabled"));
  
  if (!mdata_pExp.data_isOk())
   mdata_pExp.data_SetRefData(new mcPolynomialHelpers());
  else
   ((mcPolynomial &)mdata_pExp).data_DeleteAll();
  
 } else {
  
  // by default, the subscript is a mcText
  mcASSERT(mdata_bSubEnabled, wxT("Subscript creation is disabled"));
  
  if (!mdata_pSub.data_isOk())
   mdata_pSub.data_SetRefData(new mcTextHelpers());
  else
   ((mcText &)mdata_pSub).data_SetText(wxT(""));
  
 }

 // set the expdepth
 data_Get(exp).gui_SetAsExpOf(this);

 // now we have an exponent...
 data_AddProperty(mcEP_HAS(exp));
 mcLOG(wxT("mcExpElementHelpers::data_CreateExpSub [%s] - created the "), 
  mcTXTTHIS, (exp ? wxT("exponent") : wxT("subscript")));
}

void mcExpElementHelpers::data_SetExpSub(bool exp, const mcElement &p)
{
 // this call erases previous exp (if present)
 data_CreateExpSub(exp);

 // now, weak copy the exponent 
 data_Get(exp).data_DeepCopy(p);
}

void mcExpElementHelpers::data_DestroyExpSub(bool exp)
{
 data_RemoveProperty(mcEP_HAS(exp));

 if (exp)
  mdata_pExp = mcEmptyElement; 
 else
  mdata_pSub = mcEmptyElement;

  /* CANNOT UNCOMMENT THE FOLLOWING LINE: a call to a pure virtual function would
     result otherwise....
     mcLOG(wxT("mcExpElementHelpers::data_DestroyExp [%s] - exponent removed"), mcTXTTHIS);*/ 
}

void mcExpElementHelpers::data_DeepCopyExpSub(bool exp, const mcExpElementHelpers *d)
{
 if (d->data_Get(exp) != mcEmptyElement) {

  // create & deep copy the sub/exp 
  data_CreateExpSub(exp);
  data_Get(exp).data_DeepCopy(d->data_Get(exp));

 } else {

  // or delete it in case it must be NULL
  data_DestroyExpSub(exp);
 }
}

void mcExpElementHelpers::data_DeepCopy(const mcElementHelpers *p)
{
 const mcExpElementHelpers *d = (const mcExpElementHelpers *)p;

 // deep copy basic data
 mgui_bExpRight = d->mgui_bExpRight;
 mgui_bSubRight = d->mgui_bSubRight;
 mdata_bExpEnabled = d->mdata_bExpEnabled;
 mdata_bSubEnabled = d->mdata_bSubEnabled;

 mgui_nCursorLoc = d->mgui_nCursorLoc;
 mgui_szBase = d->mgui_szBase;

 // deep copy the exponent if present...
 data_DeepCopyExpSub(TRUE, d);
 data_DeepCopyExpSub(FALSE, d);
}







// ----------------------------------------
// mcEXPELEMENTGUI
// ----------------------------------------
/*
void mcExpElementHelpers::gui_DeepCopy(const mcElementGUI *p)
{
 mcExpElementGUI *d = (mcExpElementGUI *)p;

 mgui_nCursorLoc = d->mgui_nCursorLoc;
 mgui_szBase = d->mgui_szBase;
 mcElementHelpers::sgui_DeepCopy(p);
}*/

void mcExpElementHelpers::gui_CreateExpSub(bool exp)
{
 data_CreateExpSub(exp);
 
 if (data_Get(exp).data_GetType() == mcET_POLYNOMIAL)
  ((mcPolynomial &)data_Get(exp)).gui_AddNewEmptyMonomial();
}

bool mcExpElementHelpers::gui_isEndKey(const mcKey &ev) const
{
 if (gui_isCursorInExpSub(TRUE))
  return gui_isExpSubEndKey(TRUE, ev);
 if (gui_isCursorInExpSub(FALSE))
  return gui_isExpSubEndKey(FALSE, ev);

 // the cursor is in the base...
 bool b = gui_isBaseEndKey(ev);

 // check for exponent and subscript
 if (b == TRUE && gui_GetBaseCursorPos().isEnd() && gui_hasBaseSthOnRightSide())
  return FALSE;
 if (b == TRUE && gui_GetBaseCursorPos().isBegin() && gui_hasBaseSthOnLeftSide())
  return FALSE;

 return b;
}

void mcExpElementHelpers::gui_DoRecalcSize()
{
 gui_DoRecalcBaseSize();  // this one must update mgui_szBase

 // we must call this function specially if mdata_bExpEnabled or mdata_bSubEnabled
 // is FALSE: they update the exp/sub size to zero, in that case !!!
 gui_RecalcExpSubSize(TRUE);  // this one must update data_GetExp().gui_mgui_sz
 gui_RecalcExpSubSize(FALSE);  // this one must update data_m_txtSub.gui_mgui_sz

 // if the exponent is disabled, gui_GetExpSize will return wxSize(0,0), so
 // everything works without problem; the same for the subscript
 int maxw = mcMAX(gui_GetExpSubOffsetx(TRUE)+gui_GetExpSubSize(TRUE).GetWidth(),
     gui_GetExpSubOffsetx(FALSE)+gui_GetExpSubSize(FALSE).GetWidth());

 // base offsety + base height
 int maxh = gui_GetBaseOffsety() + gui_GetBaseAndSubSize().GetHeight();

 // set as global size the maximum size we have
 mgui_sz.SetWidth(mcMAX(maxw, gui_GetBaseSize().GetWidth()));
 mgui_sz.SetHeight(maxh);
}

void mcExpElementHelpers::gui_DrawActivationRect(wxDC &dc, int x, int y) const
{
 // make all the bb of this element active
 dc.SetBrush(*mcElementHelpers::sgui_pActivationBrush);
 dc.SetPen(*wxBLACK_PEN);

 // draw the rect taking in count the sgui_nAdditionalActivationSpaceLeftRight
 // adjust value...
 dc.DrawRectangle(x-sgui_nAdditionalActivationSpaceLeftRight, y, 
      gui_GetSize().GetWidth()+sgui_nAdditionalActivationSpaceLeftRight*2,
      gui_GetSize().GetHeight());
}

void mcExpElementHelpers::gui_DrawNonActive(wxDC &dc, wxPoint &base, wxPoint &exp, wxPoint &sub) const
{
 // draw as non active both base and exp; we don't need
 // to check if exp exist or it's visible...
 gui_DrawBase(dc, base.x, base.y, mcDRW_NONACTIVE, wxDefaultPosition);
 gui_ExpSubDraw(TRUE, dc, exp.x, exp.y, mcDRW_NONACTIVE, wxDefaultPosition);
 gui_ExpSubDraw(FALSE, dc, sub.x, sub.y, mcDRW_NONACTIVE, wxDefaultPosition);
}

void mcExpElementHelpers::gui_DrawAllActive(wxDC &dc, wxPoint &orig, wxPoint &base, wxPoint &exp, wxPoint &sub) const
{
 // make all the bb of this element active
 gui_DrawActivationRect(dc, orig.x, orig.y);

 // both base and exp should be drawn using transparent mode
 gui_DrawNonActive(dc, base, exp, sub);
}

int mcExpElementHelpers::gui_Draw(wxDC &dc, int x, int y, long flags, const wxPoint &pt) const
{
 // precalc some useful data
 wxPoint orig(x, y);
 wxPoint b(x+gui_GetBaseOffsetx(), y+gui_GetBaseOffsety()),
  e(x+gui_GetExpSubOffsetx(TRUE), y+gui_GetExpSubOffsety(TRUE)),
  s(x+gui_GetExpSubOffsetx(FALSE), y+gui_GetExpSubOffsety(FALSE));
 int r = mcDRW_NOACTIVEELEM; 


 if (flags & mcDRW_NONACTIVE) {

  // no problems
  gui_DrawNonActive(dc, b, e, s);
  mcGUILOG(wxT("mcExpElementHelpers::gui_Draw [%s] - just drawn everything as inactive"), mcTXTTHIS);
  return mcDRW_NOACTIVEELEM;

 } else if (flags & mcDRW_ALLACTIVE) {

  // no problems
  gui_DrawAllActive(dc, orig, b, e, s);
  mcGUILOG(wxT("mcExpElementHelpers::gui_Draw [%s] - just drawn everything as active"), mcTXTTHIS); 

 } else {

  mcASSERT(flags & mcDRW_USEPOINT, wxT("Invalid flags"));

  // pt is a valid pointer; check if we have an exponent...
  if (!data_hasProperty(mcEP_HASEXPONENT)) {

   // point must be in the base, because exp doesn't exist or
   // it's not visible; call the base gui_Draw() function with
   // the point coord because, if the base is a container
   // of some other elements, maybe it wants to use mouse
   // position to draw as active only some portions.
   r = gui_DrawBase(dc, b.x, b.y, flags, pt);

   // the subscript, if present, is always drawn as non-active
   if (data_hasProperty(mcEP_HASSUBSCRIPT))
    gui_ExpSubDraw(TRUE, dc, s.x, s.y, mcDRW_NONACTIVE, wxDefaultPosition);

   return r;

   // exponent is hidden...
  }

  // create some variables...
  wxRect exp(e, data_GetExp().gui_GetSize());
  wxRect base(b, gui_GetBaseSize());

  // an element with an exponent should never allow the exponent to draw its
  // selection rectangle because the array containing this mcExpElement will
  // care of it, drawing the selection rectangle around this entire element...
  int expflags = flags & ~mcDRW_ALLOW_TOTAL_SELECTION;

  // check if cursor is inside the empty space
  // above and next to the base; all derived elements are assumed to
  // consider this space useless; thus the behaviour of the element
  // when the cursor is inside these zones, is defined here
  bool bInsideExp = exp.Inside(pt);
  if (!bInsideExp && !base.Inside(pt)) {

   // draw everything in the same way when (flags & mcDRW_ALLACTIVE) != 0
   gui_DrawAllActive(dc, orig, b, e, s);
   mcGUILOG(wxT("mcExpElementHelpers::gui_Draw [%s] - just drawn everything as active"), mcTXTTHIS);

  } else if (bInsideExp) {

   // the exponent cannot "decide" to make all the element active,
   // so we just have to call the base with mcDRW_NONACTIVE and
   // the exp with the pointer
   gui_DrawBase(dc, b.x, b.y, mcDRW_NONACTIVE, wxDefaultPosition);

   if (data_hasProperty(mcEP_HASSUBSCRIPT))
    gui_ExpSubDraw(FALSE, dc, s.x, s.y, mcDRW_NONACTIVE, wxDefaultPosition);

   return gui_ExpSubDraw(TRUE, dc, e.x, e.y, expflags, pt);

  } else {

   // if cursor is not in the exp nor in the empty space,
   // it MUST be inside the base
   mcASSERT(base.Inside(pt), wxT("The given cursor position is wrong"));

   if (gui_DrawAsActiveOverBase()) {

    // the base does not contain subelements: we can draw the entire
    // element as active...
    gui_DrawAllActive(dc, orig, b, e, s);

   } else {

    // the base is a container of elements (e.g. mcBracket); the cursor
    // may be placed over one of the subelements. Thus the gui_DrawBase
    // function must receive a valid mouse cursor position to decide
    // which element must be highlighted (that is, drawn as active).
    //
    // Also the ID returned by this function cannot be the ID of this
    // element: it must be the ID of the active subelement inside the
    // base !!!
    r = gui_DrawBase(dc, b.x, b.y, flags, pt);

    if (data_hasProperty(mcEP_HASSUBSCRIPT))
     gui_ExpSubDraw(FALSE, dc, s.x, s.y, mcDRW_NONACTIVE, wxDefaultPosition);

    gui_ExpSubDraw(TRUE, dc, e.x, e.y, mcDRW_NONACTIVE, wxDefaultPosition);

    return r;
   }
  }
 }

 // return our ID
 return data_GetID();
}

mcInputRes mcExpElementHelpers::gui_Input(const mcKey &ev, mcElement *newelem)
{
 if (gui_isCursorInExpSub(TRUE))
  return gui_ExpSubInput(TRUE, ev, newelem);
 else if (gui_isCursorInExpSub(FALSE))
  return gui_ExpSubInput(FALSE, ev, newelem);
 return gui_BaseInput(ev, newelem);
}

mcInsertRes mcExpElementHelpers::gui_Insert(const mcElement &toinsert, mcElement *newelem)
{
 if (gui_isCursorInExpSub(TRUE)){
  return data_GetExp().gui_Insert(toinsert, newelem);
 }
 else if (gui_isCursorInExpSub(FALSE)) {
  return data_GetSub().gui_Insert(toinsert, newelem);
 }
  
 return gui_BaseInsert(toinsert, newelem);
}

void mcExpElementHelpers::gui_OnSelect(wxDC &dc, wxRect &rc)
{
 // remove old selections
 gui_DeSelect();

 // if there's no exponent, directly call gui_OnBaseSelect
 if (!data_hasProperty(mcEP_HASEXPONENT)) {
  gui_OnBaseSelect(dc, rc);
  return;
 }

 int w = gui_GetExpSubOffsetx(TRUE), h = gui_GetBaseOffsety();
 wxRect exprc(wxPoint(w, 0), data_GetExp().gui_GetSize());
 wxRect baserc(wxPoint(0, h), mgui_szBase);

 bool base = baserc.Intersects(rc);
 bool exp = exprc.Intersects(rc);

 // does the selection intersects only the exponent ?
 if (exp && !base) {

  // select the exponent
  rc.Offset(-exprc.x, -exprc.y);
  data_GetExp().gui_OnSelect(dc, rc);
  
  // check if we must be set as selected, too
  if (data_GetExp().gui_isSelected())
   gui_Select();
  return;
 }

 // if the selection rectangle intersects exponent rect and also
 // the base rect, the entire element must be selected...
 if (exp && base) {
  this->gui_SelectAll();
  return;
 }

 // if the selection rectangle intersects the base (or the empty space) only,
 // we can call gui_OnBaseSelect...
 if (base)
  gui_OnBaseSelect(dc, rc);
}

mcElement mcExpElementHelpers::gui_GetSelection() const
{
 if (gui_isAllSelected())
  return mcElement(this);  // just copy *this...

 // if we are not completely selected and we don't have an exponent,
 // then the selection to return *must* be given by the base function...
 if (!data_hasProperty(mcEP_HASEXPONENT))
  return gui_GetBaseSelection();

 // we've got an exponent to take in count...
 if (data_GetExp().gui_isSelected())
  return data_GetExp().gui_GetSelection();

 return gui_GetBaseSelection();
}

mcMoveCursorRes mcExpElementHelpers::gui_MoveCursor(mcMoveCursorFlag flag, long modifiers)
{
 mcMoveCursorRes n = mcMCR_OKAY;

 // the IF ... ELSE IF ... construct is indispensable here: gui_ExpMoveCursor,
 // gui_BaseMoveCursor or gui_SubMoveCursor could change the cursor position from
 // exp to base, from base to sub or viceversa, so we must be sure not
 // to process twice the same flag !!!
 if (gui_isCursorInExpSub(TRUE)) {

  // the gui_ExpMoveCursor function will handle the exponent return flags
  n = gui_ExpSubMoveCursor(TRUE, flag, modifiers);

 } else if (gui_isCursorInExpSub(FALSE)) {

  // the gui_SubMoveCursor function will handle the subscript return flags
  n = gui_ExpSubMoveCursor(FALSE, flag, modifiers);

 } else if (gui_isCursorInBase()) {

  // handle the return flags of gui_BaseMoveCursor here
  mcMoveCursorRes r = gui_BaseMoveCursor(flag, modifiers);

  switch (r) {
  case mcMCR_OKAY:
  case mcMCR_CANNOT_SETFOCUS:
   break;

  case mcMCR_SETFOCUS_NEXT:

   // check if the exponent or the subscript is present
   if (gui_isOnRight(TRUE) && data_hasProperty(mcEP_HASEXPONENT))
    gui_EditExpSub(TRUE);
   else if (data_hasProperty(mcEP_HASSUBSCRIPT))
    gui_EditExpSub(FALSE);
   else
    return mcMCR_SETFOCUS_NEXT;
   break;

  case mcMCR_SETFOCUS_PREVIOUS:

   // check if the exponent is present
   if (gui_isOnRight(TRUE) || !data_hasProperty(mcEP_HASEXPONENT))
    return mcMCR_SETFOCUS_PREVIOUS;
   else
    gui_EditExpSub(TRUE);
   break;

  case mcMCR_SETFOCUS_BELOW:

   // check if the subscript is present
   if (data_hasProperty(mcEP_HASSUBSCRIPT))
    gui_EditExpSub(FALSE);
   else
    return mcMCR_SETFOCUS_BELOW;
   break;

  case mcMCR_SETFOCUS_ABOVE:

   // check if the exponent is present
   if (data_hasProperty(mcEP_HASEXPONENT))
    gui_EditExpSub(TRUE);
   else
    return mcMCR_SETFOCUS_ABOVE;
   break;
  }
 }

 return n;
}

int mcExpElementHelpers::gui_MoveCursorUsingPoint(wxDC &dc, const wxPoint &p)
{
 // check if the mouse cursor is inside exponent or
 // inside the base
 wxRect rc(wxPoint(0, gui_GetBaseOffsety()), gui_GetBaseSize());
 wxPoint pt(p);

 if (rc.Inside(p)) {

  // cursor is inside the base
  pt.y -= gui_GetBaseOffsety();
  int r = gui_BaseMoveCursorUsingPoint(dc, pt);

  if (r == mcMCR_CANNOT_SETFOCUS)
   return mcMCR_CANNOT_SETFOCUS;

  // ok, now the cursor is inside the base
  mgui_nCursorLoc = mcECL_INSIDEBASE;
  return mcMCR_OKAY;

 } else if (data_hasProperty(mcEP_HASEXPONENT)) {

  // cursor is inside exp or empty space ?
  // STRANGE ERROR WITH GCC & MINGW COMPILERS: if in the following
  // line I do not use the THIS pointer to access gui_GetExpSubOffsetx(TRUE, ()
  // function I get an error.....
  wxRect exp(wxPoint(this->gui_GetExpSubOffsetx(TRUE), 0), 
         data_GetExp().gui_GetSize());

  if (exp.Inside(p)) {
   // it's inside the exponent...
   int r = gui_ExpSubMoveCursorUsingPoint(TRUE, dc, p);

   if (r == mcMCR_CANNOT_SETFOCUS)
    return mcMCR_CANNOT_SETFOCUS;

   // ok, now the cursor is inside the base
   mgui_nCursorLoc = mcECL_INSIDEEXPONENT;
   return mcMCR_OKAY;
  }

  // it's inside empty space: do nothing

 } else {

  /*mcASSERT(0, wxT("Cursor cannot be in empty space because when ")
   wxT("the exponent is absent, there's no empty space"));*/
 }

 return mcMCR_OKAY;
}

void mcExpElementHelpers::gui_SetCursorPos(const mcCursorPos &code)
{
 if (code.isBegin()) {

  // if the exponent is placed on the left...
  if (gui_hasBaseSthOnLeftSide())
   gui_SetExpSubCursorPos(TRUE, code);
  else
   gui_SetBaseCursorPos(code); // if there is no exponent on the left...

 } else {

  mcASSERT(code.isEnd(), wxT("gui_SetCursorPos can handle only mcCP_BEGIN, mcCP_END"));

  // if the exponent is visible and placed on the right
  if (gui_hasBaseSthOnRightSide())
   gui_SetExpSubCursorPos(TRUE, code);

  // if there is no exponent on the right and there is
  // a subscript (the exponent has higher priority than
  // subscript)....
  if (!data_hasProperty(mcEP_HASEXPONENT) || !gui_isOnRight(TRUE)) {

   // the subscript, if present, is always on the right: it has
   // higher priority than the base
   if (data_hasProperty(mcEP_HASSUBSCRIPT))
    gui_SetExpSubCursorPos(FALSE, code);
   else
    gui_SetBaseCursorPos(code);
  }
 }
}

void mcExpElementHelpers::gui_GetCursorPos(mcCursorPos &cp) const
{
 if (gui_isCursorInExpSub(TRUE))
  gui_GetExpSubCursorPos(TRUE, cp);
 else if (gui_isCursorInExpSub(FALSE))
  gui_GetExpSubCursorPos(FALSE, cp);
 else {

 // cursor is in the base...
 mcCursorPos r(gui_GetBaseCursorPos());

 // if there's no exponent/subscript, the mcCP_BEGIN/mcCP_END flags
 // should be okay...
 if (r.isBegin() && !gui_hasBaseSthOnLeftSide())
  cp.gui_Push(mcCP_BEGIN);
 else if (r.isEnd() && !gui_hasBaseSthOnRightSide())
  cp.gui_Push(mcCP_END);
 else
  // ... but if they are present, the cursor is at the begin/end
  // of the base, NOT at the begin/end of the global element...
  cp.gui_Push(mgui_nCursorLoc);
 }
}

int mcExpElementHelpers::gui_GetRelCursorPos(wxDC &dc, wxPoint *pt) const
{
 int n;
 if (gui_isCursorInExpSub(TRUE))
  return gui_GetExpSubRelCursorPos(TRUE, dc, pt);
 else if (gui_isCursorInExpSub(FALSE))
  return gui_GetExpSubRelCursorPos(FALSE, dc, pt);

 // cursor is in the base...
 n = gui_GetBaseRelCursorPos(dc, pt);

 // add base offsets
 pt->y += gui_GetBaseOffsety();
 pt->x += gui_GetBaseOffsetx();

 return n;
}

int mcExpElementHelpers::gui_GetYAnchor() const
{
 // the y-amount of pixels to leave above the center line of the
 // containing expression must be a value which makes the
 // center line of the base *always* coincide with the center
 // line of the containing expression
 return gui_GetBaseSize().GetHeight()/2 + gui_GetBaseOffsety();
}

void mcExpElementHelpers::gui_UpdateExpDepth()
{
 // update the exponent
 if (data_GetExp() != mcEmptyElement)
  data_GetExp().gui_SetAsExpOf(this);
 
 // update the subscript
 if (data_GetSub() != mcEmptyElement)
  data_GetSub().gui_SetAsExpOf(this);
 
 // always call base class version
 mcElementHelpers::gui_UpdateExpDepth();
}

bool mcExpElementHelpers::gui_isCursorInBase() const
{
 // negative flags are preserved for mcExpElement use
 if (mgui_nCursorLoc == mcECL_INSIDEBASE)
  return TRUE;
 return FALSE;
}

bool mcExpElementHelpers::gui_hasBaseSthOnRightSide() const
{
 if ((gui_isOnRight(TRUE) && data_hasProperty(mcEP_HASEXPONENT))
  || data_hasProperty(mcEP_HASSUBSCRIPT))
  return TRUE;
 return FALSE;
}

bool mcExpElementHelpers::gui_hasBaseSthOnLeftSide() const
{
 if (!gui_isOnRight(TRUE) && data_hasProperty(mcEP_HASEXPONENT))
  return TRUE;
 return FALSE;
}

int mcExpElementHelpers::gui_HandleSubExpEditKeys(const mcKey &key)
{
 // if the user wants to edit the exponent, let him do it
 if (mcMathCore::Get()->m_pEditExpKey->MatchKey(key)
  && mdata_bExpEnabled) {
  gui_EditExpSub(TRUE);
  return mcIR_OKAY;
 }

 // same for the subscript
 if (mcMathCore::Get()->m_pEditSubscriptKey->MatchKey(key)
  && mdata_bSubEnabled) {
  gui_EditExpSub(FALSE);
  return mcIR_OKAY;
 }

 // in this way we are sure to return something which is
 // not the mcIR_OKAY flag...
 return !mcIR_OKAY;
}

wxSize mcExpElementHelpers::gui_GetBaseAndSubSize() const
{
 int h = gui_GetBaseSize().GetHeight();

 // if subscript is present, make sure h is great enough
 if (data_hasProperty(mcEP_HASSUBSCRIPT))
  h = mcMAX(gui_GetExpSubOffsety(FALSE) - gui_GetBaseOffsety()
      + gui_GetExpSubSize(FALSE).GetHeight(), h);

 return wxSize(gui_GetBaseSize().GetWidth()+gui_GetExpSubSize(FALSE).GetWidth(), h);
}








// ----------------------------------------------
// mcEXPELEMENTGUI - element & subscript handlers
// ----------------------------------------------

bool mcExpElementHelpers::gui_isCursorInExpSub(bool exp, bool bCheckBeginEndExp) const
{
 // be sure that exponent is visible
 if (!data_hasProperty(mcEP_HAS(exp)))
  return FALSE;

 // check the easiest case
 if (mgui_nCursorLoc == mcECL_INSIDE(exp))
  return TRUE;

 // check if cursor is at begin or end of the exp
 if (bCheckBeginEndExp && mgui_nCursorLoc == mcECL_END(exp))
  return TRUE;

 if (bCheckBeginEndExp && exp && mgui_nCursorLoc == mcECL_EXPONENTBEGIN)
  return TRUE;

 return FALSE;
}

bool mcExpElementHelpers::gui_isExpSubEndKey(bool exp, const mcKey &ev) const
{
    if (mgui_nCursorLoc == mcECL_BEGIN(exp)) {

  // at this position you're allowed only to delete previous
  // elements....
  if (mcMathCore::Get()->m_pDeleteKey->MatchKey(ev))
   return FALSE;

  // all other inputs are refused
  return TRUE;

 } else if (mgui_nCursorLoc == mcECL_INSIDE(exp)) {
        
  // the exp/sub class will care of this question; however, 
        // exp/sub always accept all input, so it should always 
        // return FALSE.... 
        return data_Get(exp).gui_isEndKey(ev);

    } else if (mgui_nCursorLoc == mcECL_END(exp)) {

        // at this position you're allowed only to delete previous 
        // characters.... 
        if (mcMathCore::Get()->m_pDeleteKey->MatchKey(ev))
            return FALSE;
        if (mcGetEditKey(exp)->MatchKey(ev))
            return FALSE;

        // all other inputs are refused
        return TRUE;
    }

 // if exponent is not in the exponent nor at the end of it; this
 // is not a cursor position we can handle...
 return FALSE;
}

int mcExpElementHelpers::gui_ExpSubDraw(bool exp, wxDC &dc, int x, int y, 
             long flags, const wxPoint &pt) const
{
 // is the exponent/subscript visible ? 
 if (!data_hasProperty(mcEP_HAS(exp)))
  return mcDRW_NOACTIVEELEM; // no exp/sub, no ID 

 // draw the exponent/subscript at the given pos 
 return data_Get(exp).gui_Draw(dc, x, y, flags, pt);
}

wxSize mcExpElementHelpers::gui_GetExpSubSize(bool exp)
{
 if (data_hasProperty(mcEP_HAS(exp)))
  return data_Get(exp).gui_GetSize();

 /* exp/sub is not visible, thus
 it doesn't occupy any space */
 return wxSize(0, 0);
}

// in these two versions, the CONST versions
// of gui() and gui_GetSize() are used...

wxSize mcExpElementHelpers::gui_GetExpSubSize(bool exp) const
{
 if (data_hasProperty(mcEP_HAS(exp)))
  return data_Get(exp).gui_GetSize();

 /* exp/sub is not visible, thus
 it doesn't occupy any space */
 return wxSize(0, 0);
}

void mcExpElementHelpers::gui_RecalcExpSubSize(bool exp)
{
 // is exp/sub allocated ? 
 if (data_Get(exp) == mcEmptyElement)
  return; // no exp/sub, no size to recalc 

 // update exp/sub size 
 data_Get(exp).gui_RecalcSize();
}




int mcExpElementHelpers::gui_GetBaseOffsety() const
{ return mcElementHelpers::gui_GetBaseOffsety(gui_GetExpSubSize(TRUE).GetHeight()); }

int mcExpElementHelpers::gui_GetBaseOffsetx() const
{
 // the base should *always* be drawn starting from the leftmost point...
 return 0;
}



int mcExpElementHelpers::gui_GetExpSubOffsety(bool exp) const
{
 if (!exp)
  return gui_GetBaseOffsety() + 
   mcElementHelpers::gui_GetSubscriptOffsety(gui_GetBaseSize().GetHeight());

 // the exponent, if visible, is *always* placed at the top of the element...
 return 0;
}

int mcExpElementHelpers::gui_GetExpSubOffsetx(bool exp) const
{
 // if the exponent is placed on the right of the element, we must
 // return the size of the entire base...
 if (exp && gui_isOnRight(exp))
  return gui_GetBaseSize().GetWidth();
 if (exp)
  return 0;

 // the subscripts can be placed only on the right...
 return gui_GetBaseSize().GetWidth();
}




int mcExpElementHelpers::gui_GetExpSubRelCursorPos(bool exp, wxDC &dc, wxPoint *pt) const
{
 if (mgui_nCursorLoc == mcECL_BEGIN(exp)) {

  // cursor is at the begin of an exponent placed on the left of
  // the element but ready to type at "element level"
  pt->x = 0;
  pt->y = 0;

  return gui_GetHeight();

 } else if (mgui_nCursorLoc == mcECL_INSIDE(exp)) {

  // set the point to the upper-left coord 
  pt->x = 0;
  pt->y = 0;

  // call exponent's function 
  int n = data_Get(exp).gui_GetRelCursorPos(dc, pt);

  // set the cursor position relative to the coord. 
  // of this element adding base width 
  pt->x += gui_GetExpSubOffsetx(exp);
  pt->y += gui_GetExpSubOffsety(exp);
  return n;

 } else if (mgui_nCursorLoc == mcECL_END(exp)) {

  // cursor is at the end of the exponent but ready 
  // to type at "element level"; because both the 
  // mcECL_EXPONENTEND and mcECL_SUBSCRIPTEND 
  // flags are handled in the same way, here we use  
  // fixed functions. 
  pt->x = gui_GetWidth();
  pt->y = gui_GetExpSubOffsety(exp);
  return gui_GetHeight() - pt->y;
 }

 // cursor is not inside exp...
 return mcNotInside(exp);
}

mcMoveCursorRes mcExpElementHelpers::gui_ExpSubMoveCursor(bool exp,
                mcMoveCursorFlag flags, 
                long modifiers)
{
 mcMoveCursorRes r;
 if (mgui_nCursorLoc == mcECL_INSIDE(exp)) {

  // inside this branch we can always assume the exponent visible:
  // the cursor is inside it !!!
  r = data_Get(exp).gui_MoveCursor(flags, modifiers);

  switch (r) {
  case mcMCR_SETFOCUS_NEXT:
   if (gui_isOnRight(exp))
    mgui_nCursorLoc = mcECL_END(exp);
   else
    gui_EditBaseAndSetPos(mcCP_BEGIN);
   break;

  case mcMCR_SETFOCUS_PREVIOUS:
   if (gui_isOnRight(exp))
    gui_EditBaseAndSetPos(mcCP_END);
   else
    mgui_nCursorLoc = mcECL_BEGIN(exp);
   break;

  case mcMCR_SETFOCUS_BELOW:
   gui_EditBase();
   break;

  case mcMCR_SETFOCUS_ABOVE:
   return mcMCR_SETFOCUS_ABOVE;

  default:
   return r;
  }

 } else if (mgui_nCursorLoc == mcECL_END(exp)) {

  // in this branch we can assume the exponent placed at the right
  // of the element: otherwise mgui_nCursorLoc would never assume
  // the mcECL_EXPONENTEND position
  switch (flags) {
  case mcMCF_LEFT:
  case mcMCF_UP:
   gui_EditExpSub(exp);
   data_Get(exp).gui_SetCursorPos(mcCP_END);
   break;

  case mcMCF_RIGHT:
   return mcMCR_SETFOCUS_NEXT;

  case mcMCF_DOWN:
   return mcMCR_SETFOCUS_BELOW;
  }

 } else if (mgui_nCursorLoc == mcECL_BEGIN(exp)) {

  // in this branch we can assume the exponent placed at the left
  // of the element: otherwise mgui_nCursorLoc would never assume
  // the mcECL_EXPONENTBEGIN position
  switch (flags) {
  case mcMCF_LEFT:
   return mcMCR_SETFOCUS_PREVIOUS;

  case mcMCF_DOWN:
   return mcMCR_SETFOCUS_BELOW;

  case mcMCF_RIGHT:
  case mcMCF_UP:
   gui_EditExpSub(exp);
   data_Get(exp).gui_SetCursorPos(mcCP_BEGIN);
   break;
  }

 } else {

  mcASSERT(0, wxT("unhandled cursor pos"));
 }

 // everything should be okay
 return mcMCR_OKAY;
}
/*
mcMoveCursorRes mcExpElementHelpers::gui_SubMoveCursor(mcMoveCursorFlag flags, long modifiers)
{
 int r;

 if (mgui_nCursorLoc == mcECL_INSIDESUBSCRIPT) {

  // inside this branch we can always assume the subscript visible:
  // the cursor is inside it !!!
  r = data_GetSub().gui_MoveCursor(flags, modifiers);

  switch (r) {
  case mcMCR_SETFOCUS_NEXT:
   mgui_nCursorLoc = mcECL_SUBSCRIPTEND;
   break;

  case mcMCR_SETFOCUS_PREVIOUS:
   gui_EditBaseAndSetPos(mcCP_END);
   break;

  case mcMCR_SETFOCUS_BELOW:
   return mcMCR_SETFOCUS_BELOW;

  case mcMCR_SETFOCUS_ABOVE:
   gui_EditBase();
   break;
  }

 } else if (mgui_nCursorLoc == mcECL_SUBSCRIPTEND) {

  // move the cursor
  switch (flags) {
  case mcMCF_LEFT:
  case mcMCF_DOWN:
   gui_EditSub();
   data_GetSub().gui_SetCursorPos(mcCP_END);
   break;

  case mcMCF_RIGHT:
   return mcMCR_SETFOCUS_NEXT;

  case mcMCF_UP:
   return mcMCR_SETFOCUS_ABOVE;
  }

 } else {

  mcASSERT(0, wxT("unhandled cursor pos"));
 }

 // everything should be okay
 return mcMCR_OKAY;
}*/




int mcExpElementHelpers::gui_ExpSubMoveCursorUsingPoint(bool exp, wxDC &dc, const wxPoint &p)
{
 if (!gui_isCursorInExpSub(exp))
  return mcNotInside(exp);

 // we do not have to handle any return flag...
 return data_Get(exp).gui_MoveCursorUsingPoint(dc, p);
}

mcInputRes mcExpElementHelpers::gui_ExpSubInput(bool exp, const mcKey &ev, mcElement *pnew)
{
 if (mgui_nCursorLoc == mcECL_BEGIN(exp)) {

  if (mcMathCore::Get()->m_pDeleteKey->MatchKey(ev)) {

   // user wants to delete something on the previous element...
   return mcIR_DELETE_PREVIOUS;

  } else {

   // something is wrong; all input keys should have
   // been blocked by gui_isExpEndKey function
   mcASSERT(0, wxT("Code should never get here"));
  }

 } else if (mgui_nCursorLoc == mcECL_INSIDE(exp)) {

  // mcPolynomial will care of everything... 
  mcInputRes result = data_Get(exp).gui_Input(ev, pnew);
  if (result == mcIR_DELETE_PREVIOUS || result == mcIR_DELETE_THIS) {

   // remove the exp/sub 
   gui_DeleteExpSub(exp);
  }

  gui_RecalcSize();   // size has been modified 

 } else if (mgui_nCursorLoc == mcECL_END(exp)) {

  if (mcMathCore::Get()->m_pDeleteKey->MatchKey(ev)) {

   // put the cursor at exp/sub level, moving the cursor 
   gui_ExpSubMoveCursor(exp, mcMCF_LEFT, mcMCF_NOMODIFIERS);

  } else if (mcGetEditKey(exp)->MatchKey(ev)) {

   // the user decided to edit the sub/exp 
   gui_EditExpSub(exp);

  } else {

   mcASSERT(0, wxT("All the other input should have been blocked ")
    wxT("by isSub/ExpEndKey() functions"));
  }
 }

 // everything's okay
 return mcIR_OKAY;
}

void mcExpElementHelpers::gui_EditExpSub(bool exp)
{
 // cursor is now inside exp/sub 
 mgui_nCursorLoc = mcECL_INSIDE(exp);

 // exp/sub has not allocated yet, do it now 
 if (data_Get(exp) == mcEmptyElement) {

  bool allowed;
  
  if (exp)
   allowed = mcElementHelpers::math_isExpAllowed(this);
  else
   allowed = mcElementHelpers::math_isSubAllowed(this);

  if (allowed) {

   gui_CreateExpSub(exp);
   gui_RecalcSize();

  } else {

   // another exp/sub nest level is not allowed !!! 
   mcMathCore::Get()->SyntaxError(wxT("Cannot nest another exp/sub"));
   return;
  }
 }

 // check that the exp/sub is not 'too' empty... 
 gui_CheckExpSub(exp);

 // save exp/sub flag 
 bool old = data_hasProperty(mcEP_HAS(exp));

 // if this is not the first time the exp/sub is being 
 // edited, this flag should be already set 
 data_AddProperty(mcEP_HAS(exp));

 // if this is the first time exp/sub become visible, we 
 // must recalculate size of this entire element (and set 
 // cursor position at the end of the exp/sub) 
 if (old == FALSE)  {
  gui_RecalcSize();
  data_Get(exp).gui_SetCursorPos(mcCP_END);
 }
}




void mcExpElementHelpers::gui_EditBaseAndSetPos(const mcCursorPos &cp)
{
 gui_EditBase();
 gui_SetBaseCursorPos(cp);
}





void mcExpElementHelpers::gui_CheckExpSub(bool exp)
{
 if (exp) {
  mcPolynomial p(data_GetExp());
  if (p.data_isArrayEmpty()) {
   p.gui_AddNewEmptyMonomial();
   
   // the size of this element has changed...
   gui_RecalcSize();
  }
 } else {
  // default implementation does nothing
 }
}

void mcExpElementHelpers::gui_SetExpSubCursorPos(bool exp, const mcCursorPos &code)
{
 if (!data_hasProperty(mcEP_HAS(exp)))
  return;

 if (code.isEnd() && gui_isOnRight(exp))
  mgui_nCursorLoc = mcECL_END(exp);
 if (code.isBegin() && !gui_isOnRight(exp))
  mgui_nCursorLoc = mcECL_BEGIN(exp);
}

void mcExpElementHelpers::gui_GetExpSubCursorPos(bool exp, mcCursorPos &cp) const
{
 if (!data_hasProperty(mcEP_HAS(exp))) {
  cp.gui_Push(mcCP_UNDEFINED);
  return;
 }

 if (mgui_nCursorLoc == mcECL_BEGIN(exp))
  cp.gui_Push(mcCP_BEGIN);
 else if (mgui_nCursorLoc == mcECL_INSIDE(exp))
  data_Get(exp).gui_GetCursorPos(cp);
 else if (mgui_nCursorLoc == mcECL_END(exp))
  cp.gui_Push(mcCP_END);
 else
  cp.gui_Push(mcCP_UNDEFINED);
}

void mcExpElementHelpers::gui_DeleteExpSub(bool exp)
{ 
 // move cursor in the base 
 gui_EditBase();

 // when exponent is deleted, it doesn't care if the 
 // exponent is placed on the left and on the right: 
 // the cursor must always be placed on the rightmost 
 // point of the base; the same for the subscript 
 gui_SetBaseCursorPos(mcCP_END);

 // delete the exponent/subscript 
 data_DestroyExpSub(exp);
 data_RemoveProperty(mcEP_HAS(exp));
}









// ----------------------------------------
// mcEXPELEMENTIO
// ----------------------------------------

wxXml2Node mcExpElementHelpers::io_GetMathML(bool bGetPresentation) const
{
 bool expv = data_hasProperty(mcEP_HASEXPONENT);
 bool subv = data_hasProperty(mcEP_HASSUBSCRIPT);
 wxString nodename;

 // there are four cases: exp visible and sub hidden, sub visible and
 // exp hidden, both visible, both hidden...
 if (expv && !subv)
  nodename = wxT("msup");
 else if (!expv && subv)
  nodename = wxT("msub");
 else if (expv && subv)
  nodename = wxT("msubsup");
 else {

  // we don't need to create any wrapper tag
  return io_GetBaseMathML(bGetPresentation);
 }

 // save base and exponent/subscript Math ML
 wxXml2Node base = io_GetBaseMathML(bGetPresentation);
 wxXml2Node maintag(wxXML_ELEMENT_NODE, wxXml2EmptyDoc, nodename);

 // add the exp or/and sub mathML
 if (bGetPresentation) {

  // the base must always be the first
  maintag.AddChild(base);

  // if present, then comes the subscript
  if (subv) {

   wxXml2Node node(data_GetSub().io_GetMathML(bGetPresentation));
   maintag.AddChild(node);
  }

  // if present, last is the exponent
  if (expv) {

   wxXml2Node node(data_GetExp().io_GetMathML(bGetPresentation));
   maintag.AddChild(node);
  }

 } else {

  mcASSERT(0, wxT("still to implement"));
 }

 // we have exported both exponent & subscript->..
 return maintag;
}


wxString mcExpElementHelpers::io_GetInlinedExpr() const
{
 bool expv = data_hasProperty(mcEP_HASEXPONENT);
 bool subv = data_hasProperty(mcEP_HASSUBSCRIPT);
 bool bracketize = FALSE;
 wxString str = io_GetBaseInlinedExpr();

 if (subv) {

  // add the subscript inlined expression
  str += wxT("_") + data_GetSub().io_GetInlinedExpr();
 }

 if (expv) {

  str += wxT("^");

  if (data_GetExp().data_GetChildrenCount() > 1 &&
   data_GetExp().data_GetType() != mcET_BRACKET)
   bracketize = TRUE;

  // add the exponent inlined expression, possibly
  // bracketizing it...
  if (bracketize) str += wxT("(");
  str += data_GetExp().io_GetInlinedExpr();
  if (bracketize) str += wxT(")");
 }

 // we have exported both exponent & subscript->..
 return str;
}

int GetLastRightBracketIdx(const wxString &str, int nest = 0)
{
 int i=0, max=str.Len();
 do {
  if (i >= max) return -1; // could not find the last right bracket

  if (mcBracketHelpers::gui_isLeftParenthesis(str.GetChar(i)))
   nest++;
  else if (mcBracketHelpers::gui_isRightParenthesis(str.GetChar(i)))
   nest--;
  i++;
 } while (nest > 0);

 return i;
}

void mcExpElementHelpers::io_GetExpSubInlinedToken(wxString &subexp) //const
{
 // remove the exponent/subscript symbol...
 subexp.Remove(0, 1);

 // if the string begins like:   ^(...)    or    _(....)
 if (mcBracketHelpers::gui_isLeftParenthesis(subexp.GetChar(0))) {

  // find the matching right parenthesis for the first
  // left parenthesis...
  int i = GetLastRightBracketIdx(subexp);

  // truncate the string to that last right parenthesis...
  subexp.Truncate(i);

 } else {

  subexp = subexp.BeforeFirst(wxT('+'));
  subexp = subexp.BeforeFirst(wxT('-'));

  // take only the first monomial as exp/sub
  int i = GetLastRightBracketIdx(subexp, 1);

  // truncate the string to that last right parenthesis...
  if (i > 0) subexp.Truncate(i-1);
 }
}

bool mcExpElementHelpers::io_ImportInlinedExpr(const wxString &str, int *count, wxString &pErr)
{
 // first of all, let the abse import its part of the given string:
 // exponent and subscript inlined expressions, if present, always
 // follows the base...
 if (!io_ImportBaseInlinedExpr(str, count, pErr))
  return FALSE;

/* return io_ImportExpSub(str, count, pErr);
}

bool mcExpElementHelpers::io_ImportExpSub(const wxString &str, int *count, wxString &pErr)
{*/
 wxString subexp = str.Right(str.Len()-*count);
 bool bexp, bsub;
 int n = 0;

 // then, if everything is okay, check if an exponent or a subscript
 // must be imported ...
 bexp = (subexp.GetChar(0) == wxT('^'));
 bsub = (subexp.GetChar(0) == wxT('_'));
 if (bexp || bsub) {

  io_GetExpSubInlinedToken(subexp);

 } else {

  // our import process finishes here
  return TRUE;
 }

 // import the EXPONENT
 if (bexp) {

  mcIOLOG(wxT("mcExpElementHelpers::io_ImportInlinedExpr - importing the exp [%s]"), subexp.c_str());

  // this call erases previous exponent (if present) and (if not
  // already present) creates it...
  data_CreateExpSub(TRUE);

  if (!data_GetExp().io_ImportInlinedExpr(subexp, &n, pErr)) {

   *count += n+1;
   return FALSE;
  }
 }

 // import the SUBSCRIPT
 if (bsub) {

  mcIOLOG(wxT("mcExpElementHelpers::io_ImportInlinedExpr - importing the subscript [%s]"), subexp.c_str());

  // this call erases previous sub (if present) and (if not
  // already present) creates it...
  data_CreateExpSub(FALSE);

  if (!data_GetSub().io_ImportInlinedExpr(subexp, &n, pErr)) {
   *count += n;
   return FALSE;
  }
 }

 *count += n+1;  // take in count also the wxT('^') or '_' symbol
 return TRUE;
}





// -------------------------
// mcEXPELEMENTMATH
// -------------------------

bool mcExpElementHelpers::math_hasExp() const
{
 // this function cannot be placed in the header because it uses mcExpElement...
 //return data_hasProperty(mcEP_HASEXPONENT);
 return (data_GetExp() != mcEmptyElement) && data_hasProperty(mcEP_HASEXPONENT);
}

bool mcExpElementHelpers::math_hasSub() const
{
 // this function cannot be placed in the header because it uses mcExpElement...
 //return data_hasProperty(mcEP_HASEXPONENT);
 return (data_GetSub() != mcEmptyElement) && data_hasProperty(mcEP_HASSUBSCRIPT);
}

const mcPolynomial &mcExpElementHelpers::math_GetConstExp() const
{
 const mcElement &e = data_GetExp();

 // if not present, create it....
 if (e == mcEmptyElement) {
  //data_CreateExp();
  return *mcPolynomialHelpers::smath_pOne;
  //return (const mcPolynomial &)data_GetExp();
 }

 // exponent should be a polynomial
 mcASSERT(e.data_GetType() == mcET_POLYNOMIAL,
  wxT("mcExpElementMath can work only on mcPolynomials as exp"));
 return (const mcPolynomial &)data_GetExp();
}

mcPolynomial &mcExpElementHelpers::math_GetExp()
{
 if (data_GetExp() == mcEmptyElement) {
  data_CreateExpSub(TRUE);
  data_SetExpSub(TRUE, *mcPolynomialHelpers::smath_pOne);
 }
 return (mcPolynomial &)data_GetExp();
}

const mcText &mcExpElementHelpers::math_GetConstSub() const
{
 const mcElement &e = data_GetSub();

 // if not present, create it....
 if (e == mcEmptyElement)
  return *mcTextHelpers::smath_pEmpty;

 // exponent should be a mcText
 mcASSERT(e.data_GetType() == mcET_TEXT,
  wxT("mcExpElementMath can work only on mcText as sub"));
 return (const mcText &)e;
}
/*
const mcPolynomial &mcExpElementHelpers::math_data_GetExp() const
{
 // if exponent does not exist, then return a polynomial containing
 // only one mcNumber set to 1.0
 if (data_GetExp() == NULL)
  return mcPolynomial::math_pOne;
 return (const mcPolynomial &)data_GetExp();
}

const mcText *mcExpElementHelpers::math_GetConstSub() const
{
 // if exponent does not exist, then return an empty mcText
 if (data_GetSub() == NULL)
  return mcText::math_pEmpty;
 return (const mcText *)data_GetSub();
}*/

mcRealValue mcExpElementHelpers::math_EvaluateExp() const
{
 // WARNING: we cannot just call data_GetExp()->math_Evaluate()
 //          because if the exponent is not present, the function
 //          would call mcNumber::math_pOne.math_Evaluate()
 //          which would then call mcExpElementHelpers::math_Evaluate()
 //          resulting in an infinite loop...
 if (!math_hasExp())
  return 1.0;
 return data_GetExp().math_Evaluate();
}

mcRealValue mcExpElementHelpers::math_Evaluate() const
{
 mcRealValue base = math_EvaluateBase();
 mcRealValue exp = math_EvaluateExp();

 // now, just raise the base to the exp; just be sure that everything
 // is valid: if you try pow(*mcRealValue::pNAN, -1) you will get an exception !!!
 if (base.isNAN() ||
  exp.isNAN())
  return *mcRealValue::pNAN;
 return base.pow(exp);
}

mcExpSimRes mcExpElementHelpers::math_Simplify(long flags, mcElement *pnew)
{
 // no exp ? no simplifications to do for the exponent...
 if (!math_hasExp())
  return math_SimplifyBase(flags, pnew);

 // simplify exponent
 mcMATHLOG(wxT("mcExpElementHelpers::math_Simplify [%s]"), mcTXTTHIS);
 mcExpSimRes r = data_GetExp().math_Simplify(mcEXPSIM_NOFLAGS, NULL);

 switch (r) {
 case mcESR_DONE:
  return math_SimplifyExp(flags, pnew);

 case mcESR_INVALID_DATA:
 case mcESR_NOTFINISHED:
  return r;

 case mcESR_DELETE_THIS:

  // delete the exponent
  data_DestroyExpSub(TRUE);
  break;

 case mcESR_REPLACE_THIS:
 case mcESR_DISTRIBUTE:
  break;

 default:
  mcASSERT(0, wxT("Unhandled return flag"));
 }

 return mcESR_DONE;
}

mcExpSimRes mcExpElementHelpers::math_Expand(long flags, mcElement *newelem)
{
 return math_ExpandBase(flags, newelem);

 //return mcESR_NOTFINISHED;
}

mcExpSimRes mcExpElementHelpers::math_SimplifyExp(long flags, mcElement *pnew)
{
 // if the exponent cannot be evaluated, we'll get a NAN as result
 mcRealValue d = data_GetExp().math_Evaluate();

 if (d == 0.0) {

  // we can simplify the base, whatever it is, to one...
  mcNumber replacement(*mcNumberHelpers::smath_pOne);
  (*pnew) = replacement;
  return mcESR_REPLACE_THIS;
 }

 if (d > 0.0 && d < 1.0 && smath_bConvertToRadicalWhenPossible) {

  mcRadical replacement;
  mcExpElement copy(this);

  // convert this mcExpElement into a mcRadical
  copy.data_DestroyExpSub(TRUE);
  replacement.data_GetContent().math_WrapSimple(copy);

  (*pnew) = replacement;
  return mcESR_REPLACE_THIS;
 }

 if (d == 1.0) {

  // just check if the exponent is containing a simple mcNumber("1.0")
  // (using the math_Evaluate() function we cannot be sure...);
  // if it is, then remove the exponent...
  if (math_GetConstExp().data_GetCount() == 1) {
   mcMonomial m(math_GetConstExp().data_GetElemOfType(0, mcET_MONOMIAL));

   if (m.data_GetCount() == 1 &&
    m.data_Get(0).data_GetType() == mcET_NUMBER)
    data_DestroyExpSub(TRUE);
  }

  return mcESR_DONE;
 }

 // the exponent cannot be evaluated or, if it is, it does not
 // evaluate to any special value which allow us special simplification,
 // so we can just try to call the base/exp simplification routine...
 return math_SimplifyBaseExp(flags, pnew);
}

mcBasicOpRes mcExpElementHelpers::math_RaiseTo(const mcPolynomial &p)
{
 mcMATHLOG(wxT("mcExpElementHelpers::math_RaiseTo [%s] - raising to [%s]"),
   mcTXTTHIS, mcTXT(p));
 math_GetExp().math_SimpleMultiplyBy(p);

 return mcBOR_REMOVE_OPERAND;
}

bool mcExpElementHelpers::math_CompareExp(const mcExpElement &p, long flags) const
{
 if (!this->math_hasExp() && !p.math_hasExp())
  return TRUE;  // exponent is missing for both

 // compare the two exponents
 const mcPolynomial &exp = p.math_GetConstExp();
 return math_GetExp().math_Compare(exp, flags);
}

bool mcExpElementHelpers::math_CompareSub(const mcExpElement &p, long flags) const
{
 if (!this->math_hasSub() && !p.math_hasSub())
  return TRUE;  // exponent is missing for both

 // compare the two exponents
 return data_GetSub().math_Compare(p.data_GetSub(), flags);
}

bool mcExpElementHelpers::math_Compare(const mcElement &p, long flags) const
{
 // first of all discard the most common case
 if (data_GetType() != p.data_GetType())
  return FALSE;

 mcExpElement e(p);

 // then, check the bases
 if (!math_CompareThisOnly(e, flags))
  return FALSE;

 // check the subscript
 if (!math_CompareSub(e, flags))
  return FALSE;

 // last, check the exponent
 if (!math_CompareExp(e, flags))
  return FALSE;

 // ok; the two elements are identic
 // (and their children, too)
 return TRUE;
}

mcBasicOpRes mcExpElementHelpers::math_MakeReciprocal(mcElement *)
{
 // just multiply our exponent by -1..... that is, change the sign of the
 // exponent (a quicker operation respect to the * -1)
 math_GetExp().math_ChangeAllSigns();

 return mcBOR_REMOVE_OPERAND;
}

mcBasicOpRes mcExpElementHelpers::math_MultOrDiv(const mcElement &e, mcElement *pp, bool mult)
{
 mcMATHLOG(wxT("mcExpElementHelpers::math_MultOrDiv - %s [%s] by [%s]"),
  (mult ? wxT("multiplying") : wxT("dividing")), mcTXTTHIS, mcTXT(e));
 mcExpElement p(e);

 // get the exponents
 const mcPolynomial &exp1 = math_GetConstExp();
 const mcPolynomial &exp2 = p.math_GetConstExp(); // don't create exp if not necessary...
 mcASSERT(exp1.math_CanBeAddedWith(exp2),
  wxT("Two polynomials that cannot be added ?!?"));

 // check if the two bases are the same:
 //
 //   x^n * x^m  =  x^(n+m)    or     x^n / x^m  =  x^(n-m)
 //
 // where x is not necessary a mcSymbol, just the base of this mcExpElement
 if (math_CompareThisOnly(p, FALSE)) {

  // catch this simple case; otherwise we would see a lot of
  // passages like:
  //                  kx/k   -.    k^(1-1)x
  // which can damage readability
  if ((!this->math_hasExp() && !p.math_hasExp()) ||
   exp1.math_Compare(exp2, FALSE)) {

   // since the two exponents are identic, the result of this
   // operation is:
   //
   //   x^n * x^n  =  x^2n    or     x^n / x^n  =  x^0  = 1
   //
   if (mult)
    math_GetExp().math_SimpleMultiplyBy(*mcNumberHelpers::smath_pTwo);
   else
    math_GetExp().math_ResetToZero();

   mcMATHLOG(wxT("mcExpElementHelpers::math_MultOrDiv - result is [%s]"), mcTXTTHIS);
   return mcBOR_REMOVE_OPERAND;
  }

  // the two bases are identic: we can add/subtract the exponents
  // (if they are present)
  if (mult)
   data_GetExp().math_SimpleAdd(exp2);
  else
   data_GetExp().math_SimpleSubtract(exp2);

  mcMATHLOG(wxT("mcExpElementHelpers::math_MultOrDiv - result is [%s]"), mcTXTTHIS);
  return mcBOR_REMOVE_OPERAND;
 }

 // check if the two exponents are the same...
 //
 //   x^n * y^n  =  (x*y)^n    or     x^n / y^n  =  (x/y)^n
 //
 if (exp1.math_Compare(exp2, FALSE)) {

  // the two exponents are identic: we can mult/divide the bases...
  if (mult)
   return math_MultiplyBaseOnlyBy(p, pp);
  else
   return math_DivideBaseOnlyBy(p, pp);
 }

 // no quick operations can be done
 if (mult)
  return math_MultiplyBaseBy(p, pp);
 return math_DivideBaseBy(p, pp);
}

mcBasicOpRes mcExpElementHelpers::math_DivideBy(const mcElement &e, mcElement *pp)
{
 mcASSERT(math_CanBeDivBy(e),
  wxT("This element cannot be divided by the given one"));
 return math_MultOrDiv(e, pp, FALSE);
}

mcBasicOpRes mcExpElementHelpers::math_MultiplyBy(const mcElement &e, mcElement *pp)
{
 mcASSERT(math_CanBeMultWith(e),
  wxT("This element cannot be multiplied by the given one"));
 return math_MultOrDiv(e, pp, TRUE);
}

mcMathType mcExpElementHelpers::math_GetMathType() const
{
 // if this element does not have an exponent, a call to
 // data_GetExp()->math_GetMathType(); would end in
 // a stack overflow since mcPolynomial::math_GetMathType
 // would probably call mcExpElementHelpers::math_GetMathType...
 if (!math_hasExp())
  return math_GetBaseMathType();

 mcMathType res = math_GetExp().math_GetMathType();
 return math_GetBaseMathType().math_RaiseTo(res);
}

mcMonomial mcExpElementHelpers::math_GetBaseLCM(const mcElement &p) const
{
 // just multiply ourselves with the given element
 mcExpElement res(this);
 mcMonomial m;

 m.data_AddElements(&res, 1);
 res.math_SimpleMultiplyBy(p);

 return m;
}

mcMonomial mcExpElementHelpers::math_GetLCM(const mcElement &p) const
{
 mcExpElement e(p);

 if (!math_CompareThisOnly(p, FALSE)) {

  // the bases are different thus we need to use
  // a specific algorithm for this element...
  return math_GetBaseLCM(p);
 }

 mcMonomial m;
 if (!this->math_hasExp()) {
  mcExpElement res(p);
  m.data_AddElements(&res, 1);
  return m;
 }

 if (!e.math_hasExp()) {
  mcExpElement res(this);
  m.data_AddElements(&res, 1);
  return m;
 }

 // we both have an exponent: then just take the lcm between them
 mcElement exp = math_GetExp().math_GetLCM(e.data_GetExp());
 mcExpElement res(this);

 res.data_SetExpSub(TRUE, exp);
 m.data_AddElements(&res, 1);

 mcMATHLOG(wxT("mcExpElementHelpers::math_GetLCM - the lcm between [%s] and [%s] is [%s]"),
    mcTXTTHIS, mcTXT(p), mcTXT(res));

 return m;
}

mcMonomial mcExpElementHelpers::math_GetGCD(const mcElement &p) const
{
 mcExpElement e(p);

 if (data_GetType() != p.data_GetType())
  return *mcMonomialHelpers::smath_pOne;

 if (math_CompareThisOnly(p, FALSE)) {

  // if both the two elements have the same base and they
  // both have an exponent, then we can just use mcPolynomial's GCD
  // function to get the GCD between the exponents...
  if (math_hasExp() && e.math_hasExp()) {

   mcMonomial res;

   // build an element with the same base of *this (which should
   // be also the same base of p) and with an exponent set to the
   // GCD of the two exponents
   mcExpElement content(this);
   mcMonomial gcd(math_GetExp().math_GetGCD(e.math_GetExp()));
   content.data_CreateExpSub(TRUE);
   content.math_GetExp().data_AddElements(&gcd, 1);

   res.data_AddElements(&content, 1);
   return res;

  } else {

   // let the derived class overload only this piece of the algorithm
   return math_GetBaseGCD(p);
  }
 }

 return *mcMonomialHelpers::smath_pOne;
}

mcMonomial mcExpElementHelpers::math_GetBaseGCD(const mcElement &p) const
{
 mcASSERT(!math_hasExp() || !mcExpElement(p).math_hasExp(),
  wxT("This case should have been handled by mcExpElementHelpers::math_GetGCD"));
 mcMonomial res;

 // put into the monomial to return a copy of the element
 // without the exponent...
 if (math_hasExp())
  res.data_AddElements(&p, 1);
 else {
  mcElement tmp(this);
  res.data_AddElements(&tmp, 1);
 }

 return res;
}

---

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

[ Top ]