Main page

---

Function.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 mcFUNCTION_H
#define mcFUNCTION_H

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

// required includes
#include "mc/Bracket.h"
#include "mc/Text.h"

#ifdef mcUSE_WXSCRIPT
 #include <wx/script.h>   // script classes (a wxWidgets extension)

 class wxScriptFunction;
 class wxScriptFunctionArray;
 class wxScriptFile;

#else

 #define wxScriptFunction  void
 #define wxScriptFunctionArray wxArrayPtrVoid

#endif


mcDEFINE_HELPER_CLASSES(mcFunction)





#define mcFUNCTION_TYPE_NOTSET   -1

#define mcFUNCTION_TYPE_NOTFOUND  -1



class mcFunctionHelpers : public mcExpElementHelpers
{
 mcDEFINE_REFERENCE_DATA(mcFunction, mcET_FUNCTION);

#ifdef mcENABLE_DATA
protected:
 
 mcBracket mdata_eArg;

 mcText mdata_eName;

 int mdata_nFncType;

#endif



#ifdef mcENABLE_GUI
public:    // customizable variables

 static int sgui_nSpaceAboveBelow;
 static int sgui_nSpaceLeftRight;

 virtual int gui_GetSpaceAboveBelow() const  { return sgui_nSpaceAboveBelow; }
 virtual int gui_GetSpaceLeftRight() const  { return sgui_nSpaceLeftRight; }

protected:

 // the mcFunctionGUI class uses the positive values of mgui_nCursorPos
 // to store cursor position:
 // zero means that the cursor is placed on the leftmost point of
 // the base; one means that it's placed on the right of the first
 // letter of the function name....

#define mcFUNCTION_INSIDENAME   0
#define mcFUNCTION_INSIDEARG   1

 int mgui_nCursorPos;

public:     // customizable variables

 static mcKey *sgui_pNewFunction;

#endif



public:

 mcFunctionHelpers() {

  // this will also reset the string stored in mdata_eName...
  data_SetFncType(mcFUNCTION_TYPE_NOTSET);

  mdata_eName.data_SetFilter(wxT("abcdefghijklmnopqrstuvwxyz")
         wxT("ABCDEFGHIJKLMNOPQRSTUVWXYZ'"));
  data_Init();
 }

 virtual ~mcFunctionHelpers() {}

protected:

 void gui_Init() {
  mcExpElementHelpers::gui_Init();
  mgui_nCursorPos = mcFUNCTION_INSIDEARG;
  mdata_eName.hlp()->mgui_bDrawEmptyBoxIfEmpty = FALSE;
 }




#ifdef mcENABLE_DATA
public:

#ifdef __MCDEBUG__
 wxString data_BaseDebug(long flags) const;
#endif

 int data_GetChildrenCount() const {
  // the mcText used for the function name and the mcBracket used
  // as argument container are always present...
  return mcExpElementHelpers::data_GetChildrenCount()+2;
 }

 const mcElement &data_GetConstChild(int n) const {
  mcRETURN_ELEMENT_CHILD(n, mcExpElementHelpers);
  if (n == 0) return data_GetArgObj();
  if (n == 1) return data_GetNameObj();
  return mcEmptyElement;
 }
 
 void data_SetChild(int n, const mcElement &newchild) {
  mcSET_ELEMENT_CHILD(n, mcExpElementHelpers, newchild);
  mcASSERT((n == 0 && newchild.data_GetType() == mcET_BRACKET) ||
     (n == 1 && newchild.data_GetType() == mcET_TEXT),
     wxT("Invalid new child"));

  if (n == 0) data_SetArgObj(newchild);
  if (n == 1) data_SetNameObj(newchild);
  }

 void data_DeepCopy(const mcElementHelpers *p) {
  const mcFunctionHelpers *e = (const mcFunctionHelpers *)p;

  mdata_eArg.hlp()->data_DeepCopy(e->mdata_eArg.hlp());
  mdata_eName.hlp()->data_DeepCopy(e->mdata_eName.hlp());
  mdata_nFncType = e->mdata_nFncType;
  mcExpElementHelpers::data_DeepCopy(e);
 }

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

