Main page

---

MathBox.cpp

Go to the documentation of this file.

// MathGUI = 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 "MathBox.h"
#endif


// includes
#include "mg/mgprec.h"

#ifndef mgPRECOMP
   // for the "Insert fraction, radical, function" commands
   #include "mc/MathCore.h"
   #include "mc/Function.h"
   #include "mc/Fraction.h"
   #include "mc/Radical.h"

   #include "mg/GUIUtils.h"
   #include "mg/MathBox.h"
#endif

// Additional wxWidgets headers
#include <wx/image.h>
#include <wx/wfstream.h>
#include <wx/txtstrm.h>
#include <wx/mstream.h>
#include <wx/filename.h>
#include <wx/clipbrd.h>



// set up customizable variables
int mgMathBox::nCursorWidth = 2;
int mgMathBox::nSpaceAround = 5;
bool mgMathBox::bUseNativeNewLines = TRUE;


mgMathBoxCmd mgMathBox::cmd[] = 
{
   // simple edit commands
   { mgMBC_CUT, wxT("Cut") },
   { mgMBC_COPY_ASPLAIN, wxT("Copy as plain text") },
   { mgMBC_COPY_ASMATHML, wxT("Copy as MathML") },
   { mgMBC_PASTE, wxT("Paste") },
   { mgMBC_SELECTALL, wxT("Select all") },

   { mgMBC_CREATENEW_ANDLINE, wxT("Create a new line connected with AND") },
   { mgMBC_CREATENEW_ORLINE, wxT("Create a new line connected with OR") },
   { mgMBC_SIMPLEEND, wxT("") },

   // advanced edit commands
   { mgMBC_EMBED_NUMFRACTION, wxT("Embed as num of a fraction") },
   { mgMBC_EMBED_DENFRACTION, wxT("Embed as den of a fraction") },
   { mgMBC_EMBED_RADICAL, wxT("Embed into a radical") },
   { mgMBC_EMBED_BRACKET, wxT("Bracketize") },  
   { mgMBC_ADVEND, wxT("") },

#ifdef __MGDEBUG__
   { mgMBC_DEBUG, wxT("View debug info") },
#endif

   { mgMBC_LAST, wxT("") }
};


// defines the custom command event sent to the client window
// (by default it's the parent window) when the element under
// mouse cursor changes...
DEFINE_EVENT_TYPE( mgEVT_ACTIVE_ELEM_CHANGED )




// mgMATHBOX
IMPLEMENT_CLASS(mgMathBox, wxWindow)//wxResizeableControl)
BEGIN_EVENT_TABLE(mgMathBox, wxWindow)//wxResizeableControl)

   // focus events
   EVT_SET_FOCUS(mgMathBox::OnSetFocus)
   EVT_KILL_FOCUS(mgMathBox::OnFocusLost)

   // miscellaneous events
   EVT_SIZE(mgMathBox::OnSize)
   EVT_PAINT(mgMathBox::OnPaint)

   // mouse events
   //EVT_SET_CURSOR(mgMathBox::OnSetCursor)     // not needed
   //EVT_RIGHT_DOWN(mgMathBox::OnRDown)
   EVT_RIGHT_UP(mgMathBox::OnRUp)            // used for context menu
   EVT_LEAVE_WINDOW(mgMathBox::OnLeaveWindow)
   EVT_LEFT_DOWN(mgMathBox::OnLDown)         // used for starting selections
   EVT_LEFT_UP(mgMathBox::OnLUp)          // used to end selections
   EVT_MOTION(mgMathBox::OnMouseMove)        // used to select

   // keyboard events
   EVT_CHAR(mgMathBox::OnChar)

   // context menu events
   EVT_MENU_RANGE(mgMATHBOX_CONTEXTMENU_BASEID,
               mgMATHBOX_CONTEXTMENU_FINALID,
               mgMathBox::OnCtxMenuItem)
END_EVENT_TABLE()






// --------------------------------------------
// mgMATHBOX - general functions
// --------------------------------------------

void mgMathBox::Init()
{
   m_pClient = NULL; // this is the only pointer contained by mgMathBox

   // set WHITE as the window background color
   SetBackgroundColour(wxColour(255, 255, 255));   

   // init all
   SetClientEvtHandler(GetParent());
   m_bProcSpecialChar = FALSE;
   m_bAutoExpand = FALSE;
   Clean();

   // init the selection rect
   ResetSelectionRect();

   // if the caret of this window does not exist, create it
   if (GetCaret() == NULL)
      SetCaret(new wxCaret(this, nCursorWidth, 10));  

   // by default, everything is initially enabled... use
   // the #EnableInput, #EnableSelection, #EnableContextMenu
   // to modify those variables...
   EnableInput(TRUE);
   m_bSelectionEnabled = TRUE;
   m_bContextMenuEnabled = TRUE;
   m_bPreProcessingEnabled = TRUE;

   UpdateCaretPos();
   UpdateCaret();
}

void mgMathBox::EnableInput(bool bEnable)
{
   m_bInputEnabled = bEnable;

   // set the type of cursor accordingly
   if (m_bInputEnabled) {
      SetCursor(wxCursor(wxCURSOR_IBEAM));
   } else {
      SetCursor(wxCursor(wxCURSOR_ARROW));
   }

   // the caret must be hidden when input is disabled...
   UpdateCaret();
}

void mgMathBox::DeepCopy(const mgMathBox &tocopy)
{
   // deep copy everything
   m_mathContent.data_DeepCopy(tocopy.m_mathContent);

   m_rcSelection = tocopy.m_rcSelection;
   m_bProcSpecialChar = tocopy.m_bProcSpecialChar;

   // remaining variables doesn't need to be deep copied...
}

void mgMathBox::Clean()
{
   // re init  
   m_mathContent.data_Clear();

   // create a mcMathAndSystem with a mcMathLine with the left member
   // containing a mcEmptyBox...
   GetMathObj().gui_AddEmptyLineToNewAndSystem();
   /*data_AddLineToNewAndSystem(new mcMathLine());
   GetMathObj().data_GetSys(0).data_GetLine(0).data_GetLeftMem().gui_AddNewEmptyMonomial();*/

   // update everything
   ResetGUI();
}

wxString mgMathBox::GetDebug() const
{
   // return just the contained math data debug info...
   return m_mathContent.data_GetDebug(0, mcELEMENT_DBG_SELECTION);
}





// --------------------------------------------
// mgMATHBOX - SIZE functions
// --------------------------------------------

wxSize mgMathBox::GetContentSize() const
{
   int w = m_mathContent.gui_GetWidth()+nSpaceAround*2,
      h = m_mathContent.gui_GetHeight()+nSpaceAround*2;

   return wxSize(w, h);
}

void mgMathBox::FitContents()
{
   // update client size to contain all the data. This could mean
   // that this function expands the window; it never shrinks it. <-- WHY ???
   wxSize min = GetContentSize();
   SetSize(min);
   UpdateContentPos();
   /*wxSize sz = GetSize();
   if (min.GetWidth() > sz.GetWidth()) sz.SetWidth(min.GetWidth());
   if (min.GetHeight() > sz.GetHeight()) sz.SetHeight(min.GetHeight());
   SetSize(sz);*/
}

void mgMathBox::SetSizeHintsToFitContents()
{
   FitContents();

   // with this call, resize system will not be allowed to shrink this
   // window under the content size...
   wxSize s = GetContentSize();
   SetSizeHints(s.GetWidth(), s.GetHeight());
}




// --------------------------------------------
// mgMATHBOX - UPDATE functions
// --------------------------------------------

void mgMathBox::UpdateContentPos()
{  
   wxSize sz(GetClientSize()), mathsz(GetContentSize());

   // center vertically the mcMathOrSystem in this window.
   m_ptPos.y = (sz.GetHeight()-mathsz.GetHeight())/2;

   // center horizontally the mcMathOrSystem in this window.
   m_ptPos.x = (sz.GetWidth()-mathsz.GetWidth())/2;

   // this is the top-leftmost position allowed...
   if (m_ptPos.x < 0) m_ptPos.x = 0;
   if (m_ptPos.y < 0) m_ptPos.y = 0;
}

