Main page

---

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

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

#ifndef mcPRECOMP
    #include <wx/dcscreen.h>
    #include "mc/Parenthesis.h"
 #include "mc/Monomial.h"
#endif



mcIMPLEMENT_MAIN_CLASS(mcParenthesis, mcDecoration);


// global objects
mcParenthesis mcEmptyParenthesis(NULL);




// ----------------------------------------
// mcPARENTHESISDATA
// ----------------------------------------
void mcParenthesisHelpers::data_OnNeighborChange()
{ 
 if (mcMathCore::Get()->isGUIEnabled())
  gui_RebuildFont(); 
}


// ----------------------------------------
// mcPARENTHESISGUI
// ----------------------------------------

void mcParenthesisHelpers::gui_DoRecalcSize()
{
 wxScreenDC dc;

 // using our special font, get the size of our symbol...
 dc.SetFont(mgui_fLastFont);
 mgui_sz = gui_GetSizeOf(&dc, data_GetSymbol());

 // ...and add the spaces defined in mcBracketGUI
 mgui_sz.SetHeight(mgui_sz.GetHeight()+mcBracketHelpers::sgui_nSpaceAboveBelow*2);
 mgui_sz.SetWidth(mgui_sz.GetWidth()+mcBracketHelpers::sgui_nSpaceLeftRight*2);
}

void mcParenthesisHelpers::gui_RebuildFont()
{
 wxString tmp;
 wxScreenDC dc;

 // this will be our minimum height
 int h = gui_GetHeightOfChar(&dc, this);

 // now, try to find the best height...
 h = mcMAX(h, gui_GetMaxHeightToNextBracket(!data_isLeftBracket()));
 
 // if required, update our font...
 if (h != mgui_sz.GetHeight()) {

  mgui_fLastFont = mcBracketHelpers::gui_RebuildFont(this, h);
  gui_RecalcSize();
  
  // if required, notify to the parent that we have changed size,
  // forcing its resizing...
  //hlp()->RecalcParentSize();
  //mcASSERT(0, "");
 }
}

int mcParenthesisHelpers::gui_Draw(wxDC &hDC, int Offsetx, int Offsety, long flags, const wxPoint &pt) const
{
 // this piece of code would require that everything is updated each
 // time the cursor is moved: this would create flickering...
#if 0
 // highlight this parenthesis if it has the focus...
 mcElement p = hlp()->GetParent();
 if (p && p.data_GetType() == mcET_MONOMIAL) {
  if (((mcMonomial &)p).gui_isCursorOn(hlp())) {

   // as highlighting, use a -filled rounded rect
   hDC.SetBrush(*wxCYAN_BRUSH);
   hDC.gui_DrawRoundedRectangle(Offsetx, Offsety, gui_GetWidth(), gui_GetHeight(), 2);
  }
 }
#endif

 // draw the bracket... we cannot use the std font to print '('
 // or ')', because the contained expression can be taller or
 // shorter than the normal font height...
 gui_SelectStyle(hDC);
 hDC.SetFont(mgui_fLastFont);
 hDC.DrawText(data_GetSymbol(), Offsetx, Offsety);

 return data_GetID();
}

mcInputRes mcParenthesisHelpers::gui_Input(const mcKey &key, mcElement *pnew)
{
 wxChar c = (wxChar)key.GetKeyCode();
 
 // intercept the creation character...
 if (!data_hasProperty(mcEP_INITIALIZED)) {
  if (mcBracketHelpers::sgui_strLeftParentheses.Contains(c)) {
   
   // set this as a LEFT parenthesis
   mdata_bLeftBracket = TRUE;
   
  } else if (mcBracketHelpers::sgui_strRightParentheses.Contains(c)) {
   
   // set this as a RIGHT parenthesis
   mdata_bLeftBracket = FALSE;

  } else {
   
   mcASSERT(0, wxT("Which creation char did we receive ?"));
  }

  // now, notify to the polynomial parent that we were added into
  // one of its monomials...
/*  mcElement parent1 = hlp()->GetParent();
  if (parent1 && parent1.data_GetType() == mcET_MONOMIAL) {
  
   mcElement parent2 = parent1.GetParent();
   if (parent2 && parent2.data_GetType() == mcET_POLYNOMIAL) {

    // ok, we can proceed
    ((mcPolynomial*)parent2).gui_
     OnNewParenthesis(data_isLeftBracket());
   }
  }*/
  
  data_AddProperty(mcEP_INITIALIZED);
  gui_RecalcSize();
 }

 // handle the input as all other decorations... 
 return mcDecorationHelpers::gui_Input(key, pnew);
}



// these macros are used to avoid the repetition of the same code
// in the following functions...
// these macros are able to walk the given mcElementArray both
// going forward and backward, starting from the given index.

