void ListView::ChangeSelection(int delta, bool additive)
{
if (selections_.Empty())
return;
if (!multiselect_)
additive = false;
// If going downwards, use the last selection as a base. Otherwise use first
unsigned selection = delta > 0 ? selections_.Back() : selections_.Front();
int direction = delta > 0 ? 1 : -1;
unsigned numItems = GetNumItems();
unsigned newSelection = selection;
unsigned okSelection = selection;
PODVector<unsigned> indices = selections_;
while (delta != 0)
{
newSelection += direction;
if (newSelection >= numItems)
break;
UIElement* item = GetItem(newSelection);
if (item->IsVisible())
{
indices.Push(okSelection = newSelection);
delta -= direction;
}
}
if (!additive)
SetSelection(okSelection);
else
SetSelections(indices);
}
void
TabNavigationWalker::Sort (GPtrArray *array, Types *types)
{
int end = array->len;
bool swapped;
do {
end --;
swapped = false;
for (int i = 0; i < end; i++) {
UIElement *left = NULL;
UIElement *right = NULL;
DeepTreeWalker left_walker ((UIElement *) array->pdata [i], Logical, types);
DeepTreeWalker right_walker ((UIElement *) array->pdata [i + 1], Logical, types);
while ((left = left_walker.Step ()) && !types->IsSubclassOf (left->GetObjectType (), Type::CONTROL)) { }
while ((right = right_walker.Step ()) && !types->IsSubclassOf (right->GetObjectType (), Type::CONTROL)) { }
if (TabCompare ((Control *)left, (Control *)right) > 0) {
left = (UIElement *) array->pdata [i];
array->pdata [i] = array->pdata [i + 1];
array->pdata [i + 1] = left;
swapped = true;
}
}
} while (swapped);
}
void LANDiscovery::CreateUI()
{
SetLogoVisible(true); // We need the full rendering window
auto* graphics = GetSubsystem<Graphics>();
UIElement* root = GetSubsystem<UI>()->GetRoot();
auto* cache = GetSubsystem<ResourceCache>();
auto* uiStyle = cache->GetResource<XMLFile>("UI/DefaultStyle.xml");
// Set style to the UI root so that elements will inherit it
root->SetDefaultStyle(uiStyle);
int marginTop = 20;
CreateLabel("1. Start server", IntVector2(20, marginTop-20));
startServer_ = CreateButton("Start server", 160, IntVector2(20, marginTop));
stopServer_ = CreateButton("Stop server", 160, IntVector2(20, marginTop));
stopServer_->SetVisible(false);
// Create client connection related fields
marginTop += 80;
CreateLabel("2. Discover LAN servers", IntVector2(20, marginTop-20));
refreshServerList_ = CreateButton("Search...", 160, IntVector2(20, marginTop));
marginTop += 80;
CreateLabel("Local servers:", IntVector2(20, marginTop - 20));
serverList_ = CreateLabel("", IntVector2(20, marginTop));
// No viewports or scene is defined. However, the default zone's fog color controls the fill color
GetSubsystem<Renderer>()->GetDefaultZone()->SetFogColor(Color(0.0f, 0.0f, 0.1f));
}
void PlatformWindowSite::OnMouseButtonDblClk(gm::PointF clientMousePos, int button)
{
POINT screenMousePos;
::GetCursorPos(&screenMousePos);
UIElement* hitElement = nullptr;
UIElement* child = GetRootElement();
// Visual* child = get_Child();
if (child)
{
hitElement = child->HitTest_(clientMousePos);
}
// hitElement = child;
if (hitElement)
{
MouseButtonEventArgs* args = new MouseButtonEventArgs(nullptr, 0);
if (button == 0) args->set_RoutedEvent(UIElement::get_MouseLeftButtonDoubleClickEvent());
else if (button == 1) args->set_RoutedEvent(UIElement::get_MouseMiddleButtonDoubleClickEvent());
else args->set_RoutedEvent(UIElement::get_MouseRightButtonDoubleClickEvent());
args->m_screenpos = Point(float(screenMousePos.x), float(screenMousePos.y));
args->m_clientpos = clientMousePos;
hitElement->RaiseEvent(args);
}
}
void PlatformWindowSite::OnSize(gm::RectI r)
{
UIElement* uielement = dynamic_cast<UIElement*>(this);
// Done in OnSizing
#if 0
m_ownerVisual->OnWindowSizeChanged(windowWidth, windowHeight);
#endif
int clientWidth = r.Width;
int clientHeight = r.Height;
#if 0 // Event
m_ownerVisual->OnSize(m_ownerVisual);
#endif
// TODO, not here, like this ??
UIElement* child = GetRootElement();
if (child)
{
/*
m_ownerVisual->set_ActualWidth(windowWidth);
m_ownerVisual->set_ActualHeight(windowHeight);
child->DoLayoutSize(gm::SizeF(clientWidth, clientHeight));
*/
uielement->m_desiredSize = gm::SizeF(clientWidth, clientHeight);
uielement->m_availSize = gm::SizeF(clientWidth, clientHeight);
uielement->InvalidateMeasure();
uielement->InvalidateArrange();
}
}
void UIButton::InitDefaultElements()
{
UIElement Element;
// Button
{
Element.SetTexture(0, UIManager::Instance().ElementTextureRect(UICT_Button, 0));
Element.SetFont(0);
Element.TextureColor().States[UICS_Normal] = Color(1, 1, 1, 150.0f / 255);
Element.TextureColor().States[UICS_Pressed] = Color(1, 1, 1, 200.0f / 255);
Element.FontColor().States[UICS_MouseOver] = Color(0, 0, 0, 1.0f);
elements_.push_back(MakeSharedPtr<UIElement>(Element));
}
// Fill layer
{
Element.SetTexture(0, UIManager::Instance().ElementTextureRect(UICT_Button, 1), Color(1, 1, 1, 0));
Element.TextureColor().States[UICS_MouseOver] = Color(1, 1, 1, 160.0f / 255);
Element.TextureColor().States[UICS_Pressed] = Color(0, 0, 0, 60.0f / 255);
Element.TextureColor().States[UICS_Focus] = Color(1, 1, 1, 30.0f / 255);
elements_.push_back(MakeSharedPtr<UIElement>(Element));
}
}
void SoundEffects::CreateUI()
{
UIElement* root = GetSubsystem<UI>()->GetRoot();
auto* cache = GetSubsystem<ResourceCache>();
auto* uiStyle = cache->GetResource<XMLFile>("UI/DefaultStyle.xml");
// Set style to the UI root so that elements will inherit it
root->SetDefaultStyle(uiStyle);
// Create buttons for playing back sounds
for (unsigned i = 0; i < NUM_SOUNDS; ++i)
{
Button* button = CreateButton(i * 140 + 20, 20, 120, 40, soundNames[i]);
// Store the sound effect resource name as a custom variable into the button
button->SetVar(VAR_SOUNDRESOURCE, soundResourceNames[i]);
SubscribeToEvent(button, E_PRESSED, URHO3D_HANDLER(SoundEffects, HandlePlaySound));
}
// Create buttons for playing/stopping music
Button* button = CreateButton(20, 80, 120, 40, "Play Music");
SubscribeToEvent(button, E_RELEASED, URHO3D_HANDLER(SoundEffects, HandlePlayMusic));
button = CreateButton(160, 80, 120, 40, "Stop Music");
SubscribeToEvent(button, E_RELEASED, URHO3D_HANDLER(SoundEffects, HandleStopMusic));
auto* audio = GetSubsystem<Audio>();
// Create sliders for controlling sound and music master volume
Slider* slider = CreateSlider(20, 140, 200, 20, "Sound Volume");
slider->SetValue(audio->GetMasterGain(SOUND_EFFECT));
SubscribeToEvent(slider, E_SLIDERCHANGED, URHO3D_HANDLER(SoundEffects, HandleSoundVolume));
slider = CreateSlider(20, 200, 200, 20, "Music Volume");
slider->SetValue(audio->GetMasterGain(SOUND_MUSIC));
SubscribeToEvent(slider, E_SLIDERCHANGED, URHO3D_HANDLER(SoundEffects, HandleMusicVolume));
}
bool Menu::SaveXML(XMLElement& dest)
{
// Write type and internal flag
if (!dest.SetString("type", GetTypeName()))
return false;
if (internal_)
{
if (!dest.SetBool("internal", internal_))
return false;
}
// Write attributes
if (!Serializable::SaveXML(dest))
return false;
// Write child elements
for (unsigned i = 0; i < children_.Size(); ++i)
{
UIElement* element = children_[i];
XMLElement childElem = dest.CreateChild("element");
if (!element->SaveXML(childElem))
return false;
}
// Save the popup element as a "virtual" child element
if (popup_)
{
XMLElement childElem = dest.CreateChild("element");
childElem.SetBool("popup", true);
if (!popup_->SaveXML(childElem))
return false;
}
return true;
}
UIElement * UserInterface::Activate(){
UIElement * stackTop = GetStackTop();
if (!stackTop)
return NULL;
UIElement * result = NULL;
result = stackTop->Activate();
if (result)
{
if (result->activationMessage.Length() == 0){
// assert(false && "Activatable UI element has no valid activation message string!");
return NULL;
}
if (result->activationMessage.Length() != 0){
if (result->activationMessage.Type() == String::WIDE_CHAR)
result->activationMessage.ConvertToChar();
List<String> msgs = result->activationMessage.Tokenize("&");
for (int i = 0; i < msgs.Size(); ++i){
Message * message = new Message(msgs[i]);
message->element = result;
MesMan.QueueMessage(message);
}
return result;
}
else {
std::cout<<"\nonActivate and activationMessage both NULL in element: "<<result->name;
return NULL;
}
}
return result;
}
/// Fetches all elements conforming to the bitwise and'ed (&) state flags provided.
bool UserInterface::GetElementsByState(int stateFlag, List<UIElement*> & listToFill){
UIElement * e = this->GetStackTop();
if (!e)
return false;
e->GetElementsByState(stateFlag, listToFill);
return true;
}
/// If allUi is specified, the action will try, similar to hover, and go through the entire stack from the top down until it processes an element.
UIElement * UserInterface::Click(int x, int y, bool allUi){
UIElement * elementClicked = NULL;
if (allUi){
for (int i = stack.Size()-1; i >= 0; --i)
{
UIElement * stackElement = stack[i];
elementClicked = stackElement->Click(x,y);
if (elementClicked)
break;
}
/// If still no result, try the root.
if (!elementClicked)
{
elementClicked = root->Click(x,y);
}
/// Demand hover will have to be investigated how it could work in this mode, if at all.
}
/// Old code for just the stack-top
else {
UIElement * stackTop = GetStackTop();
if (!stackTop)
return NULL;
/// Clear the active-flag?
elementClicked = stackTop->Click(x,y);
}
return elementClicked;
}
bool UserInterface::scroll(bool up){
UIElement *clikedElem = findElem(userInterfaceListener.getMousePos());
if(clikedElem!=nullptr){
return clikedElem->executeScroll(up);
}
return false;
}
void ScrollView::Update(float timeStep)
{
// Update touch scrolling here if necessary
if (touchScrollSpeed_ == Vector2::ZERO && touchScrollSpeedMax_ == Vector2::ZERO && !barScrolling_)
return;
// Check if we should not scroll:
// - ScrollView is not visible, is not enabled, or doesn't have focus
// - The element being dragged is not a child of the ScrollView, or is one of our scrollbars
if (!IsVisible() || !IsEnabled() || !HasFocus())
{
touchScrollSpeed_ = Vector2::ZERO;
touchScrollSpeedMax_ = Vector2::ZERO;
return;
}
if (GetSubsystem<UI>()->IsDragging())
{
Vector<UIElement*> dragElements = GetSubsystem<UI>()->GetDragElements();
for (unsigned i = 0; i < dragElements.Size(); i++)
{
UIElement* dragElement = dragElements[i];
int dragButtons = dragElement->GetDragButtonCombo();
if (dragButtons != MOUSEB_LEFT)
continue;
UIElement* dragParent = dragElement->GetParent();
bool dragElementIsChild = false;
while (dragParent)
{
if (dragParent == this)
{
dragElementIsChild = true;
break;
}
dragParent = dragParent->GetParent();
}
if (!dragElementIsChild || dragElement == horizontalScrollBar_->GetSlider() ||
dragElement == verticalScrollBar_->GetSlider())
{
touchScrollSpeed_ = Vector2::ZERO;
touchScrollSpeedMax_ = Vector2::ZERO;
return;
}
}
}
// Update view position
IntVector2 newPosition = viewPosition_;
newPosition.x_ += (int)touchScrollSpeed_.x_;
newPosition.y_ += (int)touchScrollSpeed_.y_;
SetViewPosition(newPosition);
// Smooth deceleration
ScrollSmooth(timeStep);
}
Console::Console(Context* context) :
Object(context),
historyRows_(DEFAULT_HISTORY_SIZE),
historyPosition_(0)
{
UI* ui = GetSubsystem<UI>();
UIElement* uiRoot = ui->GetRoot();
background_ = new BorderImage(context_);
background_->SetBringToBack(false);
background_->SetClipChildren(true);
background_->SetEnabled(true);
background_->SetVisible(false); // Hide by default
background_->SetPriority(200); // Show on top of the debug HUD
background_->SetLayout(LM_VERTICAL);
rowContainer_ = new UIElement(context_);
rowContainer_->SetClipChildren(true);
rowContainer_->SetLayout(LM_VERTICAL);
background_->AddChild(rowContainer_);
lineEdit_ = new LineEdit(context_);
lineEdit_->SetFocusMode(FM_FOCUSABLE); // Do not allow defocus with ESC
background_->AddChild(lineEdit_);
uiRoot->AddChild(background_);
SetNumRows(DEFAULT_CONSOLE_ROWS);
SubscribeToEvent(lineEdit_, E_TEXTFINISHED, HANDLER(Console, HandleTextFinished));
SubscribeToEvent(lineEdit_, E_UNHANDLEDKEY, HANDLER(Console, HandleLineEditKey));
SubscribeToEvent(E_SCREENMODE, HANDLER(Console, HandleScreenMode));
SubscribeToEvent(E_LOGMESSAGE, HANDLER(Console, HandleLogMessage));
SubscribeToEvent(E_POSTUPDATE, HANDLER(Console, HandlePostUpdate));
}
void UIElements::setup(const Common::Point &pt) {
_slotStart = 0;
_itemList.clear();
_scoreValue = 0;
_active = true;
UICollection::setup(pt);
hide();
_object1.setup(1, 3, 1, 0, 0, 255);
add(&_object1);
// Set up the inventory slots
int xp = 0;
for (int idx = 0; idx < 4; ++idx) {
UIElement *item = NULL;
switch (idx) {
case 0:
item = &_slot1;
break;
case 1:
item = &_slot2;
break;
case 2:
item = &_slot3;
break;
case 3:
item = &_slot4;
break;
}
xp = idx * 63 + 2;
item->setup(9, 1, idx, xp, 4, 255);
add(item);
}
// Setup bottom-right hand buttons
xp += 62;
_question.setup(1, 4, 7, xp, 16, 255);
_question.setEnabled(false);
add(&_question);
xp += 21;
_scrollLeft.setup(1, 4, 1, xp, 16, 255);
add(&_scrollLeft);
_scrollLeft._isLeft = true;
xp += 22;
_scrollRight.setup(1, 4, 4, xp, 16, 255);
add(&_scrollRight);
_scrollRight._isLeft = false;
// Set up the score
_score.postInit();
add(&_score);
// Set interface area
_bounds = Rect(0, BF_INTERFACE_Y - 1, SCREEN_WIDTH, SCREEN_HEIGHT);
updateInventory();
}
void UIElement::OnComputedPropertyValueChanging(PropertyValue* pPropertyVal, const Variant& oldValue, const Variant& newValue, bool handled)
{
if (pPropertyVal->m_dp == get_ShadowTreeProperty())
{
// remove old
UIElement* uielement = get_ShadowTree();
if (uielement)
{
uielement->SetRoot(nullptr);
uielement->set_Parent(nullptr);
uielement->set_ParentWindow(nullptr);
}
handled = true;
}
if (m_elementProvider)
{
PROPERTYID propertyId = 0;
if (pPropertyVal->m_dp == Window::get_TitleTextProperty())
{
propertyId = UIA_NamePropertyId;
}
HRESULT hr;
if (propertyId)
{
hr = UiaRaiseAutomationPropertyChangedEvent(m_elementProvider, propertyId, oldValue, newValue);
}
}
baseClass::OnComputedPropertyValueChanging(pPropertyVal, oldValue, newValue, handled);
}
DebugHud::DebugHud(Context* context) :
Object(context),
profilerMaxDepth_(M_MAX_UNSIGNED),
profilerInterval_(1000),
useRendererStats_(false),
mode_(DEBUGHUD_SHOW_NONE)
{
UI* ui = GetSubsystem<UI>();
UIElement* uiRoot = ui->GetRoot();
statsText_ = new Text(context_);
statsText_->SetAlignment(HA_LEFT, VA_TOP);
statsText_->SetPriority(100);
statsText_->SetVisible(false);
uiRoot->AddChild(statsText_);
modeText_ = new Text(context_);
modeText_->SetAlignment(HA_LEFT, VA_BOTTOM);
modeText_->SetPriority(100);
modeText_->SetVisible(false);
uiRoot->AddChild(modeText_);
profilerText_ = new Text(context_);
profilerText_->SetAlignment(HA_RIGHT, VA_TOP);
profilerText_->SetPriority(100);
profilerText_->SetVisible(false);
uiRoot->AddChild(profilerText_);
SubscribeToEvent(E_POSTUPDATE, HANDLER(DebugHud, HandlePostUpdate));
}
void ListView::SetHierarchyMode(bool enable)
{
if (enable == hierarchyMode_)
return;
hierarchyMode_ = enable;
UIElement* container;
if (enable)
{
overlayContainer_ = new UIElement(context_);
overlayContainer_->SetName("LV_OverlayContainer");
overlayContainer_->SetInternal(true);
AddChild(overlayContainer_);
overlayContainer_->SetSortChildren(false);
overlayContainer_->SetClipChildren(true);
container = new HierarchyContainer(context_, this, overlayContainer_);
}
else
{
if (overlayContainer_)
{
RemoveChild(overlayContainer_);
overlayContainer_.Reset();
}
container = new UIElement(context_);
}
container->SetName("LV_ItemContainer");
container->SetInternal(true);
SetContentElement(container);
container->SetEnabled(true);
container->SetSortChildren(false);
}
void Window::GetBatches(PODVector<UIBatch>& batches, PODVector<float>& vertexData, const IntRect& currentScissor)
{
if (modal_)
{
// Modal shade
if (modalShadeColor_ != Color::TRANSPARENT)
{
UIElement* rootElement = GetRoot();
const IntVector2& rootSize = rootElement->GetSize();
UIBatch batch(rootElement, BLEND_ALPHA, IntRect(0, 0, rootSize.x_, rootSize.y_), 0, &vertexData);
batch.AddQuad(0, 0, rootSize.x_, rootSize.y_, 0, 0, 0, 0, modalShadeColor_);
UIBatch::AddOrMerge(batch, batches);
}
// Modal frame
if (modalFrameColor_ != Color::TRANSPARENT && modalFrameSize_ != IntVector2::ZERO)
{
UIBatch batch(this, BLEND_ALPHA, currentScissor, 0, &vertexData);
int x = GetIndentWidth();
IntVector2 size = GetSize();
size.x_ -= x;
batch.AddQuad(x - modalFrameSize_.x_, -modalFrameSize_.y_, size.x_ + 2 * modalFrameSize_.x_, size.y_ + 2 * modalFrameSize_.y_, 0, 0, 0, 0, modalFrameColor_);
UIBatch::AddOrMerge(batch, batches);
}
}
BorderImage::GetBatches(batches, vertexData, currentScissor);
}
void Menu::HandleFocusChanged(StringHash eventType, VariantMap& eventData)
{
if (!showPopup_)
return;
using namespace FocusChanged;
UIElement* element = static_cast<UIElement*>(eventData[P_ELEMENT].GetPtr());
UIElement* root = GetRoot();
// If another element was focused due to the menu button being clicked, do not hide the popup
if (eventType == E_FOCUSCHANGED && static_cast<UIElement*>(eventData[P_CLICKEDELEMENT].GetPtr()))
return;
// If clicked emptiness or defocused, hide the popup
if (!element)
{
ShowPopup(false);
return;
}
// Otherwise see if the clicked element has either the menu item or the popup in its parent chain.
// In that case, do not hide
while (element)
{
if (element == this || element == popup_)
return;
if (element->GetParent() == root)
element = static_cast<UIElement*>(element->GetVar(originHash).GetPtr());
else
element = element->GetParent();
}
ShowPopup(false);
}
void FileSelector::RefreshFiles()
{
FileSystem* fileSystem = GetSubsystem<FileSystem>();
ignoreEvents_ = true;
fileList_->RemoveAllItems();
fileEntries_.Clear();
Vector<String> directories;
Vector<String> files;
fileSystem->ScanDir(directories, path_, "*", SCAN_DIRS, false);
fileSystem->ScanDir(files, path_, GetFilter(), SCAN_FILES, false);
fileEntries_.Reserve(directories.Size() + files.Size());
for (unsigned i = 0; i < directories.Size(); ++i)
{
FileSelectorEntry newEntry;
newEntry.name_ = directories[i];
newEntry.directory_ = true;
fileEntries_.Push(newEntry);
}
for (unsigned i = 0; i < files.Size(); ++i)
{
FileSelectorEntry newEntry;
newEntry.name_ = files[i];
newEntry.directory_ = false;
fileEntries_.Push(newEntry);
}
// Sort and add to the list view
// While items are being added, disable layout update for performance optimization
Sort(fileEntries_.Begin(), fileEntries_.End(), CompareEntries);
UIElement* listContent = fileList_->GetContentElement();
listContent->DisableLayoutUpdate();
for (unsigned i = 0; i < fileEntries_.Size(); ++i)
{
String displayName;
if (fileEntries_[i].directory_)
displayName = "<DIR> " + fileEntries_[i].name_;
else
displayName = fileEntries_[i].name_;
Text* entryText = new Text(context_);
fileList_->AddItem(entryText);
entryText->SetText(displayName);
entryText->SetStyle("FileSelectorListText");
}
listContent->EnableLayoutUpdate();
listContent->UpdateLayout();
ignoreEvents_ = false;
// Clear filename from the previous dir so that there is no confusion
SetFileName(String::EMPTY);
lastUsedFilter_ = GetFilter();
}
geometry UIElement::MakeVisibleGeometry(geometry clip)
{
m_visibleGeometryValid = true;
//gm::RectF bounds = clip.GetBounds();
geometry clipThis = get_Clip();
if (clipThis != nullptr)
{
clip &= clipThis;
}
#ifdef _DEBUG
gm::RectF bounds = clip.GetBounds();
#endif
geometry geom = GetHitGeometry();
#ifdef _DEBUG
gm::RectF bounds2 = geom.GetBounds();
#endif
clip &= geom;
#ifdef _DEBUG
gm::RectF bounds3 = clip.GetBounds();
#endif
size_t nchildren = GetChildrenCount();
for (size_t i = nchildren; i > 0; --i)
{
Visual* child = GetChild(i-1);
geometry geom2 = child->MakeVisibleGeometry(clip);
clip |= geom2;
}
UIElement* shadowTree = get_ShadowTree();
if (shadowTree)
{
geometry geom2 = shadowTree->MakeVisibleGeometry(clip);
#ifdef _DEBUG
gm::RectF bounds5 = geom2.GetBounds();
#endif
clip |= geom2;
}
#ifdef _DEBUG
gm::RectF bounds4 = clip.GetBounds();
#endif
set_VisibleGeometry(clip);
return clip;
}
/// Get the button
void GameEconomicGameClient::HandlerConfigurationWindowButtonPressed(StringHash eventType, VariantMap& eventData)
{
/// Get needed resources
Renderer* renderer = GetSubsystem<Renderer>();
ResourceCache* cache = GetSubsystem<ResourceCache>();
UI* ui_ = GetSubsystem<UI>();
UIElement * UIRoot = ui_->GetRoot();
GameStateHandlerComponent * gamestatehandlercomponent_ = GetSubsystem<GameStateHandlerComponent>();
/// get the button that was clicked
Button* clicked = static_cast<Button*>(eventData[UIMouseClick::P_ELEMENT].GetPtr());
/// Get TheName
String ClickedButton(clicked->GetName().ToLower());
/// If exit was clicked
if (ClickedButton.Contains("apply")==true)
{
/// Get parameters
Slider * VideoBloomParam1= (Slider *)UIRoot->GetChild("VideoBloomParam1Slider",true);
Slider * VideoBloomParam2= (Slider *)UIRoot->GetChild("VideoBloomParam2Slider",true);
float VideoBloomParam1Value = VideoBloomParam1->GetValue();
float VideoBloomParam2Value = VideoBloomParam2->GetValue();
/// Set parameter
effectRenderPath->SetShaderParameter("BloomMix", Vector2(VideoBloomParam1Value,VideoBloomParam2Value));
return;
}
/// If exit was clicked
if (ClickedButton.Contains("save")==true)
{
/// Get parameters
Slider * VideoBloomParam1= (Slider *)UIRoot->GetChild("VideoBloomParam1Slider",true);
Slider * VideoBloomParam2= (Slider *)UIRoot->GetChild("VideoBloomParam2Slider",true);
CheckBox * GameForceTabletModeCheckBox = (CheckBox *) UIRoot->GetChild("GameForceTabletModeCheckBox",true);
///Create new config
Configuration SaveNewConfig;
/// Copy info
SaveNewConfig.GameModeForceTablet= GameForceTabletModeCheckBox->IsChecked();
SaveNewConfig.VideoBloomParam1 = VideoBloomParam1->GetValue();
SaveNewConfig.VideoBloomParam2 = VideoBloomParam2->GetValue();
/// Save new config
SaveConfiguration(SaveNewConfig);
return;
}
return;
}
/// If false, will use current stack top to get hover element. If using mouse you should pass true as argument.
UIElement * UserInterface::GetHoverElement(bool fromRoot /* = false */)
{
if (fromRoot)
return root->GetElementByState(UIState::HOVER);
UIElement * stackTop = GetStackTop();
if (stackTop)
return stackTop->GetElementByState(UIState::HOVER);
return NULL;
}
UIElement* UI::drag(const MouseCursor& cursor) {
UIElement* selected = getSelected();
if(!selected) return 0;
selected->drag(cursor.getPos());
return selected;
}
void UIStatic::InitDefaultElements()
{
UIElement Element;
{
Element.SetFont(0, Color(1, 1, 1, 1), Font::FA_Hor_Left | Font::FA_Ver_Top);
Element.FontColor().States[UICS_Disabled] = Color(200.0f / 255, 200.0f / 255, 200.0f / 255, 200.0f / 255);
elements_.push_back(MakeSharedPtr<UIElement>(Element));
}
}
void CocoWidget::removeAllUIElementsAndCleanUp(bool cleanup)
{
int times = this->m_UIElements->count();
for (int i=0;i<times;i++){
UIElement* element = (UIElement*)(this->m_UIElements->lastObject());
this->m_UIElements->removeObject(element);
element->releaseResoures();
delete element;
element = NULL;
}
}
void DropDownList::HandleItemClicked(StringHash eventType, VariantMap& eventData)
{
// Resize the selection placeholder to match the selected item
UIElement* selectedItem = GetSelectedItem();
if (selectedItem)
placeholder_->SetSize(selectedItem->GetSize());
// Close and defocus the popup. This will actually send the selection forward
if (listView_->HasFocus())
GetSubsystem<UI>()->SetFocusElement(focusMode_ < FM_FOCUSABLE ? nullptr : this);
ShowPopup(false);
}
void MechanicsHud::HandleRelease(StringHash eventType, VariantMap& eventData)
{
using namespace Released;
UIElement* ele = static_cast<UIElement*>(eventData[Released::P_ELEMENT].GetPtr());
String mechanicID = ele->GetVar("mechanicID").GetString();
VariantMap vm;
vm[MechanicRequest::P_MECHANICID] = mechanicID;
SendEvent(E_MECHANICREQUEST, vm);
}
UIElement*UserInterface::findElem(const glm::vec2 &pnt) {
for (auto it = slots.rbegin(); it != slots.rend(); ++it) {
if (!(*it)->isVisible())
continue;
UIElement *el = (*it)->containPoint(pnt);
if (el != nullptr && el->isVisible() && el->isEnabled()) {
return el;
}
}
return nullptr;
}