Main page

---

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


// includes
#include "mg/mgprec.h"
#include <wx/wfstream.h>      // not included by wxprec.h
#include <wx/mstream.h>

#ifndef mgPRECOMP
   #include "mg/MathWnd.h"
#endif




// tell Doxygen not to parse the following lines
#ifndef DOXYGEN_SKIP

// Creates the array of mgMathBox structures
#include <wx/arrimpl.cpp>  // this is a magic incantation which must be done!
WX_DEFINE_OBJARRAY(wxMathBoxArray);

#endif


#define CMATHWND_SPACE_LEFT         10
#define CMATHWND_SPACE_RIGHT     10
#define CMATHWND_SPACE_ABOVE     10
#define CMATHWND_SPACE_BOTTOM    10

#define CMATHWND_DEFAULT_BOXWIDTH   140
#define CMATHWND_DEFAULT_BOXHEIGHT  80


// the event tables connect the wxWidgets events with the functions (event
// handlers) which process them. It can be also done at run-time, but for the
// simple menu events like this the static method is much simpler.
IMPLEMENT_CLASS(mgMathWnd, wxScrolledWindow)
BEGIN_EVENT_TABLE(mgMathWnd, wxScrolledWindow)

   // children change handlers
    EVT_CHILD_CREATED(wxID_ANY, mgMathWnd::OnChildWindowChange)
    EVT_CHILD_MOVED(wxID_ANY, mgMathWnd::OnChildWindowChange)
    EVT_CHILD_RESIZED(wxID_ANY, mgMathWnd::OnChildWindowChange)
    EVT_CHILD_CLOSED(wxID_ANY, mgMathWnd::OnChildWindowChange)

   // focus events
   //EVT_SET_FOCUS(mgMathWnd::OnSetFocus)
/* EVT_KILL_FOCUS(mgMathWnd::OnFocusLost)

   // miscellaneous events
   EVT_SIZE(mgMathWnd::OnSize)*/
   //EVT_PAINT(mgMathWnd::OnPaint)

   // mouse events
/* EVT_RIGHT_DOWN(mgMathWnd::OnRDown)
   EVT_RIGHT_UP(mgMathWnd::OnRUp)
   EVT_LEFT_DOWN(mgMathWnd::OnLDown)
   EVT_LEFT_UP(mgMathWnd::OnLUp)
   EVT_MOTION(mgMathWnd::OnMouseMove)

   // keyboard events
   EVT_CHAR(mgMathWnd::OnChar)

   // context menu events
   EVT_MENU_RANGE(CUSTOMID_BASE, CUSTOMID_BASE+MAXMENU_ITEMS, mgMathWnd::OnCtxMenuItem)*/
END_EVENT_TABLE()





// Constructor\Destructor
mgMathWnd::mgMathWnd(wxWindow *parent, wxWindowID id, 
      const wxPoint &pos) : wxScrolledWindow(parent, -1, 
      pos, parent->GetSize(), wxSUNKEN_BORDER | wxHSCROLL | wxVSCROLL | 
                           wxNO_FULL_REPAINT_ON_RESIZE, wxT("MathWnd"))
{
   SetFocus();
   //GetCaret()->Show();
   
   // set white as the window background color
   SetBackgroundColour(wxColour(255, 255, 255));
   
   // init all
   Clean();
   
   // SetFocus() seems not to work properly; place a SetFocus event
   // on the queue... 
   wxFocusEvent evt(wxEVT_SET_FOCUS, GetId());
   GetEventHandler()->AddPendingEvent(evt);

   Refresh();
}

mgMathWnd::~mgMathWnd() {
   
   // wxMathBoxArray will automatically delete all allocated objects...
   // it's too easy !!! :-)
}


// GENERAL functions
void mgMathWnd::Clean()
{
   // delete everything
   GetChildren().DeleteContents(TRUE);
   GetChildren().Clear();
   
   // re init
   m_nSelBox = 0;
   m_nActiveElemID = -1;
   AddBox(FALSE, FALSE);
   
   // update cursor position, bitmap of current line and client size
   //UpdateCaretPos();
   //CheckNewSize();
   //UpdateBoxBmp(0);
}

