Main page

---

ExpContainer.h

Go to the documentation of this file.

// MathCore = a WYSIWYG equation editor + a powerful math engine     //
// Copyright (C) 2003 by Francesco Montorsi                          //
//                                                                   //
// This library is free software; you can redistribute it and/or     //
// modify it under the terms of the GNU Lesser General Public        //
// License as published by the Free Software Foundation; either      //
// version 2.1 of the License, or (at your option) any later         //
// version.                                                          //
//                                                                   //
// This library is distributed in the hope that it will be useful,   //
// but WITHOUT ANY WARRANTY; without even the implied warranty of    //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the      //
// GNU Lesser General Public License for more details.               //
//                                                                   //
// You should have received a copy of the GNU Lesser General Public  //
// License along with this program; if not, write to the Free        //
// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,   //
// MA 02111-1307, USA.                                               //
//                                                                   //
// For any comment, suggestion or feature request, please contact    //
// the administrator of the project at frm@users.sourceforge.net     //
//                                                                   //



#ifndef mcEXPCONTAINER_H
#define mcEXPCONTAINER_H

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

// required includes
#include "mc/ExpElement.h"



mcDEFINE_HELPER_CLASSES(mcExpContainer)






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

 mcPolynomial m_eContent;

#endif


#ifdef mcENABLE_GUI
protected:

 int mgui_nCursorPos;
 
#define mcEXPCONTAINER_LEFTMOST   1

#define mcEXPCONTAINER_INSIDEEXPR  2

#define mcEXPCONTAINER_RIGHTMOST     3

#endif





public:

 mcExpContainerHelpers() {
  mdata_bExpEnabled = TRUE;
  mdata_bSubEnabled = FALSE; // do not allow subscripts
 }

 virtual ~mcExpContainerHelpers() {}


protected:

 void gui_Init() {
  mcExpElementHelpers::gui_Init();

  // cursor begins inside the ExpContainer
  mgui_nCursorPos = mcEXPCONTAINER_INSIDEEXPR;
 }



#ifdef mcENABLE_DATA
public:

 int data_GetChildrenCount() const {
  return mcExpElementHelpers::data_GetChildrenCount() + 
   (data_GetContent() != mcEmptyPolynomial);
 }

 const mcElement &data_GetConstChild(int n) const {
  mcRETURN_ELEMENT_CHILD(n, mcExpElementHelpers);
  if (n == 0 && data_GetContent() != mcEmptyElement)
   return data_GetContent();
  return mcEmptyElement;
 }
 
 void data_SetChild(int n, const mcElement &newchild) {
  mcSET_ELEMENT_CHILD(n, mcExpElementHelpers, newchild);
  if (n == 0) {
   mcASSERT(newchild.data_GetType() == mcET_POLYNOMIAL, wxT("Invalid new child"));
   data_SetContent(newchild);
  }
  }


 void data_DeepCopy(const mcElementHelpers *p) {
  const mcExpContainerHelpers *b = (const mcExpContainerHelpers *)p;

  // deep copy the contents
  data_GetContent().data_DeepCopy(b->data_GetContent());
  mcExpElementHelpers::data_DeepCopy(p);
 }

 bool data_isSameAs(const mcElementHelpers *p) const {
  if (!mcElementHelpers::data_isSameAs(p))
   return FALSE;

  const mcExpContainerHelpers *ed = (const mcExpContainerHelpers *)p;
  if (m_eContent != ed->m_eContent) return FALSE;
  return TRUE;
 }

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


 virtual void data_SetContent(const mcPolynomial &p) {
  data_GetContent().data_DeleteAll();
  data_GetContent().data_AddElements(
   p.hlp()->data_GetArray(), p.hlp()->data_GetCount(), -1, TRUE);
 }

 mcPolynomial &data_GetContent()     { return m_eContent; }
 const mcPolynomial &data_GetContent() const  { return m_eContent; }

/* mcPolynomialHelpers *data_GetContentHlp()     { return m_eContent.hlp(); }
 const mcPolynomialHelpers *data_GetContentHlp() const  { return m_eContent.hlp(); }
*/

 virtual void data_AddElements(mcElement *p, int num, int pos = -1, bool bOverwrite = FALSE) {

  // just call the math_AddElements function of the content
  data_GetContent().data_AddElements(p, num, pos, bOverwrite);
 }

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

  // just call the math_AddNewElement function of the content
  return data_GetContent().data_AddNewElement(t, bOverwrite, pos);
 }

#endif   // mcENABLE_DATA




