Main page

---

Symbol.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 SYMBOL_H
#define SYMBOL_H

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

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



mcDEFINE_HELPER_CLASSES(mcSymbol)














class mcSymbolHelpers : public mcExpElementHelpers
{
 mcDEFINE_REFERENCE_DATA(mcSymbol, mcET_SYMBOL);

#ifdef mcENABLE_DATA
protected:  // DATA variables

 mcSymbolProperties *mdata_pEntry;

#endif



#ifdef mcENABLE_GUI
protected:  // GUI variables
 
 // mcSymbol uses the mcExpElementGUI cursor positions + 
 // cursor positions defined here:  
#define mcSYMBOL_LEFTMOST  0  
#define mcSYMBOL_RIGHTMOST  1  
 
 int mgui_nCursorPos;

public:   // customizable variables

 static wxColour sgui_clrUndefSymbols;

#endif


#ifdef mcENABLE_MATH
public:  // customizable variables

 static int smath_nUnknownOrderPos;
 static int smath_nParameterOrderPos;
 static int smath_nConstantOrderPos;

#endif



public:

 mcSymbolHelpers() {
  mdata_pEntry = NULL;

  // mcSymbol allows both exponents and subscript
  mdata_bSubEnabled = mdata_bExpEnabled = TRUE;
  data_Init();
 }

 virtual ~mcSymbolHelpers() { data_Unlink(); }

protected:

 void gui_Init() {

  // this sets the cursor pos to zero
  mcExpElementHelpers::gui_Init();

  // cursor begins positioned at the end of the symbol; infact, when
  // the mcSymbol class has been allocated by MathCore input system, the user
  // has already pressed the symbol associated with mcSymbol class
  mgui_nCursorPos = mcSYMBOL_RIGHTMOST;
 }




#ifdef mcENABLE_DATA
public:

#ifdef __MCDEBUG__

 wxString data_BaseDebug(long flags) const;
#endif

 void data_DeepCopy(const mcElementHelpers *p) {

  // link this symbol to the same mcSymbolProperties of 'p'
  data_LinkWith(((const mcSymbolHelpers *)p)->mdata_pEntry);
  mcExpElementHelpers::data_DeepCopy(p);
 }

 bool data_isSameAs(const mcElementHelpers *p) const {
  if (!mcElementHelpers::data_isSameAs(p))
   return FALSE;
  return mdata_pEntry == ((const mcSymbolHelpers *)p)->mdata_pEntry;
 }




 void data_LinkWith(mcSymbolProperties *prop) {
  if (mdata_pEntry) data_Unlink();
  if (prop == NULL) return;
  mdata_pEntry = prop; 
  prop->data_Link(this);
 }

 void data_Unlink() {
  if (mdata_pEntry) mdata_pEntry->data_Unlink(this);
  mdata_pEntry = NULL;
 }

 bool data_isLinked() const
  { return mdata_pEntry != NULL; }

 bool data_isLinkedWith(const mcSymbolProperties *p) const
  { return mdata_pEntry == p; }

 void data_Update();





 wxString data_GetSubscript() const {
  mcASSERT(mdata_pEntry, wxT("An unlinked symbol ?"));
  return mdata_pEntry->m_strSubscript; // should be in sync with mcExpElement's subscript
 }

 wxString data_GetSymbol() const {
  mcASSERT(mdata_pEntry, wxT("An unlinked symbol ?"));
  return mdata_pEntry->m_strSymbol;
 }

 wxString data_GetInlinedSymbol() const {
  mcASSERT(mdata_pEntry, wxT("An unlinked symbol ?"));
  return mdata_pEntry->io_GetInlinedSym();
 }

 wxString data_GetEncodedType() const {
  if (data_isParameter()) return wxT("p");
  if (data_isUnknown()) return wxT("u");
  if (data_isConstant()) return wxT("c");
  return wxEmptyString; // unregistered ?
 }

 mcRealValue data_GetValue() const {
  return mdata_pEntry->m_fValue;
 }

 const mcExtRange *data_GetDomain() const {
  return mdata_pEntry->m_pDomain;
 }

 mcExtRange *data_GetDomain() {
  return mdata_pEntry->m_pDomain;
 }

 const mcSymbolProperties *data_GetConstProperties() const {
  return mdata_pEntry;
 }

 mcSymbolProperties *data_GetProperties() {
  return mdata_pEntry;
 }





 bool data_isGreekSymbol() const {
  mcASSERT(mdata_pEntry, wxT("An unlined symbol ?"));
  return mdata_pEntry->m_fEncoding == wxFONTENCODING_ISO8859_7;
 }

 bool data_isRegistered() const {
  mcASSERT(mdata_pEntry, wxT("An unlinked symbol ?"));
  return mdata_pEntry->data_isRegistered();
 }