#define START_ARRAY_SCAN(backward, arr, idx)     \
 {  /* this is the scope of wxT("max") and wxT("i") */   \
  int max = (backward ? 0 : arr.data_GetCount()); \
  int i=idx;            \
  while (1) {            \
   if (backward && i < max)       \
    break;           \
   if (!backward && i >= max)       \
    break;           \
   mcElement curr = arr.data_Get(i);


#define END_ARRAY_SCAN(backward)        \
   if (!backward) i++;  /* go forward */   \
   else i--;  /* go backward */     \
  }              \
 }


int mcParenthesisHelpers::gui_GetMaxHeightToNextBracket(bool left)
{
 return 50;
/* mcElement parent = hlp()->GetParent();
 int h = 0;

 if (parent && parent.data_GetType() == mcET_MONOMIAL) {

  mcMonomial &m = (mcMonomial*)parent;

  // we must adapt our size to the element placed on the right
  int idx = m.data_GetIndexOf(hlp());
  mcASSERT(idx != -1, 
   wxT("This element MUST be a children of the monomial..."));  
  
  // check the following members of this monomial...
  if (SearchInMonomial(m, &h, left, (left ? idx-1 : idx+1)))
   return h;
  
  // now check the members of the following monomials...
  if (m.GetParent() && m.GetParent().data_GetType() == mcET_POLYNOMIAL) {

   mcPolynomial &p = (mcPolynomial &)m.GetParent();
   int idx = p.data_GetIndexOf(m);
   mcASSERT(idx != -1, 
    wxT("The monomial MUST be a children of this polynomial..."));

   START_ARRAY_SCAN(left, p, (left ? idx-1 : idx+1))

    if (curr.data_GetType() == mcET_MONOMIAL) {
     
     mcMonomial &mm = (mcMonomial &)p.data_Get(i);
     if (SearchInMonomial(mm, &h, left, 0))
      return h;
     
     // while parsing all the elements which follow this parenthesis,
     // also register the height of the tallest element we found..
     h = mcMAX(h, curr.gui_GetHeight());
    }

   END_ARRAY_SCAN(left)
  }
 }
   
 return h;*/
}

bool mcParenthesisHelpers::gui_SearchInMonomial(mcMonomial &m, int *h, bool left, int idx)
{
 START_ARRAY_SCAN(left, m, idx)

  if (curr.data_GetType() == mcET_PARENTHESIS) {
   
   // ok, we have found another parenthesis in the same monomial
   // which contains this one...
   if (mcParenthesis(curr).data_isLeftBracket() == left)
    return TRUE;
  }
  
  // while parsing all the elements which follow this parenthesis,
  // also register the height of the tallest element we found..
  if (h) *h = mcMAX(*h, curr.gui_GetHeight());

 END_ARRAY_SCAN(left)

 return FALSE;
}
/*
wxString mcParenthesisHelpers::data_GetSymbol() const
{
 if (data_isLeftBracket())
  return wxT("(");
 return wxT(")");
}*/




// ----------------------------------------
// mcPARENTHESISIO
// ----------------------------------------

bool mcParenthesisHelpers::io_isBeginChar(const wxString &str) const
{ 
 if (mcBracketHelpers::sgui_bCreateBothSymbols)
  return FALSE;  // build only mcBrackets 

 // build a mcParenthesis (it will be eventually replaced by a mcBracket later)
 wxChar c = str.GetChar(0);
 if (mcBracketHelpers::gui_isLeftParenthesis(c) || 
  mcBracketHelpers::gui_isRightParenthesis(c))
  return TRUE;

 return FALSE;
}

bool mcParenthesisHelpers::io_ImportInlinedExpr(const wxString &str, int *count, wxString &pErr)
{
 wxChar c = str.GetChar(0);

 if (mcBracketHelpers::sgui_strLeftParentheses.Contains(c)) {
  
  // set this as a LEFT parenthesis
  mdata_bLeftBracket = TRUE;
  
 } else if (mcBracketHelpers::sgui_strRightParentheses.Contains(c)) {
  
  // set this as a RIGHT parenthesis
  mdata_bLeftBracket = FALSE;

  // dow we have to import an exponent ?
  if (str.GetChar(1) == wxT('^')) {

   wxString exp(str.Right(str.Len()-1));
   mcExpElementHelpers::io_GetExpSubInlinedToken(exp);

   // import the exponent
   //mcSAFE_DELETE(mdata_pTmpExp);
   mdata_pTmpExp.data_DeleteAll();
   if (!mdata_pTmpExp.io_ImportInlinedExpr(exp, count, pErr))
    return FALSE;

   // return here
   *count += 2;  // this is required for ")^"
   return TRUE;
  }

 } else {
  
  mcASSERT(0, wxT("Error in mcParenthesisHelpers::io_isBeginChar"));
 }

 *count = 1;
 return TRUE;
}

---

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

[ Top ]