wxString mgMathWnd::GetDebug()
{
   wxString str;

   str = wxT("\n------------- Math window debug info: -------------\n\n");
   for (int i=0; i < GetBoxCount(); i++) {

      str += wxString::Format(wxT("||||||||||| MATH BOX #%d:\n"), i);
      str += GetBox(i)->GetDebug();
   }

   return str;
}


// SCROLLBAR functions
void mgMathWnd::UpdateScrollRange()
{
    wxNode *Child = GetChildren().First();
    wxSize GesSize;
    while (Child)
    {
        wxWindow *chw = wxDynamicCast(Child->GetData(),wxResizeableControl);
        if (chw)
        {
            wxRect rect = chw->GetRect();
            rect.x += GetScrollPos(wxHORIZONTAL);
            rect.y += GetScrollPos(wxVERTICAL);
            if (rect.GetBottom() > GesSize.y)
                GesSize.y = rect.GetBottom();
            if (rect.GetRight() > GesSize.x)
                GesSize.x = rect.GetRight();
        }
        Child = Child->Next();
    }
    SetScrollbars(1,1,GesSize.x,GesSize.y,
      GetScrollPos(wxHORIZONTAL),GetScrollPos(wxVERTICAL),true);
}


// CURSOR functions
/*
void mgMathWnd::UpdateCaretPos()
{
   // get current cursor position   
   wxDC dc;
   int n;

   GetCaret()->Move(GetBox(m_nSelBox)->GetCursorPos(dc, GetBox(m_nSelBox)->GetPosition().x, 
      GetBox(m_nSelBox), &n))->GetPosition().y;
   GetCaret()->SetSize(mgMathWnd_CURSOR_WIDTH, n);
}
/*
void mgMathWnd::SetCursorColor(wxColour col)
{
   //m_brushCursor.SetColour(col);
   //m_penCursor.SetColour(col);
}*/
/*
void mgMathWnd::UpdateBB(wxDC &dc, wxPoint &cursor)
{
   // this function must be as fast as possible (it's called at every
   // mouse movement)
   
   // create some variables (remember that the window maybe scrolled)
   wxRect rc(GetBox(m_nSelBox), GetBox(m_nSelBox)->GetPosition()->GetPosition().y.x, 
      GetBox(m_nSelBox)->GetWidth(), GetBox(m_nSelBox)->GetHeight());
   
   // check if cursor is inside the bb of the selected line
   if (rc.Inside(cursor)) {
      
      // tranform from scrolled window coord to line coord.
      cursor.x -= GetBox(m_nSelBox)->GetPosition().x;
      cursor.y -= GetBox(m_nSelBox)->GetPosition().y;
      
      // update the bitmap of the line; this step cannot be skipped because
      // this function also checks cursor position and the function isIDChanged()
      // is based on this check...
      UpdateBoxBmp(&cursor);
      
   } else {
      
      // update the bitmap of the line; this step cannot be skipped because
      // this function also checks cursor position and the function isIDChanged()
      // is based on this check...
      UpdateBoxBmp(DRW_NONACTIVE);
   }
   
   // if the activation state hasn't changed, do nothing (to avoid
   // flickering)
   if (!GetBox(m_nSelBox)->isIDChanged())
      return;
   
   // redraw only the modified element
   ReDrawSelBox(dc);
}
/*
void mgMathWnd::DrawCursor(bool bDraw)
{
   // if user pressed a key, stop erasing the cursor for a while
   /*if (m_nWait > 0 && bDraw == FALSE) {
      m_nWait -= mgMathWnd_CURSOR_PERIOD;
      return;
   }
   
   // create a DC for the window
   wxDC dc;
   
   if (bDraw) {
      
      // draw a black cursor
      dc.SetBrush(m_brushCursor);
      dc.SetPen(m_penCursor);
      dc.DrawRectangle(m_rcLastPosCursor);
      
   } else {
      
      // to erase old cursor, blit the current used bitmap on
      // the screen (current used bitmap is stored with also
      // activation and selection state, but without cursor)
      DrawBoxBmp(dc, m_nSelBox);
   }
}*/





// BOX UTILITY functions
/*
int mgMathWnd::UpdateBoxBmp(const wxPoint &p)
{
   return GetBox(m_nSelBox)->UpdateBoxBmp(m_hMemDC, GetBox(m_nSelBox), GetBox(m_nSelBox), p)->GetPosition()->GetPosition().y.x; 
}*/


