JIndex
JNamedConstant::PrepareToRender
(
const JExprRenderer& renderer,
const JPoint& upperLeft,
const JSize fontSize,
JExprRectList* rectList
)
{
if (strcmp(JPGetStdNamedConstName(itsNameIndex), JPGetPiString()) == 0)
{
JRect ourRect;
ourRect.top = upperLeft.y;
ourRect.left = upperLeft.x;
ourRect.bottom = upperLeft.y + renderer.GetLineHeight(fontSize);
ourRect.right = upperLeft.x + renderer.GetGreekCharWidth(fontSize, kGreekPiChar);
const JCoordinate ourMidline = ourRect.ycenter();
return rectList->AddRect(ourRect, ourMidline, fontSize, this);
}
else
{
return JFunction::PrepareToRender(renderer, upperLeft, fontSize, rectList);
}
}
void
JSummation::Render
(
const JExprRenderer& renderer,
const JExprRectList& rectList
)
const
{
// find ourselves in the list
JIndex ourIndex;
const JBoolean found = rectList.FindFunction(this, &ourIndex);
assert( found );
const JRect ourRect = rectList.GetRect(ourIndex);
const JCoordinate ourMidline = rectList.GetMidline(ourIndex);
const JSize fontSize = rectList.GetFontSize(ourIndex);
// draw ourselves
JCoordinate h = ourRect.left;
const JSize spaceWidth = renderer.GetStringWidth(fontSize, " ");
const JSize argCount = GetArgCount();
for (JIndex i=1; i<=argCount; i++)
{
const JFunction* f = this;
const JFunction* arg = GetArg(i);
if (arg->GetType() == kJNegationType)
{
renderer.DrawString(h, ourMidline, fontSize, JPGetSubtractionString());
f = arg;
const JNegation* neg = dynamic_cast<const JNegation*>(arg);
assert( neg != NULL );
arg = neg->GetArg();
}
else if (i > 1)
{
renderer.DrawString(h, ourMidline, fontSize, JPGetAdditionString());
}
arg->Render(renderer, rectList);
JIndex argIndex;
const JBoolean found = rectList.FindFunction(arg, &argIndex);
assert( found );
const JRect argRect = rectList.GetRect(argIndex);
h = argRect.right;
if (ParenthesizeArgForRender(*f, *arg))
{
renderer.DrawParentheses(argRect);
h += renderer.GetParenthesisWidth(argRect.height());
}
h += spaceWidth;
}
}
JIndex
JConjugate::PrepareToRender
(
const JExprRenderer& renderer,
const JPoint& upperLeft,
const JSize fontSize,
JExprRectList* rectList
)
{
const JSize barHeight = renderer.GetHorizBarHeight();
// get rectangle for our argument
JPoint argUpperLeft = upperLeft;
argUpperLeft.y += barHeight;
JFunction* arg = GetArg();
const JIndex argIndex =
arg->PrepareToRender(renderer, argUpperLeft, fontSize, rectList);
// calculate our rectangle
JRect ourRect = rectList->GetRect(argIndex);
ourRect.top -= barHeight;
// save our rectangle
const JCoordinate ourMidline = rectList->GetMidline(argIndex);
return rectList->AddRect(ourRect, ourMidline, fontSize, this);
}
JIndex
JAbsValue::PrepareToRender
(
const JExprRenderer& renderer,
const JPoint& upperLeft,
const JSize fontSize,
JExprRectList* rectList
)
{
const JSize barWidth = renderer.GetVertBarWidth();
// get rectangle for our argument
JPoint argUpperLeft = upperLeft;
argUpperLeft.x += barWidth;
JFunction* arg = GetArg();
const JIndex argIndex =
arg->PrepareToRender(renderer, argUpperLeft, fontSize, rectList);
// calculate our rectangle
JRect ourRect = rectList->GetRect(argIndex);
ourRect.left -= barWidth;
ourRect.right += barWidth;
// save our rectangle
const JCoordinate ourMidline = rectList->GetMidline(argIndex);
return rectList->AddRect(ourRect, ourMidline, fontSize, this);
}
void
JNamedConstant::Render
(
const JExprRenderer& renderer,
const JExprRectList& rectList
)
const
{
if (strcmp(JPGetStdNamedConstName(itsNameIndex), JPGetPiString()) == 0)
{
// find ourselves in the list
JIndex ourIndex;
const JBoolean found = rectList.FindFunction(this, &ourIndex);
assert( found );
const JRect ourRect = rectList.GetRect(ourIndex);
const JCoordinate ourMidline = rectList.GetMidline(ourIndex);
const JSize fontSize = rectList.GetFontSize(ourIndex);
// draw the greek character for pi
renderer.DrawGreekCharacter(ourRect.left, ourMidline, fontSize, kGreekPiChar);
}
else
{
JFunction::Render(renderer, rectList);
}
}
void
JFunctionWithVar::Render
(
const JExprRenderer& renderer,
const JExprRectList& rectList
)
const
{
// find ourselves in the list
JIndex ourIndex;
const JBoolean found = rectList.FindFunction(this, &ourIndex);
assert( found );
const JRect ourRect = rectList.GetRect(ourIndex);
const JCoordinate ourMidline = rectList.GetMidline(ourIndex);
const JSize fontSize = rectList.GetFontSize(ourIndex);
// draw base name
JString baseName, subscript;
itsVariableList->GetVariableName(itsVariableIndex, &baseName, &subscript);
DrawString(renderer, ourRect.left, ourMidline, fontSize, baseName);
// draw subscript
if (!subscript.IsEmpty())
{
const JCoordinate subLeft =
ourRect.left + GetStringWidth(renderer, fontSize, baseName);
const JSize subFontSize = renderer.GetSuperSubFontSize(fontSize);
const JSize subHeight = renderer.GetLineHeight(subFontSize);
DrawString(renderer, subLeft, ourMidline + subHeight/2, subFontSize, subscript);
}
// draw our array index
if (itsArrayIndex != NULL)
{
itsArrayIndex->Render(renderer, rectList);
JIndex argIndex;
const JBoolean found = rectList.FindFunction(itsArrayIndex, &argIndex);
assert( found );
renderer.DrawSquareBrackets(rectList.GetRect(argIndex));
}
}
JIndex
JFunction::PrepareToRender
(
const JExprRenderer& renderer,
const JPoint& upperLeft,
const JSize fontSize,
JExprRectList* rectList
)
{
const JString text = Print();
JRect ourRect;
ourRect.top = upperLeft.y;
ourRect.left = upperLeft.x;
ourRect.bottom = upperLeft.y + renderer.GetLineHeight(fontSize);
ourRect.right = upperLeft.x + renderer.GetStringWidth(fontSize, text);
const JCoordinate ourMidline = ourRect.ycenter();
return rectList->AddRect(ourRect, ourMidline, fontSize, this);
}
void
JLogB::Render
(
const JExprRenderer& renderer,
const JExprRectList& rectList
)
const
{
// find ourselves in the list
JIndex ourIndex;
const JBoolean found = rectList.FindFunction(this, &ourIndex);
assert( found );
const JRect ourRect = rectList.GetRect(ourIndex);
const JCoordinate ourMidline = rectList.GetMidline(ourIndex);
const JSize fontSize = rectList.GetFontSize(ourIndex);
// draw ourselves
const JCharacter* name = GetName();
const JSize nameLength = strlen(name);
assert( nameLength > 1 );
assert( name[ nameLength-1 ] == '(' );
const JString fnName = JString(name, nameLength-1);
renderer.DrawString(ourRect.left, ourMidline, fontSize, fnName);
// draw the base
(GetArg1())->Render(renderer, rectList);
// draw the argument
const JFunction* arg = GetArg2();
arg->Render(renderer, rectList);
JIndex argIndex;
const JBoolean foundArg = rectList.FindFunction(arg, &argIndex);
assert( foundArg );
renderer.DrawParentheses(rectList.GetRect(argIndex));
}
void
JFunctionWithVar::DrawString
(
const JExprRenderer& renderer,
const JCoordinate left,
const JCoordinate midline,
const JSize fontSize,
const JString& str
)
const
{
JCoordinate x = left;
const JCharacter* greekPrefix = JPGetGreekCharPrefixString();
const JSize greekPrefixLength = JPGetGreekCharPrefixLength();
JString s = str;
JIndex greekIndex;
while (s.LocateSubstring(greekPrefix, &greekIndex) &&
greekIndex < s.GetLength() - greekPrefixLength + 1)
{
if (greekIndex > 1)
{
const JString s1 = s.GetSubstring(1, greekIndex-1);
renderer.DrawString(x, midline, fontSize, s1);
x += renderer.GetStringWidth(fontSize, s1);
}
const JCharacter c = s.GetCharacter(greekIndex + greekPrefixLength);
renderer.DrawGreekCharacter(x, midline, fontSize, c);
x += renderer.GetGreekCharWidth(fontSize, c);
s.RemoveSubstring(1, greekIndex + greekPrefixLength);
}
if (!s.IsEmpty())
{
renderer.DrawString(x, midline, fontSize, s);
}
}
JSize
JFunctionWithVar::GetStringWidth
(
const JExprRenderer& renderer,
const JSize fontSize,
const JString& str
)
const
{
JSize w = 0;
const JCharacter* greekPrefix = JPGetGreekCharPrefixString();
const JSize greekPrefixLength = JPGetGreekCharPrefixLength();
JString s = str;
JIndex greekIndex;
while (s.LocateSubstring(greekPrefix, &greekIndex) &&
greekIndex < s.GetLength() - greekPrefixLength + 1)
{
if (greekIndex > 1)
{
const JString s1 = s.GetSubstring(1, greekIndex-1);
w += renderer.GetStringWidth(fontSize, s1);
}
const JCharacter c = s.GetCharacter(greekIndex + greekPrefixLength);
w += renderer.GetGreekCharWidth(fontSize, c);
s.RemoveSubstring(1, greekIndex + greekPrefixLength);
}
if (!s.IsEmpty())
{
w += renderer.GetStringWidth(fontSize, s);
}
return w;
}
void
JAbsValue::Render
(
const JExprRenderer& renderer,
const JExprRectList& rectList
)
const
{
// find ourselves in the list
JIndex ourIndex;
const JBoolean found = rectList.FindFunction(this, &ourIndex);
assert( found );
const JRect ourRect = rectList.GetRect(ourIndex);
// draw ourselves
renderer.DrawVertBar(ourRect.left, ourRect.top, ourRect.height());
(GetArg())->Render(renderer, rectList);
renderer.DrawVertBar(ourRect.right - renderer.GetVertBarWidth(),
ourRect.top, ourRect.height());
}
void
JConjugate::Render
(
const JExprRenderer& renderer,
const JExprRectList& rectList
)
const
{
// find ourselves in the list
JIndex ourIndex;
const JBoolean found = rectList.FindFunction(this, &ourIndex);
assert( found );
const JRect ourRect = rectList.GetRect(ourIndex);
// draw ourselves
renderer.DrawHorizBar(ourRect.left, ourRect.top, ourRect.width());
GetArg()->Render(renderer, rectList);
}
void
JFunction::Render
(
const JExprRenderer& renderer,
const JExprRectList& rectList
)
const
{
// find ourselves in the list
JIndex ourIndex;
const JBoolean found = rectList.FindFunction(this, &ourIndex);
assert( found );
const JRect ourRect = rectList.GetRect(ourIndex);
const JCoordinate ourMidline = rectList.GetMidline(ourIndex);
const JSize fontSize = rectList.GetFontSize(ourIndex);
// display the output of Print
const JString text = Print();
renderer.DrawString(ourRect.left, ourMidline, fontSize, text);
}
JIndex
JLogB::PrepareToRender
(
const JExprRenderer& renderer,
const JPoint& upperLeft,
const JSize fontSize,
JExprRectList* rectList
)
{
// intialize our rectangle
const JCharacter* name = GetName();
const JSize nameLength = strlen(name);
assert( nameLength > 1 );
assert( name[ nameLength-1 ] == '(' );
const JString fnName = JString(name, nameLength-1);
JRect ourRect;
ourRect.top = upperLeft.y;
ourRect.left = upperLeft.x;
ourRect.bottom = upperLeft.y + renderer.GetLineHeight(fontSize);
ourRect.right = upperLeft.x + renderer.GetStringWidth(fontSize, fnName);
// get rectangle for base
JPoint argUpperLeft(ourRect.right, ourRect.top);
const JSize baseFontSize = renderer.GetSuperSubFontSize(fontSize);
JFunction* base = GetArg1();
const JIndex baseIndex =
base->PrepareToRender(renderer, argUpperLeft, baseFontSize, rectList);
const JRect baseRect = rectList->GetRect(baseIndex);
argUpperLeft.x = baseRect.right;
// get rectangle for argument -- gives our midline
JFunction* arg = GetArg2();
const JIndex argIndex =
arg->PrepareToRender(renderer, argUpperLeft, fontSize, rectList);
const JRect argRect = rectList->GetRect(argIndex);
ourRect = JCovering(ourRect, argRect);
const JCoordinate ourMidline = rectList->GetMidline(argIndex);
// shift argument to make space for left parenthesis
const JSize parenWidth = renderer.GetParenthesisWidth(argRect.height());
rectList->ShiftRect(argIndex, parenWidth, 0);
// we need space for two parentheses
ourRect.right += 2*parenWidth;
// shift the base down
rectList->ShiftRect(baseIndex, 0, ourMidline - ourRect.top);
ourRect = JCovering(ourRect, rectList->GetRect(baseIndex));
// save our rectangle
return rectList->AddRect(ourRect, ourMidline, fontSize, this);
}
JIndex
JParallel::PrepareToRender
(
const JExprRenderer& renderer,
const JPoint& upperLeft,
const JSize fontSize,
JExprRectList* rectList
)
{
// intialize our rectangle and midline
JPoint argUpperLeft = upperLeft;
JRect ourRect(upperLeft, argUpperLeft);
ourRect.bottom += renderer.GetLineHeight(fontSize);
JCoordinate ourMidline = (ourRect.top + ourRect.bottom)/2;
const JCoordinate origMidline = ourMidline;
// get rectangle for each argument
const JSize opWidth =
2*(renderer.GetStringWidth(fontSize, " ") + renderer.GetVertBarWidth());
const JSize argCount = GetArgCount();
{
for (JIndex i=1; i<=argCount; i++)
{
JFunction* arg = GetArg(i);
const JIndex argIndex =
arg->PrepareToRender(renderer, argUpperLeft, fontSize, rectList);
JRect argRect = rectList->GetRect(argIndex);
argUpperLeft.x = argRect.right + opWidth;
if (ParenthesizeArgForRender(*this, *arg))
{
const JSize parenWidth = renderer.GetParenthesisWidth(argRect.height());
rectList->ShiftRect(argIndex, parenWidth, 0);
argRect = rectList->GetRect(argIndex);
argUpperLeft.x += 2*parenWidth;
ourRect.right = argRect.right + parenWidth;
}
ourRect = JCovering(ourRect, argRect);
const JCoordinate argMidline = rectList->GetMidline(argIndex);
if (argMidline > ourMidline)
{
ourMidline = argMidline;
}
}
}
// adjust the argument rectangles so all the midlines are the same
// (ourMidline is guaranteed to stay constant)
if (argCount > 1 && ourMidline > origMidline)
{
for (JIndex i=1; i<=argCount; i++)
{
const JFunction* arg = GetArg(i);
JIndex argIndex;
const JBoolean found = rectList->FindFunction(arg, &argIndex);
assert( found );
rectList->SetMidline(argIndex, ourMidline);
ourRect = JCovering(ourRect, rectList->GetRect(argIndex));
}
}
// save our rectangle
return rectList->AddRect(ourRect, ourMidline, fontSize, this);
}
JIndex
JFunctionWithVar::PrepareToRender
(
const JExprRenderer& renderer,
const JPoint& upperLeft,
const JSize fontSize,
JExprRectList* rectList
)
{
// intialize our rectangle and midline
JString baseName, subscript;
itsVariableList->GetVariableName(itsVariableIndex, &baseName, &subscript);
JRect ourRect;
ourRect.top = upperLeft.y;
ourRect.left = upperLeft.x;
ourRect.bottom = upperLeft.y + renderer.GetLineHeight(fontSize);
ourRect.right = upperLeft.x + GetStringWidth(renderer, fontSize, baseName);
JCoordinate ourMidline = ourRect.ycenter();
// add in subscript
if (!subscript.IsEmpty())
{
const JSize subFontSize = renderer.GetSuperSubFontSize(fontSize);
const JCoordinate subHeight = renderer.GetLineHeight(subFontSize);
if (ourMidline + subHeight > ourRect.bottom)
{
ourRect.bottom = ourMidline + subHeight;
}
ourRect.right += GetStringWidth(renderer, subFontSize, subscript);
}
// add in array index
if (itsArrayIndex != NULL)
{
// get rectangle for array index
JPoint argUpperLeft(ourRect.right, ourRect.top);
const JIndex argIndex =
itsArrayIndex->PrepareToRender(renderer, argUpperLeft, fontSize, rectList);
ourRect = JCovering(ourRect, rectList->GetRect(argIndex));
ourMidline = rectList->GetMidline(argIndex);
// shift array index to make space for left bracket
const JSize bracketWidth = renderer.GetSquareBracketWidth(ourRect.height());
rectList->ShiftRect(argIndex, bracketWidth, 0);
// we need space for two brackets
ourRect.right += 2*bracketWidth;
}
// save our rectangle
return rectList->AddRect(ourRect, ourMidline, fontSize, this);
}
void
JParallel::Render
(
const JExprRenderer& renderer,
const JExprRectList& rectList
)
const
{
// find ourselves in the list
JIndex ourIndex;
const JBoolean found = rectList.FindFunction(this, &ourIndex);
assert( found );
const JRect ourRect = rectList.GetRect(ourIndex);
const JCoordinate ourMidline = rectList.GetMidline(ourIndex);
const JSize fontSize = rectList.GetFontSize(ourIndex);
// draw ourselves
const JSize spaceWidth = renderer.GetStringWidth(fontSize, " ");
const JSize barWidth = renderer.GetVertBarWidth();
const JSize lineHeight = renderer.GetLineHeight(fontSize);
JSize maxBarLength;
if (((JSize) ourRect.height()) > lineHeight)
{
maxBarLength = JLFloor(ourRect.height()/2.0);
}
else
{
maxBarLength = ourRect.height();
}
JSize barLength;
if (ourMidline > ourRect.ycenter())
{
barLength = 2*(ourRect.bottom - ourMidline);
}
else
{
barLength = 2*(ourMidline - ourRect.top);
}
if (barLength > maxBarLength)
{
barLength = maxBarLength;
}
const JCoordinate barTop = ourMidline - barLength/2;
const JSize argCount = GetArgCount();
for (JIndex i=1; i<=argCount; i++)
{
const JFunction* arg = GetArg(i);
arg->Render(renderer, rectList);
JIndex argIndex;
const JBoolean found = rectList.FindFunction(arg, &argIndex);
assert( found );
const JRect argRect = rectList.GetRect(argIndex);
JCoordinate h = argRect.right + spaceWidth;
if (ParenthesizeArgForRender(*this, *arg))
{
renderer.DrawParentheses(argRect);
h += renderer.GetParenthesisWidth(argRect.height());
}
if (i < argCount)
{
renderer.DrawVertBar(h, barTop, barLength);
renderer.DrawVertBar(h + barWidth, barTop, barLength);
}
}
}
JIndex
JSummation::PrepareToRender
(
const JExprRenderer& renderer,
const JPoint& upperLeft,
const JSize fontSize,
JExprRectList* rectList
)
{
// intialize our rectangle and midline
JPoint argUpperLeft = upperLeft;
JRect ourRect(upperLeft, argUpperLeft);
ourRect.bottom += renderer.GetLineHeight(fontSize);
JCoordinate ourMidline = ourRect.ycenter();
const JCoordinate origMidline = ourMidline;
// get rectangle for each argument
const JSize spaceWidth = renderer.GetStringWidth(fontSize, " ");
const JSize plusWidth = renderer.GetStringWidth(fontSize, JPGetAdditionString());
const JSize minusWidth = renderer.GetStringWidth(fontSize, JPGetSubtractionString());
const JSize argCount = GetArgCount();
{
for (JIndex i=1; i<=argCount; i++)
{
JFunction* f = this;
JFunction* arg = GetArg(i);
if (arg->GetType() == kJNegationType)
{
argUpperLeft.x += minusWidth + spaceWidth;
if (i > 1)
{
argUpperLeft.x += spaceWidth;
}
f = arg;
JNegation* neg = dynamic_cast<JNegation*>(arg);
assert( neg != NULL );
arg = neg->GetArg();
}
else if (i > 1)
{
argUpperLeft.x += plusWidth + 2*spaceWidth;
}
const JIndex argIndex =
arg->PrepareToRender(renderer, argUpperLeft, fontSize, rectList);
JRect argRect = rectList->GetRect(argIndex);
argUpperLeft.x = argRect.right;
if (ParenthesizeArgForRender(*f, *arg))
{
const JSize parenWidth = renderer.GetParenthesisWidth(argRect.height());
rectList->ShiftRect(argIndex, parenWidth, 0);
argRect = rectList->GetRect(argIndex);
argUpperLeft.x += 2*parenWidth;
ourRect.right = argRect.right + parenWidth;
}
ourRect = JCovering(ourRect, argRect);
const JCoordinate argMidline = rectList->GetMidline(argIndex);
if (argMidline > ourMidline)
{
ourMidline = argMidline;
}
}
}
// adjust the argument rectangles so all the midlines are the same
// (ourMidline is guaranteed to stay constant)
if (argCount > 1 && ourMidline > origMidline)
{
for (JIndex i=1; i<=argCount; i++)
{
const JFunction* arg = GetArg(i);
if (arg->GetType() == kJNegationType)
{
const JNegation* neg = dynamic_cast<const JNegation*>(arg);
assert( neg != NULL );
arg = neg->GetArg();
}
JIndex argIndex;
const JBoolean found = rectList->FindFunction(arg, &argIndex);
assert( found );
rectList->SetMidline(argIndex, ourMidline);
ourRect = JCovering(ourRect, rectList->GetRect(argIndex));
}
}
// save our rectangle
return rectList->AddRect(ourRect, ourMidline, fontSize, this);
}
