bool Demo6Sample::handleAddColumn(const CEGUI::EventArgs& e)
{
using namespace CEGUI;
// get access to the widgets that contain details about the column to add
MultiColumnList* mcl = static_cast<MultiColumnList*>(WindowManager::getSingleton().getWindow("Demo6/MainList"));
Editbox* idbox = static_cast<Editbox*>(WindowManager::getSingleton().getWindow("Demo6/ControlPanel/ColumnPanel/NewColIDBox"));
Editbox* widthbox = static_cast<Editbox*>(WindowManager::getSingleton().getWindow("Demo6/ControlPanel/ColumnPanel/NewColWidthBox"));
Editbox* textbox = static_cast<Editbox*>(WindowManager::getSingleton().getWindow("Demo6/ControlPanel/ColumnPanel/NewColTextBox"));
// get ID for new column
CEGUI::uint id = atoi(idbox->getText().c_str());
// get width to use for new column (in pixels)
float width = atof(widthbox->getText().c_str());
// get column label text
String text = textbox->getText();
// re-set the widget contents
idbox->setText("");
widthbox->setText("");
textbox->setText("");
// ensure a minimum width of 10 pixels
if (width < 10.0f)
width = 10.0f;
// finally, add the new column to the list.
mcl->addColumn(text, id, cegui_absdim(width));
// event was handled.
return true;
}
///////////////////////////////////////////////////////////////////////////////////////////////
//Network Transport 20120618(¿ù)
///////////////////////////////////////////////////////////////////////////////////////////////
bool GUILogin::handleSubmit(const CEGUI::EventArgs&)
{
using namespace CEGUI;
// get the text entry editbox
Editbox* editboxName = static_cast<Editbox*>(d_root->getChild("GameIDInput"));
// get text out of the editbox
String edit_text(editboxName->getText());
if(edit_text.empty())
return false;
Editbox* editboxPassword = static_cast<Editbox*>(d_root->getChild("PasswordInput"));
// get text out of the editbox
String edit_text2(editboxPassword->getText());
if(edit_text.empty())
return false;
if(edit_text2.empty())
return false;
SFProtobufPacket<SFPacketStore::Login> PktLogin(CGSF::Login);
// PktLogin.SetOwnerSerial(g_engine->GetLocalID());
PktLogin.GetData().set_username(edit_text.c_str());
PktLogin.GetData().set_password(edit_text2.c_str());
g_pCasualGameManager->GetNetwork()->TCPSend(&PktLogin);
editboxName->setText("");
editboxPassword->setText("");
return true;
}
bool Demo6Sample::handleDeleteColumn(const CEGUI::EventArgs& e)
{
using namespace CEGUI;
// get access to the widgets that contain details about the column to delete
MultiColumnList* mcl = static_cast<MultiColumnList*>(WindowManager::getSingleton().getWindow("Demo6/MainList"));
Editbox* idbox = static_cast<Editbox*>(WindowManager::getSingleton().getWindow("Demo6/ControlPanel/ColumnPanel/DelColIDBox"));
// obtain the id of the column to be deleted
CEGUI::uint id = atoi(idbox->getText().c_str());
// attempt to delete the column, ignoring any errors.
try
{
mcl->removeColumnWithID(id);
}
catch (InvalidRequestException)
{}
// reset the delete column ID box.
idbox->setText("");
// event was handled.
return true;
}
bool Demo6Sample::handleDeleteColumn(const CEGUI::EventArgs& args)
{
using namespace CEGUI;
// get access to the widgets that contain details about the column to delete
MultiColumnList* mcl = static_cast<MultiColumnList*>(static_cast<const WindowEventArgs&>(args).window->getRootWindow()->getChild("MainList"));
Editbox* idbox = static_cast<Editbox*>(static_cast<const WindowEventArgs&>(args).window->getRootWindow()->getChild("ControlPanel/ColumnPanel/DelColIDBox"));
// obtain the id of the column to be deleted
CEGUI::uint id = atoi(idbox->getText().c_str());
// attempt to delete the column, ignoring any errors.
CEGUI_TRY
{
mcl->removeColumnWithID(id);
}
CEGUI_CATCH (InvalidRequestException)
{}
// reset the delete column ID box.
idbox->setText("");
// event was handled.
return true;
}
bool GuiConfig::HandleConfigOK(const CEGUI::EventArgs& e)
{
Editbox* playerName = static_cast<Editbox*>(winMgr.getWindow("CONFIGPLAYERNAME"));
/*
if (_stricmp(GConfig->GetPlayerName(), playerName->getText().c_str()))
{
if (GClientGame)
{
GClientGame->SendMessageNick(playerName->getText().c_str());
}
}
*/
bool bScreenConfigHasChanged = false;
{
Checkbox *pcb = (Checkbox*)winMgr.getWindow("CHKBFS");
bScreenConfigHasChanged |= GConfig->IsEnable("CHKBFS") != pcb->isSelected();
GConfig->SetEnable("CHKBFS", (int)pcb->isSelected() );
}
{
Checkbox *pcb = (Checkbox*)winMgr.getWindow("CHKBVSYNC");
bScreenConfigHasChanged |= GConfig->IsEnable("CHKBVSYNC") != pcb->isSelected();
GConfig->SetEnable("CHKBVSYNC", (int)pcb->isSelected() );
}
GConfig->SetPlayerName(playerName->getText().c_str());
// Resolution
Combobox* resCB = static_cast<Combobox*>(winMgr.getWindow("RESOLUTION"));
ListboxItem *resib = resCB->getSelectedItem();
if (resib)
{
int selres = resCB->getItemIndex(resib);
bScreenConfigHasChanged |= (GConfig->GetQuality("Width") != mResolutions[selres].width);
bScreenConfigHasChanged |= (GConfig->GetQuality("Height") != mResolutions[selres].height);
GConfig->SetQuality("Width", mResolutions[selres].width);
GConfig->SetQuality("Height", mResolutions[selres].height);
}
if (bScreenConfigHasChanged)
{
tstring onoksschanged = ".00 ";
onoksschanged += GLoc->GetString("OK");
((ZProtoGUI*)GProtoGui)->mMessageboxGui.Show(GLoc->GetString("SCREENCHANGED"), onoksschanged.c_str(), mOnOK);
Hide();
}
else
{
mOnOK();
Hide();
}
return true;
}
bool Demo6Sample::handleDeleteRow(const CEGUI::EventArgs& e)
{
using namespace CEGUI;
// get access to the widgets that contain details about the row to delete.
MultiColumnList* mcl = static_cast<MultiColumnList*>(WindowManager::getSingleton().getWindow("Demo6/MainList"));
Editbox* idxbox = static_cast<Editbox*>(WindowManager::getSingleton().getWindow("Demo6/ControlPanel/ColumnPanel/DelRowIdxBox"));
// get index of row to delete.
CEGUI::uint idx = atoi(idxbox->getText().c_str());
// attempt to delete the row, ignoring any errors.
try
{
mcl->removeRow(idx);
}
catch (InvalidRequestException)
{}
// clear the row index box
idxbox->setText("");
// event was handled.
return true;
}
/*************************************************************************
Handler for mouse button down events in editbox
*************************************************************************/
bool Combobox::editbox_MouseDownHandler(const EventArgs& e)
{
// only interested in left button
if (((const MouseEventArgs&)e).button == LeftButton)
{
Editbox* editbox = getEditbox();
// if edit box is read-only, show list
if (editbox->isReadOnly())
{
ComboDropList* droplist = getDropList();
// if there is an item with the same text as the edit box, pre-select it
ListboxItem* item = droplist->findItemWithText(editbox->getText(), 0);
if (item)
{
droplist->setItemSelectState(item, true);
droplist->ensureItemIsVisible(item);
}
// no matching item, so select nothing
else
{
droplist->clearAllSelections();
}
showDropList();
return true;
}
}
return false;
}
bool Demo6Sample::handleDeleteRow(const CEGUI::EventArgs& args)
{
using namespace CEGUI;
// get access to the widgets that contain details about the row to delete.
MultiColumnList* mcl = static_cast<MultiColumnList*>(static_cast<const WindowEventArgs&>(args).window->getRootWindow()->getChild("MainList"));
Editbox* idxbox = static_cast<Editbox*>(static_cast<const WindowEventArgs&>(args).window->getRootWindow()->getChild("ControlPanel/RowControl/DelRowIdxBox"));
// get index of row to delete.
CEGUI::uint idx = atoi(idxbox->getText().c_str());
// attempt to delete the row, ignoring any errors.
CEGUI_TRY
{
mcl->removeRow(idx);
}
CEGUI_CATCH (InvalidRequestException)
{}
// clear the row index box
idxbox->setText("");
// event was handled.
return true;
}
//----------------------------------------------------------------------------//
void FalagardEditbox::setupVisualString(String& visual) const
{
Editbox* w = static_cast<Editbox*>(d_window);
if (w->isTextMasked())
visual.assign(w->getText().length(), w->getMaskCodePoint());
else
visual.assign(w->getTextVisual());
}
bool GUIApplication::onConsoleInput(const CEGUI::EventArgs&)
{
Editbox* inputBox = static_cast<Editbox*>(m_guiContext->getRootWindow()->getChild("console/input"));
String consoleCommand = inputBox->getText();
inputBox->setText("");
doConsoleCommand(consoleCommand);
return true;
}
void Spinner::onValueChanged(WindowEventArgs& e)
{
Editbox* editbox = getEditbox();
// mute to save doing unnecessary events work.
bool wasMuted = editbox->isMuted();
editbox->setMutedState(true);
// Update text with new value.
// (allow empty and '-' cases to equal 0 with no text change required)
if (!(d_currentValue == 0 &&
(editbox->getText().empty() || editbox->getText() == "-")))
{
editbox->setText(getTextFromValue());
}
// restore previous mute state.
editbox->setMutedState(wasMuted);
fireEvent(EventValueChanged, e, EventNamespace);
}
bool Demo6Sample::handleSetItem(const CEGUI::EventArgs& e)
{
using namespace CEGUI;
// get access to the widgets that contain details about the item to be modified
MultiColumnList* mcl = static_cast<MultiColumnList*>(WindowManager::getSingleton().getWindow("Demo6/MainList"));
Editbox* idbox = static_cast<Editbox*>(WindowManager::getSingleton().getWindow("Demo6/ControlPanel/ColumnPanel/SetItemIDBox"));
Editbox* rowbox = static_cast<Editbox*>(WindowManager::getSingleton().getWindow("Demo6/ControlPanel/ColumnPanel/SetItemRowBox"));
Editbox* textbox = static_cast<Editbox*>(WindowManager::getSingleton().getWindow("Demo6/ControlPanel/ColumnPanel/SetItemTextBox"));
// get ID of column to be affected
CEGUI::uint id = atoi(idbox->getText().c_str());
// get index of row to be affected
CEGUI::uint row = atoi(rowbox->getText().c_str());
// get new text for item
String text = textbox->getText();
// reset input boxes
idbox->setText("");
rowbox->setText("");
textbox->setText("");
// create a new ListboxTextItem using the new text string
ListboxTextItem* item = new ListboxTextItem(text);
// set the selection brush to be used for this item.
item->setSelectionBrushImage(&ImagesetManager::getSingleton().getImageset("TaharezLook")->getImage("MultiListSelectionBrush"));
// attempt to set the new item in place
try
{
mcl->setItem(item, id, row);
}
// something went wrong, so cleanup the ListboxTextItem.
catch (InvalidRequestException)
{
delete item;
}
// event was handled.
return true;
}
void EditboxStyle::draw()
{
Editbox *w = static_cast<Editbox*>(getWidget());
Rect rect(Position(), w->getSize());
TextPosition tpos(rect, getTextHAlign(), getTextVAlign(), getTextHSpacing(), getTextVSpacing());
Color bg = getBGColor();
if(w->isFocused()) {
bg += vec4(0.4f, 0.4f, 0.4f, 0.0f);
}
else if(w->isHovered()) {
bg += vec4(0.2f, 0.2f, 0.2f, 0.0f);
}
iuiGetRenderer()->drawRect(rect, bg);
iuiGetRenderer()->drawOutlineRect(rect, getBorderColor());
iuiGetRenderer()->drawFont(tpos, getFontColor(), w->getText().c_str(), w->getText().size());
if(w->isFocused() && ist::GetTick()%1000<500) {
vec2 tsize = iuiGetRenderer()->computeTextSize(w->getText().c_str(), w->getCursorPos());
Line l(Position(tsize.x, 0.0f), Position(tsize.x, tsize.y));
iuiGetRenderer()->drawLine(l, getBorderColor());
}
}
bool GUI::handleSubmit(const EventArgs& eventArgs)
{
// get the text entry editbox
Editbox *editbox = static_cast<Editbox *> (guiConsole->getChild(EntryBoxID));
// get text out of the editbox
CEGUI::String edit_text(editbox->getText());
// if the string is not empty
if (!edit_text.empty()) {
// add this entry to the command history buffer
history.push_back(edit_text);
// reset history position
historyPosition = history.size();
// this is the member function that the agent uses to send the text to the brain
agent->handleText(editbox->getText().c_str());
// erase text in text entry box.
editbox->setText("");
}
// re-activate the text entry box
editbox->activate();
return true;
}
bool Demo6Sample::handleAddRow(const CEGUI::EventArgs& e)
{
using namespace CEGUI;
// get access to the widgets that contain details about the row to add
MultiColumnList* mcl = static_cast<MultiColumnList*>(WindowManager::getSingleton().getWindow("Demo6/MainList"));
Editbox* idbox = static_cast<Editbox*>(WindowManager::getSingleton().getWindow("Demo6/ControlPanel/ColumnPanel/RowColIDBox"));
Editbox* textbox = static_cast<Editbox*>(WindowManager::getSingleton().getWindow("Demo6/ControlPanel/ColumnPanel/RowTextBox"));
// get the ID of the initial column item to set
CEGUI::uint id = atoi(idbox->getText().c_str());
// get the text that is to be set initially into the specified column of the new row
String text = textbox->getText();
// reset input boxes
idbox->setText("");
textbox->setText("");
// construct a new ListboxTextItem with the required string
ListboxTextItem* item = new ListboxTextItem(text);
// set the selection brush to use for this item.
item->setSelectionBrushImage(&ImagesetManager::getSingleton().getImageset("TaharezLook")->getImage("MultiListSelectionBrush"));
// attempt to add a new row, using the new ListboxTextItem as the initial content for one of the columns
try
{
mcl->addRow(item, id);
}
// something went wrong, so cleanup the ListboxTextItem
catch (InvalidRequestException)
{
delete item;
}
// event was handled.
return true;
}
void Spinner::onTextChanged(WindowEventArgs& e)
{
Editbox* editbox = getEditbox();
// update only if needed
if (editbox->getText() != d_text)
{
// done before doing base class processing so event subscribers see
// 'updated' version.
editbox->setText(d_text);
e.handled = true;
Window::onTextChanged(e);
}
}
/*************************************************************************
Handler for when text changes
*************************************************************************/
void Combobox::onTextChanged(WindowEventArgs& e)
{
Editbox* editbox = getEditbox();
// update ourselves only if needed (prevents perpetual event loop & stack overflow)
if (editbox->getText() != getText())
{
// done before doing base class processing so event subscribers see 'updated' version of this.
editbox->setText(getText());
++e.handled;
selectListItemWithEditboxText();
Window::onTextChanged(e);
}
}
bool GUIApplication::onSendBtnClicked(const EventArgs& args)
{
Window* myOutput = m_guiContext->getRootWindow()->getChild("chatWindow/output");
MultiLineEditbox* realOutput = static_cast<MultiLineEditbox*>(myOutput);
Editbox* realInput = static_cast<Editbox*>(m_guiContext->getRootWindow()->getChild("chatWindow/input"));
if (realOutput && realInput)
{
String newLine = realInput->getText();
if (newLine.empty())
newLine = "You clicked me!";
else
{
RemotePeersManager::getManager()->sendChatMessage(newLine.c_str());
}
realOutput->appendText(newLine);
realInput->setText("");
}
return true;
}
//----------------------------------------------------------------------------//
void FalagardEditbox::render()
{
Editbox* w = static_cast<Editbox*>(d_window);
const StateImagery* imagery;
// draw container etc
// get WidgetLookFeel for the assigned look.
const WidgetLookFeel& wlf = getLookNFeel();
// try and get imagery for the approprite state.
imagery = &wlf.getStateImagery(
w->isDisabled() ? "Disabled" : (w->isReadOnly() ? "ReadOnly" : "Enabled"));
// peform the rendering operation for the container.
imagery->render(*w);
// get destination area for text
const Rect textArea(wlf.getNamedArea("TextArea").getArea().getPixelRect(*w));
//
// Required preliminary work for text rendering operations
//
Font* font = w->getFont();
// no font == no more rendering
if (!font)
return;
// This will point to the final string to be used for rendering. Useful
// because it means we do not have to have duplicate code or be copying
// getText() for handling masked/unmasked text.
String* editText;
// Create a 'masked' version of the string if needed.
String maskedText, windowText;
if (w->isTextMasked())
{
maskedText.insert(0, w->getText().length(), w->getMaskCodePoint());
editText = &maskedText;
}
// text not masked to editText will be the windows getText() String.
else
{
windowText = w->getTextVisual();
editText = &windowText;
}
// calculate best position to render text to ensure carat is always visible
float textOffset;
size_t cartIndex = w->getCaratIndex();
#ifdef CEGUI_BIDI_SUPPORT
// the char before the cart bidi type
bool currCharIsRtl = false;
if ((editText->size() > 0) && (cartIndex > 0))
{
size_t curCartIndex = w->getCaratIndex();
BidiCharType charBeforeCartType = w->getBiDiVisualMapping()->
getBidiCharType((*editText)[curCartIndex - 1]);
// for neutral chars you decide by the char after
for (; BCT_NEUTRAL == charBeforeCartType &&
(editText->size() > curCartIndex); curCartIndex++)
{
charBeforeCartType = w->getBiDiVisualMapping()->
getBidiCharType((*editText)[curCartIndex - 1]);
}
currCharIsRtl = (BCT_RIGHT_TO_LEFT == charBeforeCartType);
}
bool isFirstChar = cartIndex == 0;
// the pos is by the char before
if (!isFirstChar)
cartIndex--;
// we need to find the cart pos by the logical to visual map
if (w->getBiDiVisualMapping()->getV2lMapping().size() > cartIndex)
cartIndex = w->getBiDiVisualMapping()->getL2vMapping()[cartIndex];
// for non RTL char - the cart pos is after the char
if (!currCharIsRtl)
cartIndex++;
// if first char is not rtl - we need to stand at the start of the line
if (isFirstChar)
{
bool firstCharRtl =
(editText->size() > 0) &&
(BCT_RIGHT_TO_LEFT == w->getBiDiVisualMapping()->
getBidiCharType((*editText)[0]));
if (!firstCharRtl)
cartIndex--;
}
#endif
float extentToCarat = font->getTextExtent(editText->substr(0, cartIndex));
// get carat imagery
const ImagerySection& caratImagery = wlf.getImagerySection("Carat");
// store carat width
float caratWidth = caratImagery.getBoundingRect(*w, textArea).getWidth();
// if box is inactive
if (!w->hasInputFocus())
textOffset = d_lastTextOffset;
// if carat is to the left of the box
else if ((d_lastTextOffset + extentToCarat) < 0)
textOffset = -extentToCarat;
// if carat is off to the right.
else if ((d_lastTextOffset + extentToCarat) >= (textArea.getWidth() - caratWidth))
textOffset = textArea.getWidth() - extentToCarat - caratWidth;
// else carat is already within the box
else
textOffset = d_lastTextOffset;
ColourRect colours;
float alpha_comp = w->getEffectiveAlpha();
//
// Draw label text
//
// setup initial rect for text formatting
Rect text_part_rect(textArea);
// allow for scroll position
text_part_rect.d_left += textOffset;
// centre text vertically within the defined text area
text_part_rect.d_top += (textArea.getHeight() - font->getFontHeight()) * 0.5f;
// get unhighlighted text colour (saves accessing property twice)
colour unselectedColour(getUnselectedTextColour());
// see if the editbox is active or inactive.
bool active = (!w->isReadOnly()) && w->hasInputFocus();
#ifdef CEGUI_BIDI_SUPPORT
if (w->getSelectionLength() == 0)
{
// no highlighted text - we can draw the whole thing
colours.setColours(unselectedColour);
colours.modulateAlpha(alpha_comp);
font->drawText(w->getGeometryBuffer(), *editText,
text_part_rect.getPosition(), &textArea, colours);
// adjust rect for next section
text_part_rect.d_left += font->getTextExtent(*editText);
}
else
{
// there is highlighted text - because of the BiDi support - the
// highlighted area can be in some cases nonconsecutive.
// So - we need to draw it char by char (I guess we can optimize it more
// but this is not that big performance hit because it only happens if
// we have highlighted text - not that common...)
for (size_t i = 0 ; i < editText->size() ; i++)
{
// get the char
String currChar = editText->substr(i, 1);
size_t realPos = 0;
// get he visual pos of the char
if (w->getBiDiVisualMapping()->getV2lMapping().size() > i)
{
realPos = w->getBiDiVisualMapping()->getV2lMapping()[i];
}
// check if it is in the highlighted region
bool highlighted =
realPos >= w->getSelectionStartIndex() &&
realPos < w->getSelectionStartIndex() + w->getSelectionLength();
float charAdvance = font->getGlyphData(currChar[0])->getAdvance(1.0f);
if (highlighted)
{
colours.setColours(getSelectedTextColour());
colours.modulateAlpha(alpha_comp);
{
// calculate area for selection imagery.
Rect hlarea(textArea);
hlarea.d_left = text_part_rect.d_left ;
hlarea.d_right = text_part_rect.d_left + charAdvance ;
// render the selection imagery.
wlf.getStateImagery(active ? "ActiveSelection" :
"InactiveSelection").
render(*w, hlarea, 0, &textArea);
}
}
else
{
colours.setColours(unselectedColour);
colours.modulateAlpha(alpha_comp);
}
font->drawText(w->getGeometryBuffer(), currChar,
text_part_rect.getPosition(), &textArea, colours);
// adjust rect for next section
text_part_rect.d_left += charAdvance;
}
}
#else
//
// Render selection imagery.
//
if (w->getSelectionLength() != 0)
{
// calculate required start and end offsets of selection imagery.
float selStartOffset =
font->getTextExtent(editText->substr(0, w->getSelectionStartIndex()));
float selEndOffset =
font->getTextExtent(editText->substr(0, w->getSelectionEndIndex()));
// calculate area for selection imagery.
Rect hlarea(textArea);
hlarea.d_left += textOffset + selStartOffset;
hlarea.d_right = hlarea.d_left + (selEndOffset - selStartOffset);
// render the selection imagery.
wlf.getStateImagery(active ? "ActiveSelection" :
"InactiveSelection").
render(*w, hlarea, 0, &textArea);
}
// draw pre-highlight text
String sect = editText->substr(0, w->getSelectionStartIndex());
colours.setColours(unselectedColour);
colours.modulateAlpha(alpha_comp);
font->drawText(w->getGeometryBuffer(), sect, text_part_rect.getPosition(),
&textArea, colours);
// adjust rect for next section
text_part_rect.d_left += font->getTextExtent(sect);
// draw highlight text
sect = editText->substr(w->getSelectionStartIndex(), w->getSelectionLength());
colours.setColours(getSelectedTextColour());
colours.modulateAlpha(alpha_comp);
font->drawText(w->getGeometryBuffer(), sect, text_part_rect.getPosition(),
&textArea, colours);
// adjust rect for next section
text_part_rect.d_left += font->getTextExtent(sect);
// draw post-highlight text
sect = editText->substr(w->getSelectionEndIndex());
colours.setColours(unselectedColour);
colours.modulateAlpha(alpha_comp);
font->drawText(w->getGeometryBuffer(), sect, text_part_rect.getPosition(),
&textArea, colours);
// remember this for next time.
d_lastTextOffset = textOffset;
#endif
//
// Render carat
//
if (active && (!d_blinkCaret || d_showCaret))
{
Rect caratRect(textArea);
caratRect.d_left += extentToCarat + textOffset;
caratImagery.render(*w, caratRect, 0, &textArea);
}
}