/*
void mgMathWnd::UpdateBoxBmp()
{
   wxPoint p = wxGetMousePosition();
   
   // remap cursor position in the correct way
   ScreenToClient(p);      // from screen to window coord
   p.x -= GetBox(m_nSelBox)->GetPosition().x;   // from scrolled window to line coord
   p.y -= GetBox(m_nSelBox)->GetPosition().y;
   
   // use std version of the function
   UpdateBoxBmp(&p);
}*/

void mgMathWnd::SelectBox(int n)
{
   //mcASSERT(n >= 0 && n < (int)GetBoxCount(), "Invalid new index");
   
   // save last line in the bitmap, without activation and selection state
   //GetBox(m_nSelBox)->DeSelect();
   //UpdateBoxBmp(m_nSelBox, DRW_NONACTIVE);
   
   // select the new line; caller should redraw to get a correct output
   m_nSelBox = n;
   /*wxFocusEvent ev(wxEVT_SET_FOCUS, GetBox(n)->GetId());
   GetBox(n)->OnSetFocus(ev);
   GetBox(n)->Refresh();*/
   //GetBox(n)->SetFocus();
   ((GetChildren().Item(n))->GetData())->SetFocus();

   // update the bitmap of the selected line
   //UpdateBoxBmp(m_nSelBox);
}

void mgMathWnd::AddBox(bool bMath, bool bCopyLast)
{
   wxSize sz(CMATHWND_DEFAULT_BOXWIDTH, CMATHWND_DEFAULT_BOXHEIGHT);
   wxPoint pos(15, 15);

   if (GetBoxCount() > 0) {
      int n = GetBoxCount()-1;
      pos = GetBox(n)->GetPosition();
      pos.x += 0; pos.y += GetBox(n)->GetSize().GetHeight()+10;
      sz = GetBox(n)->GetSize();
   }

   // first of all, create a new mgMathBox
   mgResizeableBox *pnew;
   if (bMath)
      pnew = new mgResizeableMathBox(this, -1, pos, sz);
   else
      pnew = new mgResizeableTextBox(this, -1, pos, sz);
   m_arrMathBox.Add(pnew);
   
   // create some pointers
   mgResizeableBox *pold = GetSelBox();
   
   // select the new line (so the bitmap of the previous
   // selected line is updated)
   SelectBox(GetChildren().GetCount()-1);
   //mgResizeableBox *boh = GetSelBox();
   //mcASSERT(pnew == boh, "SelectBox doesn't work");
   
   // then, copy the last line if requested
   if (bCopyLast) {
      
      // deep copy everything
      pnew->DeepCopy(*pold);
   }
   
   // redraw
   Refresh();
}

/*
void mgMathWnd::SelectBoxByPoint(wxPoint &pt)
{
   wxRect rc;
   
   // set up some fixed data on the rect structure
   rc.width = GetClientSize().GetWidth();
   rc.x = GetBox(m_nSelBox)->GetPosition().x;
   
   // move the cursor on another data line
   for (int i=0; i < 1; i++) {
      
      // skip currently selected line; we have already tested
      // that it's not the line where the user clicked
      if (i == m_nSelBox) continue;
      
      // set up the rect for this line
      rc.y = GetBox(m_nSelBox)->GetPosition().y;
      rc.height = GetBox(m_nSelBox)->GetHeight();
      
      // is the cursor inside this line's rectangle ?
      if (rc.Inside(pt)) {
         
         // yes, select it
         SelectBox(i);
         
         // update cursor data
         UpdateCaretPos();
         
         // redraw and exit this event handler
         Refresh();
         return;
      }
   }
   
   // no lines have been selected; deselect the current line
   GetBox(m_nSelBox)->DeSelect();
   UpdateBoxBmp(m_nSelBox, &pt);
   Refresh();
}
*/
void mgMathWnd::DeleteBox(int n)
{
   // removes the selected line
   (GetChildren().Item(n)->GetData())->Destroy();
   
   // select previous if following does not exist
   if (m_nSelBox >= 1)
      m_nSelBox--;
   
   // redraw window
   Refresh();
}




// mgMathWnd EVENT HANDLERS

