Main page

---

EmptyBox.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 "EmptyBox.cpp"
#endif

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

#ifndef mcPRECOMP
    #include <wx/dcscreen.h>
 #include "mc/MathCore.h"
 #include "mc/ElementArray.h"
 #include "mc/EmptyBox.h"
 #include "mc/Parenthesis.h"
#endif


mcIMPLEMENT_MAIN_CLASS(mcEmptyBox, mcDecoration);


// setup customizable variables
float mcEmptyBoxHelpers::sgui_fEmptyBoxCharWidth =
#ifdef __WXMSW__
 3.0f;
#else
 2.0f;
#endif
float mcEmptyBoxHelpers::sgui_fEmptyBoxCharHeight = 0.8f;
wxBrush *mcEmptyBoxHelpers::sgui_pEmptyBoxBrush = NULL;

// This is the special key which must be used to create a new fraction
// through the mcElementGUI input system. It is set in 
// mcMathCore::Setugui(), as all other static variables (see that 
// function for more info about this), to "x+127".
// This is not a simple CTRL+127 combination because gui_isBeginKey() will
// return TRUE only if the given key is set as a special key.
mcKey *mcEmptyBoxHelpers::sgui_pNewEmptyBox = NULL;





// ----------------------------------------
// mcEMPTYBOXGUI
// ----------------------------------------

bool mcEmptyBoxHelpers::gui_isEndKey(const mcKey &key) const
{ 
 // the mcMonomial, which are always the parents of mcEmptyBox,
 // should be able to handle the mcIR_REPLACE_THIS flag even if the
 // replacement element is a mult/div op; this is why we check here,
 // for mcAddOp and mcSubOp only...
 //
 // IMPORTANT: we also make an exception for right mcParentheses:
 //            they are handled by mcMonomial...
 //
 mcElementType m = mcElementHelpers::gui_isKeyBeginKey(key);
 wxChar c = key.GetKeyCode();

 if (m == mcET_ADDOP || m == mcET_SUBOP || 
  (m == mcET_PARENTHESIS && mcBracketHelpers::gui_isRightParenthesis(c)))
  return TRUE;

 return FALSE;
}

void mcEmptyBoxHelpers::gui_DoRecalcSize()
{
 wxScreenDC dc;

 // Returns the size (in pixels) of an empty box.
 // You can't use directly m_fEmptyBoxCharWidth/HEIGHT
 // values to get empty boxeswxT(' size: they')re expressed in 'character'
 // units; this function works as a characters2pixels converter.
 mgui_sz = wxSize((int)(gui_GetWidthOfChar(&dc, this)*sgui_fEmptyBoxCharWidth),
    (int)(gui_GetHeightOfChar(&dc, this)*sgui_fEmptyBoxCharHeight));
}

mcInputRes mcEmptyBoxHelpers::gui_Input(const mcKey &key, mcElement *e)
{
 mcElementType m;

 // except for m_pDeleteKey, and the first character received immediately
 // after allocation, all the characters typed in an empty box
 // replace the empty box itself...
 if (!data_hasProperty(mcEP_INITIALIZED)) {

  // we're now ready to work...
  data_AddProperty(mcEP_INITIALIZED);
  gui_RecalcSize();

  return mcIR_OKAY;
 }

 // handle delete & cancel keys
 if (mcMathCore::Get()->m_pDeleteKey->MatchKey(key) ||
  mcMathCore::Get()->m_pCancelKey->MatchKey(key))
  return mcIR_DIRECT_DELETE;

 // create a new element with the given key
 if (((m=mcElementHelpers::gui_isKeyBeginKey(key)) != mcET_INVALID)) {

  // create a new element of the right type
  mcElement replacement = mcElementHelpers::data_NewElem(m);
  replacement.gui_Input(key, NULL);
  (*e) = replacement;

 } else {

  // not a delete/cancel key nor a new class begin char ?
  mcMathCore::Get()->SyntaxError(wxT("Unrecognized character"));
  return mcIR_OKAY;
 }

 // replace this empty box with the new element stored in pnew
 return mcIR_REPLACE_THIS;
}

mcInsertRes mcEmptyBoxHelpers::gui_Insert(const mcElement &toinsert, mcElement *newelem)
{
 //(*newelem) = mcElement(this);
 (*newelem) = toinsert;
 return mcINSR_REPLACE_THIS;
}

mcMoveCursorRes mcEmptyBoxHelpers::gui_MoveCursor(mcMoveCursorFlag flag, long modifiers)
{
 // manage cursor movement for empty boxes
 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;

 // flag should be MC_USEPOINT...
 return mcMCR_OKAY;
}

int mcEmptyBoxHelpers::gui_MoveCursorUsingPoint(wxDC &, const wxPoint &)
{
 // we don't have any cursor variable because, if the
 // cursor is inside this element, it can be placed
 // in one position only...
 return mcMCR_OKAY;
}

int mcEmptyBoxHelpers::gui_GetRelCursorPos(wxDC &, wxPoint *pt) const
{
 int h = (int)((gui_GetHeight()/100.)*70.);

 // cursor is always at the beginning....
 pt->x = (int)((gui_GetWidth()/100.)*49.); // place cursor at the 49% of the empty box
 pt->y = (gui_GetHeight()-h)/2;

 // cursor height = empty box height
 return h;//gui_GetHeight();
}

int mcEmptyBoxHelpers::gui_Draw(wxDC &dc, int x, int y, long flags, const wxPoint &pt) const
{
 // draw the rect filled with the right color
 dc.SetBrush(*sgui_pEmptyBoxBrush);
 dc.SetPen(*wxBLACK_PEN);
 dc.DrawRectangle(x, y, gui_GetWidth(), gui_GetHeight());

 if (flags & mcDRW_USEPOINT || flags & mcDRW_ALLACTIVE)
  return data_GetID();
 return mcDRW_NOACTIVEELEM;
}






// ----------------------------------------
// mcEMPTYBOXIO
// ----------------------------------------

wxXml2Node mcEmptyBoxHelpers::io_GetMathML(bool bGetPresentation) const
{
 mcUNUSED(bGetPresentation);
 
 // use a new tag (both for presentation & content MathML)
 // specific for MathCore: MEMPTYBOX
 return wxXml2Node(wxXML_ELEMENT_NODE, wxXml2EmptyDoc, wxT("memptybox"));
}

wxString mcEmptyBoxHelpers::io_GetInlinedExpr() const
{
 // an emptybox cannot be exported nor in MathML nor as an inlined expr
 return io_GetInlinedExprTag();
}

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

 if (tag.GetChildren() != NULL) {
  pErr = wxT("An empty box tag (specific for MathCore, not part of MathML 2.0)\n")
    wxT("cannot contain children.");
  return FALSE;
 }

 return TRUE;
}

---

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

[ Top ]