void mgMathBox::UpdateCaret()
{
   // the caret should have been already built.. anyway better check
   mgCaret *cur = GetCaret();
   if (!cur) return;

   //bool oldstate = cur->IsVisible();
   if (!m_bInputEnabled || isSelecting()) {

      // never show the caret in these cases
      cur->ForceHide();    

   } else {

      cur->ForceShow();
   }

   //if (oldstate != cur->IsVisible())
   // ForceBmpUpdate();
}

void mgMathBox::UpdateCaretPos()
{
   wxClientDC dc(this);
   int n;
   
   // get current cursor position
   wxPoint p = m_mathContent.gui_GetRelCursorPos(dc, GetXPos(), GetYPos(), &n);
   mcASSERT(n != 0, wxT("Cursor is not positioned in a valid point..."));
   
   // and update the window's caret
   wxCaret *cur = GetCaret();
   if (!cur) return;
   cur->Move(p);
   cur->SetSize(nCursorWidth, n);

   UpdateCaret();
}

int mgMathBox::UpdateMathBmp(long flags, const wxPoint &p)
{
   // IF WE DO SOMETHING LIKE THIS:
   // 
   // wxRect rc(GetXPos(), GetYPos(),  m_mathContent.gui_GetWidth(), 
   //                         m_mathContent.gui_GetHeight());
   // if (!rc.Inside(cursor)) {
   //    mgLogBoxEvent("mgMathBox::UpdateActiveElem() - update rejected");
   //    return;
   // }
   //
   // THEN WE WOULD:
   // 1) make this function a little slower, instead of faster,
   //    because mcMathOrSystemHelpers::gui_UpdateBmp already
   //    does this type of check
   // 2) render something wrong (that is, still as active) when
   //    the cursor exits the math content box because math contents
   //    would never receive the info "the mouse cursor is not over you"
   //    and thus would continue to draw as active something which is not
   //    anymore.
   
   // mcMathOrSystem will care of everything...
   int x=GetXPos(), y=GetYPos();
   int ret = m_mathContent.gui_UpdateBmp(x, y, flags, p);

   // do we need to redraw ?
   if (m_mathContent.gui_NeedsRefresh()) {

      wxClientDC dc(this);
      RedrawMath(dc, x, y);
   }

   // do we need to fire an event ?
   if (m_mathContent.gui_isIDChanged()) {

      wxCommandEvent ev(mgEVT_ACTIVE_ELEM_CHANGED, GetId());
      ev.SetExtraLong(m_mathContent.gui_GetActiveElemID());
      if (m_pClient) m_pClient->AddPendingEvent(ev);
   }

   return ret;
}

void mgMathBox::UpdateMathBmpWithCurrentPos()
{
   wxPoint p = wxGetMousePosition();

   // remap cursor position in the correct way
   p = ScreenToClient(p);     // from screen to window coord.

   // use std version of the function
   UpdateMathBmp(mcDRW_USEPOINT, p);
}

void mgMathBox::ForceBmpUpdate()
{
   int x=GetXPos(), y=GetYPos();
   wxPoint p = wxGetMousePosition();

   // remap cursor position in the correct way
   p = ScreenToClient(p);     // from screen to window coord.

   // force the update
   m_mathContent.gui_ForceBmpUpdate(x, y, mcDRW_USEPOINT, p);

   // and redraw the updated bitmap
   wxClientDC dc(this);
   RedrawMath(dc, x, y);
}




// --------------------------------------------
// mgMATHBOX - miscellaneous
// --------------------------------------------

void mgMathBox::RedrawMath(wxDC &dc, int x, int y)
{
   // before drawing, we must be sure that caret is hidden
#if 0
   mgCaret *caret = GetCaret();
   if (caret) caret->ForceHide();
#endif
   m_mathContent.gui_DrawBmp(dc, x, y);

   // after drawing, we should restore the caret, if it
   // is necessary
   UpdateCaret();
}

void mgMathBox::ResetGUI()
{
   m_mathContent.gui_SetCursorPos(mcCP_BEGIN);
   m_mathContent.gui_UpdateExpDepth();
   m_mathContent.gui_DeepRecalcSize();

   // the order is important !
   ForceBmpUpdate();
   UpdateContentPos();
   UpdateCaretPos(); 
   Refresh();
}

void mgMathBox::CheckReturnFlag(int res)
{
   switch (res) {
   case mcMCR_SETFOCUS_PREVIOUS:
   case mcMCR_SETFOCUS_NEXT:
   case mcMCR_SETFOCUS_ABOVE:
   case mcMCR_SETFOCUS_BELOW:
      mcMathCore::Get()->SyntaxError(wxT("Cannot move cursor beyond math data"));
      break;

   case mcMCR_CANNOT_SETFOCUS:
      //m_mathContent.gui_DeSelect();     // WHY ?
      //Refresh();
      break;
   }
}



// --------------------------------------------
// mgMATHBOX - miscellaneous event handlers
// --------------------------------------------

void mgMathBox::OnPaint(wxPaintEvent &ev)
{
   wxCaretSuspend cs(this);
   wxPaintDC dc(this);

   // on MS windows, this sets up some optimizations
   dc.BeginDrawing();
   
   // draw the selection rectangle
   dc.SetBrush(*wxCYAN_BRUSH);
   dc.DrawRectangle(m_rcSelection);
   
   // draw using the image of the line
   RedrawMath(dc, GetXPos(), GetYPos());
   
   // on MS windows, shut down draw optimizations
   dc.EndDrawing();

   // for debugging
   mgLogBoxEvent(wxT("mgMathBox::OnPaint() - window repainted"));
}

void mgMathBox::OnSize(wxSizeEvent &se)
{
   // when size changes, the cursor position must be updated because
   // the math data is centered in the window...
   UpdateCaretPos();

   // we need to erase old bitmap: we can now its exact position
   // because our m_ptPos variable has not been updated yet...
   wxClientDC dc(this);
   dc.SetPen(*wxWHITE_PEN);
   dc.SetBrush(*wxWHITE_BRUSH);
   dc.DrawRectangle(m_ptPos, GetContentSize());

   // we can now draw the new bitmap in the updated pos...
   UpdateContentPos();
   UpdateCaretPos();
   RedrawMath(dc, GetXPos(), GetYPos());

   // for debugging
   mgLogBoxEvent(wxT("mgMathBox::OnSize() - window resized"));
}

void mgMathBox::OnSpecialChar(wxKeyEvent &ke)
{
   m_bProcSpecialChar = TRUE;
   OnChar(ke);
   m_bProcSpecialChar = FALSE;
}

