Main page

---

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

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

#ifndef mcPRECOMP
 #include "mc/Element.h"
 #include "mc/ExpContainer.h"
#endif



mcIMPLEMENT_ABSTRACT_CLASS(mcExpContainer, mcExpElement);



// ----------------------------------------
// mcExpContainerGUI
// ----------------------------------------

bool mcExpContainerHelpers::gui_isBaseEndKey(const mcKey &ev) const
{
 // using cursor position, decide if the given character is okay
 switch (mgui_nCursorPos) {
 case mcEXPCONTAINER_LEFTMOST:
 case mcEXPCONTAINER_RIGHTMOST:
  if (mcMathCore::Get()->MatchEditKeys(ev))
   return FALSE;
  return TRUE;
 }
 
 // mgui_nCursorPos must be mcEXPCONTAINER_INSIDEEXPR
 mcASSERT(mgui_nCursorPos == mcEXPCONTAINER_INSIDEEXPR, wxT("Invalid cursor position"));
 return FALSE;
}

void mcExpContainerHelpers::gui_EditBase()
{  
 // set cursor on the base
 mgui_nCursorPos = mcEXPCONTAINER_INSIDEEXPR;
 mgui_nCursorLoc = mcECL_INSIDEBASE;
}

void mcExpContainerHelpers::gui_OnBaseSelect(wxDC &dc, wxRect &rc)
{
 // be sure that the selection rectangle is not inside the left
 // or right bracket
 wxPoint orig(gui_GetContentOffsetX(), gui_GetContentOffsetY());
 wxRect content(orig, data_GetContent().gui_GetSize());

 // the parent has got an extended selection; cannot select only a part of
 // the bracket....
/* if (hlp()->GetParent().data_GetType() == mcET_POLYNOMIAL) {
  if (((mcElementArray *)(hlp()->GetParent())).gui_GetSelElemCount() > 0) {
   gui_SelectAll();
   return;
  }
 }*/
 //mcASSERT(0, "");
 
 // just recall the mcPolynomial's gui_OnSelect function: it will find the
 // element whose bounding box intersects with the selection rectangle
 // and it will select it; ignore the selection if it intersects the
 // brackets only.
 if (content.Intersects(rc)) {

  rc.Offset(-content.x, -content.y);
  data_GetContent().gui_OnSelect(dc, rc);
 }

 // if our contents are selected, we are too
 if (data_GetContent().gui_isSelected())
  gui_Select();
}

int mcExpContainerHelpers::gui_DrawBase(wxDC &dc, int x, int y, long flags, 
          const wxPoint &pt) const
{
 wxPoint org(x+gui_GetContentOffsetX(), y+gui_GetContentOffsetY()), mypt=pt;
 wxRect rc(org, data_GetContent().gui_GetSize());
 bool ret = FALSE;
 int r;
 
 if (flags & mcDRW_USEPOINT) {
  
  if (rc.Inside(pt)) {
  
   // the mouse cursor is inside the math content: we must return the ID
   // of the active element contained inside it, not our ID...
   ret = TRUE;

  } else {

   // the cursor is not inside the contents: it's useless to tell
   // them to check the point coords we give them...
   flags &= ~mcDRW_USEPOINT;
  }
 }
 
 // should we allot to the contents to draw itself as entirely
 // selected, if it is ?
 flags &= ~mcDRW_ALLOW_TOTAL_SELECTION;
 if (!data_GetContent().gui_isAllSelected())
  flags |= mcDRW_ALLOW_TOTAL_SELECTION; 

 // draw the content
 r = data_GetContent().gui_Draw(dc, org.x, org.y, flags, mypt);
 
 // draw the container graphic
 gui_DrawContainer(dc, x, y, flags, pt);
 
 // choose which ID must be returned
 return (ret == TRUE) ? r : data_GetID();
}

