Main page

---

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

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

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


mcIMPLEMENT_MAIN_CLASS(mcBracket, mcExpElement);


// setup customizable variables
int mcBracketHelpers::sgui_nSpaceLeftRight = 0;
int mcBracketHelpers::sgui_nSpaceAboveBelow = 0;
bool mcBracketHelpers::sgui_bCreateBothSymbols = FALSE;
wxString mcBracketHelpers::sgui_strLeftParentheses = wxT("([{");
wxString mcBracketHelpers::sgui_strRightParentheses = wxT(")]}");







// ----------------------------------------
// mcBRACKETDATA
// ----------------------------------------

wxString mcBracketHelpers::data_GetBracketLeftSymbol(int n) const
{
 if (n == -1) n = data_ChooseBracketType();

 // return bracket symbols basing on m_nBracketType variable
 switch (n) {
 case mcBRACKET_SIMPLE_BRACKETS:
  return wxT("(");
 case mcBRACKET_SQUARE_BRACKETS:
  return wxT("[");
 default:
  return wxT("{");
 }
}

wxString mcBracketHelpers::data_GetBracketRightSymbol(int n) const
{
 if (n == -1) n = data_ChooseBracketType();

 // return bracket symbols basing on m_nBracketType variable
 switch (n) {
 case mcBRACKET_SIMPLE_BRACKETS:
  return wxT(")");
 case mcBRACKET_SQUARE_BRACKETS:
  return wxT("]");
 default:
  return wxT("}");
 }
}

int mcBracketHelpers::data_ChooseBracketType() const
{
 // reset the "bracket type tracker"
 int brtype = mcBRACKET_SIMPLE_BRACKETS;

 // scan the array
 mcElementArray p(data_GetContent());

 // We are sure that the content is a mcPolynomial: it is
 // created by mcBracket and thus we can be sure of it.
 // Now, mcPolynomials, always contains mcMonomials, and we
 // must search for other brackets in the monomials of the
 // contained polynomial, NOT directly in the contained
 // polynomial
 for (int j=0; j < p.data_GetCount(); j++) {

  if (p.data_Get(j).data_GetType() == mcET_MONOMIAL) {

   // get a pointer to monomial's data
   mcElementArray m(p.data_Get(j));

   // now we can use the mcElementArrayData facilities
   // (GetElemOfType & GetNumOfElemType)
   for (int i=0, max=m.data_GetNumOfElemType(mcET_BRACKET); i < max; i++) {

    mcBracket b(m.data_GetElemOfType(i, mcET_BRACKET));
    brtype += b.data_GetBracketDepth();
   }
  }
 }

 return brtype;
}




// ----------------------------------------
// mcBRACKETGUI
// ----------------------------------------

int mcBracketHelpers::gui_GetContentOffsetY() const
{
 // center bracket vertically
 return (mgui_szBracket.GetHeight() - data_GetContent().gui_GetHeight())/2;
}

int mcBracketHelpers::gui_GetContentOffsetX() const
{
 // just add the width of one bracket.
 return mgui_szBracket.GetWidth();
}

wxFont mcBracketHelpers::gui_RebuildFont(const mcElementHelpers *elem, int h)
{
 wxFont fnt;

 // using bracket's font & content height
 wxString str = elem->gui_GetStyleForThis()->
  GetTextSettingsFor(mcET_ADDOP)->m_hFont.GetFaceName();
  
 fnt.SetFamily(wxSWISS);
 
#ifndef __WXGTK__
 // this is really a problem for wxGTK: it seems that not all fonts
 // can accept any point-size. If we try to select an unsupported
 // point-size and then we use the font, we will get an error....
 // this implies that brackets cannot change their parentheses
 // height on wxGTK.... sorry
 int n = h+mcBracketHelpers::sgui_nSpaceAboveBelow*2;
 fnt.SetFaceName(str);
 fnt.SetPointSize((int)mcElementHelpers::gui_Pixels2PointSize(n));
#endif

 return fnt;
}