void mgMathWnd::OnChildWindowChange(wxCommandEvent &ev)
{
   // check which child window sent this message
   wxWindow *w = FindWindowById(ev.GetId(), this);
   if (w != NULL) {
      wxPoint newpos = w->GetPosition();
      if (w->GetPosition().x < 0) newpos.x = 0;
      if (w->GetPosition().y < 0) newpos.y = 0;
      
      w->Move(newpos);
   }

   // scrollbar range could have changed
   UpdateScrollRange();
}

void mgMathWnd::OnPaint(wxPaintEvent &ev)
{
   wxPaintDC dc(this);

   // on MS windows, this sets up some optimizations
   dc.BeginDrawing();
   
   // draw all the lines
   //int y = GetBox(m_nSelBox)->GetPosition().y;
   //DrawBoxBmp(dc, TRUE);

   for (int i=0; i < (int)m_arrMathBox.GetCount(); i++) {
      
      // draw the line using stored bitmap
      //DrawBoxBmp(dc, i, TRUE);
      
      // add the space between two lines
      //y += mgMathWnd_SPACE_INTERLINE;
      GetBox(i)->Refresh();
   }


   // be sure to unselect from memory DC previous bmp
   //m_hMemDC.SelectObject(wxNullBitmap);
   
   // on MS windows, shut down draw optimizations
   dc.EndDrawing();
}

void mgMathWnd::OnSize(wxSizeEvent &se)
{
   //int w = se.GetSize().GetWidth()-GetBox(m_nSelBox)->GetPosition().x-CMATHWND_SPACE_RIGHT;
   
   // update width inside all lines; this is required for line
   // description feature
   /*for (int i=0; i < 1; i++)
      GetBox(m_nSelBox)->SetParentWidth(w);*/
   
   // update also cursor pos (it could be inside line description)
   //UpdateCaretPos();
}


// MOUSE events
/*
void mgMathWnd::OnLDown(wxMouseEvent &me)
{
   // stop flashing cursor
   GetCaret()->Show(FALSE);
   
   // prepare some variables
   wxDC dc;
   wxPoint pt = me.GetLogicalPosition(dc);
   
   // get some data
   wxRect rc(GetBox(m_nSelBox), GetBox(m_nSelBox), GetBox(m_nSelBox)->GetWidth()->GetPosition()->GetPosition().y.x, 
      GetBox(m_nSelBox)->GetHeight());// = GetBoxBB(m_nSelBox);
   
   // move the cursor where user clicked
   if (rc.Inside(pt)) {
      
      // move the cursor inside the math data
      GetBox(m_nSelBox)->MoveCursor(dc, MC_USEPOINT, pt.x, pt.y-GetBox(m_nSelBox))->GetPosition().y;
      UpdateCaretPos();
      
   } /*else {
      
      // try to select line using the point
      SelectBoxByPoint(pt);
   }*/
   /*
   // set up the capture of the cursor
   m_ptOrigin = pt;
   
   m_rcSelection.x = m_ptOrigin.x;
   m_rcSelection.y = m_ptOrigin.y;
   
   // capture the mouse (so, if it exits the window
   // the OnLUP function will still be called)
   CaptureMouse();
   
   // change cursor
   //SetCursor(wxCursor(wxCURSOR_RIGHT_ARROW));//*wxCROSS_CURSOR);
}

void mgMathWnd::OnRDown(wxMouseEvent &me)
{
   //wxDC dc;
   //wxMenu m;
   //wxPoint pt = me.GetLogicalPosition(dc);
   //OnLDown(me);
   
   //SelectBoxByPoint(pt);
   //GetBox(m_nSelBox)->GetMathObj()->MultiplyBySel();
   
   //UpdateBoxBmp(m_nSelBox, &pt);
   //ReDrawSelBox(dc);
   
   //PopupMenu(&m, me.GetPosition());
}

void mgMathWnd::OnLUp(wxMouseEvent &me)
{
   // maybe the user just selected another data line
   if (GetCapture() == this) {
      
      // restore the conditions before the user started the click
      ReleaseMouse();
      //SetCursor(wxNullCursor);
      //m_tCursor.Start();
      
      // move the cursor inside the math data
      wxDC dc;
      wxPoint pt = me.GetLogicalPosition(dc);
      wxRect rc(GetBox(m_nSelBox), GetBox(m_nSelBox)->GetPosition()->GetPosition().y.x, 
         GetBox(m_nSelBox)->GetWidth(), GetBox(m_nSelBox)->GetHeight());
      
      // check if point is over the selected line
      if (rc.Inside(pt)) {
         
         // user released button over the selected line; move the cursor
         // to the nearest available position
         GetBox(m_nSelBox)->MoveCursor(dc, MC_USEPOINT, pt.x, pt.y-GetBox(m_nSelBox))->GetPosition().y;
         UpdateCaretPos();
      } else if (!rc.Inside(m_ptOrigin)) {
         
         // user clicked in an empty area and released the button in another
         // empty area
         //OnSyntaxErr("Nothing in that point");
      }
      
      /*wxString tmp;
      tmp.Printf(wxT("top-left: %d, %d\n\nwidth: %d\nheight: %d\n\norigin: %d, %d"), m_rcSelection.x, m_rcSelection.y, m_rcSelection.width, m_rcSelection.height, m_ptOrigin.x, m_ptOrigin.y);
      wxMessageBox(tmp, _(wxT("About g_nsMathStudio")), wxOK | wxICON_INFORMATION, this);*/
