/*
 * MathPlanner 3.0.1 - Mathematical design tool.
 * Copyright(C) 2002  Jarmo Nikkanen
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation.
 *
 * You should have received a copy of the GNU General Public License with this program.
 *
 */


// DISPLAY REAL NUMBER *******************************
// ***************************************************


#include "RealComplexDisplay.h"
#include "Error.h"
#include "Datastore.h"
#include "AppControl.h"
#include "ConfigReader.h"
#include "Object_string.h"
#include "Extern.h"

#include <math.h>

display::display()
{

}

void display::Init(ApplicationControl *ap,class string_object *st)
{
  AppControl=ap;
  string=st;
  ValueLo.Init(ap);
  ValueLob.Init(ap);
  ValueLoc.Init(ap);
  ValueLod.Init(ap);
  PiiLo.Init(ap);
  DiveLo.Init(ap);
  StrLo.Init(ap);
  StrLob.Init(ap);
  SqrtLo.Init(ap);
  SqrtLob.Init(ap);
  ExpLo.Init(ap);
  ExpLayout.Init(ap);
  MarkLo.Init(ap);
  MarkLob.Init(ap);
  MainStr.Init(ap);

  exp_hi_limit=ap->Prefs->Int("UpperExpLimit");
  exp_low_limit=ap->Prefs->Int("LowerExpLimit");
  value_overide=false;
}


void display::SetValueOveride()
{
	 value_overide=true;
}

bool display::SetRational(double real,QString mark,QString mark2,bool show_zero)
{
	 double v,exponent,in,out,inb;
   layout_rect val,exp,valc,sqr,zero,pii,mar,marb;
   QString text_exp,text_value;
   int x,al,digits=7,up,lo;
   mpl_rational rat;

   if (real==floor(real)) return(false); // Do not use this if there is no fractional part

   al=AppControl->CenterLine(string);

   if (!real_to_rational(real,&rat,&info)) { NBug(3,"RTR FAIL"); return(false); }

   NBug(3,"RAT-A",rat.a);
   NBug(3,"RAT-B",rat.b);

   v=fabs(rat.a);
   if (v==0.0) v=1.0;
   exponent=floor(log10(v));
   if (exponent>5) return(false);

   v=fabs(rat.b);
   if (v==0.0) v=1.0;
   exponent=floor(log10(v));
   if (exponent>5) return(false);


   rational=true;
   show=false;

   bounds.width=0;
   bounds.ascent=0;
   bounds.descent=0;

   zero.width=1; zero.ascent=1; zero.descent=1;

   hasout=hasoutb=false;
   hasroot=hasrootb=false;
   mark_a=mark_b=false;

   if (!mark.isNull()) mark_a=true;
   if (!mark2.isNull()) mark_b=true;;

   if (rat.b==1.0) upper_only=true;
   else upper_only=false;

   if (rat.a!=0.0 && rat.b!=0.0) {

           pii=PiiLo.GetOuterRect(string->GetFont(FONT_TYPE_NORMAL),QString(QChar(0x3C0)));
           if (mark_a) mar=MarkLo.GetOuterRect(string->GetFont(FONT_TYPE_NORMAL),mark);
           if (mark_b) marb=MarkLob.GetOuterRect(string->GetFont(FONT_TYPE_NORMAL),mark2);
           // UPPER

           if (info.root) { if (!create_root(rat.a,&in,&out)) { ErrorReport("SetRational","A Root"); return(false); } }
           if (!info.root) out=rat.a;

           if (out>=1) {  hasout=true;
           val=ValueLo.GetOuterRect(string->GetFont(FONT_TYPE_NORMAL),mpl_real2text_dec(out,digits));
           }

           if (info.root && in>1) hasroot=true;
           if (hasroot && out==1) hasout=false;
           if (info.pii_location==1 && out==1) hasout=false;


           up=0;

           if (hasout) StrLo.SetSize(up++,val);
           if (info.pii_location==1) StrLo.SetSize(up++,pii);

           if (hasroot) {
              val=ValueLob.GetOuterRect(string->GetFont(FONT_TYPE_NORMAL),mpl_real2text_dec(in,digits));
              SqrtLo.SetSize(0,val); SqrtLo.SetSize(1,zero);
              sqr=SqrtLo.GetOuterRect();
              StrLo.SetSize(up++,sqr);
           }


           if (!hasroot && !hasout && info.pii_location!=1) { ErrorReport("SetRational","Nothing to display"); return(false); }


     if (upper_only==false) {

           // LOWER
           lo=0;
           if (info.root) { if (!create_root(rat.b,&inb,&out)) { ErrorReport("SetRational","B Root"); return(false); }  }
           if (!info.root) out=rat.b;

           if (out>1) {  hasoutb=true;
           valc=ValueLoc.GetOuterRect(string->GetFont(FONT_TYPE_NORMAL),mpl_real2text_dec(out,digits));
           }

           if (info.root && inb>1) hasrootb=true;



           if (hasoutb) StrLob.SetSize(lo++,valc);

           if (info.pii_location==2) StrLob.SetSize(lo++,pii);

           if (hasrootb) {
              val=ValueLod.GetOuterRect(string->GetFont(FONT_TYPE_NORMAL),mpl_real2text_dec(inb,digits));
              SqrtLob.SetSize(0,val); SqrtLob.SetSize(1,zero);
              sqr=SqrtLob.GetOuterRect();
              StrLob.SetSize(lo++,sqr);
           }


           DiveLo.SetSize(0,StrLo.GetOuterRect(up));
           DiveLo.SetSize(1,StrLob.GetOuterRect(lo));

           x=0;
           if (mark_a) MainStr.SetSize(x++,mar);
           MainStr.SetSize(x++,DiveLo.GetOuterRect(al));
           if (mark_b) MainStr.SetSize(x++,marb);
           exp=MainStr.GetOuterRect(x);
     } // upper_only
     else  {
           x=0;
           if (mark_a) MainStr.SetSize(x++,mar);
           MainStr.SetSize(x++,StrLo.GetOuterRect(up));
           if (mark_b) MainStr.SetSize(x++,marb);
           exp=MainStr.GetOuterRect(x);
     }
           bounds.width=exp.width;
           bounds.ascent=exp.ascent;
           bounds.descent=exp.descent;
           show=true;

   } // if zeroes
   else { NBug(3,"Zeroes FAIL"); return(false); }


   return(true);

}


