Main page

---

Operator.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 "Operator.h"
#endif

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

#ifndef mcPRECOMP
    #include <wx/dcscreen.h>
 #include "mc/Operator.h"
 #include "mc/MathUtils.h"
#endif



mcIMPLEMENT_ABSTRACT_CLASS(mcOperator, mcElement);


// setup customizable variables
wxString mcOperatorHelpers::strOpSymbol[] = { wxT("+"), wxT("-"), wxT("*"), wxT("/:") };
wxSize mcOperatorHelpers::sgui_szReal[mcNUM_OPERATORS][mcELEMENTMATH_MAX_EXPDEPTH];
wxSize mcOperatorHelpers::sgui_sz[mcELEMENTMATH_MAX_EXPDEPTH];
const mcStyleArray *mcOperatorHelpers::sgui_pLastStyle = NULL;




// ----------------------
// mcOPERATORDATA
// ----------------------

bool mcOperatorHelpers::data_isAllowedBefore(mcElementType type) const
{
 if (mcOperatorHelpers::data_isOp(type))
  return FALSE;  // two operators cannot be adiacent...
 return TRUE;
}



// ----------------------
// mcOPERATORGUI
// ----------------------

void mcOperatorHelpers::gui_DoRecalcSize()
{
 if (gui_GetStyleArray() == sgui_pLastStyle) {

  mcGUILOG(wxT("mcOperatorHelpers::gui_DoRecalcSize - skipped an operator recalc process"));
  mgui_sz = sgui_sz[gui_GetExpDepth()]; 
  return;  // no need to recalc anything
 }

 mcGUILOG(wxT("mcOperatorHelpers::gui_DoRecalcSize - recalculating ALL operator' sizes"));
 sgui_pLastStyle = gui_GetStyleArray();
 wxScreenDC dc;

 // save the width and height of this operator (they are set
 // to the maximum width and height found among all the
 // operators, so all the operators occupy the same size)
 //gui_SelectStyle(dc);
 for (int j=0; j < mcELEMENTMATH_MAX_EXPDEPTH; j++) {
 
  // set the right style for this exponent depth
  gui_GetStyleArray()->Get(j)->gui_Select(dc, this);
  sgui_sz[j].Set(-1, -1);

  for (int i=0; i < mcNUM_OPERATORS; i++) {
   wxString str = strOpSymbol[i].GetChar(0);

   int w = gui_GetWidthOf(&dc, str);
   int h = gui_GetHeightOf(&dc, str);

   sgui_sz[j].SetWidth(mcMAX(w, sgui_sz[j].GetWidth()));
   sgui_sz[j].SetHeight(mcMAX(h, sgui_sz[j].GetHeight()));

   // save the real size for this op
   sgui_szReal[i][j].Set(w, h);
  }
 }

 // last update our internal pointer
 mgui_sz = sgui_sz[gui_GetExpDepth()];
}

int mcOperatorHelpers::gui_Draw(wxDC &hDC, int x, int y, long flags, const wxPoint &pt) const
{
 wxSize real(gui_GetRealSize());
 mcGUILOG(wxT("mcOperatorHelpers::gui_Draw [%s] - size [%d;%d], real size [%d;%d]"),
    mcTXTTHIS, mgui_sz.GetWidth(), mgui_sz.GetHeight(),
    real.GetWidth(), real.GetHeight());

 // draw the symbol using correct colors and fonts
 gui_SelectStyle(hDC);

 hDC.DrawText(data_GetOpSymbol(),
  x+(mgui_sz.GetWidth()-real.GetWidth())/2,
  y+(mgui_sz.GetHeight()-real.GetHeight())/2);

 return data_GetID();
}

mcInputRes mcOperatorHelpers::gui_Input(const mcKey &key, mcElement *)
{
 wxString str = (wxChar)key.GetKeyCode();

 // be sure the given char is the char which defines hlp()
 // operator
 mcASSERT(data_GetOpSymbol().Contains(str),
  wxT("Given char wasn't the right symbol for this operator"));

 // update size of hlp() op
 gui_RecalcSize();

 return mcIR_OKAY;
}