 bool data_isParameter() const {
  mcASSERT(mdata_pEntry, wxT("An unlinked symbol ?"));
  return mdata_pEntry->data_isParameter();
 }

 bool data_isUnknown() const {
  mcASSERT(mdata_pEntry, wxT("An unlinked symbol ?"));
  return mdata_pEntry->data_isUnknown();
 }

 bool data_isConstant() const {
  mcASSERT(mdata_pEntry, wxT("An unlinked symbol ?"));
  return mdata_pEntry->data_isConstant();
 }





 void data_SetSymbol(const wxString &str);

 void data_SetValue(double d)    { mdata_pEntry->m_fValue = d; }
 void data_SetAsGreek(bool b = TRUE)   { mdata_pEntry->m_fEncoding = wxFONTENCODING_ISO8859_7; }
 void data_SetSubscript(const wxString &str);

#endif   // mcENABLE_DATA




#ifdef mcENABLE_GUI
public:


 bool gui_isBeginKey(const mcKey &ke) const;

 bool gui_isBaseEndKey(const mcKey &key) const;

 bool gui_DrawAsActiveOverBase() const { return TRUE; }
  
 mcInputRes gui_BaseInput(const mcKey &ke, mcElement *pnew);
 mcInputRes gui_SubInput(const mcKey &ev, mcElement *pnew);
 mcInsertRes gui_BaseInsert(const mcElement &, mcElement *);

 mcMoveCursorRes gui_BaseMoveCursor(mcMoveCursorFlag flag, long modifiers);
 void gui_GetBaseCursorPos(mcCursorPos &) const; 
 int gui_BaseMoveCursorUsingPoint(wxDC &, const wxPoint &);
 int gui_GetBaseRelCursorPos(wxDC &dc, wxPoint *pt) const;
 int gui_DrawBase(wxDC &dc, int x, int y, long flags, const wxPoint &pt) const;

 void gui_SetBaseCursorPos(const mcCursorPos &code);
 void gui_EditBase();
 void gui_DoRecalcBaseSize();
 

#endif  // mcENABLE_GUI




#ifdef mcENABLE_MATH
public:

 bool math_isListedBeforeOf(const mcElement &s) const;

 int math_GetOrderPos() const {
  if (data_isParameter()) return smath_nParameterOrderPos;
  if (data_isUnknown()) return smath_nUnknownOrderPos;
  if (data_isConstant()) return smath_nConstantOrderPos;
  return -1; // unregistered ?
 }




 bool math_CompareThisOnly(const mcElement &, long flags) const;

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

 // these do not apply
 virtual mcBasicOpRes math_Add(const mcElement &, mcElement *p, bool add)  { return mcBOR_REMOVE_OPERAND; }
 virtual mcBasicOpRes math_MultiplyBaseOnlyBy(const mcElement &, mcElement *p) { return mcBOR_REMOVE_OPERAND; }
 virtual mcBasicOpRes math_DivideBaseOnlyBy(const mcElement &, mcElement *p)  { return mcBOR_REMOVE_OPERAND; }

 bool math_CanBeDivBy(const mcElement &p) const  { return math_CompareThisOnly(p, TRUE); }
 bool math_CanBeMultWith(const mcElement &p) const { return math_CompareThisOnly(p, TRUE); }
 bool math_CanBeAddedWith(const mcElement &p) const { return FALSE; }

 mcRealValue math_GetBaseLenght() const { return 1; }

 mcRealValue math_EvaluateBase() const;
 mcMathType math_GetBaseMathType() const;


#endif  // mcENABLE_MATH



#ifdef mcENABLE_IO
public:

 bool io_isBeginTag(const wxXml2Node &tag) const {
  if (tag.GetName() == wxT("mi"))
   return TRUE;
  return FALSE;
 }

 bool io_isBeginChar(const wxString &str) const {
  if (wxIsalpha(str.GetChar(0)))
   return TRUE;
  return FALSE;
 }
 
 wxXml2Node io_GetBaseMathML(bool bGetPresentation) const;
 wxString io_GetBaseInlinedExpr() const;

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

#endif  // mcENABLE_IO
};




class mcSymbol : public mcExpElement
{
 mcDEFINE_MAIN_CLASS(Symbol, mcExpElement);

public:

 mcSymbol(const mcSymbolProperties *sym)
 { data_SetRefData(new mcSymbolHelpers()); hlp()->data_LinkWith((mcSymbolProperties *)sym); }

 mcSymbol operator^(const mcPolynomial &m) const
 { mcSymbol ret(*this); ret.math_RaiseTo(m); return ret; }
 mcSymbol &operator^=(const mcPolynomial &m)
 { *this = (*this)^m;return *this; }



 static mcSymbolArray arrParameters;
 
 static mcSymbolArray arrConstants;
 
 static mcSymbolArray arrUnknowns;

 static mcSymbolArray arrUnregistered;