mcInputRes mcExpContainerHelpers::gui_BaseInput(const mcKey &key, mcElement *pnew)
{
 // discard the begin character used to create this element
 if (gui_isBeginKey(key) != FALSE && 
  !data_hasProperty(mcEP_INITIALIZED)) {

  // create an empty box in the contained expression
  data_GetContent().gui_AddNewEmptyMonomial();
 
  // this element is now ready for input
  data_AddProperty(mcEP_INITIALIZED);
  gui_RecalcSize();

  return mcIR_OKAY;
 }

 // handle the EDITEXP and EDITSUBSCRIPT keypresses, if the cursor
 // is not placed inside the contained expression...
 if (mgui_nCursorPos == mcEXPCONTAINER_LEFTMOST || 
  mgui_nCursorPos == mcEXPCONTAINER_RIGHTMOST) {

  if (gui_HandleSubExpEditKeys(key) == mcIR_OKAY)
   return mcIR_OKAY;
 }
 
 switch (mgui_nCursorPos) {
 case mcEXPCONTAINER_LEFTMOST:
  
  if (mcMathCore::Get()->m_pDeleteKey->MatchKey(key)) {
   
   // delete previous elements
   return mcIR_DELETE_PREVIOUS;
   
  } else if (mcMathCore::Get()->m_pCancelKey->MatchKey(key)) {
   
   // delete this class
   return mcIR_DELETE_THIS; 
  } 
  
  mcMathCore::Get()->SyntaxError(wxT("Cannot type here"));
  break;

 case mcEXPCONTAINER_RIGHTMOST:

  if (mcMathCore::Get()->m_pDeleteKey->MatchKey(key)) {
   
   // delete this class
   return mcIR_DELETE_THIS; 
   
  } else if (mcMathCore::Get()->m_pCancelKey->MatchKey(key)) {
   
   // delete next elements
   return mcIR_DELETE_NEXT;
  } 
  
  mcMathCore::Get()->SyntaxError(wxT("Cannot type here"));
  break;
  
 case mcEXPCONTAINER_INSIDEEXPR:

  // let the contained expression process the input
  mcInputRes r = data_GetContent().gui_Input(key, pnew);
  return gui_HandleContentInput(r, pnew);
 }
 
 return mcIR_OKAY;
}

mcInsertRes mcExpContainerHelpers::gui_BaseInsert(const mcElement &toinsert, mcElement *)
{
 mcASSERT(mgui_nCursorPos != mcEXPCONTAINER_LEFTMOST &&
  mgui_nCursorPos != mcEXPCONTAINER_RIGHTMOST,
  wxT("Invalid position"));

 return data_GetContent().gui_Insert(toinsert, NULL);
}

mcInputRes mcExpContainerHelpers::gui_HandleContentInput(mcInputRes r, mcElement *)
{
 switch (r) {
 case mcIR_OKAY:
  break;
  
 case mcIR_DELETE_THIS:
 case mcIR_DELETE_PREVIOUS:
 case mcIR_DELETE_NEXT:
  return mcIR_DELETE_THIS;
  
 default:
  mcASSERT(0, wxT("Unhandled return flag"));
 }
 
 // size should have changed
 gui_RecalcSize();
 return mcIR_OKAY;
}