  const mcFunctionHelpers *fd = (const mcFunctionHelpers *)p;
  if (mdata_eName != fd->mdata_eName) return FALSE;
  if (mdata_eArg != fd->mdata_eArg) return FALSE;
  return TRUE;
 }

 void data_CreateSub();

 wxString data_GetName() const;

 void data_CheckName();

 void data_SetName(const wxString &str)
  { mdata_eName.hlp()->data_SetText(str); }

 mcText &data_GetNameObj()       { return mdata_eName; }
 const mcText &data_GetNameObj() const    { return mdata_eName; }
 mcTextHelpers *data_GetNameObjHlp()     { return mdata_eName.hlp(); }
 const mcTextHelpers *data_GetNameObjHlp() const  { return mdata_eName.hlp(); }

 mcBracket &data_GetArgObj()       { return mdata_eArg; }
 const mcBracket &data_GetArgObj() const    { return mdata_eArg; }
 mcBracketHelpers *data_GetArgObjHlp()    { return mdata_eArg.hlp(); }
 const mcBracketHelpers *data_GetArgObjHlp() const { return mdata_eArg.hlp(); }

 void data_SetNameObj(const mcText &p)   { mdata_eName.hlp()->data_DeepCopy(p.hlp()); }
 void data_SetArgObj(const mcBracket &p)   { mdata_eArg.hlp()->data_DeepCopy(p.hlp()); }
 

 bool data_isRegistered() const
  { return mdata_nFncType != mcFUNCTION_TYPE_NOTSET; }



 // WHAT's THE TYPE OF A FUNCTION SINCE WE LOAD IT FROM SCRIPTS ?
 void data_SetFncType(int n);
 int data_GetFncType() const      { return mdata_nFncType; }

 wxScriptFunction *data_GetScript() const;

#endif  // mcENABLE_DATA




#ifdef mcENABLE_GUI
public:


 int gui_GetArgOffsetx() const;
 int gui_GetArgOffsety() const;
 int gui_GetNameOffsetx() const;
 int gui_GetNameOffsety() const;

 void gui_Setup(int functiontype);
 wxSize gui_GetSizeOfArg() const;
 wxSize gui_GetSizeOfName() const;





 bool gui_isBeginKey(const mcKey &key) const {

  if (key.MatchKey(*sgui_pNewFunction))
   return TRUE;
  return FALSE;
 }
 
 bool gui_isBaseEndKey(const mcKey &ev) const {  
  if (mgui_nCursorPos == mcFUNCTION_INSIDENAME) {
   if (mdata_eName.gui_isEndKey(ev))
    return TRUE;

   // mcText doesn't return TRUE for some situations...
   if (mdata_eName.gui_GetCursorPos().isBegin() &&
    !ev.MatchKey(*mcMathCore::Get()->m_pCancelKey) &&
    mdata_eName.hlp()->data_isToReject(ev.GetKeyCode()))
    return TRUE;
  }

  if (mgui_nCursorPos == mcFUNCTION_INSIDEARG && 
   mdata_eArg.hlp()->gui_isEndKey(ev))
   return TRUE;
  return FALSE;
 }

 bool gui_DrawAsActiveOverBase() const { return FALSE; }
 
 int gui_DrawBase(wxDC &dc, int x, int y, long flags, const wxPoint &pt) const; 
 int gui_BaseMoveCursorUsingPoint(wxDC &dc, const wxPoint &);
 int gui_GetBaseRelCursorPos(wxDC &dc, wxPoint *pt) const;
 mcMoveCursorRes gui_BaseMoveCursor(mcMoveCursorFlag, long modifiers);
 mcMoveCursorRes gui_MoveCursor(mcMoveCursorFlag, long modifiers);
 mcInputRes gui_BaseInput(const mcKey &key, mcElement *pnew);
 mcInsertRes gui_BaseInsert(const mcElement &, mcElement *);
 void gui_GetBaseCursorPos(mcCursorPos &) const;

 int gui_GetExpOffsetx() const;
 int gui_GetExpOffsety() const;

 int gui_GetSubOffsetx() const;
 int gui_GetSubOffsety() const;

 void gui_SetCursorPos(const mcCursorPos &code);
 void gui_SetBaseCursorPos(const mcCursorPos &) {}
 void gui_DoRecalcBaseSize();

 void gui_EditBase();
 void gui_EditBaseAndSetPos(const mcCursorPos &cp);

 bool gui_hasBaseSthOnRightSide() const {
  return FALSE;
 }

 mcMoveCursorRes gui_ExpMoveCursor(mcMoveCursorFlag, long);
 mcMoveCursorRes gui_SubMoveCursor(mcMoveCursorFlag, long);  

 void gui_CheckSub();