void mgMathBox::OnChar(wxKeyEvent &ke)
{
   wxClientDC dc(this);
   int r, mod=mcMCF_NOMODIFIERS;
/*
   if (ke.GetKeyCode() == 13 && !m_bProcSpecialChar)
      return;
*/
   // block here the ALT+xxxx keypresses.
   if (ke.AltDown()) {
      ke.Skip();     // otherwise menu shortcut won't work
      return;
   }

   // block here some other special keypresses
   // (like the Windows' START keypress)
   if (ke.GetKeyCode() == WXK_START
#ifdef __WXMSW__
      || ke.GetKeyCode() == 397  // on winXP at least, start button has keycode = 397
#endif
      ) {
      ke.Skip();
      return;
   }

   // is input enabled ?
   if (!m_bInputEnabled) {
      wxBell();         // cannot accept any input... sorry
      return;
   }

   // are we moving the cursor and selecting ?
   if (ke.ShiftDown())  
      mod = mcMCF_EXTEND_SELECTION; // maybe: pass to the gui_MoveCursor a "modifier"

   // remove the SHIFT flag from capital letters....
   if (ke.GetKeyCode() >= 65 && ke.GetKeyCode() <= 90 && ke.ShiftDown())
      ke.m_shiftDown = FALSE;

   switch (ke.m_keyCode) {

      // cursor movement keys handlers
   case WXK_LEFT:
      r = m_mathContent.gui_MoveCursor(mcMCF_LEFT, mod);
      CheckReturnFlag(r);
      UpdateCaretPos();
      break;
   case WXK_RIGHT:
      r = m_mathContent.gui_MoveCursor(mcMCF_RIGHT, mod);
      CheckReturnFlag(r);
      UpdateCaretPos();
      break;
   case WXK_UP:
      r = m_mathContent.gui_MoveCursor(mcMCF_UP, mod);
      CheckReturnFlag(r);
      UpdateCaretPos();
      break;
   case WXK_DOWN:
      r = m_mathContent.gui_MoveCursor(mcMCF_DOWN, mod);
      CheckReturnFlag(r);
      UpdateCaretPos();
      break;
   case WXK_HOME:
      m_mathContent.gui_SetCursorPos(mcCP_BEGIN);
      UpdateCaretPos();
      break;
   case WXK_END:
      m_mathContent.gui_SetCursorPos(mcCP_END);
      UpdateCaretPos();
      break;


   default:

      if (!m_bProcSpecialChar) {

         // a numpad key was pressed; ignore it; this function will be called
         // again, by wxWidgets, with a translated ASCII code
         if (ke.m_keyCode >= WXK_NUMPAD0 && ke.m_keyCode <= WXK_NUMPAD9)
            return;

#ifdef __WXMSW__
         // a little exception: if user pressed CTRL+ENTER we must correct,
         // on win32 the key event which we receive....
         if (ke.ControlDown() && ke.GetKeyCode() == 10) {

            // Get Win32 native scancode
            if ((ke.GetRawKeyFlags() >> 16) == 28) // 28 = ENTER scancode
               ke.m_keyCode = 13;
         }
#endif
      }

#ifdef __WXGTK__
      // this flag is always set on Linux when the NUMLOCK is on)... but this would
      // prevent MathCore from recognizing the keypress...
      ke.m_metaDown = false;
#endif

      // convert the wxKeyEvent to a mcKey
      mcKey mykey(ke);

      // to create a relational operator, we must always
      // use special keys...
      wxChar c = ke.GetKeyCode();
      if (m_bProcSpecialChar || c == mcMMRO_LESS || 
         c == mcMMRO_GREATER || c == mcMMRO_EQUAL)
         mykey.SetAsSpecialKey();

      // one of ()0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      // or abcdefghijklmnopqrstuvwxyz key was pressed
      mgLogBoxEvent(wxT("mgMathBox::OnChar() - before processing: [%s]"), 
         m_mathContent.io_GetInlinedExpr().c_str());
      m_mathContent.gui_Input(mykey, NULL);
      mgLogBoxEvent(wxT("mgMathBox::OnChar() - after processing: [%s]"), 
         m_mathContent.io_GetInlinedExpr().c_str());

      // update cursor pos and redraw the window
      if (m_bAutoExpand)
         FitContents();
      
      UpdateContentPos();
      UpdateCaretPos();

      Refresh();
      ForceBmpUpdate();
      //UpdateMathBmpWithCurrentPos();    
   }

   // for debugging
   mgLogBoxEvent(wxT("mgMathBox::OnChar() - input handled"));
}





// --------------------------------------------
// mgMATHBOX - mouse event handlers
// --------------------------------------------

void mgMathBox::OnSetCursor(wxSetCursorEvent &ev)
{
   SetCursor(wxCursor(wxCURSOR_ARROW));//*wxSTANDARD_CURSOR);

   // for debugging
   mgLogBoxEvent(wxT("mgMathBox::OnSetCursor() - cursor has been set"));
}

void mgMathBox::OnLeaveWindow(wxMouseEvent &ev)
{
   // sometimes, when the user moves the cursor out of the mcMathOrSystem
   // very fast, the math system doesn't receive a correct UpdateActiveElem()
   // call and thus, the element highlighting remains even if the mouse
   // cursor is not over that element anymore...
   UpdateMathBmp(mcDRW_NONACTIVE);  

   // for debugging
   mgLogBoxEvent(wxT("mgMathBox::OnLeaveWindow() - cursor has leaved the box"));
}

void mgMathBox::OnLDown(wxMouseEvent &me)
{
   // if the selection system is not enabled, then this event handler's
   // code should not be executed since it only handles the SELECTION
   if (!m_bSelectionEnabled)
      return;
   
   // the first thing to do, is to delete the old selection...
   bool needsupdate = m_mathContent.gui_isSelected();
   m_mathContent.gui_DeSelect();
   if (needsupdate) ForceBmpUpdate();

   // prepare some variables
   wxClientDC dc(this);
   wxPoint pt = me.GetLogicalPosition(dc);

   // set up the drag start point of the selection
   m_rcSelection.x = pt.x;
   m_rcSelection.y = pt.y;

   // this settings will work as a flag: the selection
   // rectangle is now being dragged (see isSelecting())
   m_rcSelection.width = 0;
   m_rcSelection.height = 0;

   // capture the mouse (so, if it exits the window
   // the OnLUP function will still be called)
   CaptureMouse();

   // hide caret & change cursor
   UpdateCaret(); 
   //SetCursor(*wxSTANDARD_CURSOR);

   // for debugging
   mgLogBoxEvent(wxT("mgMathBox::OnLDown() - started selection dragging"));
}

void mgMathBox::OnLUp(wxMouseEvent &me)
{
   // when this event handler is called, then it is because
   // the user should be selecting something...
   // check if the drag point was in this same mgMathBox
   if (GetCapture() == this) {

      // user has just finished to create a selection rectangle...
      // all the math data must have been already selected by
      // OnMouseMove... just reset selection system
      ResetSelectionRect();

      // free the cursor
      ReleaseMouse();      

      // move the cursor inside the math data
      wxClientDC dc(this);
      wxPoint pt = me.GetLogicalPosition(dc);
      wxRect rc(GetRectOfContents());

      // check if point is inside the math data
      if (rc.Inside(pt)) {

         // user released button over the math expression; move the cursor
         // to the nearest available position
         m_mathContent.gui_MoveCursorUsingPoint(dc, 
                        wxPoint(pt.x-rc.x, pt.y-rc.y));
         
         // don't use CheckReturnFlag since it would emit
         // a dummy sound if the given position is not valid
         // (and this almost always TRUE when the user
         //  drags a big rectangle on the math data)           

      } else {

         if (pt.x < rc.x) {

            // the cursor is on the LEFT side of the math content
            m_mathContent.gui_SetCursorPos(mcCP_BEGIN);

         } else if (pt.x > rc.x+rc.width) {

            // the cursor is on the RIGHT side of the math content
            m_mathContent.gui_SetCursorPos(mcCP_END);

         } else if (pt.y < rc.y || pt.y > rc.y+rc.height) {

            // the cursor is above/below the math content: ajust
            // the point so that it falls inside the math content
            pt.y = rc.y+m_mathContent.gui_GetHeight()/2;
            m_mathContent.gui_MoveCursorUsingPoint(dc, 
                        wxPoint(pt.x-rc.x, pt.y-rc.y));
         }
      }

      // restore caret & cursor
      UpdateCaretPos();
      UpdateCaret();
      //SetCursor(*m_pCursor);

      // for debugging
      mgLogBoxEvent(wxT("mgMathBox::OnLUp() - selection ended (%d elements selected)"),
                  m_mathContent.gui_isSelected());
   }
}

void mgMathBox::OnRUp(wxMouseEvent &me)
{
   // this event handler is used only for context menu handling
   if (!m_bContextMenuEnabled)
      return;

   // check if the user right-clicked on the selection or not
   wxClientDC dc(this);
   wxPoint tmp = me.GetLogicalPosition(dc);
   if (m_mathContent.gui_GetActiveElemID() != mcDRW_ONSELECTION) {

      // create a dummy selection to select the element the
      // user right-clicked on...
      m_rcSelection.x = tmp.x;
      m_rcSelection.y = tmp.y;
      m_rcSelection.width = 1;
      m_rcSelection.height = 1;

      // if this selection rectangle would destroy the
      // current selection without selecting anything new, 
      // then avoid it...
      if (m_rcSelection.Intersects(GetRectOfContents())) {  

         // if the user clicked on a valid element, we are sure
         // it's now selected
         m_rcSelection.x-=GetXPos();
         m_rcSelection.y-=GetYPos();
         m_mathContent.gui_OnSelect(dc, m_rcSelection);
         ForceBmpUpdate();

      }

      // we can now proceed...
   }

   // create the context menu
   wxMenu m;
   m_eSelection = m_mathContent.gui_GetSelection();
   GetContextMenu(m, m_eSelection);

   // pop up the context menu
   PopupMenu(&m, tmp);

   // for debugging
   mgLogBoxEvent(wxT("mgMathBox::OnRUp() - popped the context menu"));
}

