Main page

---

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

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

#ifndef mcPRECOMP
    #include <wx/dcscreen.h>
 #include "mc/MathCore.h"
 #include "mc/Text.h"
 #include "mc/MathLine.h"
 #include "mc/MathSystem.h"
 #include "mc/MathOrSystem.h"
#endif


// customizable variables
int mcMathOrSystemHelpers::sgui_nSpaceAboveBelow = 5;
int mcMathOrSystemHelpers::sgui_nSpaceLeftRight = 5;
int mcMathOrSystemHelpers::sgui_nSpaceBetween = 10;
bool mcMathOrSystemHelpers::sgui_bHorizOrientation = TRUE;
bool mcMathOrSystemHelpers::sgui_bDrawOrLabels = FALSE;



// ------------------------
// mcMATHORSYSTEMDATA
// ------------------------

#ifdef __MCDEBUG__

wxString mcMathOrSystemHelpers::data_Debug(long flags) const
{
 wxString str, type = data_GetDescString();

 // create a string containing the debug info for all the
 // equations\inequalities contained
 str.Alloc(2048);
 str = wxT("\n\n  ::::: mcMathOrSystem\n");
 str += wxT("  ::::: Classified as '") + type + wxT("'\n");
 str += wxT("  ") + wxString(wxT('-'), 75)+ wxT("\n\n");
 for (int i=0; i < data_GetCount(); i++) {  
  if (i) str += wxT("\n\n\n");
  //str += wxString::Format("EQUATION\\INEQUALITY #%d\n", i);
  str += data_Get(i).data_GetDebug(mcMathCore::Get()->m_nIndentationStep, flags);
    /*Indent(data_Get(i).data_GetDebug(0, flags), 
    mcMathCore::Get()->m_nIndentationStep);*/
 }

 return str;
}

wxString mcMathOrSystemHelpers::data_GetMemoryInfoStr() const
{
 wxString str;

 str = wxT("\n\n::::::::: MathCore class sizes:\n") + 
    mcElementHelpers::data_GetGlobalMemoryInfo(); 

#ifdef mcENABLE_COW_DEBUG
 str += wxString::Format(wxT("\n\nMaximum shared instances of a ")
  wxT("mcElement-derived class: %d"), mcMathCore::Get()->m_nMaxSharing);
 str += wxString::Format(wxT("\n\nMaximum shared instances of a ")
  wxT("mcValue-derived class: %d"), mcValue::m_nMaxValueSharing);
#endif

 return str;
}

#endif  // __MCDEBUG__

void mcMathOrSystemHelpers::data_Delete(int n)
{ delete ((mcMathAndSystem*)data_GetItem(n)); }

mcAbstractItem *mcMathOrSystemHelpers::data_GetCopyOf(int n) const
{ return new mcMathAndSystem(data_GetSys(n)); }

wxString mcMathOrSystemHelpers::data_GetDescString() const
{
 // create the classification string
 return math_GetMathType().io_GetDescString() + 
   math_GetMathSystemType().io_GetDescString(data_GetLineCount());
}

int mcMathOrSystemHelpers::data_GetLineCount() const
{
 int total=0;

 // get the total number of lines
 for (int i=0; i<data_GetCount(); i++)
  total+=data_GetSys(i).data_GetCount();
 return total;
}

void mcMathOrSystemHelpers::data_AddLineToLastAndSystem(mcMathLine *toadd)
{
 if (data_GetCount() == 0) 
  data_AddLineToNewAndSystem(toadd); 
 else
  data_GetLastSys().data_AddLine(toadd); 
}

void mcMathOrSystemHelpers::data_AddLineToNewAndSystem(mcMathLine *toadd)
{
 mcMathAndSystem *s=new mcMathAndSystem();

 // adds the line
 s->data_AddLine(toadd);
 data_AddSys(s);
}

void mcMathOrSystemHelpers::data_SetFilter(const mcFilter *p, int n)
{
 if (n <= -1) {

  // set the filter for all the elements
  for (int i=0; i < data_GetCount(); i++)
   data_GetSys(i).data_SetFilter(p, -1);
  return;
 }

 data_GetSys(n).data_SetFilter(p, -1);
}





// ------------------------
// mcMATHORSYSTEMGUI
// ------------------------

void mcMathOrSystemHelpers::gui_RecalcSymbolSize()
{
 wxScreenDC dc;
 gui_SelectStyle(dc);

 if (sgui_bDrawOrLabels)
  mgui_szSymbol = gui_GetSizeOf(&dc, wxT("OR"));
 else
  mgui_szSymbol = gui_GetSizeOf(&dc, wxT("v"));
}

void mcMathOrSystemHelpers::gui_DrawSystemSymbols(wxDC &dc, int x, int y, long flags) const
{
 gui_SelectStyle(dc);
 dc.SetBackgroundMode(wxTRANSPARENT);

 // draw all the connector symbols
 for (int i=0; i<data_GetCount()-1; i++)
  if (sgui_bDrawOrLabels)
   dc.DrawText(wxT("OR"), x+gui_GetXOfSymbol(i), y+gui_GetYOfSymbol(i));
  else
   dc.DrawText(wxT("v"), x+gui_GetXOfSymbol(i), y+gui_GetYOfSymbol(i));
}