mcMoveCursorRes mcOperatorHelpers::gui_MoveCursor(mcMoveCursorFlag flag, long modifiers)
{
 // if mcOperatorHelpers::gui_MoveCursor is called, it means that the cursor
 // position is wrong...
 mcASSERT(0, wxT("Code should never get here; cursor position is wrong"));
 /*if (flag == mcMCF_LEFT) return mcMCR_SETFOCUS_PREVIOUS;
 if (flag == mcMCF_RIGHT) return mcMCR_SETFOCUS_NEXT;
 if (flag == mcMCF_UP) return mcMCR_SETFOCUS_ABOVE;
 if (flag == mcMCF_DOWN) return mcMCR_SETFOCUS_BELOW;
 */
 // just to make compiler happy
 return mcMCR_OKAY;
}

int mcOperatorHelpers::gui_MoveCursorUsingPoint(wxDC &dc, const wxPoint &p)
{
 mcASSERT(0, wxT("Code should never get here; cursor position is wrong"));

 // just to make compiler happy
 return mcMCR_OKAY;
}

int mcOperatorHelpers::gui_GetRelCursorPos(wxDC &hDC, wxPoint *pt) const
{
 // if mcOperatorHelpers::gui_GetRelCursorPos is called, it means that the
 // cursor position is wrong...
 mcASSERT(0, wxT("Code should never get here; cursor position is wrong"));
 pt->x = 0;
 pt->y = 0;

 // just to make compiler happy
 return gui_GetHeight();
}

bool mcOperatorHelpers::gui_isBeginKey(const mcKey &key) const
{
 wxString str = (wxChar)key.GetKeyCode();
 if (key.GetKeyCode() != 0 && key.GetModifiers() == 0 && 
  data_GetOpSymbol().Contains(str))
  return TRUE;
 return FALSE;
}





// ----------------------
// mcOPERATORIO
// ----------------------

bool mcOperatorHelpers::io_isBeginTag(const wxXml2Node &tag) const
{
 if (tag.GetName().CmpNoCase(wxT("mo")) != 0)
  return FALSE;
 if (tag.GetChildren().GetType() != wxXML_TEXT_NODE)
  return FALSE;  // ERROR !!!! NOT WELL-FORMED MATHML

 wxString str = tag.GetChildren().GetContent();
 for (int n=0; n < mcNUM_OPERATORS; n++)
  if (strOpSymbol[n].Contains(str))
   return n;

 return FALSE;
}

bool mcOperatorHelpers::io_isBeginChar(const wxString &str) const
{
 if (data_GetOpSymbol().Contains(str))
  return TRUE;
 return FALSE;
}

wxXml2Node mcOperatorHelpers::io_GetMathML(bool bGetPresentation) const
{
 // set up the given tag to represent an operator of hlp() type
 return wxXml2Node(wxXML_TEXT_NODE, wxXml2EmptyDoc, wxT("mo"), data_GetOpSymbol());
}

wxString mcOperatorHelpers::io_GetInlinedExpr() const
{
 return data_GetOpSymbol().Left(1);
}

bool mcOperatorHelpers::io_ImportPresentationMathML(wxXml2Node tag, wxString &pErr)
{
 mcASSERT(tag.GetName() == wxT("mo"), wxT("Error in mcOperatorHelpers::io_isBeginTag()"));

 if (tag.GetChildren().GetType() != wxXML_TEXT_NODE) {

  // ooooooops
  pErr = wxT("The MathML to import is not valid MathML 2.0\n")
    wxT("or there was an error while parsing it.");
  return FALSE;
 }

 // extract data & check it
 wxString str = tag.GetChildren().GetContent();
 mcASSERT(data_GetOpSymbol().Contains(str),
   wxT("Error in mcOperatorHelpers::io_isBeginTag"));

 return TRUE;

}

bool mcOperatorHelpers::io_ImportInlinedExpr(const wxString &str, int *count, wxString &pErr)
{
 wxString opchar(str.GetChar(0));
 mcASSERT(data_GetOpSymbol().Contains(opchar), 
  wxT("Error in mcOperatorHelpers::io_isBeginChar"));

 // there are no info to import in a mcOperator....
 *count = 1;
 return TRUE;
}

---

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

[ Top ]