void
JXStyleMenuTable::TableDrawCell
(
JPainter& p,
const JPoint& cell,
const JRect& origRect
)
{
if (cell.x == kTextColumnIndex && cell.y >= JXStyleMenu::kFirstColorCmd)
{
JRect rect = AdjustRectForSeparator(cell.y, origRect);
JRect colorRect = rect;
colorRect.Shrink(0, kHilightBorderWidth);
colorRect.right = colorRect.left + colorRect.height();
const JBoolean origFill = p.IsFilling();
p.SetFilling(kJTrue);
p.SetPenColor(itsStyleMenu->IndexToColor(cell.y));
p.Rect(colorRect);
p.SetFilling(origFill);
rect = origRect;
rect.left += colorRect.width() + kHMarginWidth;
JXTextMenuTable::TableDrawCell(p, cell, rect);
}
else
{
JXTextMenuTable::TableDrawCell(p, cell, origRect);
}
}
void
JXFSBindingTable::TableDrawCell
(
JPainter& p,
const JPoint& cell,
const JRect& rect
)
{
JPoint editCell;
if (GetEditedCell(&editCell) && cell == editCell)
{
return;
}
HilightIfSelected(p, cell, rect);
const JFSBinding* b = itsBindingList->GetBinding(cell.y);
JFSBinding::CommandType type;
JBoolean singleFile;
const JString& cmd = b->GetCommand(&type, &singleFile);
if (cell.x == kPatternColumn)
{
p.SetFont(JGetMonospaceFontName(), kJDefaultMonoFontSize, JFontStyle());
JRect r = rect;
r.left += kHMarginWidth;
p.String(r, b->GetPattern(), JPainter::kHAlignLeft, JPainter::kVAlignCenter);
p.SetFont(JGetDefaultFontName(), kJDefaultFontSize, JFontStyle());
}
else if (cell.x == kCommandColumn)
{
p.SetFont(JGetMonospaceFontName(), kJDefaultMonoFontSize, JFontStyle());
JRect r = rect;
r.left += kHMarginWidth;
p.String(r, cmd, JPainter::kHAlignLeft, JPainter::kVAlignCenter);
p.SetFont(JGetDefaultFontName(), kJDefaultFontSize, JFontStyle());
}
else if (cell.x == kTypeColumn)
{
const JString& str = itsTypeMenu->GetItemText(kCmdTypeToMenuIndex[type]);
p.String(rect, str, JPainter::kHAlignCenter, JPainter::kVAlignCenter);
}
else if (cell.x == kSingleFileColumn && singleFile)
{
JRect r;
r.top = rect.ycenter();
r.left = rect.xcenter();
r.bottom = r.top+1;
r.right = r.left+1;
r.Expand(3, 3);
p.SetFilling(kJTrue);
p.Ellipse(r);
p.SetFilling(kJFalse);
}
}
void
JXColorWheel::SetColor
(
const JPoint& pt
)
{
if (itsImage == NULL)
{
Redraw();
}
const JRect bounds = GetBoundsGlobal();
const JCoordinate max = JMin(bounds.height(), bounds.width() - kSliderWidth - kSliderMargin);
const JCoordinate size = max - 2*kWheelMargin - 1;
const JCoordinate center = size/2 + kWheelMargin;
const JCoordinate dx = - pt.x + center;
const JCoordinate dy = pt.y - center;
const JFloat r = JMin(sqrt(dx*dx + dy*dy) / center, 1.0);
const JFloat a = 0.5 + atan2(dy, dx) / (2.0 * kJPi);
const JSize b = JRound(itsBrightnessSlider->GetValue());
SetColor(JHSB(JRound(a * kJMaxHSBValue), JRound(r * kJMaxHSBValue), b));
}
void
TestWidget::CreateImageBuffer()
{
// clear itsImageBuffer so Draw() will work correctly
jdelete itsImageBuffer;
itsImageBuffer = NULL;
// create image
const JRect bounds = GetBounds();
JXImage* imageBuffer =
jnew JXImage(GetDisplay(), bounds.width(), bounds.height());
assert( imageBuffer != NULL );
imageBuffer->SetDefaultState(JXImage::kRemoteStorage);
// draw to image
JXImagePainter* p = imageBuffer->CreatePainter();
Draw(*p, GetBounds());
jdelete p;
// save object
itsImageBuffer = imageBuffer;
}
void
CBCommandTable::HandleDNDHere
(
const JPoint& pt,
const JXWidget* source
)
{
JIndex newRowIndex = itsDNDRowIndex;
JPoint cell;
if (GetCell(JPinInRect(pt, GetBounds()), &cell))
{
const JRect r = GetCellRect(cell);
if (pt.y <= r.ycenter())
{
newRowIndex = cell.y;
}
else
{
newRowIndex = cell.y + 1;
}
}
if (newRowIndex != itsDNDRowIndex)
{
itsDNDRowIndex = newRowIndex;
Refresh();
}
}
void
JXSearchTextButton::Draw
(
JXWindowPainter& p,
const JRect& rect
)
{
const JRect bounds = GetBounds();
JRect r;
r.top = bounds.ycenter() - kArrowHalfHeight;
r.bottom = r.top + 2*kArrowHalfHeight + 1;
r.left = bounds.xcenter() - kArrowHalfWidth;
r.right = r.left + 2*kArrowHalfWidth;
const JColorIndex colorIndex =
IsActive() ? (p.GetColormap())->GetGrayColor(40) :
(p.GetColormap())->GetInactiveLabelColor();
if (itsFwdFlag)
{
r.right++;
JXFillArrowRight(p, r, colorIndex);
}
else
{
r.left--;
JXFillArrowLeft(p, r, colorIndex);
}
}
void
JXTabGroup::PlaceCardFile()
{
const JSize h = kSelMargin + kBorderWidth + 2*kTextMargin +
(GetFontManager())->GetLineHeight(itsFontName, itsFontSize, itsFontStyle);
JRect r = GetAperture();
if (itsEdge == kTop)
{
r.top += h;
}
else if (itsEdge == kLeft)
{
r.left += h;
}
else if (itsEdge == kBottom)
{
r.bottom -= h;
}
else if (itsEdge == kRight)
{
r.right -= h;
}
else
{
assert( 0 );
}
r.Shrink(kBorderWidth, kBorderWidth);
itsCardFile->Place(r.left, r.top);
itsCardFile->SetSize(r.width(), r.height());
}
void JBtnObj::update(JGraphics g, double dx, double dy, JRegion& rgn, double scale) {
JRect rect = getIExtent(dx, dy, scale), thumb;
JRegion frgn(rect.shrinkBy(depth, depth));
if ((rect.width > 0) && (rect.height > 0)) {
g.setJColor(bkgnd);
g.fillJRect(rect);
thumb = rect.shrink(depth, depth);
if ((thumb.width > 0) && (thumb.height > 0)) {
switch (type) {
case TYPE_RECT:
g.draw3DJRect(thumb, ((value) ? -depth : depth));
break;
case TYPE_LEFT:
case TYPE_RIGHT:
case TYPE_UP:
case TYPE_DOWN:
g.draw3DJTriangle(thumb,
((value) ? -depth : depth), type-1);
break;
}
if (label.length()) {
g.setJColor(color);
drawText(g, label, thumb.shrink(depth, depth));
}
}
}
}
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
JXTextMenuTable::Draw
(
JXWindowPainter& p,
const JRect& rect
)
{
JXMenuTable::Draw(p, rect);
const JCoordinate w = GetApertureWidth();
const JSize rowCount = GetRowCount();
for (JIndex i=1; i<rowCount; i++) // ignore separator after last item
{
if (itsTextMenuData->HasSeparator(i))
{
JRect r = GetCellRect(JPoint(1,i));
r.top = r.bottom - kSeparatorHeight;
r.right = r.left + w;
// JXDrawDownFrame(p, r, kSeparatorHeight/2);
r.top = r.ycenter() - 1;
r.bottom = r.top + 2;
JXDrawDownFrame(p, r, 1);
}
}
if (itsHilightRow != 0)
{
const JRect r = GetCellRect(JPoint(1, itsHilightRow));
JRect r1 = AdjustRectForSeparator(itsHilightRow, r);
r1.right = r1.left + w;
JXDrawUpFrame(p, r1, kHilightBorderWidth);
}
}
void
JXRowHeaderWidget::HandleMouseDrag
(
const JPoint& origPt,
const JXButtonStates& buttonStates,
const JXKeyModifiers& modifiers
)
{
if (itsDragType != kInvalidDrag)
{
JPoint pt = origPt;
// keep col width larger than minimum
if (pt.y < itsDragCellRect.top + itsMinRowHeight)
{
pt.y = itsDragCellRect.top + itsMinRowHeight;
}
// check if we have moved
if (pt.y != itsPrevPt.y)
{
JPainter* p = NULL;
const JBoolean ok = GetDragPainter(&p);
assert( ok );
const JRect enclApG = (GetEnclosure())->GetApertureGlobal();
JRect enclAp = JXContainer::GlobalToLocal(enclApG);
// scroll, if necessary
const JPoint ptG = JXContainer::LocalToGlobal(pt);
const JPoint ptT = JPinInRect(itsTable->JXContainer::GlobalToLocal(ptG),
itsTable->GetBounds());
const JRect tableAp = itsTable->GetAperture();
const JCoordinate x = tableAp.xcenter();
const JRect tableRect(ptT.y-1, x-1, ptT.y+1, x+1);
if (itsTable->ScrollToRect(tableRect))
{
(GetWindow())->Update();
enclAp = JXContainer::GlobalToLocal(enclApG); // local coords changed
}
else
{
// erase the old line
p->Line(enclAp.left, itsPrevPt.y, enclAp.right, itsPrevPt.y);
}
// draw the new line
p->Line(enclAp.left, pt.y, enclAp.right, pt.y);
// ready for next call
itsPrevPt = pt;
}
}
}
void
JXButton::DrawBorder
(
JXWindowPainter& p,
const JRect& origFrame
)
{
JSize borderWidth = GetBorderWidth();
if (borderWidth > 0 && IsActive())
{
JRect frame = origFrame;
if (itsIsReturnButtonFlag)
{
p.JPainter::Rect(frame);
frame.Shrink(1,1);
borderWidth--;
}
if (itsIsPushedFlag)
{
JXDrawDownFrame(p, frame, borderWidth);
}
else
{
JXDrawUpFrame(p, frame, borderWidth);
}
}
else if (borderWidth > 0)
{
p.SetLineWidth(borderWidth);
p.SetPenColor((GetColormap())->GetInactiveLabelColor());
p.RectInside(origFrame);
}
}
void
JXGetStringDialog::BuildWindow
(
const JCharacter* windowTitle,
const JCharacter* prompt,
const JCharacter* initialValue,
const JBoolean password
)
{
// begin JXLayout
JXWindow* window = new JXWindow(this, 310,110, "");
assert( window != NULL );
JXTextButton* okButton =
new JXTextButton(JGetString("okButton::JXGetStringDialog::JXLayout"), window,
JXWidget::kFixedRight, JXWidget::kFixedBottom, 190,80, 60,20);
assert( okButton != NULL );
okButton->SetShortcuts(JGetString("okButton::JXGetStringDialog::shortcuts::JXLayout"));
JXTextButton* cancelButton =
new JXTextButton(JGetString("cancelButton::JXGetStringDialog::JXLayout"), window,
JXWidget::kFixedLeft, JXWidget::kFixedBottom, 60,80, 60,20);
assert( cancelButton != NULL );
cancelButton->SetShortcuts(JGetString("cancelButton::JXGetStringDialog::shortcuts::JXLayout"));
itsInputField =
new JXInputField(window,
JXWidget::kHElastic, JXWidget::kFixedTop, 20,40, 270,20);
assert( itsInputField != NULL );
JXStaticText* promptDisplay =
new JXStaticText(JGetString("promptDisplay::JXGetStringDialog::JXLayout"), window,
JXWidget::kHElastic, JXWidget::kFixedTop, 20,20, 270,20);
assert( promptDisplay != NULL );
promptDisplay->SetToLabel();
// end JXLayout
window->SetTitle(windowTitle);
SetButtons(okButton, cancelButton);
promptDisplay->SetText(prompt);
if (password)
{
const JRect r = itsInputField->GetFrame();
delete itsInputField;
itsInputField =
new JXPasswordInput(window,
JXWidget::kHElastic, JXWidget::kFixedTop,
r.left, r.top, r.width(), r.height());
assert( itsInputField != NULL );
}
else if (!JStringEmpty(initialValue))
{
itsInputField->SetText(initialValue);
}
itsInputField->SetIsRequired();
}
JBoolean
GetEnclosure
(
const JArray<JRect>& rectList,
const JIndex rectIndex,
JIndex* enclIndex
)
{
const JRect theRect = rectList.GetElement(rectIndex);
JBoolean found = kJFalse;
*enclIndex = 0;
JSize minArea = 0;
const JSize count = rectList.GetElementCount();
for (JIndex i=1; i<=count; i++)
{
if (i != rectIndex)
{
const JRect r = rectList.GetElement(i);
const JSize a = r.area();
if (r.Contains(theRect) && (a < minArea || minArea == 0))
{
minArea = a;
found = kJTrue;
*enclIndex = i;
}
}
}
return found;
}
JBoolean
JXEditTable::CreateInputField
(
const JPoint& cell,
const JRect& cellRect
)
{
itsInputField = CreateXInputField(cell, cellRect.left, cellRect.top,
cellRect.width(), cellRect.height());
assert( itsInputField != NULL );
itsInputField->SetTable(this);
itsInputField->SetFocusColor(GetFocusColor());
if (itsEditMenuHandler != NULL && itsEditMenuHandler->HasEditMenu())
{
itsInputField->ShareEditMenu(itsEditMenuHandler, kJFalse, kJFalse);
}
if (itsInputField->Focus())
{
return kJTrue;
}
else
{
DeleteInputField();
return kJFalse;
}
}
void
ResizeWidgetDialog::BuildWindow
(
const JXWidget* widget
)
{
// begin JXLayout
JXWindow* window = new JXWindow(this, 160,120, "");
assert( window != NULL );
JXTextButton* cancelButton =
new JXTextButton(JGetString("cancelButton::ResizeWidgetDialog::JXLayout"), window,
JXWidget::kFixedRight, JXWidget::kFixedTop, 20,90, 50,20);
assert( cancelButton != NULL );
JXTextButton* okButton =
new JXTextButton(JGetString("okButton::ResizeWidgetDialog::JXLayout"), window,
JXWidget::kFixedRight, JXWidget::kFixedTop, 90,90, 50,20);
assert( okButton != NULL );
okButton->SetShortcuts(JGetString("okButton::ResizeWidgetDialog::shortcuts::JXLayout"));
itsWidth =
new JXIntegerInput(window,
JXWidget::kHElastic, JXWidget::kFixedTop, 70,20, 70,20);
assert( itsWidth != NULL );
itsHeight =
new JXIntegerInput(window,
JXWidget::kHElastic, JXWidget::kFixedTop, 70,50, 70,20);
assert( itsHeight != NULL );
JXStaticText* obj1_JXLayout =
new JXStaticText(JGetString("obj1_JXLayout::ResizeWidgetDialog::JXLayout"), window,
JXWidget::kFixedLeft, JXWidget::kFixedTop, 20,20, 50,20);
assert( obj1_JXLayout != NULL );
obj1_JXLayout->SetToLabel();
JXStaticText* obj2_JXLayout =
new JXStaticText(JGetString("obj2_JXLayout::ResizeWidgetDialog::JXLayout"), window,
JXWidget::kFixedLeft, JXWidget::kFixedTop, 20,50, 50,20);
assert( obj2_JXLayout != NULL );
obj2_JXLayout->SetToLabel();
// end JXLayout
window->SetTitle("Change widget size");
SetButtons(okButton, cancelButton);
const JRect r = widget->GetBoundsGlobal();
itsWidth->SetLowerLimit(50);
itsWidth->SetUpperLimit(2000);
itsWidth->SetValue(r.width());
itsHeight->SetLowerLimit(50);
itsHeight->SetUpperLimit(2000);
itsHeight->SetValue(r.height());
}
void JLEDObj::update(JGraphics g, double dx, double dy, JRegion& rgn, double scale) {
JRect rect = getIExtent(dx, dy, scale);
if (value == 0) g.setJColor(bkgnd);
else g.setJColor(color);
if ((rect.width > depth2) && (rect.height > depth2)) {
g.fillJRect(rect.shrink(depth, depth));
} else g.fillJRect(rect);
}
JRect
JXWidget::GetApertureGlobal()
const
{
JRect apG = itsFrameG;
apG.Shrink(itsBorderWidth, itsBorderWidth);
return apG;
}
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;
}
}
void J1DSliderObj::paint(JGraphics g, double dx, double dy, JRegion& rgn, double scale) {
JRect rect = getIExtent(dx, dy, scale);
g.setJColor(moduleColor);
if ((rect.width > depth2+2) && (rect.height > depth2+2)) {
g.draw3DJRect(rect, depth);
g.draw3DJRect(rect.shrink(depth, depth), -1);
} else g.fillJRect(rect);
update(g, dx, dy, rgn, scale);
}
JBoolean
JXWidget::ScrollToRectCentered
(
const JRect& origRect,
const JBoolean forceScroll
)
{
const JRect ap = GetAperture();
if (!forceScroll && ap.Contains(origRect))
{
return kJFalse;
}
JRect r = origRect;
const JCoordinate dw = ap.width() - r.width();
if (dw > 0)
{
r.Shrink(-dw/2, 0);
}
const JCoordinate dh = ap.height() - r.height();
if (dh > 0)
{
r.Shrink(0, -dh/2);
}
return ScrollToRect(r);
}
JXImage::JXImage
(
JXDisplay* display,
Drawable source,
const JRect& rect
)
:
JImage(rect.width(), rect.height(), display->GetColormap())
{
JXImageFromDrawable(display, source, rect);
}
JXImage::JXImage
(
JXDisplay* display,
JXColormap* colormap,
Drawable source,
const JRect& rect
)
:
JImage(rect.width(), rect.height(), colormap)
{
JXImageFromDrawable(display, colormap, source, rect);
}
void
JXTextCheckbox::Draw
(
JXWindowPainter& p,
const JRect& rect
)
{
const JRect bounds = GetBounds();
const JCoordinate y = bounds.ycenter();
// draw button
const JRect boxRect(y - kBoxHalfHeight, kMarginWidth,
y + kBoxHalfHeight, kMarginWidth + kBoxHeight);
const JBoolean drawChecked = DrawChecked();
const JBoolean isActive = IsActive();
if (drawChecked && isActive)
{
JXDrawDownFrame(p, boxRect, kJXDefaultBorderWidth, kJTrue, itsPushedColor);
}
else if (isActive)
{
JXDrawUpFrame(p, boxRect, kJXDefaultBorderWidth, kJTrue, itsNormalColor);
}
else
{
p.SetFilling(kJTrue);
if (drawChecked)
{
p.SetPenColor(itsPushedColor);
}
else
{
p.SetPenColor(itsNormalColor);
}
p.JPainter::Rect(boxRect);
p.SetFilling(kJFalse);
p.SetLineWidth(kJXDefaultBorderWidth);
p.SetPenColor((GetColormap())->GetInactiveLabelColor());
p.RectInside(boxRect);
}
// draw text
JRect textRect = bounds;
textRect.left += 2*kMarginWidth + kBoxHeight;
p.SetFont(itsFontName, itsFontSize, itsFontStyle);
p.String(textRect.left, textRect.top, itsLabel, itsULIndex,
textRect.width(), JPainter::kHAlignLeft,
textRect.height(), JPainter::kVAlignCenter);
}
void
TestWidget::Print
(
JPagePrinter& p
)
{
if (!p.OpenDocument())
{
return;
}
const JCoordinate headerHeight = p.JPainter::GetLineHeight();
const JCoordinate footerHeight = JRound(1.5 * headerHeight);
const JString dateStr = JGetTimeStamp();
JBoolean cancelled = kJFalse;
for (JIndex i=1; i<=3; i++)
{
if (!p.NewPage())
{
cancelled = kJTrue;
break;
}
// draw the header
JRect pageRect = p.GetPageRect();
p.String(pageRect.left, pageRect.top, "testjx TestWidget");
p.String(pageRect.left, pageRect.top, dateStr,
pageRect.width(), JPainter::kHAlignRight);
p.LockHeader(headerHeight);
// draw the footer
pageRect = p.GetPageRect();
const JString pageNumberStr = "Page " + JString(i);
p.String(pageRect.left, pageRect.bottom - footerHeight, pageNumberStr,
pageRect.width(), JPainter::kHAlignCenter,
footerHeight, JPainter::kVAlignBottom);
p.LockFooter(footerHeight);
// draw the page
DrawStuff(p);
}
if (!cancelled)
{
p.CloseDocument();
}
}
void
TestFloatTable::DrawPrintHeader
(
JPagePrinter& p,
const JCoordinate headerHeight
)
{
JRect pageRect = p.GetPageRect();
p.String(pageRect.left, pageRect.top, "testjx NumberTable");
const JString dateStr = JGetTimeStamp();
p.String(pageRect.left, pageRect.top, dateStr,
pageRect.width(), JPainter::kHAlignRight);
}
void
TestFloatTable::DrawPrintFooter
(
JPagePrinter& p,
const JCoordinate footerHeight
)
{
JRect pageRect = p.GetPageRect();
const JString pageNumberStr = "Page " + JString(p.GetPageIndex());
p.String(pageRect.left, pageRect.bottom - footerHeight, pageNumberStr,
pageRect.width(), JPainter::kHAlignCenter,
footerHeight, JPainter::kVAlignBottom);
}
void
CMArray2DTable::DrawPrintHeader
(
JPagePrinter& p,
const JCoordinate headerHeight
)
{
JRect pageRect = p.GetPageRect();
p.String(pageRect.left, pageRect.top, itsArrayDir->GetExpression());
const JString dateStr = JGetTimeStamp();
p.String(pageRect.left, pageRect.top, dateStr,
pageRect.width(), JPainter::kHAlignRight);
}
void
CBSearchDocument::PlaceCmdLineWidgets()
{
CBExecOutputDocument::PlaceCmdLineWidgets();
JXWindow* window = GetWindow();
JXWidget::HSizingOption hSizing;
JXWidget::VSizingOption vSizing;
const JRect frame = GetFileDisplayInfo(&hSizing, &vSizing);
itsIndicator->Place(frame.left, frame.ycenter() - kIndicatorHeight/2);
itsIndicator->SetSize(frame.width(), kIndicatorHeight);
}
void
JXTabGroup::DrawCloseButton
(
const JIndex index,
JXWindowPainter& p,
const JRect& rect
)
{
if (index != itsMouseIndex)
{
return;
}
else if (!TabCanClose(index))
{
itsCloseRect.Set(0,0,0,0);
return;
}
if (itsEdge == kTop || itsEdge == kBottom)
{
itsCloseRect.top = rect.ycenter() - itsCloseImage->GetHeight()/2;
itsCloseRect.bottom = itsCloseRect.top + itsCloseImage->GetHeight();
itsCloseRect.right = rect.right - kCloseMarginWidth;
itsCloseRect.left = itsCloseRect.right - itsCloseImage->GetWidth();
}
else if (itsEdge == kLeft)
{
itsCloseRect.top = rect.top + kCloseMarginWidth;
itsCloseRect.bottom = itsCloseRect.top + itsCloseImage->GetHeight();
itsCloseRect.left = rect.xcenter() - itsCloseImage->GetWidth()/2;
itsCloseRect.right = itsCloseRect.left + itsCloseImage->GetWidth();
}
else // itsEdge == kRight
{
itsCloseRect.bottom = rect.bottom - kCloseMarginWidth;
itsCloseRect.top = itsCloseRect.bottom - itsCloseImage->GetHeight();
itsCloseRect.left = rect.xcenter() - itsCloseImage->GetWidth()/2;
itsCloseRect.right = itsCloseRect.left + itsCloseImage->GetWidth();
}
if (itsClosePushedFlag)
{
p.Image(*itsClosePushedImage, itsClosePushedImage->GetBounds(), itsCloseRect);
}
else
{
p.Image(*itsCloseImage, itsCloseImage->GetBounds(), itsCloseRect);
}
}