void mcBracketHelpers::gui_DoRecalcBaseSize()
{
 wxString tmp;
 wxScreenDC dc;

 // compute size of content
 mgui_szBase = data_GetContent().gui_GetSize();

 // if required, update the font...
 if (mgui_szBase.GetHeight() != mgui_szBracket.GetHeight())
  mgui_fLastFont = gui_RebuildFont(this, mgui_szBase.GetHeight());

 // now use the font to calculate bracket's height
 dc.SetFont(mgui_fLastFont);
 mgui_szBracket.Set(0, 0);
 mgui_szBracket = gui_GetSizeOf(&dc, data_GetBracketLeftSymbol());
 mcASSERT(mgui_szBracket != wxSize(0, 0), wxT("Couldn't get bracket size"));

 // update size member
 mgui_szBase.SetWidth(mgui_szBase.GetWidth() + mgui_szBracket.GetWidth()*2 + gui_GetSpaceLeftRight()*2);
 mgui_szBase.SetHeight(mgui_szBracket.GetHeight() + gui_GetSpaceAboveBelow()*2);
}

void mcBracketHelpers::gui_DrawContainer(wxDC &hDC, int Offsetx, int Offsety, 
           long flags, const wxPoint &pt) const
{
 // we don't need to check the mouse position because we
 // do not want to highlight all the contained expression if the
 // cursor is over it or if it is over the parentheses; 
 // instead, we highlight the part of the expression involved
 // (see the mcExpContainerHelpers::gui_Draw() function) 
 mcUNUSED(pt);

 // 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...
 mcElementHelpers::gui_SelectStyle(hDC);
 hDC.SetFont(mgui_fLastFont);

 hDC.DrawText(data_GetBracketLeftSymbol(), Offsetx, Offsety);
 hDC.DrawText(data_GetBracketRightSymbol(), Offsetx+mgui_szBracket.GetWidth()+
  data_GetContent().gui_GetWidth(), Offsety);
}

mcInputRes mcBracketHelpers::gui_BaseInput(const mcKey &key, mcElement *pnew)
{
 if (!sgui_bCreateBothSymbols) {

  // intercept delete keypresses and create mcParenthesis
  // which replace the brackets...
  switch (mgui_nCursorPos) {
  case mcEXPCONTAINER_LEFTMOST:
   if (mcMathCore::Get()->m_pCancelKey->MatchKey(key))
    return gui_OnRemoveLeftBracket(pnew);
   break;  // proceed with normal processing
   
  case mcEXPCONTAINER_RIGHTMOST:
   if (mcMathCore::Get()->m_pDeleteKey->MatchKey(key))
    return gui_OnRemoveRightBracket(pnew);
   break;  // proceed with normal processing
  }
 }

 mcInputRes n = mcExpContainerHelpers::gui_BaseInput(key, pnew);

 // all the inputs dropped to the contained polynomial,
 // can change the type of brackets of this class...
 if (mgui_nCursorPos == mcEXPCONTAINER_INSIDEEXPR)
  data_ChooseBracketType();
 return n;
}

mcInputRes mcBracketHelpers::gui_OnRemoveRightBracket(mcElement *pnew)
{
 mgui_bRemoveLeftBracket = FALSE;
 *pnew = mcElement(this);
 return mcIR_DISTRIBUTE; 
}

mcInputRes mcBracketHelpers::gui_OnRemoveLeftBracket(mcElement *pnew)
{
 mgui_bRemoveLeftBracket = TRUE;
 *pnew = mcElement(this);
 return mcIR_DISTRIBUTE; 
}

mcInputRes mcBracketHelpers::gui_HandleContentInput(mcInputRes r, mcElement *pnew)
{
 if (!sgui_bCreateBothSymbols && r == mcIR_DELETE_NEXT)
  return gui_OnRemoveRightBracket(pnew);

 if (!sgui_bCreateBothSymbols && r == mcIR_DELETE_PREVIOUS)
  return gui_OnRemoveLeftBracket(pnew);

 return mcExpContainerHelpers::gui_HandleContentInput(r, pnew);
}





// ----------------------------------------
// mcBracketHelpersIO
// ----------------------------------------

