/*************************************************************************
Render text lines.
*************************************************************************/
void MultiLineEditbox::cacheTextLines(const Rect& dest_area)
{
// text is already formatted, we just grab the lines and render them with the required alignment.
Rect drawArea(dest_area);
drawArea.offset(Point(-d_horzScrollbar->getScrollPosition(), -d_vertScrollbar->getScrollPosition()));
Renderer* renderer = System::getSingleton().getRenderer();
const Font* fnt = getFont();
if (fnt)
{
// get layers to use for rendering
float textZ = renderer->getZLayer(4) - renderer->getCurrentZ();
float selZ = renderer->getZLayer(3) - renderer->getCurrentZ();
// calculate final colours to use.
ColourRect colours;
float alpha = getEffectiveAlpha();
colour normalTextCol = d_normalTextColour;
normalTextCol.setAlpha(normalTextCol.getAlpha() * alpha);
colour selectTextCol = d_selectTextColour;
selectTextCol.setAlpha(selectTextCol.getAlpha() * alpha);
colour selectBrushCol = hasInputFocus() ? d_selectBrushColour : d_inactiveSelectBrushColour;
selectBrushCol.setAlpha(selectBrushCol.getAlpha() * alpha);
// Cache font info
const float fLineSpacing = fnt->getLineSpacing ();
// for each formatted line.
for (size_t i = 0; i < d_lines.size(); ++i)
{
Rect lineRect(drawArea);
// Check line is within the dest_area
if ( lineRect.d_top < dest_area.d_bottom && lineRect.d_top + fLineSpacing > dest_area.d_top )
{
const LineInfo& currLine = d_lines[i];
String lineText(d_text.substr(currLine.d_startIdx, currLine.d_length));
// if it is a simple 'no selection area' case
if ((currLine.d_startIdx >= d_selectionEnd) ||
((currLine.d_startIdx + currLine.d_length) <= d_selectionStart) ||
(d_selectionBrush == NULL))
{
colours.setColours(normalTextCol);
// render the complete line.
d_renderCache.cacheText(lineText, fnt, LeftAligned, lineRect, textZ, colours, &dest_area);
}
// we have at least some selection highlighting to do
else
{
// Start of actual rendering section.
String sect;
size_t sectIdx = 0, sectLen;
float selStartOffset = 0.0f, selAreaWidth = 0.0f;
// render any text prior to selected region of line.
if (currLine.d_startIdx < d_selectionStart)
{
// calculate length of text section
sectLen = d_selectionStart - currLine.d_startIdx;
// get text for this section
sect = lineText.substr(sectIdx, sectLen);
sectIdx += sectLen;
// get the pixel offset to the beginning of the selection area highlight.
selStartOffset = fnt->getTextExtent(sect);
// draw this portion of the text
colours.setColours(normalTextCol);
d_renderCache.cacheText(sect, fnt, LeftAligned, lineRect, textZ, colours, &dest_area);
// set position ready for next portion of text
lineRect.d_left += selStartOffset;
}
// calculate the length of the selected section
sectLen = ceguimin(d_selectionEnd - currLine.d_startIdx, currLine.d_length) - sectIdx;
// get the text for this section
sect = lineText.substr(sectIdx, sectLen);
sectIdx += sectLen;
// get the extent to use as the width of the selection area highlight
selAreaWidth = fnt->getTextExtent(sect);
// draw the text for this section
colours.setColours(selectTextCol);
d_renderCache.cacheText(sect, fnt, LeftAligned, lineRect, textZ, colours, &dest_area);
// render any text beyond selected region of line
if (sectIdx < currLine.d_length)
{
// update render position to the end of the selected area.
lineRect.d_left += selAreaWidth;
// calculate length of this section
sectLen = currLine.d_length - sectIdx;
// get the text for this section
sect = lineText.substr(sectIdx, sectLen);
// render the text for this section.
colours.setColours(normalTextCol);
d_renderCache.cacheText(sect, fnt, LeftAligned, lineRect, textZ, colours, &dest_area);
}
// calculate area for the selection brush on this line
lineRect.d_left = drawArea.d_left + selStartOffset;
lineRect.d_right = lineRect.d_left + selAreaWidth;
lineRect.d_bottom = lineRect.d_top + fLineSpacing;
// render the selection area brush for this line
colours.setColours(selectBrushCol);
d_renderCache.cacheImage(*d_selectionBrush, lineRect, selZ, colours, &dest_area);
}
}
// update master position for next line in paragraph.
drawArea.d_top += fLineSpacing;
}
}
}
Setup_Colors::Setup_Colors() :
mSelected(-1)
{
setName(_("Colors"));
mColorBox = new ListBox(userPalette);
mColorBox->addSelectionListener(this);
mScroll = new ScrollArea(mColorBox);
mScroll->setHorizontalScrollPolicy(gcn::ScrollArea::SHOW_NEVER);
mTextPreview = new TextPreview(rawmsg);
mPreview = new BrowserBox(BrowserBox::AUTO_WRAP);
mPreview->setOpaque(false);
// don't do anything with links
mPreview->setLinkHandler(NULL);
mPreviewBox = new ScrollArea(mPreview);
mPreviewBox->setHeight(20);
mPreviewBox->setScrollPolicy(gcn::ScrollArea::SHOW_NEVER,
gcn::ScrollArea::SHOW_NEVER);
mGradTypeLabel = new Label(_("Type:"));
mGradTypeSlider = new Slider(0, 3);
mGradTypeSlider->setWidth(180);
mGradTypeSlider->setActionEventId("slider_grad");
mGradTypeSlider->setValue(0);
mGradTypeSlider->addActionListener(this);
mGradTypeSlider->setEnabled(false);
mGradTypeText = new Label;
std::string longText = _("Static");
if (getFont()->getWidth(_("Pulse")) > getFont()->getWidth(longText))
longText = _("Pulse");
if (getFont()->getWidth(_("Rainbow")) > getFont()->getWidth(longText))
longText = _("Rainbow");
if (getFont()->getWidth(_("Spectrum")) > getFont()->getWidth(longText))
longText = _("Spectrum");
mGradTypeText->setCaption(longText);
mGradDelayLabel = new Label(_("Delay:"));
mGradDelayText = new TextField();
mGradDelayText->setWidth(40);
mGradDelayText->setRange(20, 100);
mGradDelayText->setNumeric(true);
mGradDelayText->setEnabled(false);
mGradDelaySlider = new Slider(20, 100);
mGradDelaySlider->setWidth(180);
mGradDelaySlider->setValue(mGradDelayText->getValue());
mGradDelaySlider->setActionEventId("slider_graddelay");
mGradDelaySlider->addActionListener(this);
mGradDelaySlider->setEnabled(false);
mRedLabel = new Label(_("Red:"));
mRedText = new TextField;
mRedText->setWidth(40);
mRedText->setRange(0, 255);
mRedText->setNumeric(true);
mRedText->setEnabled(false);
mRedSlider = new Slider(0, 255);
mRedSlider->setWidth(180);
mRedSlider->setValue(mRedText->getValue());
mRedSlider->setActionEventId("slider_red");
mRedSlider->addActionListener(this);
mRedSlider->setEnabled(false);
mGreenLabel = new Label(_("Green:"));
mGreenText = new TextField;
mGreenText->setWidth(40);
mGreenText->setRange(0, 255);
mGreenText->setNumeric(true);
mGreenText->setEnabled(false);
mGreenSlider = new Slider(0, 255);
mGreenSlider->setWidth(180);
mGreenSlider->setValue(mGreenText->getValue());
mGreenSlider->setActionEventId("slider_green");
mGreenSlider->addActionListener(this);
mGreenSlider->setEnabled(false);
mBlueLabel = new Label(_("Blue:"));
mBlueText = new TextField;
mBlueText->setWidth(40);
mBlueText->setRange(0, 255);
mBlueText->setNumeric(true);
mBlueText->setEnabled(false);
mBlueSlider = new Slider(0, 255);
mBlueSlider->setWidth(180);
mBlueSlider->setValue(mBlueText->getValue());
mBlueSlider->setActionEventId("slider_blue");
mBlueSlider->addActionListener(this);
mBlueSlider->setEnabled(false);
setOpaque(false);
// Do the layout
LayoutHelper h(this);
ContainerPlacer place = h.getPlacer(0, 0);
place(0, 0, mScroll, 6, 6).setPadding(2);
place(0, 6, mPreviewBox, 6).setPadding(2);
place(0, 7, mGradTypeLabel, 3);
place(3, 7, mGradTypeSlider);
place(4, 7, mGradTypeText, 2).setPadding(1);
place(0, 8, mRedLabel, 3);
place(3, 8, mRedSlider);
place(5, 8, mRedText).setPadding(1);
place(0, 9, mGreenLabel, 3);
place(3, 9, mGreenSlider);
place(5, 9, mGreenText).setPadding(1);
place(0, 10, mBlueLabel, 3);
place(3, 10, mBlueSlider);
place(5, 10, mBlueText).setPadding(1);
place(0, 11, mGradDelayLabel, 3);
place(3, 11, mGradDelaySlider);
place(5, 11, mGradDelayText).setPadding(1);
mGradTypeText->setCaption("");
setDimension(gcn::Rectangle(0, 0, 365, 280));
}
unsigned int getRowHeight() const
{
return 2 * getFont()->getHeight();
}
void MGuiEditText::onEvent(MWinEvent * windowEvent)
{
MGuiWindow * parent = getParentWindow();
MMouse * mouse = MMouse::getInstance();
switch(windowEvent->type)
{
case MWIN_EVENT_MOUSE_WHEEL_MOVE:
case MWIN_EVENT_MOUSE_MOVE:
if(parent->isHighLight() && isMouseInside())
{
setHighLight(true);
if(m_pointerEvent) // send mouse move gui event
{
MGuiEvent guiEvent;
guiEvent.type = MGUI_EVENT_MOUSE_MOVE;
guiEvent.data[0] = windowEvent->data[0];
guiEvent.data[1] = windowEvent->data[1];
m_pointerEvent(this, &guiEvent);
}
// break events
if(parent->breakEvents())
return;
}
else
{
setHighLight(false);
}
if(isPressed() && mouse->isLeftButtonPushed())
{
m_endSelectionId = getFont()->findPointedCharacter(
getText(),
getPosition(),
getTextSize(),
getMouseLocalPosition()
);
autoScrolling();
}
break;
case MWIN_EVENT_MOUSE_BUTTON_DOWN:
if(isHighLight())
{
if(windowEvent->data[0] == MMOUSE_BUTTON_LEFT)
{
// unpress all edit text
unsigned int i;
unsigned int size = parent->getEditTextsNumber();
for(i=0; i<size; i++)
parent->getEditText(i)->setPressed(false);
setPressed(true);
setCharId(
getFont()->findPointedCharacter(
getText(),
getPosition(),
getTextSize(),
getMouseLocalPosition()
)
);
// start select
setSelection(getCharId(), getCharId());
}
if(m_pointerEvent) // send mouse button down gui event
{
MGuiEvent guiEvent;
guiEvent.type = MGUI_EVENT_MOUSE_BUTTON_DOWN;
guiEvent.data[0] = windowEvent->data[0];
m_pointerEvent(this, &guiEvent);
}
}
else
{
if(isPressed() && windowEvent->data[0] == MMOUSE_BUTTON_LEFT)
{
setPressed(false);
sendVariable();
}
}
break;
case MWIN_EVENT_CHAR:
case MWIN_EVENT_KEY_DOWN:
if(isPressed())
{
editText(windowEvent);
autoScrolling();
}
break;
}
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_FreetypeGlyphVector_getGlyphs
(JNIEnv *env, jobject obj, jintArray codepoints, jintArray glyphs,
jlongArray fonts)
{
PangoFcFont *default_font, *current_font;
PangoFontset *pfs;
jint *cpvals;
jint length;
int i;
/* Set up default font and fontset */
default_font = getFont(env, obj);
current_font = default_font;
pfs = getFontSet(env, obj);
/* Retrieve string information */
length = (*env)->GetArrayLength (env, codepoints);
cpvals = (*env)->GetIntArrayElements (env, codepoints, NULL);
jint *glyphArray = (*env)->GetIntArrayElements (env, glyphs, NULL);
jlong *fontArray = (*env)->GetLongArrayElements (env, fonts, NULL);
/* A design goal of Pango is to be threadsafe, but it's admitted that it is
* not actually threadsafe at the moment. Using gdk locking here to be safe,
* but I don't know if if actually helps at all... */
gdk_threads_enter();
for( i = 0; i < length; i++ )
{
/* Ensure the current font has the requested character; if it doesn't,
* try the default font before pulling a new font out of the fontset.
* Once chosen, a font will be used until a character not in the font is
* encountered. */
if (!pango_fc_font_has_char(current_font, cpvals[i]))
{
if (pango_fc_font_has_char(default_font, cpvals[i]))
{
current_font = default_font;
g_object_ref(current_font);
}
else
{
current_font = (PangoFcFont*)pango_fontset_get_font(pfs, cpvals[i]);
}
}
else
{
g_object_ref(current_font);
}
/* Get glyph, and store both glyph and pointer to font */
glyphArray[i] = (int)pango_fc_font_get_glyph(current_font,
(gunichar)cpvals[i]);
fontArray[i] = PTR_TO_JLONG(current_font);
}
gdk_threads_leave();
(*env)->ReleaseIntArrayElements (env, glyphs, glyphArray, 0);
(*env)->ReleaseIntArrayElements (env, codepoints, cpvals, 0);
(*env)->ReleaseLongArrayElements (env, fonts, fontArray, 0);
}
void Window::draw(Graphics* graphics)
{
const Color &faceColor = getBaseColor();
Color highlightColor, shadowColor;
const int alpha = getBaseColor().a;
highlightColor = faceColor + 0x303030;
highlightColor.a = alpha;
shadowColor = faceColor - 0x303030;
shadowColor.a = alpha;
Rectangle d = getChildrenArea();
// Fill the background around the content
graphics->setColor(faceColor);
// Fill top
graphics->fillRectangle(Rectangle(0,0,getWidth(),d.y - 1));
// Fill left
graphics->fillRectangle(Rectangle(0,d.y - 1, d.x - 1, getHeight() - d.y + 1));
// Fill right
graphics->fillRectangle(Rectangle(d.x + d.width + 1,
d.y - 1,
getWidth() - d.x - d.width - 1,
getHeight() - d.y + 1));
// Fill bottom
graphics->fillRectangle(Rectangle(d.x - 1,
d.y + d.height + 1,
d.width + 2,
getHeight() - d.height - d.y - 1));
if (isOpaque())
{
graphics->fillRectangle(d);
}
// Construct a rectangle one pixel bigger than the content
d.x -= 1;
d.y -= 1;
d.width += 2;
d.height += 2;
// Draw a border around the content
graphics->setColor(shadowColor);
// Top line
graphics->drawLine(d.x,
d.y,
d.x + d.width - 2,
d.y);
// Left line
graphics->drawLine(d.x,
d.y + 1,
d.x,
d.y + d.height - 1);
graphics->setColor(highlightColor);
// Right line
graphics->drawLine(d.x + d.width - 1,
d.y,
d.x + d.width - 1,
d.y + d.height - 2);
// Bottom line
graphics->drawLine(d.x + 1,
d.y + d.height - 1,
d.x + d.width - 1,
d.y + d.height - 1);
drawChildren(graphics);
int textX;
int textY;
textY = ((int)getTitleBarHeight() - getFont()->getHeight()) / 2;
switch (getAlignment())
{
case Graphics::LEFT:
textX = 4;
break;
case Graphics::CENTER:
textX = getWidth() / 2;
break;
case Graphics::RIGHT:
textX = getWidth() - 4;
break;
default:
throw GCN_EXCEPTION("Unknown alignment.");
}
graphics->setColor(getForegroundColor());
graphics->setFont(getFont());
graphics->pushClipArea(Rectangle(0, 0, getWidth(), getTitleBarHeight() - 1));
graphics->drawText(getCaption(), textX, textY, getAlignment());
graphics->popClipArea();
}
void ItemShortcutContainer::draw(gcn::Graphics *graphics)
{
if (config.getValue("guialpha", 0.8) != mAlpha)
{
mAlpha = config.getValue("guialpha", 0.8);
mBackgroundImg->setAlpha(mAlpha);
}
Graphics *g = static_cast<Graphics*>(graphics);
graphics->setFont(getFont());
for (int i = 0; i < mMaxItems; i++)
{
const int itemX = (i % mGridWidth) * mBoxWidth;
const int itemY = (i / mGridWidth) * mBoxHeight;
g->drawImage(mBackgroundImg, itemX, itemY);
// Draw item keyboard shortcut.
const std::string key = keyboard.keyString(keyboard.KEY_SHORTCUT_1 + i);
graphics->setColor(guiPalette->getColor(Palette::TEXT));
g->drawText(key, itemX + 2, itemY + 2, gcn::Graphics::LEFT);
if (itemShortcut->getItem(i) < 0)
continue;
Item *item =
player_node->getInventory()->findItem(itemShortcut->getItem(i));
if (item)
{
// Draw item icon.
Image* image = item->getImage();
if (image)
{
std::string caption;
if (item->getQuantity() > 1)
caption = toString(item->getQuantity());
else if (item->isEquipped())
caption = "Eq.";
g->drawImage(image, itemX, itemY);
if (item->isEquipped())
g->setColor(guiPalette->getColor(Palette::ITEM_EQUIPPED));
g->drawText(caption, itemX + mBoxWidth / 2,
itemY + mBoxHeight - 14, gcn::Graphics::CENTER);
}
}
}
if (mItemMoved)
{
// Draw the item image being dragged by the cursor.
Image* image = mItemMoved->getImage();
if (image)
{
const int tPosX = mCursorPosX - (image->getWidth() / 2);
const int tPosY = mCursorPosY - (image->getHeight() / 2);
g->drawImage(image, tPosX, tPosY);
g->drawText(toString(mItemMoved->getQuantity()),
tPosX + mBoxWidth / 2, tPosY + mBoxHeight - 14,
gcn::Graphics::CENTER);
}
}
}
static int
getMathKernAt(int f, int g, MathKernSide side, int height)
{
int rval = 0;
if (fontarea[f] == OTGR_FONT_FLAG) {
XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]);
const char* table = font->getMathTable();
if (table == NULL)
return rval;
uint16_t offset = SWAP(((const MathTableHeader*)table)->mathGlyphInfo);
if (offset == 0)
return rval;
const MathGlyphInfo* glyphInfo = (const MathGlyphInfo*)(table + offset);
offset = SWAP(glyphInfo->mathKernInfo);
if (offset == 0)
return rval;
const MathKernInfo* mathKernInfo = (const MathKernInfo*)(((const char*)glyphInfo) + offset);
offset = SWAP(mathKernInfo->coverage);
if (offset == 0)
return rval;
const Coverage* coverage = (const Coverage*)(((const char*)mathKernInfo) + offset);
int32_t index = getCoverage(coverage, g);
if (index >= 0 && index < SWAP(mathKernInfo->kernInfoCount)) {
if (side == topRight)
offset = SWAP(mathKernInfo->kernInfo[index].topRight);
else if (side == bottomRight)
offset = SWAP(mathKernInfo->kernInfo[index].bottomRight);
else if (side == topLeft)
offset = SWAP(mathKernInfo->kernInfo[index].topLeft);
else if (side == bottomLeft)
offset = SWAP(mathKernInfo->kernInfo[index].bottomLeft);
else
assert(0); // we should not reach here
if (offset == 0)
return rval;
const MathKernTable* kernTable = (const MathKernTable*)(((const char*)mathKernInfo) + offset);
uint16_t count = SWAP(kernTable->heightCount);
// kern[] array immediately follows the height[] array with |count| elements
const MathValueRecord* kern = &kernTable->height[0] + count;
if (count == 0 || height < SWAP(kernTable->height[0].value))
rval = SWAP(kern[0].value);
else {
rval = SWAP(kern[count].value);
for (int i = 0; i < count; i++) {
if (height <= SWAP(kernTable->height[i].value)) {
rval = SWAP(kern[i].value);
break;
}
}
}
}
}
return rval;
}
void ClickLabel::setCaption(const std::string& caption) {
mCaption = caption;
mGuiFont = static_cast<FIFE::GuiFont*> (getFont());
wrapText();
}
BOOL RegistryFont::load(const LOGFONT * def /* = NULL*/)
{
return getFont(id, value, def, root);
} // RegistryFont::load
void TextField::adjustHeight()
{
setHeight(getFont()->getHeight() + 4);
}
/** Constructor */
PeersDialog::PeersDialog(QWidget *parent)
: RsAutoUpdatePage(1000,parent),
historyKeeper(Rshare::dataDirectory() + "/his1.xml")
{
/* Invoke the Qt Designer generated object setup routine */
ui.setupUi(this);
connect( ui.peertreeWidget, SIGNAL( customContextMenuRequested( QPoint ) ), this, SLOT( peertreeWidgetCostumPopupMenu( QPoint ) ) );
connect( ui.peertreeWidget, SIGNAL( itemDoubleClicked ( QTreeWidgetItem *, int)), this, SLOT(chatfriend()));
/* hide the Tree +/- */
ui.peertreeWidget -> setRootIsDecorated( false );
/* Set header resize modes and initial section sizes */
QHeaderView * _header = ui.peertreeWidget->header () ;
_header->setResizeMode (0, QHeaderView::Custom);
_header->setResizeMode (1, QHeaderView::Interactive);
_header->setResizeMode (2, QHeaderView::Interactive);
/*_header->setResizeMode (3, QHeaderView::Interactive);
_header->setResizeMode (4, QHeaderView::Interactive);
_header->setResizeMode (5, QHeaderView::Interactive);
_header->setResizeMode (6, QHeaderView::Interactive);
_header->setResizeMode (7, QHeaderView::Interactive);*/
_header->resizeSection ( 0, 25 );
_header->resizeSection ( 1, 100 );
_header->resizeSection ( 2, 100 );
/*_header->resizeSection ( 3, 120 );
_header->resizeSection ( 4, 100 );
_header->resizeSection ( 5, 230 );
_header->resizeSection ( 6, 120 );
_header->resizeSection ( 7, 220 );*/
// set header text aligment
QTreeWidgetItem * headerItem = ui.peertreeWidget->headerItem();
headerItem->setTextAlignment(0, Qt::AlignHCenter | Qt::AlignVCenter);
headerItem->setTextAlignment(1, Qt::AlignHCenter | Qt::AlignVCenter);
headerItem->setTextAlignment(2, Qt::AlignHCenter | Qt::AlignVCenter);
loadEmoticonsgroupchat();
//setWindowIcon(QIcon(QString(":/images/rstray3.png")));
connect(ui.lineEdit, SIGNAL(textChanged ( ) ), this, SLOT(checkChat( ) ));
connect(ui.Sendbtn, SIGNAL(clicked()), this, SLOT(sendMsg()));
connect(ui.emoticonBtn, SIGNAL(clicked()), this, SLOT(smileyWidgetgroupchat()));
//connect( ui.msgSendList, SIGNAL( customContextMenuRequested( QPoint ) ), this, SLOT( msgSendListCostumPopupMenu( QPoint ) ) );
connect( ui.msgText, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(displayInfoChatMenu(const QPoint&)));
connect(ui.textboldChatButton, SIGNAL(clicked()), this, SLOT(setFont()));
connect(ui.textunderlineChatButton, SIGNAL(clicked()), this, SLOT(setFont()));
connect(ui.textitalicChatButton, SIGNAL(clicked()), this, SLOT(setFont()));
connect(ui.fontsButton, SIGNAL(clicked()), this, SLOT(getFont()));
connect(ui.colorChatButton, SIGNAL(clicked()), this, SLOT(setColor()));
ui.fontsButton->setIcon(QIcon(QString(":/images/fonts.png")));
_currentColor = Qt::black;
QPixmap pxm(16,16);
pxm.fill(_currentColor);
ui.colorChatButton->setIcon(pxm);
mCurrentFont = QFont("Comic Sans MS", 12);
ui.lineEdit->setFont(mCurrentFont);
setChatInfo(tr("Welcome to RetroShare's group chat."),
QString::fromUtf8("blue"));
QStringList him;
historyKeeper.getMessages(him, "", "THIS", 8);
foreach(QString mess, him)
ui.msgText->append(mess);
//setChatInfo(mess, "green");
QMenu * grpchatmenu = new QMenu();
grpchatmenu->addAction(ui.actionClearChat);
ui.menuButton->setMenu(grpchatmenu);
_underline = false;
QTimer *timer = new QTimer(this);
timer->connect(timer, SIGNAL(timeout()), this, SLOT(insertChat()));
timer->start(500); /* half a second */
ui.peertreeWidget->sortItems( 1, Qt::AscendingOrder );
/* Hide platform specific features */
#ifdef Q_WS_WIN
#endif
}
QFont SimpleFontDialog::getFont(bool* ok, QWidget* parent)
{
return getFont(ok, QFont(), parent);
}
/*************************************************************************
Format the text into lines as needed by the current formatting options.
*************************************************************************/
void MultiLineEditbox::formatText(void)
{
// clear old formatting data
d_lines.clear();
d_widestExtent = 0.0f;
String paraText;
const Font* fnt = getFont();
if (fnt != NULL)
{
float areaWidth = getTextRenderArea().getWidth();
String::size_type currPos = 0;
String::size_type paraLen;
LineInfo line;
while (currPos < d_text.length())
{
if ((paraLen = d_text.find_first_of(d_lineBreakChars, currPos)) == String::npos)
{
paraLen = d_text.length() - currPos;
}
else
{
++paraLen -= currPos;
}
paraText = d_text.substr(currPos, paraLen);
if (!d_wordWrap || (areaWidth <= 0.0f))
{
// no word wrapping, so we are just one long line.
line.d_startIdx = currPos;
line.d_length = paraLen;
line.d_extent = fnt->getTextExtent(paraText);
d_lines.push_back(line);
// update widest, if needed.
if (line.d_extent > d_widestExtent)
{
d_widestExtent = line.d_extent;
}
}
// must word-wrap the paragraph text
else
{
String::size_type lineIndex = 0;
// while there is text in the string
while (lineIndex < paraLen)
{
String::size_type lineLen = 0;
float lineExtent = 0.0f;
// loop while we have not reached the end of the paragraph string
while (lineLen < (paraLen - lineIndex))
{
// get cp / char count of next token
size_t nextTokenSize = getNextTokenLength(paraText, lineIndex + lineLen);
// get pixel width of the token
float tokenExtent = fnt->getTextExtent(paraText.substr(lineIndex + lineLen, nextTokenSize));
// would adding this token would overflow the available width
if ((lineExtent + tokenExtent) > areaWidth)
{
// Was this the first token?
if (lineLen == 0)
{
// get point at which to break the token
lineLen = fnt->getCharAtPixel(paraText.substr(lineIndex, nextTokenSize), areaWidth);
}
// text wraps, exit loop early with line info up until wrap point
break;
}
// add this token to current line
lineLen += nextTokenSize;
lineExtent += tokenExtent;
}
// set up line info and add to collection
line.d_startIdx = currPos + lineIndex;
line.d_length = lineLen;
line.d_extent = lineExtent;
d_lines.push_back(line);
// update widest, if needed.
if (lineExtent > d_widestExtent)
{
d_widestExtent = lineExtent;
}
// update position in string
lineIndex += lineLen;
}
}
// skip to next 'paragraph' in text
currPos += paraLen;
}
}
configureScrollbars();
requestRedraw();
}
void EquipmentWindow::draw(gcn::Graphics *graphics)
{
// Draw window graphics
Window::draw(graphics);
Item* item;
graphics->pushClipArea(getChildrenArea());
// A bitmask showing which slots will be affected
// by the equip / unequip button.
int highlightSlots = 0;
if (mSelected != -1)
highlightSlots = (1 << mSelected);
Item* wouldEquip = mItems->getSelectedItem();
if (wouldEquip)
highlightSlots |= wouldEquip->getInfo().getEquipSlots();
for (int i = EQUIP_LEGS_SLOT; i < EQUIP_VECTOREND; i++)
{
const gcn::Rectangle &rect = mEquipIcon[i]->getDimension();
if (highlightSlots & (1 << i))
{
const gcn::Color color = guiPalette->getColor(Palette::HIGHLIGHT);
// Set color to the highligh color
graphics->setColor(gcn::Color(color.r, color.g, color.b, getGuiAlpha()));
graphics->fillRectangle(rect);
}
// Set color black.
graphics->setColor(gcn::Color(0, 0, 0));
// Draw box border.
graphics->drawRectangle(rect);
item = (i != EQUIP_AMMO_SLOT) ?
mInventory->getItem(mEquipment->getEquipment(i)) :
mInventory->getItem(mEquipment->getArrows());
if (item)
{
// Draw Item.
Image* image = item->getImage();
if (image != mEquipIcon[i]->getImage())
mEquipIcon[i]->setImage(image);
if (i == EQUIP_AMMO_SLOT)
{
graphics->setColor(guiPalette->getColor(Palette::TEXT));
graphics->drawText(toString(item->getQuantity()),
mEquipIcon[i]->getX() + (mEquipIcon[i]->getWidth() / 2),
mEquipIcon[i]->getY() - getFont()->getHeight(),
gcn::Graphics::CENTER);
}
}
else if (mEquipIcon[i]->getImage())
mEquipIcon[i]->setImage(NULL);
}
graphics->popClipArea();
Window::drawChildren(graphics);
}
void SpellShortcutContainer::draw(Graphics *const graphics)
{
if (spellShortcut == nullptr)
return;
BLOCK_START("SpellShortcutContainer::draw")
if (settings.guiAlpha != mAlpha)
{
mAlpha = settings.guiAlpha;
if (mBackgroundImg != nullptr)
mBackgroundImg->setAlpha(mAlpha);
}
Font *const font = getFont();
const int selectedId = spellShortcut->getSelectedItem();
graphics->setColor(mForegroundColor);
drawBackground(graphics);
// +++ in future need reorder images and string drawing.
for (unsigned i = 0; i < mMaxItems; i++)
{
const int itemX = (i % mGridWidth) * mBoxWidth;
const int itemY = (i / mGridWidth) * mBoxHeight;
const int itemId = getItemByIndex(i);
if (selectedId >= 0 && itemId == selectedId)
{
graphics->drawRectangle(Rect(itemX + 1, itemY + 1,
mBoxWidth - 1, mBoxHeight - 1));
}
if (spellManager == nullptr)
continue;
const TextCommand *const spell = spellManager->getSpell(itemId);
if (spell != nullptr)
{
if (!spell->isEmpty())
{
Image *const image = spell->getImage();
if (image != nullptr)
{
image->setAlpha(1.0F);
graphics->drawImage(image,
itemX + mImageOffsetX,
itemY + mImageOffsetY);
}
}
font->drawString(graphics,
mForegroundColor,
mForegroundColor2,
spell->getSymbol(),
itemX + mTextOffsetX,
itemY + mTextOffsetY);
}
}
BLOCK_END("SpellShortcutContainer::draw")
}
EquipmentWindow::EquipmentWindow():
Window(_("Equipment")),
mSelected(-1)
{
setWindowName("Equipment");
setResizable(true);
setCloseButton(true);
setMinWidth(280);
setMinHeight(300);
setDefaultSize(280, 300, ImageRect::CENTER);
if (mInstances == 0)
{
mConfigListener = new EquipmentConfigListener();
config.addListener("showItemPopups", mConfigListener);
mShowItemInfo = config.getValue("showItemPopups", true);
mItemPopup = new ItemPopup();
mItemPopup->setOpaque(false);
mPopupMenu = new PopupMenu(INVENTORY);
}
mInstances++;
// Control that shows the Player
mBeingBox = new BeingBox();
mBeingBox->setDimension(gcn::Rectangle(50, 80, 74, 123));
mBeingBox->setBeing(player_node);
mEquipment = player_node->mEquipment.get();
mInventory = player_node->getInventory();
// Control that shows equippable items
mItems = new ItemContainer(mInventory, "showpopupmenu", this);
mItems->setEquipSlotsFilter((1 << EQUIP_VECTOREND) - 1);
mItems->addSelectionListener(this);
mInvenScroll = new ScrollArea(mItems);
mInvenScroll->setHorizontalScrollPolicy(gcn::ScrollArea::SHOW_NEVER);
std::string longestUseString = getFont()->getWidth(_("Equip")) >
getFont()->getWidth(_("Unequip")) ?
_("Equip") : _("Unequip");
mEquipButton = new Button(longestUseString, "equip", this);
mEquipButton->setEnabled(false);
for (int i = EQUIP_LEGS_SLOT; i < EQUIP_VECTOREND; i++)
{
mEquipIcon[i] = new Icon(NULL, true);
mEquipIcon[i]->setX(boxPosition[i][0]);
mEquipIcon[i]->setY(boxPosition[i][1]);
mEquipIcon[i]->setWidth(BOX_WIDTH);
mEquipIcon[i]->setHeight(BOX_HEIGHT);
add(mEquipIcon[i]);
}
add(mBeingBox);
add(mInvenScroll);
add(mEquipButton);
loadWindowState();
}
static int
getMathKernAt(int f, int g, MathKernSide side, int height)
{
int rval = 0;
if (fontarea[f] == OTGR_FONT_FLAG) {
XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]);
const char* table = font->getMathTable();
if (table == NULL)
return rval;
uint16_t offset = SWAP(((const MathTableHeader*)table)->mathGlyphInfo);
if (offset == 0)
return rval;
const MathGlyphInfo* glyphInfo = (const MathGlyphInfo*)(table + offset);
offset = SWAP(glyphInfo->mathKernInfo);
if (offset == 0)
return rval;
const MathKernInfo* mathKernInfo = (const MathKernInfo*)(((const char*)glyphInfo) + offset);
offset = SWAP(mathKernInfo->coverage);
if (offset == 0)
return rval;
const Coverage* coverage = (const Coverage*)(((const char*)mathKernInfo) + offset);
int32_t index = getCoverage(coverage, g);
if (index >= 0 && index < SWAP(mathKernInfo->kernInfoCount)) {
if (side == topRight)
offset = SWAP(mathKernInfo->kernInfo[index].topRight);
else if (side == bottomRight)
offset = SWAP(mathKernInfo->kernInfo[index].bottomRight);
else if (side == topLeft)
offset = SWAP(mathKernInfo->kernInfo[index].topLeft);
else if (side == bottomLeft)
offset = SWAP(mathKernInfo->kernInfo[index].bottomLeft);
else
assert(0); // we should not reach here
if (offset == 0)
return rval;
const MathKernTable* kernTable = (const MathKernTable*)(((const char*)mathKernInfo) + offset);
uint16_t count = SWAP(kernTable->heightCount);
// XXX: the following makes no sense WRT my understanding of the
// spec! it is just how things worked for me.
if (count == 0)
rval = SWAP(kernTable->kern[-1].value);
else if (height < SWAP(kernTable->height[0].value))
rval = SWAP(kernTable->kern[1].value);
else if (height > SWAP(kernTable->height[count].value))
rval = SWAP(kernTable->kern[count+1].value);
else {
for (int i = 0; i < count; i++) {
if (height > SWAP(kernTable->height[i].value)) {
rval = SWAP(kernTable->kern[i+1].value);
break;
}
}
}
//fprintf(stderr, " kern: %f %f\n", font->unitsToPoints(height), font->unitsToPoints(rval));
}
}
return rval;
}
void FontManager::setFont(const char *filename) {
_currentFont = getFont(filename);
}
//----------------------------------------------------------------------------//
void TreeItem::parseTextString() const
{
d_renderedString =
d_stringParser.parse(getTextVisual(), const_cast<Font*>(getFont()), &d_textCols);
d_renderedStringValid = true;
}
void TextUIDrawObject::draw(const GraphicsWeakPtr Graphics, Real32 Opacity) const
{
Graphics->drawText(getPosition(), getText(), getFont(), getColor(), getOpacity()*Opacity);
}
void Button::draw(Graphics* graphics)
{
Color faceColor = getBaseColor();
Color highlightColor, shadowColor;
int alpha = getBaseColor().a;
if (isPressed())
{
faceColor = faceColor - 0x303030;
faceColor.a = alpha;
highlightColor = faceColor - 0x303030;
highlightColor.a = alpha;
shadowColor = faceColor + 0x303030;
shadowColor.a = alpha;
}
else
{
highlightColor = faceColor + 0x303030;
highlightColor.a = alpha;
shadowColor = faceColor - 0x303030;
shadowColor.a = alpha;
}
graphics->setColor(faceColor);
graphics->fillRectangle(Rectangle(1, 1, getDimension().width-1, getHeight() - 1));
graphics->setColor(highlightColor);
graphics->drawLine(0, 0, getWidth() - 1, 0);
graphics->drawLine(0, 1, 0, getHeight() - 1);
graphics->setColor(shadowColor);
graphics->drawLine(getWidth() - 1, 1, getWidth() - 1, getHeight() - 1);
graphics->drawLine(1, getHeight() - 1, getWidth() - 1, getHeight() - 1);
graphics->setColor(getForegroundColor());
int textX;
int textY = getHeight() / 2 - getFont()->getHeight() / 2;
switch (getAlignment())
{
case Graphics::LEFT:
textX = mSpacing;
break;
case Graphics::CENTER:
textX = getWidth() / 2;
break;
case Graphics::RIGHT:
textX = getWidth() - mSpacing;
break;
default:
throw GCN_EXCEPTION("Unknown alignment.");
}
graphics->setFont(getFont());
if (isPressed())
{
graphics->drawText(getCaption(), textX + 1, textY + 1, getAlignment());
}
else
{
graphics->drawText(getCaption(), textX, textY, getAlignment());
if (isFocused())
{
graphics->drawRectangle(Rectangle(2, 2, getWidth() - 4,
getHeight() - 4));
}
}
}
void MGuiEditText::draw(void)
{
MRenderingContext * render = MGui::getInstance()->getRenderingContext();
if(! isVisible())
return;
if(! isPressed())
updateFromVariable();
// draw selection
if(isPressed())
{
render->disableTexture();
render->setColor4(MVector4(1, 0.1f, 0.1f, 0.3f));
getFont()->drawSelection(getText(), getPosition(), getTextSize(), m_startSelectionId, m_endSelectionId);
}
// set text color
if(isPressed()){
render->setColor4(getPressedColor());
}
else if(isHighLight()){
render->setColor4(getHighLightColor());
}
else{
render->setColor4(getNormalColor());
}
// draw text
render->enableTexture();
getFont()->draw(getText(), getPosition(), getTextSize());
if(isPressed() && (m_startSelectionId == m_endSelectionId)) // cursor
{
render->disableTexture();
render->setColor4(MVector4(1, 0, 0, 0.5f));
// position
MVector2 position = getFont()->getCharacterPosition(
getText(),
getPosition(),
getTextSize(),
getCharId()
);
// scale
MVector2 scale = MVector2(getTextSize() * 0.1f, getTextSize());
float offset = (getTextSize() - (getTextSize()*getFont()->getSpace()))*0.5f;
float px = (float)((int)(position.x + offset));
float py = (float)((int)position.y);
// draw
render->disableNormalArray();
render->disableTexCoordArray();
render->disableColorArray();
render->enableVertexArray();
MVector2 vertices[4] = {
MVector2(px, py),
MVector2(px, py + scale.y),
MVector2(px + scale.x, py),
MVector2(px + scale.x, py + scale.y)
};
render->setVertexPointer(M_FLOAT, 2, vertices);
render->drawArray(M_PRIMITIVE_TRIANGLE_STRIP, 0, 4);
}
MGuiEvent guiEvent;
guiEvent.type = MGUI_EVENT_DRAW;
if(m_pointerEvent)
m_pointerEvent(this, &guiEvent);
}
void Button::adjustSize()
{
setWidth(getFont()->getWidth(mCaption) + 2*mSpacing);
setHeight(getFont()->getHeight() + 2*mSpacing);
}
void UaeListBox::draw(Graphics* graphics)
{
graphics->setColor(getBackgroundColor());
graphics->fillRectangle(Rectangle(0, 0, getWidth(), getHeight()));
if (mListModel == NULL)
{
return;
}
graphics->setColor(getForegroundColor());
graphics->setFont(getFont());
// Check the current clip area so we don't draw unnecessary items
// that are not visible.
const ClipRectangle currentClipArea = graphics->getCurrentClipArea();
int rowHeight = getRowHeight();
// Calculate the number of rows to draw by checking the clip area.
// The addition of two makes covers a partial visible row at the top
// and a partial visible row at the bottom.
int numberOfRows = currentClipArea.height / rowHeight + 2;
if (numberOfRows > mListModel->getNumberOfElements())
{
numberOfRows = mListModel->getNumberOfElements();
}
// Calculate which row to start drawing. If the list box
// has a negative y coordinate value we should check if
// we should drop rows in the begining of the list as
// they might not be visible. A negative y value is very
// common if the list box for instance resides in a scroll
// area and the user has scrolled the list box downwards.
int startRow;
if (getY() < 0)
{
startRow = -1 * (getY() / rowHeight);
}
else
{
startRow = 0;
}
int i;
// The y coordinate where we start to draw the text is
// simply the y coordinate multiplied with the font height.
int y = rowHeight * startRow;
for (i = startRow; i < startRow + numberOfRows; ++i)
{
if (i == mSelected)
{
if(isFocused())
graphics->setColor(getSelectionColor());
else
graphics->setColor(0xd0d0d0);
graphics->fillRectangle(Rectangle(0, y, getWidth(), rowHeight));
graphics->setColor(getForegroundColor());
}
// If the row height is greater than the font height we
// draw the text with a center vertical alignment.
if (rowHeight > getFont()->getHeight())
{
graphics->drawText(mListModel->getElementAt(i), 1, y + rowHeight / 2 - getFont()->getHeight() / 2);
}
else
{
graphics->drawText(mListModel->getElementAt(i), 1, y);
}
y += rowHeight;
}
}
/*!
Executes a modal font dialog and returns a font.
If the user clicks OK, the selected font is returned. If the user
clicks Cancel, the \a initial font is returned.
The dialog is called \a name, with the parent \a parent.
\a initial is the initially selected font.
If the \a ok parameter is not-null, \e *\a ok is set to TRUE if the
user clicked OK, and set to FALSE if the user clicked Cancel.
This static function is less flexible than the full QFontDialog
object, but is convenient and easy to use.
Examples:
\code
bool ok;
QFont font = QFontDialog::getFont( &ok, QFont( "Times", 12 ), this );
if ( ok ) {
// font is set to the font the user selected
} else {
// the user canceled the dialog; font is set to the initial
// value, in this case Times, 12.
}
\endcode
The dialog can also be used to set a widget's font directly:
\code
myWidget.setFont( QFontDialog::getFont( 0, myWidget.font() ) );
\endcode
In this example, if the user clicks OK the font they chose will be
used, and if they click Cancel the original font is used.
*/
QFont QFontDialog::getFont( bool *ok, const QFont &initial,
QWidget *parent, const char* name)
{
return getFont( ok, &initial, parent, name );
}
void BeingPopup::show(const int x, const int y, Being *const b)
{
if (!b)
{
setVisible(false);
return;
}
Label *label1 = mBeingParty;
Label *label2 = mBeingGuild;
Label *label3 = mBeingRank;
Label *label4 = mBeingBuyBoard;
Label *label5 = mBeingSellBoard;
Label *label6 = mBeingComment;
Label *label7 = mBeingRoom;
b->updateComment();
if (b->getType() == ActorType::Npc && b->getComment().empty())
{
setVisible(false);
return;
}
mBeingName->setCaption(b->getName() + b->getGenderSignWithSpace());
if (gui)
{
if (player_relations.isGoodName(b))
mBeingName->setFont(boldFont);
else
mBeingName->setFont(gui->getSecureFont());
}
if (b->isAdvanced())
{
mBeingName->setForegroundColorAll(getThemeColor(
Theme::PLAYER_ADVANCED), getThemeColor(
Theme::PLAYER_ADVANCED_OUTLINE));
}
else
{
mBeingName->setForegroundColorAll(getThemeColor(Theme::POPUP),
getThemeColor(Theme::POPUP_OUTLINE));
}
mBeingName->adjustSize();
label1->setCaption("");
label2->setCaption("");
label3->setCaption("");
label4->setCaption("");
label5->setCaption("");
label6->setCaption("");
label7->setCaption("");
#ifdef EATHENA_SUPPORT
const ActorType::Type type = b->getType();
if (type == ActorType::Pet)
{
PetInfo *const info = PlayerInfo::getPet();
if (info)
{
// TRANSLATORS: being popup label
label1->setCaption(strprintf(_("Hungry: %d"),
info->hungry));
label1->adjustSize();
// TRANSLATORS: being popup label
label2->setCaption(strprintf(_("Intimacy: %d"),
info->intimacy));
label2->adjustSize();
label3 = nullptr;
label4 = nullptr;
label5 = nullptr;
label6 = nullptr;
label7 = nullptr;
}
}
else if (type == ActorType::Homunculus)
{
HomunculusInfo *const info = PlayerInfo::getHomunculus();
if (info)
{
// TRANSLATORS: being popup label
label1->setCaption(strprintf(_("Hungry: %d"),
info->hungry));
label1->adjustSize();
// TRANSLATORS: being popup label
label2->setCaption(strprintf(_("Intimacy: %d"),
info->intimacy));
label2->adjustSize();
label3 = nullptr;
label4 = nullptr;
label5 = nullptr;
label6 = nullptr;
label7 = nullptr;
}
}
else
#endif
{
if (!(b->getPartyName().empty()))
{
// TRANSLATORS: being popup label
label1->setCaption(strprintf(_("Party: %s"),
b->getPartyName().c_str()));
label1->adjustSize();
}
else
{
label7 = label6;
label6 = label5;
label5 = label4;
label4 = label3;
label3 = label2;
label2 = label1;
label1 = nullptr;
}
if (!(b->getGuildName().empty()))
{
// TRANSLATORS: being popup label
label2->setCaption(strprintf(_("Guild: %s"),
b->getGuildName().c_str()));
label2->adjustSize();
}
else
{
label7 = label6;
label6 = label5;
label5 = label4;
label4 = label3;
label3 = label2;
label2 = nullptr;
}
if (b->getPvpRank() > 0)
{
// TRANSLATORS: being popup label
label3->setCaption(strprintf(_("Pvp rank: %u"),
b->getPvpRank()));
label3->adjustSize();
}
else
{
label7 = label6;
label6 = label5;
label5 = label4;
label4 = label3;
label3 = nullptr;
}
if (!b->getBuyBoard().empty())
{
// TRANSLATORS: being popup label
label4->setCaption(strprintf(_("Buy shop: %s"),
b->getBuyBoard().c_str()));
label4->adjustSize();
}
else
{
label7 = label6;
label6 = label5;
label5 = label4;
label4 = nullptr;
}
if (!b->getSellBoard().empty())
{
// TRANSLATORS: being popup label
label5->setCaption(strprintf(_("Sell shop: %s"),
b->getSellBoard().c_str()));
label5->adjustSize();
}
else
{
label7 = label6;
label6 = label5;
label5 = nullptr;
}
if (!b->getComment().empty())
{
// TRANSLATORS: being popup label
label6->setCaption(strprintf(_("Comment: %s"),
b->getComment().c_str()));
label6->adjustSize();
}
else
{
label7 = label6;
label6 = nullptr;
}
#ifdef EATHENA_SUPPORT
const ChatObject *const chat = b->getChat();
if (chat)
{
// TRANSLATORS: being popup label
label7->setCaption(strprintf(_("Chat room: %s"),
chat->title.c_str()));
label7->adjustSize();
}
else
{
label7 = nullptr;
}
#endif
}
int minWidth = mBeingName->getWidth();
if (label1 && label1->getWidth() > minWidth)
minWidth = label1->getWidth();
if (label2 && label2->getWidth() > minWidth)
minWidth = label2->getWidth();
if (label3 && label3->getWidth() > minWidth)
minWidth = label3->getWidth();
if (label4 && label4->getWidth() > minWidth)
minWidth = label4->getWidth();
if (label5 && label5->getWidth() > minWidth)
minWidth = label5->getWidth();
if (label6 && label6->getWidth() > minWidth)
minWidth = label6->getWidth();
if (label7 && label7->getWidth() > minWidth)
minWidth = label7->getWidth();
const int height1 = getFont()->getHeight();
int height = height1;
if (label1)
height += height1;
if (label2)
height += height1;
if (label3)
height += height1;
if (label4)
height += height1;
if (label5)
height += height1;
if (label6)
height += height1;
if (label7)
height += height1;
setContentSize(minWidth, height);
position(x, y);
return;
}
/*!
\overload
Executes a modal font dialog and returns a font.
If the user clicks OK, the selected font is returned. If the user
clicks Cancel, the Qt default font is returned.
The dialog is called \a name, with parent \a parent.
If the \a ok parameter is not-null, \e *\a ok is set to TRUE if the
user clicked OK, and FALSE if the user clicked Cancel.
This static function is less functional than the full QFontDialog
object, but is convenient and easy to use.
Example:
\code
bool ok;
QFont font = QFontDialog::getFont( &ok, this );
if ( ok ) {
// font is set to the font the user selected
} else {
// the user canceled the dialog; font is set to the default
// application font, QApplication::font()
}
\endcode
*/
QFont QFontDialog::getFont( bool *ok, QWidget *parent,const char* name)
{
return getFont( ok, 0, parent, name );
}
/*
* Initialize a term_data
*/
static errr term_data_init(term_data *td, Widget topLevel,
int key_buf, String name,
ArgList widget_arg, Cardinal widget_arg_no, int i)
{
Widget parent;
term *t = &td->t;
int cols = 80;
int rows = 24;
char buf[80];
cptr str;
int val;
/* Create the shell widget */
parent = XtCreatePopupShell(name, topLevelShellWidgetClass, topLevel,
NULL, 0);
/* Window specific cols */
sprintf(buf, "ANGBAND_X11_COLS_%d", i);
str = getenv(buf);
val = (str != NULL) ? atoi(str) : -1;
if (val > 0) cols = val;
/* Window specific rows */
sprintf(buf, "ANGBAND_X11_ROWS_%d", i);
str = getenv(buf);
val = (str != NULL) ? atoi(str) : -1;
if (val > 0) rows = val;
/* Hack the main window must be at least 80x24 */
if (i == 0)
{
if (cols < 80) cols = 80;
if (rows < 24) rows = 24;
}
/* Reset the initial size */
widget_arg[0].value = rows;
widget_arg[1].value = cols;
/* Hack ox==oy in xaw port */
/* Window specific inner border offset (ox) */
sprintf(buf, "ANGBAND_X11_IBOX_%d", i);
str = getenv(buf);
val = (str != NULL) ? atoi(str) : -1;
if (val > 0) widget_arg[6].value = val;
/* Window specific inner border offset (oy) */
sprintf(buf, "ANGBAND_X11_IBOY_%d", i);
str = getenv(buf);
val = (str != NULL) ? atoi(str) : -1;
if (val > 0) widget_arg[6].value = val;
/* Create the interior widget */
td->widget = (AngbandWidget)
XtCreateManagedWidget(name, angbandWidgetClass,
parent, widget_arg, widget_arg_no);
/* Initialize the term (full size) */
term_init(t, cols, rows, key_buf);
/* Use a "soft" cursor */
t->soft_cursor = TRUE;
/* Erase with "white space" */
t->attr_blank = TERM_WHITE;
t->char_blank = ' ';
/* Hooks */
t->xtra_hook = Term_xtra_xaw;
t->curs_hook = Term_curs_xaw;
t->wipe_hook = Term_wipe_xaw;
t->text_hook = Term_text_xaw;
/* Save the data */
t->data = td;
/* Register the keypress event handler */
XtAddEventHandler((Widget)td->widget, KeyPressMask,
False, (XtEventHandler) handle_event, td);
/* Redraw callback */
XtAddCallback((Widget)td->widget, XtNredrawCallback,
react_redraw, td);
/* Realize the widget */
XtRealizeWidget(parent);
/* Have we redefined the font? */
if (streq(td->widget->angband.font, DEFAULT_X11_FONT))
{
XFontStruct *fnt;
/* Check if the font exists */
fnt = getFont(td->widget, (String) get_default_font(i), FALSE);
/* The font didn't exist */
if (fnt == NULL)
{
XtWarning("Couldn't find the requested font!");
}
else
{
int height, width;
/* Free the old font */
XFreeFont(XtDisplay((Widget)td->widget), td->widget->angband.fnt);
/* Update font information */
td->widget->angband.fontheight = fnt->ascent + fnt->descent;
td->widget->angband.fontwidth = fnt->max_bounds.width;
td->widget->angband.fontascent = fnt->ascent;
for (i = 0; i < NUM_COLORS; i++)
{
/* Be sure the correct font is ready */
XSetFont(XtDisplay((Widget)td->widget),
td->widget->angband.gc[i], fnt->fid);
}
/* Get the window shape */
height = (td->widget->angband.start_rows *
td->widget->angband.fontheight +
2 * td->widget->angband.internal_border);
width = (td->widget->angband.start_columns *
td->widget->angband.fontwidth +
2 * td->widget->angband.internal_border);
/* Request a change to the new shape */
if (XtMakeResizeRequest((Widget)td->widget,
width, height, NULL, NULL) == XtGeometryNo)
{
/* Not allowed */
XtWarning("Size change denied!");
}
else
{
/* Recalculate size hints */
calculateSizeHints(td->widget);
}
}
}
/* Make it visible */
XtPopup(parent, XtGrabNone);
/* Activate (important) */
Term_activate(t);
Resize_term(td->widget);
return 0;
}
/*************************************************************************
display required integrated scroll bars according to current state
of the edit box and update their values.
*************************************************************************/
void MultiLineEditbox::configureScrollbars(void)
{
float totalHeight = (float)d_lines.size() * getFont()->getLineSpacing();
float widestItem = d_widestExtent;
//
// First show or hide the scroll bars as needed (or requested)
//
// show or hide vertical scroll bar as required (or as specified by option)
if ((totalHeight > getTextRenderArea().getHeight()) || d_forceVertScroll)
{
d_vertScrollbar->show();
// show or hide horizontal scroll bar as required (or as specified by option)
if ((widestItem > getTextRenderArea().getWidth()) || d_forceHorzScroll)
{
d_horzScrollbar->show();
}
else
{
d_horzScrollbar->hide();
}
}
else
{
// show or hide horizontal scroll bar as required (or as specified by option)
if ((widestItem > getTextRenderArea().getWidth()) || d_forceHorzScroll)
{
d_horzScrollbar->show();
// show or hide vertical scroll bar as required (or as specified by option)
if ((totalHeight > getTextRenderArea().getHeight()) || d_forceVertScroll)
{
d_vertScrollbar->show();
}
else
{
d_vertScrollbar->hide();
}
}
else
{
d_vertScrollbar->hide();
d_horzScrollbar->hide();
}
}
//
// Set up scroll bar values
//
Rect renderArea(getTextRenderArea());
d_vertScrollbar->setDocumentSize(totalHeight);
d_vertScrollbar->setPageSize(renderArea.getHeight());
d_vertScrollbar->setStepSize(ceguimax(1.0f, renderArea.getHeight() / 10.0f));
d_vertScrollbar->setScrollPosition(d_vertScrollbar->getScrollPosition());
d_horzScrollbar->setDocumentSize(widestItem);
d_horzScrollbar->setPageSize(renderArea.getWidth());
d_horzScrollbar->setStepSize(ceguimax(1.0f, renderArea.getWidth() / 10.0f));
d_horzScrollbar->setScrollPosition(d_horzScrollbar->getScrollPosition());
}