int mcMathOrSystemHelpers::gui_GetActiveElemID() const
{
 if (mgui_nCurrentActive != -1) 
  return data_GetSys(mgui_nCurrentActive).gui_GetActiveElemID(); 

 return mcDRW_NOACTIVEELEM;
}

mcElement mcMathOrSystemHelpers::gui_GetSelection() const
{
 for (int i=0; i<data_GetCount(); i++) {
  if (data_Get(i).gui_isSelected()) {

   // we've found our line containing the selection
   mcMathOrSystem sys;

   // FIXME:
   sys.hlp()->data_Add(new mcMathAndSystem(data_Get(i).gui_GetSelection()));
   return sys;
  }
 }

 return mcEmptySystem;
}

bool mcMathOrSystemHelpers::gui_isIDChanged() const
{
 // check if something changed...
 if (mgui_nCurrentActive == mgui_nLastActive) {

  // if the last active line as still the same active element,
  // then the ID has not changed...
  if (mgui_nCurrentActive != -1)
   return data_GetSys(mgui_nCurrentActive).gui_isIDChanged();
  return FALSE;
 }
 return TRUE;
}

mcMathLine &mcMathOrSystemHelpers::gui_GetFocusLine()
{
 mcMathAndSystem &sel = gui_GetFocusSys();
 if (sel == mcEmptyElement) return mcEmptyLine;

 // return the line focused inside the current focused mcMathAndSystem
 return sel.gui_GetFocusLine();
}

const mcMathLine &mcMathOrSystemHelpers::gui_GetFocusLine() const
{
 const mcMathAndSystem &sel = gui_GetFocusSys();
 if (sel == mcEmptyElement) return mcEmptyLine;

 // return the line focused inside the current focused mcMathAndSystem
 return sel.gui_GetFocusLine();
}

void mcMathOrSystemHelpers::gui_AddEmptyLineToLastAndSystem()
{
 mcMathLine *toadd = new mcMathLine();
 toadd->data_GetLeftMem().gui_AddNewEmptyMonomial();

 data_AddLineToLastAndSystem(toadd);
}

void mcMathOrSystemHelpers::gui_AddEmptyLineToNewAndSystem()
{
 mcMathLine *toadd = new mcMathLine();
 toadd->data_GetLeftMem().gui_AddNewEmptyMonomial();

 data_AddLineToNewAndSystem(toadd);
}





// ------------------------
// mcMATHORSYSTEMIO
// ------------------------

bool mcMathOrSystemHelpers::io_ImportToken(const wxString &str, wxString *perr)
{
 int n;
 data_Add(new mcMathAndSystem());
 
 // process token here  
 if (!data_GetLast().io_ImportInlinedExpr(str, &n, *perr))
  return FALSE;
 return TRUE;
}



// ------------------------
// mcMATHORSYSTEMMATH
// ------------------------

void mcMathOrSystemHelpers::math_AndMerge(const mcMathOrSystem &arr1,
            const mcMathOrSystem &arr2)
{
 mcMATHLOG(wxT("mcMathOrSystemHelpers::math_AndMerge - merging [%s] with [%s]"), 
    mcTXT(arr1), mcTXT(arr2));
 
 data_Clear();
 for (int i=0; i<arr1.data_GetCount(); i++) {
  for (int j=0; j<arr2.data_GetCount(); j++) {

   mcMathAndSystem *res = new mcMathAndSystem();
   res->math_Merge(arr1.data_GetSys(i),
       arr2.data_GetSys(j));
   data_Add(res);
  }
 }
}

void mcMathOrSystemHelpers::math_OrMerge(const mcMathOrSystem &arr1,
            const mcMathOrSystem &arr2)
{
 mcMATHLOG(wxT("mcMathOrSystemHelpers::math_OrMerge - merging [%s] with [%s]"), 
    mcTXT(arr1), mcTXT(arr2));
 
 // we just have to copy arr1 and then
 // add to *this the mcMathAndSystems of arr2
 data_Clear();
 data_DeepCopy(arr1.chlp());

 for (int i=0; i < arr2.data_GetCount(); i++)
  data_Add(new mcMathAndSystem(arr2.data_GetSys(i)));
}

mcMathSystemType mcMathOrSystemHelpers::math_GetMathSystemType() const
{
 // set us to a system containing equations which is a
 // "neutral type" for the math_CombineWith function 
 mcMathSystemType ret(mcMSTL1_EQUATIONS);

 if (data_GetCount() == 0)
  return mcMSTL1_NOT_RECOGNIZED;

 // combine the types of all mcMathOrSystems...
 for (int i=0; i<data_GetCount(); i++)
  ret.math_CombineWith(data_GetSys(i).math_GetMathSystemType());
 return ret;
}

---

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

[ Top ]