void mgMathBox::OnMouseMove(wxMouseEvent &me)
{
   wxClientDC dc(this);

   // get the point in scrolled window coord
   wxPoint tmp = me.GetLogicalPosition(dc);

   if (GetCapture() == this) {

      // we are not just moving the cursor into the window:
      // we are dragging a selection rectangle...

      // update selection rectangle
      m_rcSelection.width = tmp.x-m_rcSelection.x;
      m_rcSelection.height = tmp.y-m_rcSelection.y;

      // normalize rect
      wxRect rc(m_rcSelection);
      if (rc.width < 0) {
         rc.x += rc.width;    // the X could become negative but it's okay
         rc.width = -rc.width;
      }
      if (rc.height < 0) {
         rc.y += rc.height;
         rc.height = -rc.height;
      }

      // do not allow null rects
      if (rc.width == 0) rc.width++;
      if (rc.height == 0) rc.height++;

      // check that everything's okay
      mcASSERT(rc.width > 0 && rc.height > 0, wxT("invalid rect"));     
      wxRect mathrc(GetRectOfContents());
      if (!mathrc.Intersects(rc))
         return;

      // update selection
      rc.Offset(-mathrc.x, -mathrc.y);
      m_mathContent.gui_OnSelect(dc, rc);

      // update the math bitmap: to make things clearer,
      // do not draw any activation state
      ForceBmpUpdate();

   } else {

      // we are just moving the cursor around the window:
      // update activation state...
      UpdateMathBmp(mcDRW_USEPOINT, tmp);
   }

   // for debugging
   mgLogBoxEvent(wxT("mgMathBox::OnMouseMove() - mouse movement handled"));
}



// --------------------------------------------
// mgMATHBOX - focus event handlers
// --------------------------------------------

void mgMathBox::OnSetFocus(wxFocusEvent &fe)
{
   // just for debugging purpose...
   mgLogDebug(wxT("mgMathBox::OnSetFocus() - focus set"));
}

void mgMathBox::OnFocusLost(wxFocusEvent &fe)
{
   // just for debugging purpose...
   mgLogDebug(wxT("mgMathBox::OnSetFocus() - focus lost"));
}



// --------------------------------------------
// mgMATHBOX - context menu
// --------------------------------------------

void mgMathBox::OnCtxMenuItem(wxCommandEvent &ce)
{
   wxClientDC dc(this);

   // exec the command chosen by the user
   switch (ce.GetId()-mgMATHBOX_CONTEXTMENU_BASEID) {
   case mgMBC_CUT:
      Cut(m_eSelection);
      break;

   case mgMBC_COPY_ASPLAIN:
      CopyAsPlainText(m_eSelection);
      break;

   case mgMBC_COPY_ASMATHML:
      CopyAsMathML(m_eSelection);
      break;

   case mgMBC_SELECTALL:
      m_mathContent.gui_SelectAll();
      break;

   case mgMBC_PASTE:
      Paste(m_eSelection);
      break;

   case mgMBC_EMBED_NUMFRACTION:
      EmbedAsFractionNum(m_eSelection);
      break;

   case mgMBC_EMBED_DENFRACTION:
      EmbedAsFractionDen(m_eSelection);
      break;

   case mgMBC_CREATENEW_ANDLINE:
      m_mathContent.gui_AddEmptyLineToLastAndSystem();
      break;

   case mgMBC_CREATENEW_ORLINE:
      m_mathContent.gui_AddEmptyLineToNewAndSystem();
      break;

#ifdef __MGDEBUG__
   case mgMBC_DEBUG:

      // user clicked on our special debug item
      mgLogDebug(m_mathContent.data_GetDebug(0, 
         mcELEMENT_DBG_EXPDEPTH | mcELEMENT_DBG_SELECTION | mcELEMENT_DBG_ID));
      break;
#endif

   default:
      break;

      // not our item...
//    m_mathContent.gui_ExecCmdOnSel(m_nCmdID[n]);
   }

   // update cursor pos and redraw the window
   ResetGUI();

   // for debugging
   mgLogBoxEvent(wxT("mgMathBox::OnCtxMenuItem - context menu click handled"));
}

void mgMathBox::GetContextMenu(wxMenu &m, const mcElement &selection) const
{
   int j;

   // basic edit commands
   for (j=0; j<mgMBC_SIMPLEEND; j++)
      m.Append(mgMATHBOX_CONTEXTMENU_BASEID+cmd[j].m_nID, 
               cmd[j].m_strDescription);
   m.AppendSeparator();
   
   // some more advanced commands...
   for (j=mgMBC_SIMPLEEND+1; j<mgMBC_ADVEND; j++)
      m.Append(mgMATHBOX_CONTEXTMENU_BASEID+cmd[j].m_nID, 
               cmd[j].m_strDescription);

   // should we add any math command ?
   wxArrayString arr;
   if (selection != mcEmptyElement) {
      
      // get an array of string from the math object
      //arr = m_mathContent.gui_GetPossibleOpOnSel(m_nCmdID);

   } else {
   }

   // append the math commands...
   int startid=mgMATHBOX_CONTEXTMENU_MATHCMD_BASEID+m.GetMenuItemCount();
   if (arr.GetCount()) m.AppendSeparator();
   for (j=0; j < (int)arr.GetCount(); j++)
      m.Append(startid+j, arr.Item(j));

#ifdef __WXDEBUG__
   m.AppendSeparator();
   m.Append(mgMATHBOX_CONTEXTMENU_BASEID+mgMBC_DEBUG, wxT("View debug info"));
#endif
}



// --------------------------------------------
// mgMATHBOX - context menu commands
// --------------------------------------------

void mgMathBox::InsertFraction() {
   wxKeyEvent fakekey = mcFractionHelpers::sgui_pNewFraction->GetEvent();
   OnSpecialChar(fakekey);
}

void mgMathBox::InsertRadical() {
   wxKeyEvent fakekey = mcRadicalHelpers::sgui_pNewRadical->GetEvent();
   OnSpecialChar(fakekey);
}

void mgMathBox::InsertFunction() {
   wxKeyEvent fakekey = mcFunctionHelpers::sgui_pNewFunction->GetEvent();
   OnSpecialChar(fakekey);
}

void mgMathBox::EditExponent() {
   wxKeyEvent fakekey = mcMathCore::Get()->m_pEditExpKey->GetEvent();
   OnSpecialChar(fakekey);
}

void mgMathBox::EditSubscript() {
   wxKeyEvent fakekey = mcMathCore::Get()->m_pEditSubscriptKey->GetEvent();
   OnSpecialChar(fakekey);
}

void mgMathBox::Cut(const mcElement &sel)
{
   // do copy
   CopyAsPlainText(sel);

   // do cut...
   m_mathContent.gui_DeleteSelection();
}

#define mgGET_SEL(x)                   \
   mcElement x(sel);                   \
   if (x == mcEmptyElement) {             \
      x = m_mathContent.gui_GetSelection();  \
      if (x == mcEmptyElement)            \
         return;     /* nothing to copy */   \
   }

void mgMathBox::CopyAsPlainText(const mcElement &sel)
{
   mgGET_SEL(elem);

   wxString str(elem.io_GetInlinedExpr());
   str = ConvertString(str);

   // export to clipboard
   if (wxTheClipboard->Open())
   {
      // This data objects are held by the clipboard,
      // so do not delete them in the app.
      wxTheClipboard->SetData( new wxTextDataObject(str) );
      wxTheClipboard->Close();
   }
}