 // WARNING: A UNREGISTERED mcSYMBOL CANNOT KNOW IF IT IS THE LAST SYMBOL OF
 //          THAT TYPE.... SO, WHEN IT IS DESTROYED IT CANNOT KNOW IF IT HAS
 //          TO DELETE THE UNREGISTERED SYMBOL FROM THE arrUnregistered OR NOT.
 //
 // SOLUTION: mcSymbolProperties HOLDS A LIST OF POINTERS TO THE SYMBOLS
 //           LINKED WITH THAT CLASS AND SO IT ALWAYS KNOW IF IT HAS
 //           INSTANCES OR IT'S UNLINKED.

 static void InitSymbols();

 static void CleanupSymbols();
 
 static mcSymbolArray *math_FindSymbol(
     long flags,
     const wxString &name, 
     wxFontEncoding enc = wxFONTENCODING_DEFAULT,
     const mcRealValue &value = 0.0, 
     const wxString &subscript = wxEmptyString, 
     const wxString &inlined = wxEmptyString,
     int occ = 0,
     int *entry = NULL, 
     int skipArr = -1);

 static mcSymbolArray *math_FindSymbol(long flags,
       const mcSymbolProperties &symtofind, 
       int occurrence = 0, 
       int *entry = NULL,
       int skipArr = -1);

 static void CheckArray(mcSymbolArray *);

 static void CheckSymbols();
 
 static bool LoadSymbols(const wxXml2Node &main, bool removeprevious = TRUE);

 static void LoadDefaultSymbols(bool removeprevious = TRUE);




 virtual void data_Update() {
  data_Update();
  mcElement::data_Update();
 }

 bool data_isValidContainerFor(mcElementType t) const
  { return t == mcET_SYMBOL; }



 mcWRAPPER void data_LinkWith(mcSymbolProperties *prop)
  { hlp()->data_LinkWith(prop); }
 mcWRAPPER void data_Unlink()
  { hlp()->data_Unlink(); }
 mcWRAPPER bool data_isLinked() const
  { return hlp()->data_isLinked(); }
 mcWRAPPER bool data_isLinkedWith(const mcSymbolProperties *p) const
  { return hlp()->data_isLinkedWith(p); }

 mcWRAPPER wxString data_GetSubscript() const
  { return hlp()->data_GetSubscript(); }
 mcWRAPPER wxString data_GetSymbol() const
  { return hlp()->data_GetSymbol(); }

/* //! Returns the string used to export this symbol as inlined expression.
 wxString data_GetInlinedSymbol() const {
  mcASSERT(mdata_pEntry, wxT("An unlinked symbol ?"));
  return mdata_pEntry->GetInlinedSym();
 }

 wxString data_GetEncodedType() const {
  if (data_isParameter()) return wxT("p");
  if (data_isUnknown()) return wxT("u");
  if (data_isConstant()) return wxT("c");
  return wxEmptyString; // unregistered ?
 }

 mcRealValue data_GetValue() const {
  return mdata_pEntry->m_fValue;
 }

 const mcExtRange *data_GetDomain() const {
  return mdata_pEntry->m_pDomain;
 }

 mcExtRange *data_GetDomain() {
  return mdata_pEntry->m_pDomain;
 }
*/
 mcWRAPPER const mcSymbolProperties *data_GetConstProperties() const
  { return hlp()->data_GetConstProperties(); }

 mcWRAPPER mcSymbolProperties *data_GetProperties()
  { return hlp()->data_GetProperties(); }


/*


 bool data_isGreekSymbol() const {
  mcASSERT(mdata_pEntry, wxT("An unlined symbol ?"));
  return mdata_pEntry->m_fEncoding == wxFONTENCODING_ISO8859_7;
 }

 bool data_isRegistered() const {
  mcASSERT(mdata_pEntry, wxT("An unlinked symbol ?"));
  return mdata_pEntry->isRegistered();
 }

 bool data_isParameter() const {
  mcASSERT(mdata_pEntry, wxT("An unlinked symbol ?"));
  return mdata_pEntry->isParameter();
 }

 bool data_isUnknown() const {
  mcASSERT(mdata_pEntry, wxT("An unlinked symbol ?"));
  return mdata_pEntry->isUnknown();
 }

 bool data_isConstant() const {
  mcASSERT(mdata_pEntry, wxT("An unlinked symbol ?"));
  return mdata_pEntry->math_isConstant();
 }





 void data_SetSymbol(const wxString &str);

 void data_SetValue(double d)    { mdata_pEntry->m_fValue = d; }
 void data_SetAsGreek(bool b = TRUE)   { mdata_pEntry->m_fEncoding = wxFONTENCODING_ISO8859_7; }
 void data_SetSubscript(const wxString &str);
*/

};


#endif // SYMBOL_H

---

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

[ Top ]