Main page

---

Operator.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 OPERATOR_H
#define OPERATOR_H

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

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



mcDEFINE_HELPER_CLASSES(mcOperator)





class mcOperatorHelpers : public mcDecorationHelpers
{
#ifdef mcENABLE_DATA
public:  // DATA variables


 mcElementType mdata_nType;
 
 #define mcNUM_OPERATORS   4
 
 mcKey kOpBeginChar[mcNUM_OPERATORS];

 static wxString strOpSymbol[mcNUM_OPERATORS];
 
 //wxString strMathMLOp[mcNUM_OPERATORS];
 

#endif
 


#ifdef mcENABLE_GUI
protected:  // GUI variables

 static wxSize sgui_szReal[mcNUM_OPERATORS][mcELEMENTMATH_MAX_EXPDEPTH];

 static wxSize sgui_sz[mcELEMENTMATH_MAX_EXPDEPTH];

 static const mcStyleArray *sgui_pLastStyle;

#endif




#ifdef mcENABLE_MATH
protected:  // MATH variables

 int m_nPriority;

#endif



public:

 mcOperatorHelpers() {
  mdata_nType = mcET_INVALID;
 }

 virtual ~mcOperatorHelpers() {}



#ifdef mcENABLE_DATA
public:


 bool data_isAllowedBefore(mcElementType type) const;

 // shortcuts to STATIC versions
 int data_GetOpIndex() const   { return data_GetOpIndex(data_GetType()); }
 wxString data_GetOpSymbol() const { return data_GetOpSymbol(data_GetType()); }


 void data_DeepCopy(const mcElementHelpers *p) {
  const mcOperatorHelpers *o = (const mcOperatorHelpers *)p;
  mdata_nType = o->mdata_nType;
  mcDecorationHelpers::data_DeepCopy(p);
 }


 static int data_GetOpIndex(mcElementType t) {
  mcASSERT(t != mcET_INVALID, wxT("Invalid operator type"));
  return t-mcET_ADDOP;
 }

 static wxString data_GetOpSymbol(mcElementType t) {
  mcASSERT(t != mcET_INVALID, wxT("Invalid operator type"));
  return strOpSymbol[data_GetOpIndex(t)];
 }
 
 static bool data_isOp(mcElementType t) {
  return (t == mcET_ADDOP || t == mcET_SUBOP || 
    t == mcET_MULTOP || t == mcET_DIVOP);
 }

#endif  // mcENABLE_DATA




#ifdef mcENABLE_GUI
public:

 
 bool gui_isBeginKey(const mcKey &ev) const;
 
 // operators are defined by only 1 char; thus every character
 // user presses after the begin char of the operator, is an end char
 bool gui_isEndKey(const mcKey &ev) const  { return TRUE; }
 
 mcMoveCursorRes gui_MoveCursor(mcMoveCursorFlag flag, long modifiers);
 mcInputRes gui_Input(const mcKey &ev, mcElement *newelem);
 int gui_MoveCursorUsingPoint(wxDC &dc, const wxPoint &p);
 int gui_Draw(wxDC &dc, int x, int y, long flags, const wxPoint &pt) const;
 int gui_GetRelCursorPos(wxDC &dc, wxPoint *pt) const; 
 void gui_DoRecalcSize();
 
 // these doesn't apply to an operator...
 void gui_GetCursorPos(mcCursorPos &p) const  { p.gui_Push(mcCP_BEGINEND); }
 void gui_SetCursorPos(const mcCursorPos &)  { ; }
 bool gui_LetInCursor(mcCursorPos code)   { return FALSE; }

 wxSize gui_GetRealSize() const
  { return sgui_szReal[data_GetType()-mcET_ADDOP][gui_GetExpDepth()]; }
 

#endif  // mcENABLE_GUI




#ifdef mcENABLE_MATH
public:

 mcRealValue math_GetLenght() const    { return 1.5; }


 
 virtual bool math_CanBeApplied(const mcElement &l, const mcElement &r) const = 0;

 virtual mcBasicOpRes math_Apply(mcElement &, const mcElement &, mcElement *) const = 0;

 virtual mcBasicOpRes math_ApplySimple(mcElement &, const mcElement &) const = 0;

 virtual mcRealValue math_Evaluate(mcRealValue val, mcRealValue val2) const = 0;
 
 // apply this operator between pLeft and pRight elements
 //virtual void SolveFirst(mcElement pLeft, mcElement pRight) = 0;
 bool math_Compare(const mcElement &p, long flags) const 
  { return math_CompareThisOnly(p, flags); }
 //bool hasSameContentOf(const mcElement &p) const   { return FALSE; }
 
#endif  // mcENABLE_MATH



#ifdef mcENABLE_IO
public:

 bool io_isBeginTag(const wxXml2Node &tag) const;
 bool io_isBeginChar(const wxString &str) const;

 // mathML functions 
 wxXml2Node io_GetMathML(bool bGetPresentation) const;
 wxString io_GetInlinedExpr() const;

 bool io_ImportPresentationMathML(wxXml2Node tag, wxString &pErr);
 bool io_ImportInlinedExpr(const wxString &, int *count, wxString &pErr);

#endif  // mcENABLE_IO
};




class mcOperator : public mcDecoration 
{
 mcDEFINE_ABSTRACT_CLASS(Operator, mcDecoration);
 
public:

 static wxString data_GetOpSymbol(mcElementType t)
  { return mcOperatorHelpers::data_GetOpSymbol(t); }

 wxString data_GetOpSymbol() const
  { return hlp()->data_GetOpSymbol(); }

 bool data_isValidContainerFor(mcElementType t) const
  { return t == mcET_ADDOP || t == mcET_MULTOP ||
    t == mcET_SUBOP || t == mcET_DIVOP; }

 mcWRAPPER bool math_CanBeApplied(const mcElement &l, const mcElement &r) const
  { return hlp()->math_CanBeApplied(l, r); }

 mcWRAPPER mcBasicOpRes math_Apply(mcElement &l, const mcElement &r, mcElement *pp) const
  { return hlp()->math_Apply(l, r, pp); }

 mcWRAPPER mcBasicOpRes math_ApplySimple(mcElement &l, const mcElement &r) const
  { return hlp()->math_ApplySimple(l, r); }

 mcWRAPPER mcRealValue math_Evaluate(mcRealValue val, mcRealValue val2) const
  { return hlp()->math_Evaluate(val, val2); }
};


#endif // OPERATOR_H

---

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

[ Top ]