/* }
}

void mgMathWnd::OnRUp(wxMouseEvent &me)
{
   wxDC dc;
   wxMenu m;
   
   // get the point in scrolled window coord
   wxPoint tmp = me.GetLogicalPosition(dc);
   
   if (m_nActiveElemID != DRW_ONSELECTION) {
      
      // create a dummy selection rectangle
      m_rcSelection.x = tmp.x;
      m_rcSelection.y = tmp.y;
      m_rcSelection.width = 1;
      m_rcSelection.height = 1;
      
      // select the element under cursor
      int n = GetBox(m_nSelBox)->GetPosition().y;
      GetBox(m_nSelBox)->OnSelect(dc, GetBox(m_nSelBox), GetBox(m_nSelBox), m_rcSelection)->GetPosition()->GetPosition().y.x;
      UpdateBoxBmp(&tmp);
      ReDrawSelBox(dc);
   }
   
   // get an array of string from the math object
   wxArrayString arr = GetBox(m_nSelBox)->GetPossibleOpOnSel(m_nCmdID);
   for (int i=0; i < (int)arr.GetCount(); i++) {
      m.Append(CUSTOMID_BASE+i, arr.Item(i));
   }
   
   // pop up the context menu
   PopupMenu(&m, tmp);
}

void mgMathWnd::OnCtxMenuItem(wxCommandEvent &ce)
{
   wxDC dc;
   
   // exec the command chosen by the user
   GetBox(m_nSelBox)->ExecCmdOnSel(m_nCmdID[ce.GetId()-CUSTOMID_BASE-2]);
   //GetBox(m_nSelBox)->GetMathObj()->Debug();
   
   // update cursor pos and redraw the window
   //CheckNewSize();
   UpdateCaretPos();
   UpdateBoxBmp();
   
   // redraw only modified line
   ReDrawSelBox(dc);
}

void mgMathWnd::OnMouseMove(wxMouseEvent &me)
{  
   wxDC dc;
   
   // get the point in scrolled window coord
   wxPoint tmp = me.GetLogicalPosition(dc);
   
   if (me.LeftIsDown()) {
      
      // update selection rectangle
      m_rcSelection.x = m_ptOrigin.x;
      m_rcSelection.y = m_ptOrigin.y;
      m_rcSelection.width = tmp.x-m_ptOrigin.x;
      m_rcSelection.height = tmp.y-m_ptOrigin.y;
      if (m_rcSelection.width < 0) {
         m_rcSelection.x += m_rcSelection.width;
         m_rcSelection.width = -m_rcSelection.width;
      }
      if (m_rcSelection.height < 0) {
         m_rcSelection.y += m_rcSelection.height;
         m_rcSelection.height = -m_rcSelection.height;
      }
      
      // check that everything's okay
      mcASSERT(m_rcSelection.width >= 0 && m_rcSelection.height >= 0, wxT("invalid rect"));
      mcASSERT(m_rcSelection.x >= 0 && m_rcSelection.y >= 0, wxT("invalid rect"));
      
      // update selection
      GetBox(m_nSelBox)->OnSelect(dc, GetBox(m_nSelBox), GetBox(m_nSelBox), m_rcSelection)->GetPosition()->GetPosition().y.x;
      
      // redraw for some strange reasons... :-)
      ReDrawSelBox(dc);
   }
   
   UpdateBB(dc, tmp);
}



// FOCUS events
*/
void mgMathWnd::OnSetFocus(wxFocusEvent &fe)
{
   //for (int i=0; i < GetBoxCount(); i++)
   // GetBox(i)->SetFocus();
}
/*
void mgMathWnd::OnFocusLost(wxFocusEvent &fe)
{
   // stop drawing cursor
   //m_tCursor.Stop();
   
   // erase it, and the next time, draw it
   //DrawCursor(FALSE);//, NULL);
   //m_nShow = TRUE;
}



// MISCELLANEOUS events

void mgMathWnd::OnTimer(wxTimerEvent &te)
{
   // draw or erase the cursor
   //DrawCursor(m_nShow);//, NULL);
   
   // next time, do the opposite
   //m_nShow = !m_nShow;
}

void mgMathWnd::OnChar(wxKeyEvent &ke)
{
   wxDC dc;
   
   switch (ke.m_keyCode) {
      
      // cursor movement keys handlers
   case WXK_LEFT:
      GetBox(m_nSelBox)->MoveCursor(dc, mcMCF_LEFT, 0, 0);
      break;
   case WXK_RIGHT:
      GetBox(m_nSelBox)->MoveCursor(dc, mcMCF_RIGHT, 0, 0);
      break;
   case WXK_UP:
      GetBox(m_nSelBox)->MoveCursor(dc, mcMCF_UP, 0, 0);
      break;
   case WXK_DOWN:
      GetBox(m_nSelBox)->MoveCursor(dc, mcMCF_DOWN, 0, 0);
      break;
   case WXK_HOME:
      GetBox(m_nSelBox)->SetCursorPos(mcCP_BEGIN);
      break;
   case WXK_END:
      GetBox(m_nSelBox)->SetCursorPos(mcCP_END);
      break; 
      
      
   default:
      // 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;

      // 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) {

#ifdef __WXMSW__
         // Get Win32 native scancode
         if ((ke.GetRawKeyFlags() >> 16) == 28) // 28 = ENTER scancode
            ke.m_keyCode = 13;
#endif
      }
      
      // one of ()0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
      // or abcdefghijklmnopqrstuvwxyz key was pressed
      GetBox(m_nSelBox)->Input(ke);//(unsigned char)ke.GetKeyCode(), (int)ke.GetKeyCode());
   }
   
   // update cursor pos and redraw the window
   //CheckNewSize(m_nSelBox);
   UpdateCaretPos();
   UpdateBoxBmp();
   
   // redraw only modified line
   ReDrawSelBox(dc);
}


*/