void mgMathBox::CopyAsMathML(const mcElement &sel)
{
   mgGET_SEL(elem);

   wxXml2Document doc;
   wxStringOutputStream stream;
   wxXml2Node math(elem.io_GetMathML(TRUE));

   doc.Create();
   doc.SetRoot(math);

   if (doc.Save(stream, wxT("UTF-8"), wxXML2DOC_USE_NATIVE_NEWLINES | wxXML2DOC_USE_INDENTATION) == -1)
      return;

   math.DestroyIfUnlinked();
   doc.DestroyIfUnlinked();

   // export to clipboard
   if (wxTheClipboard->Open())
   {
      // This data objects are held by the clipboard,
      // so do not delete them in the app.
      wxTheClipboard->SetData( new wxTextDataObject(stream.GetStr()) );
      wxTheClipboard->Close();
   }
}

void mgMathBox::Paste(const mcElement &sel)
{
   // STILL NOT WORKING
   wxMessageBox(wxT("Still not working..."), wxT("Sorry"));
   return;

   // check clipboard data is okay
   if (!wxTheClipboard->Open() ||
      !wxTheClipboard->IsSupported( wxDF_TEXT ))
      return;

   // import clipboard data
   wxTextDataObject data;
   wxTheClipboard->GetData( data );
   wxString str = data.GetText();   
    wxTheClipboard->Close();

   // import the data
   mcPolynomial pol;
   wxString err;
   if (!pol.io_ImportInlinedExpr(str, NULL, err)) {
      wxBell();
      return;
   }

   // insert it into the math contents
   mcInsertRes r(m_mathContent.gui_Insert(pol, NULL));
   if (r != mcINSR_OKAY) {
      wxBell();
      return;
   }
}

void mgMathBox::EmbedAsFractionNum(const mcElement &sel)
{
   mcMathLine &current = m_mathContent.gui_GetFocusLine();
   mcPolynomial &pol = current.gui_GetFocusMem();
   pol.math_EmbedInFraction(FALSE);
}

void mgMathBox::EmbedAsFractionDen(const mcElement &sel)
{
   mcMathLine &current = m_mathContent.gui_GetFocusLine();
   mcPolynomial &pol = current.gui_GetFocusMem();
   pol.math_EmbedInFraction(TRUE);
}





// --------------------------------------------
// mgMATHBOX - IO functions
// --------------------------------------------

wxString mgMathBox::ConvertString(const wxString &str) const
{
   if (!bUseNativeNewLines)
      return str;

   wxString ret(str);
#if defined(__WXMSW__)
   ret.Replace(wxT("\n"), wxT("\r\n"));
#elif defined(__WXMAC__)
   ret.Replace(wxT("\n"), wxT("\n\r"));
#endif
   return ret;
}

bool mgMathBox::Export(bool bXHTML, const wxString &filename,
                 const wxString &title, bool bMathPlayer, bool bUpperTag,
                 bool bUseNS, const wxString &ns, const wxString &href,
                 int indentstep) const
{
   wxFile f;
   wxString err;

   // create a new file with the given name in write mode,
   // overwrite existing if necessary
   mcASSERT(filename.Len() > 0, wxT("Incorrect file name"));
   if (f.Open(filename, wxFile::write) == FALSE) {

      err.Printf(wxT("Cannot overwrite %s. The file is being used by another application\n")
         wxT("which opened the file in exclusive mode. Close all the applications that use\n")
         wxT("this file and retry, or choose another file name."), filename.c_str());
      wxMessageBox(err, wxT("Error"), wxICON_ERROR | wxOK | wxCENTRE);
      return FALSE;
   }

   wxFileOutputStream stream(f);
   mcASSERT(stream.Ok(), wxT("Something wrong with the creation of file"));

   // write in the file using native line ending
   //wxTextOutputStream stream(fstream, wxEOL_NATIVE);
   return Export(bXHTML, stream, title, bMathPlayer,
         bUpperTag, bUseNS, ns, href, indentstep);
}

wxString mgMathBox::GetExportPreview(bool bXHTML, const wxString &title,
                           bool bMathPlayer, bool bUpperTag,
                           bool bUseNS, const wxString &ns,
                           const wxString &href, int indentstep) const
{
   wxStringOutputStream sos;  

   if (Export(bXHTML, sos, title, bMathPlayer,
      bUpperTag, bUseNS, ns, href, indentstep) == FALSE)
      return wxString(wxT("CANNOT PREVIEW !!!"));

   // retrieve the string result
   return sos.GetStr();
}

bool mgMathBox::Export(bool bXHTML, wxOutputStream &stream,
                 const wxString &title, bool bMathPlayer,
                  bool bUpperTag, bool bUseNS, const wxString &ns,
                  const wxString &href, int indentstep) const
{
   wxString err, str;

   //  <?xml version=wxT("1.0") encoding=wxT("UTF-8") standalone="no"?>
   wxXml2Document doc;
   doc.Create();
   doc.SetMathMLDTD();

   wxXml2Node html;
   html.CreateRoot(doc, wxT("html"));

   // create the XML header if required:
   //  <?xml-stylesheet type=wxT("text/xsl") href="[MathStudio folder]/xsl/mathml.xsl"?>
   if (!bXHTML)
      doc.SetStyleSheet(href);

   // create HTML header:
   //    <html xmlns=wxT("http://www.w3.org/1999/xhtml") xml:lang="en">
   //
   if (!bUseNS) {

      // just create an HTML decorated with XML DTD
      html.AddProperty(wxT("xmlns"), wxT("http://www.w3.org/1999/xhtml"));

   } else {

      // add a namespace
      html.AddProperty(wxT("xmlns:") + ns, wxT("http://www.w3.org/1998/Math/MathML"));
   }

   html.AddProperty(wxT("lang"), wxT("en"));
   html.AddProperty(wxT("xml:lang"), wxT("en"));

   // add the head, title & body tags:
   //   <HEAD><TITLE> [title] </TITLE></HEAD>
   //   <BODY></BODY>
   //
   html.AddContainerChild(wxT("head"));
   html.Get(wxT("head")).AddTextChild(wxT("title"), title);
   wxXml2Node body = html.AddContainerChild(wxT("body"));

   // and a comment:
   //    <!-- [MathStudio standard comment] -->.
   //
   //body.AddBreakLineChild(2);
   body.AddCommentChild(
      wxT(" MathML 2.0 exported by MathStudio - http://mathstudio.sourceforge.net - ") \
      wxT("MathStudio is an open source program released under GPL; please write to ") \
      wxT("frm@users.sourceforge.net if you encounter any problem or if you want to ") \
      wxT("give suggestions or advices. "));
   //body.AddBreakLineChild(2);

   // get math data
   wxXml2Node mathcontent(m_mathContent.io_GetMathML(TRUE));

   // create the MATH tag
   //   <MATH XMLNS:[namespace prefix if present]=
   //         wxT("http://www.w3.org/1998/Math/MathML") DISPLAY=wxT("block") MODE="display">
   //
   wxXml2Node math(wxXML_ELEMENT_NODE, body, wxT("math"));
   wxString prefix(ns);

   // if necessary add namespace syntax
   if (bUseNS) {

      if (bMathPlayer) {

         // add MathPlayer really specific lines:
         //    <OBJECT ID=MathPlayer CLASSID=></OBJECT>
         //    <?IMPORT NAMESPACE=m IMPLEMENTATION=#MathPlayer>
         //
         wxXml2Node parent(html.Get(wxT("head")));
         wxXml2Node obj(wxXML_TEXT_NODE, parent, wxT("object"));
         wxXml2Node import(wxXML_ELEMENT_NODE, parent, wxT("import"));

         obj.AddProperty(wxT("id"), wxT("MathPlayer"));
         obj.AddProperty(wxT("classid"), wxT("clsid:32F66A20-7614-11D4-BD11-00104BD3F987"));

         // just to force wxXml2Document to add a </OBJECT>
         //obj.SetChildren(new wxXml2Node(wxXML_TEXT_NODE, wxT(""), ""));

         import.SetType(wxXML_PI_NODE);
         import.SetContent(wxT("namespace=\"") + ns + wxT("\" implementation=\"#MathPlayer\""));
      }

      // this automatically adds the namespace to math (note that, even if the object
      // "mathns" is destroyed after the following }, the libxml2 object persists).
      wxXml2Namespace mathns(prefix, wxT("http://www.w3.org/1998/Math/MathML"), math);

   } else {

      // add a falsehood namespace
      // VERY IMPORTANT: without this, Mozilla & Netscape won't be able to
      // render mathML....
      math.AddProperty(wxT("xmlns"), wxT("http://www.w3.org/1998/Math/MathML"));
   }

   // set up MATH tag
   math.AddChild(mathcontent);

   // add some predefined attributes
   math.AddProperty(wxT("display"), wxT("block"));
   math.AddProperty(wxT("mode"), wxT("display"));

   // leave some space between MATH & body tag
   //body.AddBreakLineChild(2);

   // if required, make all tags uppercase
   if (bUpperTag) {

      // this will work recursively
      doc.GetRoot().MakeUpper();
   }

   // save document
   doc.Save(stream, wxT("UTF-8"), indentstep);

   // cleanup
   html.DestroyIfUnlinked();
   math.DestroyIfUnlinked();
   body.DestroyIfUnlinked();
   mathcontent.DestroyIfUnlinked();

   // last, destroy the doc
   doc.DestroyIfUnlinked();

   // close file and return OK
   return TRUE;
}