wxString mcBracketHelpers::io_GetBaseInlinedExpr() const
{
 wxString str = data_GetContent().io_GetInlinedExpr();

 // update bracket symbols
 int n = data_ChooseBracketType();

 // just add the parentheses...
 return data_GetBracketLeftSymbol(n) + str + 
   data_GetBracketRightSymbol(n);
}

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

 // check begin char and find the end one
 mcASSERT(c == wxT('(') || c == wxT('[') || c == wxT('{'), wxT("Error in mcBracketHelpers::io_isBeginChar"));
 if (c == wxT('(')) e = wxT(')');
 if (c == wxT('[')) e = wxT(']');
 if (c == wxT('{')) e = wxT('}');

 // find the end character of this element
 wxString contents = str.Right(str.Len()-1);
 contents = contents.BeforeFirst(e);

 // then, import the contained expression
 bool b = data_GetContent().io_ImportInlinedExpr(contents, count, pErr);
 *count += 2;

 return b;
}





// ----------------------------------------
// mcBRACKETMATH
// ----------------------------------------

mcExpSimRes mcBracketHelpers::math_SimplifyContents(long flags, mcElement *newelem)
{
 bool numeric = !data_GetContent().math_ContainsSymbols();
 bool factorized = data_GetContent().math_isFactorized();
 
 // in case we are just containing another bracket, even if
 // flags contains the mcEXPSIM_KEEP_FACTORIZATION flag, we
 // must expand ourselves to avoid something like:
 //
 //                     {[(a+b+c)]}
 //
 bool bracketnested = factorized &&
  data_GetContent().math_Get(0).math_isWrappingOnly(mcET_BRACKET);

 // FIXME: before using Distribute we should check if the 
 // parent polynomial contains something which can be simplified
 // (i.e. summed/subtracted) with our contents:
 //
 // 4x+5(a-y)
 //     ^^^^^--- this mcBracket should not be removed since
 //              it would not allow any further simplification...
 //
 // 4x+5(a-x)
 //     ^^^^^--- this mcBracket should be simplified to
 //              4x+5a-5x since it would bring to a simplification (4x-5x)
 
 if ((!(flags & mcEXPSIM_KEEP_FACTORIZATION) && (factorized || numeric))
  || bracketnested) {

  mcExpSimRes r = math_RemoveExp();
  if (r == mcESR_INVALID_DATA)
   return mcESR_DONE;
  if (r == mcESR_NOTFINISHED)
   return r;

  // we have to expand ourselves since we contain only numbers...
  mcMATHLOG(wxT("mcBracketHelpers::math_SimplifyContents - going to expand [%s]"), mcTXTTHIS);

  *newelem = mcElement(this);
  return mcESR_DISTRIBUTE;
 }

 return mcESR_DONE;
}

mcExpSimRes mcBracketHelpers::math_RemoveExp()
{
 if (!math_hasExp())
  return mcESR_DONE;
 
 mcMATHLOG(wxT("mcBracketHelpers::math_RemoveExp [%s] - can [%s] be removed ?"),
    mcTXTTHIS, mcTXT(math_GetExp()));
 if (!data_GetContent().math_CanBeRaisedTo(math_GetExp())) {
  
  // if the exponent is not a constant, then we cannot do anything:
  //                        (a+b+c+...z)^x
  // cannot be further expanded...
  return mcESR_INVALID_DATA;
 }
  
 // we can expand the contents raising them to our exp
 data_GetContent().math_RaiseTo(math_GetExp());
 this->data_DestroyExpSub(TRUE);
 
 // we have raised a polynomial; by now, stop here...
 return mcESR_NOTFINISHED; 
}

mcExpSimRes mcBracketHelpers::math_ExpandContents(long flags, mcElement *newelem)
{
 mcExpSimRes r = math_RemoveExp();
 if (r == mcESR_INVALID_DATA)
  return mcESR_DONE;
 if (r == mcESR_NOTFINISHED)
  return r;
 
 // unlike in math_SimplifyContents, this operation should always be performed...
 *newelem = mcElement(this);
 return mcESR_DISTRIBUTE;
}

mcBasicOpRes mcBracketHelpers::math_MakeReciprocal(mcElement *pp)
{
 // just create a fraction with our contents as denominator;
 // the brackets can be removed:
 //
 //                                   1
 //    (ax+b+......)     =   --------------------
 //                             ax + b + ....

 mcFraction f;
 f.data_SetDen(data_GetContent());

 *pp = f;

 return mcBOR_REMOVE_OPERAND;
}

---

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

[ Top ]