void display::SetNumber(double real,int digits,int digit_mode,QString mark,QString mark2,bool show_zero)
{
	 double v,exponent;

   bool exp3;
   layout_rect val,exp;
   QString text_exp,text_value;

   rational=false;

   show=false;
   bounds.width=0;
   bounds.ascent=0;
   bounds.descent=0;

   if (real!=0.0 || show_zero ) {  // Do not show zero in complex
      Bug("Start Set Number");
      show=true;
      v=fabs(real);
      if (v==0.0) v=1.0;
      exponent=floor(log10(v));

      exp_display=false; // Turn off exp-display

      if (digit_mode==DIGIT_MODE_EXP3 || digit_mode==DIGIT_MODE_EXP) exp_display=true;

      if (exponent>=(exp_hi_limit)) exp_display=true;
      if (exponent<=(-exp_low_limit)) exp_display=true;

      if (digit_mode==DIGIT_MODE_EXP3 || digit_mode==DIGIT_MODE_AUTO) exp3=true;
      else exp3=false;

      if (!value_overide) {
      if (exp_display) {
          text_exp=mpl_real2text_exp(real,exp3);
          text_value=mpl_real2text_frac(real,digits,exp3);
			}
      else text_value=mpl_real2text_dec(real,digits);
      }
      else text_value=QString("");

      value_overide=false;

      if (!mark.isNull()) text_value.insert(0,mark);
      if (!mark2.isNull() && real!=0.0) text_value.append(mark2);

      val=ValueLo.GetOuterRect(string->GetFont(FONT_TYPE_NORMAL),text_value);
			if (exp_display) exp=ExpLo.GetOuterRect(string->GetFont(FONT_TYPE_EXPONENT),text_exp);

      if (exp_display) {
      ExpLayout.SetSize(0,val);
			ExpLayout.SetSize(1,exp);
      exp=ExpLayout.GetOuterRect();
      bounds.width=exp.width;
      bounds.ascent=exp.ascent;
      bounds.descent=exp.descent;
      }
      else {
      bounds.width=val.width;
      bounds.ascent=val.ascent;
      bounds.descent=val.descent;
      }
   }
   Bug("Pass");
}