bool mgMathBox::Import(int type, const wxString &filename, wxString *pDesc)
{
   wxXml2Document doc;
   wxXml2Node root, cur;
   wxString str, err;
   int n=0;

   // check parameters
   mcASSERT(filename.Len() > 0, wxT("Incorrect file name"));

   // load the given file
   wxFileInputStream def(filename);
   wxString file(filename);
   wxString tmpfilename;

   if (def.Ok() == FALSE) {

      // load error
      err.Printf(wxT("Cannot read %s. The file is being used by another application\n") \
         wxT("which opened the file in exclusive mode. Close all the applications that use\n") \
         wxT("this file and retry, or choose another file."), filename.c_str());
      wxMessageBox(err, wxT("Error"), wxICON_ERROR | wxOK | wxCENTRE);
      return FALSE;
   }

   // check if loaded file is an XML or an XHTML file
   def.Read(str.GetWriteBuf(16), 16);
   str.UngetWriteBuf();
   def.SeekI(0);

   if (str.CmpNoCase(wxT("<?xml")) != 0 || str.CmpNoCase(wxT("<? xml")) != 0) {

      // we must convert this (X)HTML file to an XML file; we will use
      // a temporary file
      tmpfilename = wxFileName::CreateTempFileName(wxT("ms"));
      wxFileOutputStream tmpoutstream(tmpfilename);

      wxString xmlhdr = wxT("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n")
         wxT("<?xml-stylesheet type=\"text/xsl\" href=\")") + wxGetCwd() +
         wxT("/XSL/mathml.xsl\"?>\n");

      tmpoutstream.Write(xmlhdr, xmlhdr.Len());
      //tmpoutstream.SeekO(0, wxFromEnd);
      tmpoutstream.Write(def);
      file = tmpfilename;
   }

   // parse the given file
   if (doc.Load(file, &err) == FALSE) {

      // parse error
      wxMessageBox(wxT("There was an error while parsing and the given file\n")
         wxT("couldn't be imported. Error description:\n\n'") + err + wxT("'"),
         wxT("Error"), wxICON_ERROR | wxOK | wxCENTRE);
      if (!tmpfilename.IsEmpty())
         wxRemoveFile(tmpfilename);
      return FALSE;
   }

   // delete the eventually created temporary file
   if (!tmpfilename.IsEmpty())
      wxRemoveFile(tmpfilename);

   // find MATH tags and import their contents; ignore everything else
   root = doc.GetRoot();
   cur = root.Find(wxT("math"), wxT(""), 0, FALSE);

   if (cur == wxXml2EmptyNode) {
      // we couldn't find it
      err.Printf(wxT("Cannot find the MathML main tag <MATH>. The file does not contain\n")
         wxT("any MathML information or it is corrupt."));
      wxMessageBox(err, wxT("Error"), wxICON_ERROR | wxOK | wxCENTRE);
      return FALSE;
   }

   // extract MathML content from the xml document
   while (cur != wxXml2EmptyNode) {

      wxXml2Node toparse = cur.GetChildren();

      while (toparse != wxXml2EmptyNode) {

         // be sure everything is embedded in an MROW section
         if (toparse.GetType() == wxXML_ELEMENT_NODE) {

            if (toparse.GetName() != wxT("mrow"))
               toparse.Encapsulate(wxT("mrow"));

            // add a new line and import this MATH tags in it
            //if (n > 0) AddLine(FALSE);
            m_mathContent.io_ImportPresentationMathML(toparse, err);
         }

         toparse = toparse.GetNext();
      }

      // search other MATH tags
      cur = root.Find(wxT("math"), wxT(""), n, FALSE);
   }

   root.DestroyIfUnlinked();
   cur.DestroyIfUnlinked();
   doc.DestroyIfUnlinked();

   return TRUE;
}

bool mgMathBox::ImportInlinedExpr(const wxString &str)
{
   bool res = m_mathContent.io_ImportInlinedExpr(str);

   // update GUI
   m_mathContent.gui_SetFocusIdx(m_mathContent.data_GetCount()-1);
   m_mathContent.gui_SetCursorPos(mcCP_END);
   ResetGUI();

   return res;
}





// --------------------------------------------
// mgRESIZEABLEBOX
// --------------------------------------------

IMPLEMENT_CLASS(mgResizeableBox, wxResizeableControl)
BEGIN_EVENT_TABLE(mgResizeableBox, wxResizeableControl)

   // miscellaneous events
   EVT_SIZE(mgResizeableBox::OnSize)
   EVT_PAINT(mgResizeableBox::OnPaint)
   //EVT_SET_FOCUS(mgResizeableBox::OnSetFocus)
   EVT_KILL_FOCUS(mgResizeableBox::OnKillFocus)
   EVT_SET_CURSOR(mgResizeableBox::OnSetCursor)

   EVT_MOVE(mgResizeableBox::OnMove)

   // OnChildResize() handles messages sent by mgMathBox::FitContents
   // functions: that is, it handles messages sent on child's resize
   EVT_CHILD_RESIZED(wxID_ANY, mgResizeableBox::OnChildResize)
   //EVT_CHILD_SETFOCUS(wxID_ANY, mgResizeableBox::OnChildSetFocus)
   //EVT_CHILD_KILLFOCUS(wxID_ANY, mgResizeableBox::OnChildKillFocus)

END_EVENT_TABLE()


mgResizeableBox::mgResizeableBox(wxWindow *parent,
      wxWindowID id,
      const wxPoint &pos,
      const wxSize &size) :
         wxResizeableControl(parent, id, pos,  size, wxSIMPLE_BORDER |
            wxCLIP_CHILDREN | wxNO_FULL_REPAINT_ON_RESIZE, wxT("ResizeableBox"))
{
   // set up basic values
   //m_bFocus = m_bChildFocus = FALSE;
   //SetBackgroundColour(wxColour(255, 255, 0));      // yellow
   SetMinBorder(wxResizeableControl::SizeXRad*2+1);

   // hack the wxResizeableControl focus system...
   //m_hasfocus = TRUE;
   //m_movemode = MoveWin;
   //SetFocus();
   wxMoveEvent ev(pos);
   //OnMove(ev);
   this->AddPendingEvent(ev);
}

mgResizeableBox::mgResizeableBox(const mgResizeableBox &tocopy) :
      wxResizeableControl(tocopy.GetParent(), tocopy.GetId(),
                     tocopy.GetPosition(), tocopy.GetClientSize(),
                     tocopy.GetWindowStyle(), tocopy.GetName())
{
   // deep copies not only window attributes, also math data
   DeepCopy(tocopy);
}

void mgResizeableBox::DeepCopy(const mgResizeableBox &tocopy)
{
   // there's not a lot of things to copy.....
   m_nMinBorder = tocopy.m_nMinBorder;
}

int mgResizeableBox::GetBorder()
{
   // this should be a positive number, not too small (not less than
   // wxResizeableControl::SizeXRad, otherwise the squares positioned
   // on the perimeter of this window's bounding box, won't be correctly
   // drawn).
   return m_nMinBorder;
}