mcMoveCursorRes mcExpContainerHelpers::gui_BaseMoveCursor(mcMoveCursorFlag flag, long modifiers)
{
 mcMoveCursorRes result;

 // handle up/down flags for both the cursor positions which 
 // are completely under our control
 if (mgui_nCursorPos == mcEXPCONTAINER_LEFTMOST || 
  mgui_nCursorPos == mcEXPCONTAINER_RIGHTMOST) {

  if (flag == mcMCF_UP)
   return mcMCR_SETFOCUS_ABOVE;
  if (flag == mcMCF_DOWN)
   return mcMCR_SETFOCUS_BELOW;
 }
 
 switch (mgui_nCursorPos) {
 case mcEXPCONTAINER_LEFTMOST:
  mcASSERT(gui_isLeftPosEnabled(), wxT("Cursor position is wrong"));
  
  // cursor position (cursor=|):
  //    ...+ | (....)+...
  if (flag == mcMCF_LEFT) {

   // there is nothing on the left of this position,
   // which belongs to the element...
   return mcMCR_SETFOCUS_PREVIOUS;

  } else if (flag == mcMCF_RIGHT) {

   // set the cursor on the leftmost position inside the
   // content
   mgui_nCursorPos = mcEXPCONTAINER_INSIDEEXPR;
   data_GetContent().gui_SetCursorPos(mcCP_BEGIN);
  }
  break;
  
 case mcEXPCONTAINER_INSIDEEXPR:
  // cursor position (cursor=|):
  //    ...+(... | ...)+...
  
  // drop request to the expression
  result = data_GetContent().gui_MoveCursor(flag, modifiers);
  
  // check if cursor is still inside the expression
  if (result == mcMCR_SETFOCUS_PREVIOUS) {
   if (gui_isLeftPosEnabled())
    mgui_nCursorPos = mcEXPCONTAINER_LEFTMOST;
   else
    return mcMCR_SETFOCUS_PREVIOUS;

  } else if (result == mcMCR_SETFOCUS_NEXT) {
   if (gui_isRightPosEnabled())
    mgui_nCursorPos = mcEXPCONTAINER_RIGHTMOST;
   else
    return mcMCR_SETFOCUS_NEXT;

  } else if (result == mcMCR_SETFOCUS_BELOW || result == mcMCR_SETFOCUS_ABOVE) {
   
   // return the setfocus request to the caller
   return result;
  }
  break;
  
 case mcEXPCONTAINER_RIGHTMOST:
  mcASSERT(gui_isRightPosEnabled(), wxT("Cursor position is wrong"));

  // cursor position (cursor=|):
  //    ...+(....) | +...
  if (flag == mcMCF_RIGHT) {

   // there is nothing beyond this cursor position...
   return mcMCR_SETFOCUS_NEXT;

  } else if (flag == mcMCF_LEFT) {

   // set the cursor on the rightmost position inside
   // the content
   mgui_nCursorPos = mcEXPCONTAINER_INSIDEEXPR;
   data_GetContent().gui_SetCursorPos(mcCP_END);
  }
  break;

 default:
  mcASSERT(0, wxT("Unhandled cursor position"));
 }
 
 return mcMCR_OKAY;
}

int mcExpContainerHelpers::gui_BaseMoveCursorUsingPoint(wxDC &hDC, const wxPoint &pt)
{
 wxRect rc(wxPoint(0, 0), data_GetContent().gui_GetSize());  
 wxPoint mypt(pt);
 
 // user should have clicked on the content
 if (rc.Inside(mypt)) {
  
  mypt.x -= gui_GetContentOffsetX();
  mypt.y -= gui_GetContentOffsetY();

  // ask the contained polynomial to set the cursor
  int r = data_GetContent().gui_MoveCursorUsingPoint(hDC, mypt);
  if (r == mcMCR_CANNOT_SETFOCUS)
   return mcMCR_CANNOT_SETFOCUS;

  // ok, now the cursor is inside content
  mgui_nCursorPos = mcEXPCONTAINER_INSIDEEXPR;  
  return mcMCR_OKAY;
 }
 
 // do we have to set cursor on the container symbols ?
 if (mypt.x < gui_GetContentOffsetX() && gui_isLeftPosEnabled()) {
  mgui_nCursorPos = mcEXPCONTAINER_LEFTMOST;
  return mcMCR_OKAY;
 }
 if (mypt.x > gui_GetContentOffsetX()+rc.GetWidth() && gui_isRightPosEnabled()) {
  mgui_nCursorPos = mcEXPCONTAINER_RIGHTMOST;
  return mcMCR_OKAY;
 }

 return mcMCR_CANNOT_SETFOCUS;
}

int mcExpContainerHelpers::gui_GetBaseRelCursorPos(wxDC &hDC, wxPoint *pt) const
{
 int n;
 
 switch (mgui_nCursorPos) {
 case mcEXPCONTAINER_LEFTMOST:
  pt->x = 0;
  pt->y = 0;

  // use global obj height as cursor height
  return gui_GetBaseSize().GetHeight();
  
 case mcEXPCONTAINER_INSIDEEXPR:
  n = data_GetContent().gui_GetRelCursorPos(hDC, pt);
  pt->x += gui_GetContentOffsetX();
  pt->y += gui_GetContentOffsetY();

  // use content height as cursor height
  return n;
  
 case mcEXPCONTAINER_RIGHTMOST:
  pt->x = gui_GetBaseSize().GetWidth();
  pt->y = 0;

  // use global obj height as cursor height
  return gui_GetBaseSize().GetHeight();
 }
 
 // when cursor is inside exponent, mcExpElement functions
 // handle the gui_GetRelCursorPos function call
 mcASSERT(0, wxT("Unhandled cursor position"));
 
 // just to make compiler happy
 return 0;
}