layout_rect display::Bounds()
{
  return(bounds);
}

void display::Draw(QPainter *paint)
{
  if (show) {

      paint->setPen(QPen(AppControl->GetColor(FONT_TYPE_NORMAL)));
   		paint->setFont(string->GetFont(FONT_TYPE_NORMAL));

  if (rational) {

  paint->setPen(QPen(AppControl->GetColor(FONT_TYPE_NORMAL)));

  if (hasout) ValueLo.Draw(paint);
  if (info.pii_location==1) PiiLo.Draw(paint);
  if (hasroot) {
         SqrtLo.Draw(paint);
         paint->setPen(QPen(AppControl->GetColor(FONT_TYPE_NORMAL)));
         ValueLob.Draw(paint);  }

  if (mark_a) MarkLo.Draw(paint);
  if (mark_b) MarkLob.Draw(paint);

  if (upper_only==false) {

  DiveLo.Draw(paint);
  paint->setPen(QPen(AppControl->GetColor(FONT_TYPE_NORMAL)));
  if (hasoutb) ValueLoc.Draw(paint);
  if (info.pii_location==2) PiiLo.Draw(paint);
  if (hasrootb) {
         SqrtLob.Draw(paint);
         paint->setPen(QPen(AppControl->GetColor(FONT_TYPE_NORMAL)));
         ValueLod.Draw(paint); }

  } // upper_only


  }
  else { // No rational display
   		ValueLo.Draw(paint);
   		paint->setFont(string->GetFont(FONT_TYPE_EXPONENT));
   		if (exp_display) ExpLo.Draw(paint);
  }
  }
}






void display::SetPosition(QPoint p)
{
  int x=0,y=0;

  if (rational) {

  if (upper_only==false) {
  MainStr.SetPosition(p);
  if (mark_a) MarkLo.SetPosition(MainStr.GetPosition(x++));
  DiveLo.SetPosition(MainStr.GetPosition(x++));
  if (mark_b) MarkLob.SetPosition(MainStr.GetPosition(x++));

  x=0;

  StrLo.SetPosition(DiveLo.GetPosition(0));
  StrLob.SetPosition(DiveLo.GetPosition(1));

  if (hasout) ValueLo.SetPosition(StrLo.GetPosition(x++));
  if (info.pii_location==1) PiiLo.SetPosition(StrLo.GetPosition(x++));
  if (hasroot) {
      SqrtLo.SetPosition(StrLo.GetPosition(x++));
      ValueLob.SetPosition(SqrtLo.GetPosition(0));
  }
  if (hasoutb) ValueLoc.SetPosition(StrLob.GetPosition(y++));
  if (info.pii_location==2) PiiLo.SetPosition(StrLob.GetPosition(y++));
  if (hasrootb) {
      SqrtLob.SetPosition(StrLob.GetPosition(y++));
      ValueLod.SetPosition(SqrtLob.GetPosition(0));
  }
  }


  if (upper_only==true) {
  MainStr.SetPosition(p);
  if (mark_a) MarkLo.SetPosition(MainStr.GetPosition(x++));
  StrLo.SetPosition(MainStr.GetPosition(x++));
  if (mark_b) MarkLob.SetPosition(MainStr.GetPosition(x++));

  x=0;

  if (hasout) ValueLo.SetPosition(StrLo.GetPosition(x++));
  if (info.pii_location==1) PiiLo.SetPosition(StrLo.GetPosition(x++));
  if (hasroot) {
      SqrtLo.SetPosition(StrLo.GetPosition(x++));
      ValueLob.SetPosition(SqrtLo.GetPosition(0));
  }
  }


  return;
  }

  if (exp_display) {
  	ExpLayout.SetPosition(p);
  	ValueLo.SetPosition(ExpLayout.GetPosition(0));
		ExpLo.SetPosition(ExpLayout.GetPosition(1));
  }
  else ValueLo.SetPosition(p);
}