void mgResizeableBox::SetMinBorder(int n)
{
   // set the new border
   m_nMinBorder = n;
   if (GetChild()) GetChild()->Move(GetBorder(), GetBorder());

   // simulate an OnSize event
   wxSizeEvent ev(GetClientSize());
   OnSize(ev);
}
/*
void mgResizeableBox::SetFocus()
{
   //if (GetChild()) GetChild()->SetFocus();
   wxFocusEvent ev(wxEVT_SET_FOCUS, GetId());
   OnSetFocus(ev);
}*/

wxString mgResizeableBox::GetDebug()
{
   return wxT("If you want to get debug info about this resizeable box, ") \
      wxT("override the GetDebug() function.");
}

void mgResizeableBox::OnChildResize(wxCommandEvent &event)
{
   if (GetChild()) {
      int w = GetChild()->GetSize().GetWidth()+GetBorder()*2+2,
         h = GetChild()->GetSize().GetHeight()+GetBorder()*2+2;
      wxSize newsz = GetSize();

      // check if we must expand this window to contain entirely the mathbox
      if (w > newsz.GetWidth()) newsz.SetWidth(w);
      if (h > newsz.GetHeight()) newsz.SetHeight(h);
      SetSize(newsz);

      Refresh();
   }
}

void mgResizeableBox::OnSize(wxSizeEvent &event)
{
   if (GetChild() && m_hasfocus) {

      // subtract to the new size the borders
      event.m_size.SetWidth(event.GetSize().GetWidth()-GetBorder()*2-2);
      event.m_size.SetHeight(event.GetSize().GetHeight()-GetBorder()*2-2);

      // change event ID
      event.m_id = GetChild()->GetId();

      // resize the mathbox and then check if it is okay
      GetChild()->SetSize(event.GetSize());
   }

   // always recall base class event handler
   event.Skip();
}





void mgResizeableBox::OnSetFocus(wxFocusEvent &event)
{
   // give focus to the contained window, so, cursor begins to
   // flash, warning the user we are ready to receive inputs
   //if (GetChild()) GetChild()->SetFocus();
   //mgLogDebug("mgResizeableBox::OnSetFocus [%d] dropped focus to child", GetId());
   //Show();

   // let wxResizeableControl believe that we now have got the focus...
   event.Skip();
}

void mgResizeableBox::OnChildSetFocus(wxCommandEvent &ev)
{
   // draw size rect
   if (!m_hasfocus) {
      Raise();
      Update();
      m_hasfocus = true;
   }

   wxClientDC dc(this);
   ForceDrawSizeRect(dc);

   mgLogDebug(wxT("mgResizeableBox::OnChildSetFocus [%d] child has received focus"), GetId());
}





bool isChildren(wxWindow *parent, wxWindow *child)
{
   for (wxWindowList::Node *tocheck = parent->GetChildren().GetFirst(); tocheck;
                           tocheck = tocheck->GetNext()) {
      if (child == tocheck->GetData() || isChildren(tocheck->GetData(), child))
         return TRUE;
   }

   return FALSE;
}

void mgResizeableBox::OnKillFocus(wxFocusEvent &event)
{
   /*mgLogDebug(wxT("mgResizeableBox::OnKillFocus [%d] lost ") \
      wxT("focus by resizeable control; done nothing"), GetId()); */
   //Hide();
   event.Skip();
}

void mgResizeableBox::OnChildKillFocus(wxCommandEvent &event)
{
   wxWindow *focused = FindFocus();
   if (!isChildren(this, focused) && focused != this) {

      // erase size rect
      m_hasfocus = false;
      wxClientDC dc(this);
      EraseSizeRect(dc);

      //SetSize(GetChild()->GetSize());
      //GetChild()->Move(0, 0);

      mgLogDebug(wxT("mgResizeableBox::OnChildKillFocus [%d] focus ") \
         wxT("has been definetely lost"), GetId());

   } else {

      mgLogDebug(wxT("mgResizeableBox::OnChildKillFocus [%d] focus has ") \
         wxT("been set on the resizeable control or one of its children"), GetId());
   }
}




void mgResizeableBox::OnMove(wxMoveEvent &ev)
{
   /*if (m_hasfocus) { //FindFocus() == this) {
      wxPaintDC dc(this);

      // if required, draw the 8 squares that the user can use
      // to resize this (resizeable !!) window
      DrawSizeRect(dc);
   }*/
   if (GetChild())
      GetChild()->Move(ev.GetPosition().x+GetBorder(), ev.GetPosition().y+GetBorder());

   //if (GetChild())
   // GetChild()->Refresh();
}

void mgResizeableBox::OnPaint(wxPaintEvent &ev)
{
   if (m_hasfocus) { //FindFocus() == this) {
      wxPaintDC dc(this);

      wxBrush brsh(wxColour(0, 0, 0), wxBDIAGONAL_HATCH   );
      dc.SetBrush(brsh);
      dc.DrawRectangle(wxPoint(0, 0), GetClientSize());

      // if required, draw the 8 squares that the user can use
      // to resize this (resizeable !!) window
      DrawSizeRect(dc);
   }

   //if (GetChild())
   // GetChild()->Refresh();
}
/*
void mgResizeableBox::Refresh(bool eraseBackground, const wxRect* rect)
{
   if (GetChild()) GetChild()->Refresh();
   wxWindow::Refresh(eraseBackground, rect);
}
*/
void mgResizeableBox::OnSetCursor(wxSetCursorEvent &ev)
{
   // recall wxResizeableControl SetCursor event handler only if the
   // cursor is inside this window, but outside the contained math box
   if (!GetChild() || !GetChild()->GetRect().Inside(wxPoint(ev.GetX(), ev.GetY())))
      ev.Skip();
}





// mcRESIZEABLEMATHBOX
IMPLEMENT_CLASS(mgResizeableMathBox, mgResizeableBox)
BEGIN_EVENT_TABLE(mgResizeableMathBox, mgResizeableBox)

   // miscellaneous events
   /*EVT_SIZE(mgResizeableMathBox::OnSize)*/

END_EVENT_TABLE()


mgResizeableMathBox::mgResizeableMathBox(wxWindow *parent,
      wxWindowID id, const wxPoint &pos, const wxSize &size) :
         mgResizeableBox(parent, id, pos,  size)//,   m_mathBox(this)
{
   m_pMathBox = new mgMathBox(this);
   SetMinBorder(wxResizeableControl::SizeXRad*2+1);
   //SetFocus();

   //wxMouseEvent ev(wxEVT_LEFT_DOWN);
   //OnLButtonDown(ev);
   //wxFocusEvent ev(wxEVT_SET_FOCUS, GetId());
   //OnSetFocus(ev);
}

mgResizeableMathBox::mgResizeableMathBox(const mgResizeableMathBox &tocopy) :
      mgResizeableBox(tocopy.GetParent(), tocopy.GetId(), tocopy.GetPosition(),
         tocopy.GetClientSize())//, m_mathBox(tocopy.m_mathBox)
{
   m_pMathBox = new mgMathBox(*tocopy.m_pMathBox);

   // deep copies not only window attributes, also math data
   DeepCopy(tocopy);
}

void mgResizeableMathBox::DeepCopy(const mgResizeableMathBox &tocopy)
{
   mgResizeableBox::DeepCopy(tocopy);

   // deep copy the math data contained
   m_pMathBox->DeepCopy(*tocopy.m_pMathBox);
}

wxString mgResizeableMathBox::GetDebug()
{
   return m_pMathBox->GetDebug();
}

// mcRESIZEABLEMATHBOX event handlers
/*
void mgResizeableMathBox::OnSize(wxSizeEvent &event)
{
   mgResizeableBox::OnSize(event);
   m_pMathBox->FitContents();
}*/








// mcRESIZEABLEMATHBOX
IMPLEMENT_CLASS(mgResizeableTextBox, mgResizeableBox)
BEGIN_EVENT_TABLE(mgResizeableTextBox, mgResizeableBox)

END_EVENT_TABLE()