bool mgMathWnd::Export(bool bXHTML, const wxString &filename, 
                 const wxString &title, bool bMathPlayer, bool bUpperTag,
                 bool bUseNS, const wxString &ns, const wxString &href, 
                 int indentstep)
{
   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, FALSE, bMathPlayer, 
                     bUpperTag, bUseNS, ns, href, indentstep);
}

wxString mgMathWnd::GetExportPreview(bool bXHTML, const wxString &title, bool bMathPlayer,
                  bool bUpperTag,   bool bUseNS, const wxString &ns, const wxString &href, 
                  int indentstep)
{
   /*wxMemoryOutputStream mos;
   wxString res;

   if (Export(bXHTML, mos, title, TRUE, bMathPlayer, 
            bUpperTag, bUseNS, ns, href, indentstep) == FALSE)
      return wxString(wxT("CANNOT PREVIEW !!!"));
   
   // copy directly inside the string
   mos.CopyTo(res.GetWriteBuf(mos.GetSize()+1), mos.GetSize());
   res[mos.GetSize()] = wxT('\0');
   res.UngetWriteBuf();*/

   return wxEmptyString;
}

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


   // close file and return OK 
   return TRUE;
}

bool mgMathWnd::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\wxT(" encoding=\")UTF-8\wxT(" standalone=\")no\wxT("?>\n")
         wxT("<?xml-stylesheet type=\")text/xsl\wxT(" 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(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 = EncapsulateInMROW(toparse);
         
            // add a new line and import this MATH tags in it
            //if (n > 0) AddBox(FALSE);
            GetBox(m_nSelBox)->ImportMathML(toparse, &err);
         }

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

---

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

[ Top ]