#endif  // mcENABLE_GUI



#ifdef mcENABLE_MATH
public:

 bool math_CanBeAddedWith(const mcElement &p) const { return FALSE; }
 bool math_CanBeMultWith(const mcElement &p) const { return FALSE; }
 bool math_CanBeDivBy(const mcElement &p) const  { return FALSE; }
 
 // these do not apply on this object
 virtual mcBasicOpRes math_Add(const mcElement &, mcElement *p, bool add) { return mcBOR_REMOVE_OPERAND; }
 virtual mcBasicOpRes math_Subtract(const mcElement &, mcElement *p) { 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; }

 mcMathType math_GetBaseMathType() const;
 //bool hasSameContentOf(const mcElement &p) const  { return FALSE; }
 bool math_CompareThisOnly(const mcElement &p) const  { return FALSE; }

 mcRealValue math_EvaluateBase() const;
 
 // FIXME: this cannot be a fixed value: it should vary from fnc to fnc.
 mcRealValue math_GetLenght() const  { return 20; }

 int math_GetOrderPos() const   { return 4; }

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

#endif  // mcENABLE_MATH




#ifdef mcENABLE_IO
public:

 bool io_isBeginTag(const wxXml2Node &tag) const 
  { return FALSE; }

 bool io_isBeginChar(const wxString &str) const;

 // statics
 static wxArrayString io_ImportArgument(const wxString &str, int *count, wxString &pErr);
 static bool io_isFunctionBeginChar(const wxString &str);

 
 // MATH ML export functions
 wxXml2Node io_GetBaseMathML(bool bGetPresentation) const;
 wxXml2Node io_GetMathML(bool bGetPresentation) const;
 wxString io_GetBaseInlinedExpr() const;
 //wxString io_GetInlinedExpr() const;

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

 bool io_ImportBaseInlinedExpr(const wxString &, int *, wxString &) { return FALSE; }

 virtual void io_GetExpSubInlinedToken(wxString &subexp);

#endif  // mcENABLE_IO
};


class mcFunction : public mcExpElement
{
 mcDEFINE_MAIN_CLASS(Function, mcExpElement);

public:

 static wxScriptFunctionArray arrFunctions;
 
 static bool LoadScriptFile(const wxString &name);

#ifdef mcUSE_WXSCRIPT

 static wxString GetAllowedScriptFileExtString() 
  { return wxScriptFile::GetAllowedExtString(); }
 static wxArrayString GetAllowedScriptFileExt() 
  { return wxScriptFile::GetAllowedExt(); }
#else

 static wxString GetAllowedScriptFileExtString() 
  { return wxEmptyString; }
 static wxArrayString GetAllowedScriptFileExt() 
  { return wxArrayString(); }

#endif

 static int data_GetFunctionType(mcElement *p, int n);
 static int data_GetFunctionType(const wxString &str);

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



 mcWRAPPER void data_SetName(const wxString &str)
  { hlp()->data_SetName(str); }

 mcWRAPPER wxString data_GetName() const      { return hlp()->data_GetName(); }
 mcWRAPPER mcText &data_GetNameObj()       { return hlp()->data_GetNameObj(); }
 mcWRAPPER const mcText &data_GetNameObj() const    { return hlp()->data_GetNameObj(); }

 mcWRAPPER mcBracket &data_GetArgObj()      { return hlp()->data_GetArgObj(); }
 mcWRAPPER const mcBracket &data_GetArgObj() const   { return hlp()->data_GetArgObj(); }

 mcWRAPPER void data_SetNameObj(const mcText &p)
  { hlp()->data_SetNameObj(p); }
 mcWRAPPER void data_SetArgObj(const mcBracket &p)
  { hlp()->data_SetArgObj(p); }

 mcWRAPPER bool data_isRegistered() const
  { return hlp()->data_isRegistered(); }


 mcWRAPPER void data_SetFncType(int n)
  { hlp()->data_SetFncType(n); }
 mcWRAPPER int data_GetFncType() const
  { return hlp()->data_GetFncType(); }

 mcWRAPPER wxScriptFunction *data_GetScript() const
  { return hlp()->data_GetScript(); }

 mcWRAPPER void gui_Setup(int fnc)
  { hlp()->gui_Setup(fnc); }
};

#endif // mcFUNCTION_h

---

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

[ Top ]