void mcExpContainerHelpers::gui_GetBaseCursorPos(mcCursorPos &cp) const
{
 if (mgui_nCursorPos == mcEXPCONTAINER_LEFTMOST)
  cp.gui_Push(mcCP_BEGIN);
 else if (mgui_nCursorPos == mcEXPCONTAINER_RIGHTMOST)
  cp.gui_Push(mcCP_END);
 else
  cp.gui_Push(mgui_nCursorPos);
}

void mcExpContainerHelpers::gui_SetBaseCursorPos(const mcCursorPos &n)
{
 if (n.isBegin()) {
  if (gui_isLeftPosEnabled())
   mgui_nCursorPos = mcEXPCONTAINER_LEFTMOST;
  else {
   mgui_nCursorPos = mcEXPCONTAINER_INSIDEEXPR;
   data_GetContent().gui_SetCursorPos(mcCP_BEGIN);
  }
 }

 if (n.isEnd()) {
  if (gui_isRightPosEnabled())
   mgui_nCursorPos = mcEXPCONTAINER_RIGHTMOST; 
  else {
   mgui_nCursorPos = mcEXPCONTAINER_INSIDEEXPR;
   data_GetContent().gui_SetCursorPos(mcCP_END);
  }
 }
}

int mcExpContainerHelpers::gui_GetYAnchor() const
{
 return gui_GetContentOffsetY() + gui_GetBaseOffsety() + 
  data_GetContent().gui_GetYAnchor();
}




// ----------------------------------------
// mcEXPCONTAINERIO
// ----------------------------------------

wxXml2Node mcExpContainerHelpers::io_GetBaseMathML(bool bGetPresentation) const
{
 wxXml2Node maintag(wxXML_ELEMENT_NODE, wxXml2EmptyDoc, io_GetMathMLPresentationTag());
 wxXml2Node child = data_GetContent().io_GetMathML(bGetPresentation);
 maintag.AddChild(child);

 return maintag;
}

bool mcExpContainerHelpers::io_ImportPresentationMathML(wxXml2Node tag, wxString &pErr)
{
 mcASSERT(tag.GetName() == io_GetMathMLPresentationTag(), 
      wxT("Error in mcExpContainerHelpers::io_isBeginTag"));
 
 // the child of this node should be imported by m_eContent
 wxXml2Node child = tag.GetChildren();
 if (child.GetNext() != wxXml2EmptyNode) {
  
  // this tag contains more than one child; pack them in an MROW
  child.Encapsulate(wxT("mrow"));
  }
 
 return data_GetContent().io_ImportPresentationMathML(child, pErr);
}





// ----------------------------------------
// mcEXPCONTAINERMATH
// ----------------------------------------

bool mcExpContainerHelpers::math_CompareThisOnly(const mcElement &p, long flags) const
{
 if (p.data_GetType() == data_GetType()) {

  // ok, the given element has this same type...
  // now check contents
  const mcPolynomial &pcontents = mcExpContainer(p).data_GetConstContent();

  if (pcontents.math_Compare(data_GetContent(), flags))
   return TRUE;
 }

 return FALSE;
}

bool mcExpContainerHelpers::math_CanBeAddedWith(const mcElement &p) const
{
 // first of all, check the element type
 if (p.data_GetType() != data_GetType())
  return FALSE;

 mcExpContainer e(p);
 const mcPolynomial &content = e.data_GetContent();
 return data_GetContent().math_CanBeAddedWith(content);
}