mgResizeableTextBox::mgResizeableTextBox(
      wxWindow *parent,
      wxWindowID id,
      const wxPoint &pos,
      const wxSize &size) :
         //wxTextCtrl(this, -1, "", wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE),
         mgResizeableBox(parent, id, pos, size)
{
   // default size & position will be modified as soon as we set the min
   // border of this window
   m_pTextCtrl = new wxTextCtrl(parent, -1, wxT(""), wxDefaultPosition,
      wxDefaultSize, wxTE_MULTILINE);
   //m_pTextCtrl->SetWindowStyle(m_pTextCtrl->GetWindowStyle() & (~wxVSCROLL));

   // set some default properties
   //SetBackgroundColour(wxColour(0, 255, 0));
   SetMinBorder(wxResizeableControl::SizeXRad*2+1);
}
/*
mgResizeableTextBox::mgResizeableTextBox(const mgResizeableTextBox &tocopy) :
      mgResizeableBox(tocopy.GetParent(), tocopy.GetId(),
                     tocopy.GetPosition(), tocopy.GetClientSize())
{
   m_pTextCtrl = new wxTextCtrl(this, -1, wxT(""), wxDefaultPosition,
      wxDefaultSize, wxTE_MULTILINE);

   // deep copies not only window attributes, also math data
   DeepCopy(tocopy);
}

void mgResizeableTextBox::DeepCopy(const mgResizeableTextBox &tocopy)
{
   mgResizeableBox::DeepCopy(tocopy);

   // deep copy the math data contained
   m_pTextCtrl->Clear();
   m_pTextCtrl->WriteText(tocopy.m_pTextCtrl->GetValue());
}
*/
wxString mgResizeableTextBox::GetDebug()
{
   return wxT("Resizeable TEXT box content: ") + m_pTextCtrl->GetValue();
}












/*
mgResizeableBox2::mgResizeableBox2()
{
   // set up basic values
   //m_bFocus = m_bChildFocus = FALSE;
   SetBackgroundColour(wxColour(255, 255, 0));     // yellow
   SetMinBorder(wxResizeableControl::SizeXRad*2+1);

   // hack the wxResizeableControl focus system...
   //m_hasfocus = TRUE;
   //m_movemode = MoveWin;
   //SetFocus();
}
/*
mgResizeableBox2::mgResizeableBox2(const mgResizeableBox2 &tocopy) :
      wxResizeableControl(tocopy.GetParent(), tocopy.GetId(),
                     tocopy.GetPosition(), tocopy.GetClientSize(),
                     tocopy.GetWindowStyle(), tocopy.GetName())
{
   // deep copies not only window attributes, also math data
   DeepCopy(tocopy);
}

void mgResizeableBox2::DeepCopy(const mgResizeableBox2 &tocopy)
{
   // there's not a lot of things to copy.....
   m_nMinBorder = tocopy.m_nMinBorder;
}*/
/*
int mgResizeableBox2::GetBorder()
{
   // this should be a positive number, not too small (not less than
   // wxResizeableControl::SizeXRad, otherwise the squares positioned
   // on the perimeter of this window's bounding box, won't be correctly
   // drawn).
   return m_nMinBorder;
}

void mgResizeableBox2::SetMinBorder(int n)
{
   // set the new border
   m_nMinBorder = n;
   if (GetChild()) GetChild()->Move(GetBorder(), GetBorder());

   // simulate an OnSize event
   //wxSizeEvent ev(GetClientSize());
   //OnSize(ev);
}
/*
void mgResizeableBox2::SetFocus()
{
   //if (GetChild()) GetChild()->SetFocus();
   wxFocusEvent ev(wxEVT_SET_FOCUS, GetId());
   OnSetFocus(ev);
}*/
/*
wxString mgResizeableBox2::GetDebug()
{
   return wxT("If you want to get debug info about this resizeable box, ") \
      wxT("override the GetDebug() function.");
}
/*
void mgResizeableBox2::OnChildResize(wxCommandEvent &event)
{
   if (GetChild()) {
      int w = GetChild()->GetSize().GetWidth()+GetBorder()*2+2,
         h = GetChild()->GetSize().GetHeight()+GetBorder()*2+2;
      wxSize newsz = GetSize();

      // check if we must expand this window to contain entirely the mathbox
      if (w > newsz.GetWidth()) newsz.SetWidth(w);
      if (h > newsz.GetHeight()) newsz.SetHeight(h);
      SetSize(newsz);

      Refresh();
   }
}*/
/*
void mgResizeableBox2::OnSize(wxSizeEvent &event)
{
   /*if (GetChild() && m_hasfocus) {

      // subtract to the new size the borders
      event.m_size.SetWidth(event.GetSize().GetWidth()-GetBorder()*2-2);
      event.m_size.SetHeight(event.GetSize().GetHeight()-GetBorder()*2-2);

      // change event ID
      event.m_id = GetChild()->GetId();

      // resize the mathbox and then check if it is okay
      GetChild()->SetSize(event.GetSize());
   }*/
/*
   // always recall base class event handler
   event.Skip();
}




/*
void mgResizeableBox2::OnSetFocus(wxFocusEvent &event)
{
   // give focus to the contained window, so, cursor begins to
   // flash, warning the user we are ready to receive inputs
   if (GetChild()) GetChild()->SetFocus();
   mgLogDebug(wxT("mgResizeableBox2::OnSetFocus [%d] dropped focus to child"), GetId());

   // let wxResizeableControl believe that we now have got the focus...
   //event.Skip();
}

void mgResizeableBox2::OnChildSetFocus(wxCommandEvent &ev)
{
   // draw size rect
   if (!m_hasfocus) {
      Raise();
      Update();
      m_hasfocus = true;
   }

   wxClientDC dc(this);
   ForceDrawSizeRect(dc);

   mgLogDebug(wxT("mgResizeableBox2::OnChildSetFocus [%d] child has received focus"), GetId());
}

*/


/*
bool isChildren(wxWindow *parent, wxWindow *child)
{
   for (wxWindowList::Node *tocheck = parent->GetChildren().GetFirst(); tocheck;
                           tocheck = tocheck->GetNext()) {
      if (child == tocheck->GetData() || isChildren(tocheck->GetData(), child))
         return TRUE;
   }

   return FALSE;
}

void mgResizeableBox2::OnKillFocus(wxFocusEvent &event)
{
   mgLogDebug(wxT("mgResizeableBox2::OnKillFocus [%d] lost ") \
      wxT("focus by resizeable control; done nothing"), GetId());
}

void mgResizeableBox2::OnChildKillFocus(wxCommandEvent &event)
{
   wxWindow *focused = FindFocus();
   if (!isChildren(this, focused) && focused != this) {

      // erase size rect
      m_hasfocus = false;
      wxClientDC dc(this);
      EraseSizeRect(dc);

      //SetSize(GetChild()->GetSize());
      //GetChild()->Move(0, 0);

      mgLogDebug(wxT("mgResizeableBox2::OnChildKillFocus [%d] focus ") \
         wxT("has been definetely lost"), GetId());

   } else {

      mgLogDebug(wxT("mgResizeableBox2::OnChildKillFocus [%d] focus has ") \
         wxT("been set on the resizeable control or one of its children"), GetId());
   }
}


*/

/*
void mgResizeableBox2::OnPaint(wxPaintEvent &ev)
{
   if (m_hasfocus) { //FindFocus() == this) {
      //wxPaintDC dc(this);

      // if required, draw the 8 squares that the user can use
      // to resize this (resizeable !!) window
      //DrawSizeRect(dc);
   }
/*
   if (GetChild())
      GetChild()->Refresh();*//*
}
/*
void mgResizeableBox2::Refresh(bool eraseBackground, const wxRect* rect)
{
   if (GetChild()) GetChild()->Refresh();
   wxWindow::Refresh(eraseBackground, rect);
}*//*

void mgResizeableBox2::OnSetCursor(wxSetCursorEvent &ev)
{
   // recall wxResizeableControl SetCursor event handler only if the
   // cursor is inside this window, but outside the contained math box
   if (!GetChild() || !GetChild()->GetRect().Inside(wxPoint(ev.GetX(), ev.GetY())))
      ev.Skip();
}

*/

---

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

[ Top ]