#ifdef mcENABLE_GUI
public:

 virtual int gui_GetSpaceAboveBelow() const  { return 0; }

 // space between begin symbol and content, and between the
 // content and the end symbol
 virtual int gui_GetSpaceLeftRight() const  { return 0; }

 virtual mcInputRes gui_HandleContentInput(mcInputRes, mcElement *);




 virtual int gui_GetContentOffsetX() const = 0;
 virtual int gui_GetContentOffsetY() const = 0;

 virtual bool gui_isLeftPosEnabled() const = 0;
 virtual bool gui_isRightPosEnabled() const = 0;

 virtual void gui_DrawContainer(wxDC &dc, int x, int y, long flags, const wxPoint &p) const = 0;





 void gui_UpdateExpDepth() {

  // update content
  data_GetContent().gui_SetAtSameLevelOf(this);
  
  // and the exponent/subscript...
  mcExpElementHelpers::gui_UpdateExpDepth();  
 }

 virtual bool gui_DrawAsActiveOverBase() const { 
  return FALSE; 
 }

 virtual mcElement gui_GetBaseSelection() const {
  return data_GetContent().gui_GetSelection();
 }
 
 virtual bool gui_isBaseEndKey(const mcKey &ev) const;
 virtual int gui_BaseMoveCursorUsingPoint(wxDC &, const wxPoint &);
 virtual int gui_GetBaseRelCursorPos(wxDC &, wxPoint *) const;
 virtual mcMoveCursorRes gui_BaseMoveCursor(mcMoveCursorFlag flag, long modifiers);
 virtual mcInputRes gui_BaseInput(const mcKey &ke, mcElement *pnew);
 virtual mcInsertRes gui_BaseInsert(const mcElement &, mcElement *);
 virtual void gui_GetBaseCursorPos(mcCursorPos &) const; 
 virtual int gui_DrawBase(wxDC &cd, int x, int y, long flags, const wxPoint &p) const;
 virtual int gui_GetYAnchor() const;

 virtual void gui_OnBaseSelect(wxDC &dc, wxRect &rc);
 virtual void gui_SetBaseCursorPos(const mcCursorPos &);
 virtual void gui_EditBase();


#endif  // mcENABLE_GUI




#ifdef mcENABLE_MATH
public:


 //bool hasSameContentOf(const mcElement &p) const;
 bool math_CompareThisOnly(const mcElement &p, long flags) const;

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

 mcBasicOpRes math_Add(const mcElement &, mcElement *p, bool add);
 //mcBasicOpRes math_Subtract(const mcElement &, mcElement *p);
 mcBasicOpRes math_DivideBaseOnlyBy(const mcElement &, mcElement *p);
 mcBasicOpRes math_MultiplyBaseOnlyBy(const mcElement &, mcElement *p);

 mcRealValue math_GetBaseLenght() const { return 0; }

 mcRealValue math_EvaluateBase() const 
  { return data_GetContent().math_Evaluate(); }
 mcMathType math_GetBaseMathType() const 
  { return data_GetContent().math_GetMathType(); }

 mcExpSimRes math_SimplifyBase(long flags, mcElement *newelem);
 mcExpSimRes math_ExpandBase(long flags, mcElement *newelem);
 mcExpSimRes math_SimplifyBaseExp(long flags, mcElement *pnew);



 virtual mcExpSimRes math_SimplifyContents(long flags, mcElement *newelem) = 0;
 virtual mcExpSimRes math_ExpandContents(long flags, mcElement *newelem) = 0;
 virtual mcPolynomial math_GetRaisedContents() const;
 virtual mcMonomial math_GetFactors() const;

 /*mcMonomial math_GetLCM(const mcElement &p) const
  { return data_GetContent().math_GetLCM(p); }
 mcMonomial math_GetGCD(const mcElement &p) const
  { return data_GetContent().math_GetGCD(p); }*/

#endif  // mcENABLE_MATH

 



#ifdef mcENABLE_IO
protected:

 virtual wxString io_GetMathMLPresentationTag() const  { return wxEmptyString; }

public:
 bool io_isBeginTag(const wxXml2Node &tag) const {
  if (tag.GetName() == io_GetMathMLPresentationTag())
   return TRUE;
  return FALSE;
 }

 // MATH ML IO functions
 wxXml2Node io_GetBaseMathML(bool bGetPresentation) const;
 bool io_ImportPresentationMathML(wxXml2Node tag, wxString &pErr);

#endif  // mcENABLE_IO
};


class mcExpContainer : public mcExpElement
{ 
 mcDEFINE_ABSTRACT_CLASS(ExpContainer, mcExpElement);

public:

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

 mcWRAPPER void data_SetContent(const mcPolynomial &p)
  { hlp()->data_SetContent(p); }
 mcWRAPPER void data_AddElements(mcElement *p, int num, int pos = -1, bool bOverwrite = FALSE)
  { hlp()->data_AddElements(p, num, pos, bOverwrite); }
 mcWRAPPER mcElement data_AddNewElement(mcElementType t, bool bOverwrite = FALSE, int pos = -1)
  { return hlp()->data_AddNewElement(t, bOverwrite, pos); }

 mcWRAPPER mcPolynomial &data_GetContent()     { return hlp()->data_GetContent(); }
 mcWRAPPER const mcPolynomial &data_GetConstContent() const  { return hlp()->data_GetContent(); }
};


#endif // mcEXPCONTAINER_H

---

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

[ Top ]