bool mcExpContainerHelpers::math_CanBeDivBy(const mcElement &p) const
{
 // first of all, check the element type
 if (p.data_GetType() != data_GetType())
  return FALSE;

 mcExpContainer e(p);
 const mcPolynomial &content = e.data_GetConstContent();
 return data_GetContent().math_CanBeDivBy(content);
}

bool mcExpContainerHelpers::math_CanBeMultWith(const mcElement &p) const
{
 // first of all, check the element type
 if (p.data_GetType() != data_GetType())
  return FALSE;

 mcExpContainer e(p);
 const mcPolynomial &content = e.data_GetContent();
 return data_GetContent().math_CanBeMultWith(content);
}

mcPolynomial mcExpContainerHelpers::math_GetRaisedContents() const
{
 mcPolynomial res(data_GetContent());
 if (!math_hasExp()) return res;

 // raise the polynomial to the exponent we contain:
 // mcPolynomial implements the full algorithm
 res.math_RaiseTo(math_GetExp()); 
 
 return res;
}

mcExpSimRes mcExpContainerHelpers::math_SimplifyBaseExp(long flags, mcElement *pnew)
{
 mcMATHLOG(wxT("mcExpContainerHelpers::math_SimplifyBaseExp [%s]"), mcTXTTHIS);

 // it does make sense to raise our contents only if they can
 // be raised by our exponent: if they cannot and we still
 // call the mcPolynomialHelpers::math_RaiseTo function,
 // the polynomial would create a mcBracket inside it with
 // the exponent we gave it... this would be useless !
 if (!data_GetContent().math_CanBeRaisedTo(math_GetExp()) ||
  (flags & mcEXPSIM_KEEP_FACTORIZATION))
  return mcESR_DONE;

 // if contents are completely simplified, we can remove this
 // container and replace it with its contents raised to the
 // exponent of this container
 data_GetContent().math_RaiseTo(math_GetExp());
 data_DestroyExpSub(TRUE);

 return mcESR_NOTFINISHED;
}

mcExpSimRes mcExpContainerHelpers::math_SimplifyBase(long flags, mcElement *newelem)
{
 // simplify contents
 mcExpSimRes res = data_GetContent().math_Simplify(flags, newelem);
 if (res != mcESR_DONE) return res;

 // now, try to simplify this element with the simplified contents...
 return math_SimplifyContents(flags, newelem);
}

mcExpSimRes mcExpContainerHelpers::math_ExpandBase(long flags, mcElement *newelem)
{
 // expand contents
 mcExpSimRes res = data_GetContent().math_Expand(flags, newelem);
 if (res != mcESR_DONE) return res;

 // now, try to simplify this element with the simplified contents...
 return math_ExpandContents(flags, newelem);
}

mcBasicOpRes mcExpContainerHelpers::math_DivideBaseOnlyBy(const mcElement &p, mcElement *pp)
{
 if (p.data_GetType() != data_GetType()) return mcBOR_INVALID;
 mcExpContainer e(p);
 return data_GetContent().math_DivideBy(e.data_GetContent(), pp);
}

mcBasicOpRes mcExpContainerHelpers::math_Add(const mcElement &p, mcElement *pp, bool add)
{
 if (p.data_GetType() != data_GetType()) return mcBOR_INVALID;
 mcExpContainer e(p);
 return data_GetContent().math_Add(e.data_GetContent(), pp, add);
}
/*
mcBasicOpRes mcExpContainerHelpers::math_Subtract(const mcElement &p, mcElement *pp)
{
 if (p.data_GetType() != hlp().data_GetType()) return mcBOR_INVALID;
 mcExpContainer *e = (mcExpContainer *)p;
 return data_GetContent().math_Subtract(e.data_GetContent(), pp);
}*/

mcBasicOpRes mcExpContainerHelpers::math_MultiplyBaseOnlyBy(const mcElement &p, mcElement *pp)
{
 if (p.data_GetType() != data_GetType()) return mcBOR_INVALID;
 mcExpContainer e(p);
 return data_GetContent().math_MultiplyBy(e.data_GetContent(), pp);
}

mcMonomial mcExpContainerHelpers::math_GetFactors() const
{ return data_GetContent().math_GetFactors(); }

---

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

[ Top ]