Ykkrosh
9e499cdec5
Simplify hotkey system to use strings consistently. Restrict scope of GUI hotkey bindings to the associated page. Avoid hard-coding list of hotkeys. Clean up the code a little bit and fix some bugs. Remove unused "!" prefix for key negation. Fixes #567. This was SVN commit r8444.
1859 lines
47 KiB
C++
1859 lines
47 KiB
C++
/* Copyright (C) 2009 Wildfire Games.
|
|
* This file is part of 0 A.D.
|
|
*
|
|
* 0 A.D. is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* 0 A.D. is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/*
|
|
CGUI
|
|
*/
|
|
|
|
#include "precompiled.h"
|
|
|
|
#include <string>
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include "lib/res/graphics/unifont.h"
|
|
|
|
#include "GUI.h"
|
|
|
|
// Types - when including them into the engine.
|
|
#include "CButton.h"
|
|
#include "CImage.h"
|
|
#include "CText.h"
|
|
#include "CCheckBox.h"
|
|
#include "CRadioButton.h"
|
|
#include "CInput.h"
|
|
#include "CList.h"
|
|
#include "CDropDown.h"
|
|
#include "CProgressBar.h"
|
|
#include "CTooltip.h"
|
|
#include "MiniMap.h"
|
|
#include "scripting/JSInterface_GUITypes.h"
|
|
|
|
#include "ps/XML/Xeromyces.h"
|
|
#include "ps/Font.h"
|
|
|
|
#include "ps/Pyrogenesis.h"
|
|
#include "lib/input.h"
|
|
#include "lib/bits.h"
|
|
#include "lib/timer.h"
|
|
#include "lib/utf8.h"
|
|
#include "lib/sysdep/sysdep.h"
|
|
// TODO Gee: Whatever include CRect/CPos/CSize
|
|
#include "ps/Overlay.h"
|
|
#include "ps/Profile.h"
|
|
|
|
#include "scripting/ScriptingHost.h"
|
|
#include "ps/Hotkey.h"
|
|
#include "ps/Globals.h"
|
|
#include "ps/Filesystem.h"
|
|
|
|
const double SELECT_DBLCLICK_RATE = 0.5;
|
|
#include "ps/CLogger.h"
|
|
#define LOG_CATEGORY L"gui"
|
|
|
|
void CGUI::ScriptingInit()
|
|
{
|
|
JSI_IGUIObject::init();
|
|
JSI_GUITypes::init();
|
|
}
|
|
|
|
InReaction CGUI::HandleEvent(const SDL_Event_* ev)
|
|
{
|
|
InReaction ret = IN_PASS;
|
|
|
|
if (ev->ev.type == SDL_HOTKEYDOWN)
|
|
{
|
|
const char* hotkey = static_cast<const char*>(ev->ev.user.data1);
|
|
std::map<CStr, std::vector<IGUIObject*> >::iterator it = m_HotkeyObjects.find(hotkey);
|
|
if (it != m_HotkeyObjects.end())
|
|
{
|
|
for (size_t i = 0; i < it->second.size(); ++i)
|
|
{
|
|
it->second[i]->HandleMessage(SGUIMessage(GUIM_PRESSED));
|
|
it->second[i]->ScriptEvent("press");
|
|
}
|
|
}
|
|
}
|
|
|
|
else if (ev->ev.type == SDL_MOUSEMOTION)
|
|
{
|
|
// Yes the mouse position is stored as float to avoid
|
|
// constant conversions when operating in a
|
|
// float-based environment.
|
|
m_MousePos = CPos((float)ev->ev.motion.x, (float)ev->ev.motion.y);
|
|
|
|
GUI<SGUIMessage>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST, m_BaseObject,
|
|
&IGUIObject::HandleMessage,
|
|
SGUIMessage(GUIM_MOUSE_MOTION));
|
|
}
|
|
|
|
// Update m_MouseButtons. (BUTTONUP is handled later.)
|
|
else if (ev->ev.type == SDL_MOUSEBUTTONDOWN)
|
|
{
|
|
switch (ev->ev.button.button)
|
|
{
|
|
case SDL_BUTTON_LEFT:
|
|
case SDL_BUTTON_RIGHT:
|
|
case SDL_BUTTON_MIDDLE:
|
|
m_MouseButtons |= Bit<unsigned int>(ev->ev.button.button);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Only one object can be hovered
|
|
IGUIObject *pNearest = NULL;
|
|
|
|
// TODO Gee: (2004-09-08) Big TODO, don't do the below if the SDL_Event is something like a keypress!
|
|
try
|
|
{
|
|
PROFILE( "mouse events" );
|
|
// TODO Gee: Optimizations needed!
|
|
// these two recursive function are quite overhead heavy.
|
|
|
|
// pNearest will after this point at the hovered object, possibly NULL
|
|
pNearest = FindObjectUnderMouse();
|
|
|
|
// Is placed in the UpdateMouseOver function
|
|
//if (ev->ev.type == SDL_MOUSEMOTION && pNearest)
|
|
// pNearest->ScriptEvent("mousemove");
|
|
|
|
// Now we'll call UpdateMouseOver on *all* objects,
|
|
// we'll input the one hovered, and they will each
|
|
// update their own data and send messages accordingly
|
|
|
|
GUI<IGUIObject*>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST, m_BaseObject,
|
|
&IGUIObject::UpdateMouseOver,
|
|
pNearest);
|
|
|
|
if (ev->ev.type == SDL_MOUSEBUTTONDOWN)
|
|
{
|
|
switch (ev->ev.button.button)
|
|
{
|
|
case SDL_BUTTON_LEFT:
|
|
// Focus the clicked object (or focus none if nothing clicked on)
|
|
SetFocusedObject(pNearest);
|
|
|
|
if (pNearest)
|
|
{
|
|
pNearest->HandleMessage(SGUIMessage(GUIM_MOUSE_PRESS_LEFT));
|
|
pNearest->ScriptEvent("mouseleftpress");
|
|
|
|
// Block event, so things on the map (behind the GUI) won't be pressed
|
|
ret = IN_HANDLED;
|
|
}
|
|
break;
|
|
|
|
case SDL_BUTTON_RIGHT:
|
|
if (pNearest)
|
|
{
|
|
pNearest->HandleMessage(SGUIMessage(GUIM_MOUSE_PRESS_RIGHT));
|
|
pNearest->ScriptEvent("mouserightpress");
|
|
|
|
ret = IN_HANDLED;
|
|
}
|
|
break;
|
|
|
|
case SDL_BUTTON_WHEELDOWN: // wheel down
|
|
if (pNearest)
|
|
{
|
|
pNearest->HandleMessage(SGUIMessage(GUIM_MOUSE_WHEEL_DOWN));
|
|
pNearest->ScriptEvent("mousewheeldown");
|
|
|
|
ret = IN_HANDLED;
|
|
}
|
|
break;
|
|
|
|
case SDL_BUTTON_WHEELUP: // wheel up
|
|
if (pNearest)
|
|
{
|
|
pNearest->HandleMessage(SGUIMessage(GUIM_MOUSE_WHEEL_UP));
|
|
pNearest->ScriptEvent("mousewheelup");
|
|
|
|
ret = IN_HANDLED;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
if (ev->ev.type == SDL_MOUSEBUTTONUP)
|
|
{
|
|
switch (ev->ev.button.button)
|
|
{
|
|
case SDL_BUTTON_LEFT:
|
|
if (pNearest)
|
|
{
|
|
double timeElapsed = timer_Time() - pNearest->m_LastClickTime[SDL_BUTTON_LEFT];
|
|
pNearest->m_LastClickTime[SDL_BUTTON_LEFT] = timer_Time();
|
|
|
|
//Double click?
|
|
if (timeElapsed < SELECT_DBLCLICK_RATE)
|
|
{
|
|
pNearest->HandleMessage(SGUIMessage(GUIM_MOUSE_DBLCLICK_LEFT));
|
|
pNearest->ScriptEvent("mouseleftdoubleclick");
|
|
}
|
|
else
|
|
{
|
|
pNearest->HandleMessage(SGUIMessage(GUIM_MOUSE_RELEASE_LEFT));
|
|
pNearest->ScriptEvent("mouseleftrelease");
|
|
}
|
|
|
|
ret = IN_HANDLED;
|
|
}
|
|
break;
|
|
case SDL_BUTTON_RIGHT:
|
|
if (pNearest)
|
|
{
|
|
double timeElapsed = timer_Time() - pNearest->m_LastClickTime[SDL_BUTTON_RIGHT];
|
|
pNearest->m_LastClickTime[SDL_BUTTON_RIGHT] = timer_Time();
|
|
|
|
//Double click?
|
|
if (timeElapsed < SELECT_DBLCLICK_RATE)
|
|
{
|
|
pNearest->HandleMessage(SGUIMessage(GUIM_MOUSE_DBLCLICK_RIGHT));
|
|
//pNearest->ScriptEvent("mouserightdoubleclick");
|
|
}
|
|
else
|
|
{
|
|
pNearest->HandleMessage(SGUIMessage(GUIM_MOUSE_RELEASE_RIGHT));
|
|
//pNearest->ScriptEvent("mouserightrelease");
|
|
}
|
|
|
|
ret = IN_HANDLED;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Reset all states on all visible objects
|
|
GUI<>::RecurseObject(GUIRR_HIDDEN, m_BaseObject,
|
|
&IGUIObject::ResetStates);
|
|
|
|
// It will have reset the mouse over of the current hovered, so we'll
|
|
// have to restore that
|
|
if (pNearest)
|
|
pNearest->m_MouseHovering = true;
|
|
}
|
|
}
|
|
catch (PSERROR_GUI& e)
|
|
{
|
|
UNUSED2(e);
|
|
debug_warn(L"CGUI::HandleEvent error");
|
|
// TODO Gee: Handle
|
|
}
|
|
// JW: what's the difference between mPress and mDown? what's the code below responsible for?
|
|
/*
|
|
// Generally if just mouse is clicked
|
|
if (m_pInput->mDown(NEMM_BUTTON1) && pNearest)
|
|
{
|
|
pNearest->HandleMessage(GUIM_MOUSE_DOWN_LEFT);
|
|
}
|
|
*/
|
|
|
|
// BUTTONUP's effect on m_MouseButtons is handled after
|
|
// everything else, so that e.g. 'press' handlers (activated
|
|
// on button up) see which mouse button had been pressed.
|
|
if (ev->ev.type == SDL_MOUSEBUTTONUP)
|
|
{
|
|
switch (ev->ev.button.button)
|
|
{
|
|
case SDL_BUTTON_LEFT:
|
|
case SDL_BUTTON_RIGHT:
|
|
case SDL_BUTTON_MIDDLE:
|
|
m_MouseButtons &= ~Bit<unsigned int>(ev->ev.button.button);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Handle keys for input boxes
|
|
if (GetFocusedObject())
|
|
{
|
|
if (
|
|
(ev->ev.type == SDL_KEYDOWN &&
|
|
ev->ev.key.keysym.sym != SDLK_ESCAPE &&
|
|
!g_keys[SDLK_LCTRL] && !g_keys[SDLK_RCTRL] &&
|
|
!g_keys[SDLK_LALT] && !g_keys[SDLK_RALT])
|
|
|| ev->ev.type == SDL_HOTKEYDOWN
|
|
)
|
|
{
|
|
ret = GetFocusedObject()->ManuallyHandleEvent(ev);
|
|
}
|
|
// else will return IN_PASS because we never used the button.
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void CGUI::TickObjects()
|
|
{
|
|
CStr action = "tick";
|
|
GUI<CStr>::RecurseObject(0, m_BaseObject,
|
|
&IGUIObject::ScriptEvent, action);
|
|
|
|
// Also update tooltips:
|
|
m_Tooltip.Update(FindObjectUnderMouse(), m_MousePos, this);
|
|
}
|
|
|
|
void CGUI::SendEventToAll(const CStr& EventName)
|
|
{
|
|
// janwas 2006-03-03: spoke with Ykkrosh about EventName case.
|
|
// when registering, case is converted to lower - this avoids surprise
|
|
// if someone were to get the case wrong and then not notice their
|
|
// handler is never called. however, until now, the other end
|
|
// (sending events here) wasn't converting to lower case,
|
|
// leading to a similar problem.
|
|
// now fixed; case is irrelevant since all are converted to lower.
|
|
GUI<CStr>::RecurseObject(0, m_BaseObject,
|
|
&IGUIObject::ScriptEvent, EventName.LowerCase());
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Constructor / Destructor
|
|
//-------------------------------------------------------------------
|
|
CGUI::CGUI() : m_MouseButtons(0), m_FocusedObject(NULL), m_InternalNameNumber(0)
|
|
{
|
|
m_BaseObject = new CGUIDummyObject;
|
|
m_BaseObject->SetGUI(this);
|
|
|
|
// Construct the parent object for all GUI JavaScript things
|
|
m_ScriptObject = JS_NewObject(g_ScriptingHost.getContext(), NULL, g_ScriptingHost.GetGlobalObject(), NULL);
|
|
debug_assert(m_ScriptObject != NULL); // How should it handle errors?
|
|
JS_AddRoot(g_ScriptingHost.getContext(), &m_ScriptObject);
|
|
}
|
|
|
|
CGUI::~CGUI()
|
|
{
|
|
Destroy();
|
|
|
|
if (m_BaseObject)
|
|
delete m_BaseObject;
|
|
|
|
if (m_ScriptObject)
|
|
{
|
|
// Let it be garbage-collected
|
|
JS_RemoveRoot(g_ScriptingHost.getContext(), &m_ScriptObject);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
// Functions
|
|
//-------------------------------------------------------------------
|
|
IGUIObject *CGUI::ConstructObject(const CStr& str)
|
|
{
|
|
if (m_ObjectTypes.count(str) > 0)
|
|
return (*m_ObjectTypes[str])();
|
|
else
|
|
{
|
|
// Error reporting will be handled with the NULL return.
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
void CGUI::Initialize()
|
|
{
|
|
// Add base types!
|
|
// You can also add types outside the GUI to extend the flexibility of the GUI.
|
|
// Pyrogenesis though will have all the object types inserted from here.
|
|
AddObjectType("empty", &CGUIDummyObject::ConstructObject);
|
|
AddObjectType("button", &CButton::ConstructObject);
|
|
AddObjectType("image", &CImage::ConstructObject);
|
|
AddObjectType("text", &CText::ConstructObject);
|
|
AddObjectType("checkbox", &CCheckBox::ConstructObject);
|
|
AddObjectType("radiobutton", &CRadioButton::ConstructObject);
|
|
AddObjectType("progressbar", &CProgressBar::ConstructObject);
|
|
AddObjectType("minimap", &CMiniMap::ConstructObject);
|
|
AddObjectType("input", &CInput::ConstructObject);
|
|
AddObjectType("list", &CList::ConstructObject);
|
|
AddObjectType("dropdown", &CDropDown::ConstructObject);
|
|
}
|
|
|
|
void CGUI::Draw()
|
|
{
|
|
// Clear the depth buffer, so the GUI is
|
|
// drawn on top of everything else
|
|
glClear(GL_DEPTH_BUFFER_BIT);
|
|
glPushMatrix();
|
|
|
|
guiLoadIdentity();
|
|
|
|
try
|
|
{
|
|
// Recurse IGUIObject::Draw() with restriction: hidden
|
|
// meaning all hidden objects won't call Draw (nor will it recurse its children)
|
|
GUI<>::RecurseObject(GUIRR_HIDDEN, m_BaseObject, &IGUIObject::Draw);
|
|
}
|
|
catch (PSERROR_GUI& e)
|
|
{
|
|
LOGERROR(L"GUI draw error: %hs", e.what());
|
|
}
|
|
glPopMatrix();
|
|
}
|
|
|
|
void CGUI::DrawSprite(const CGUISpriteInstance& Sprite,
|
|
int CellID,
|
|
const float& Z,
|
|
const CRect& Rect,
|
|
const CRect& UNUSED(Clipping))
|
|
{
|
|
// If the sprite doesn't exist (name == ""), don't bother drawing anything
|
|
if (Sprite.IsEmpty())
|
|
return;
|
|
|
|
// TODO: Clipping?
|
|
|
|
glPushMatrix();
|
|
glTranslatef(0.0f, 0.0f, Z);
|
|
|
|
Sprite.Draw(Rect, CellID, m_Sprites);
|
|
|
|
glPopMatrix();
|
|
|
|
}
|
|
|
|
void CGUI::Destroy()
|
|
{
|
|
// We can use the map to delete all
|
|
// now we don't want to cancel all if one Destroy fails
|
|
map_pObjects::iterator it;
|
|
for (it = m_pAllObjects.begin(); it != m_pAllObjects.end(); ++it)
|
|
{
|
|
try
|
|
{
|
|
it->second->Destroy();
|
|
}
|
|
catch (PSERROR_GUI& e)
|
|
{
|
|
UNUSED2(e);
|
|
debug_warn(L"CGUI::Destroy error");
|
|
// TODO Gee: Handle
|
|
}
|
|
|
|
delete it->second;
|
|
}
|
|
|
|
for (std::map<CStr, CGUISprite>::iterator it2 = m_Sprites.begin(); it2 != m_Sprites.end(); ++it2)
|
|
for (std::vector<SGUIImage>::iterator it3 = it2->second.m_Images.begin(); it3 != it2->second.m_Images.end(); ++it3)
|
|
delete it3->m_Effects;
|
|
|
|
// Clear all
|
|
m_pAllObjects.clear();
|
|
m_Sprites.clear();
|
|
m_Icons.clear();
|
|
}
|
|
|
|
void CGUI::UpdateResolution()
|
|
{
|
|
// Update ALL cached
|
|
GUI<>::RecurseObject(0, m_BaseObject, &IGUIObject::UpdateCachedSize );
|
|
}
|
|
|
|
void CGUI::AddObject(IGUIObject* pObject)
|
|
{
|
|
try
|
|
{
|
|
// Add CGUI pointer
|
|
GUI<CGUI*>::RecurseObject(0, pObject, &IGUIObject::SetGUI, this);
|
|
|
|
// Add child to base object
|
|
m_BaseObject->AddChild(pObject); // can throw
|
|
|
|
// Cache tree
|
|
GUI<>::RecurseObject(0, pObject, &IGUIObject::UpdateCachedSize);
|
|
|
|
// Loaded
|
|
GUI<SGUIMessage>::RecurseObject(0, pObject, &IGUIObject::HandleMessage, SGUIMessage(GUIM_LOAD));
|
|
}
|
|
catch (PSERROR_GUI&)
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void CGUI::UpdateObjects()
|
|
{
|
|
// We'll fill a temporary map until we know everything
|
|
// succeeded
|
|
map_pObjects AllObjects;
|
|
|
|
try
|
|
{
|
|
// Fill freshly
|
|
GUI< map_pObjects >::RecurseObject(0, m_BaseObject, &IGUIObject::AddToPointersMap, AllObjects );
|
|
}
|
|
catch (PSERROR_GUI&)
|
|
{
|
|
// Throw the same error
|
|
throw;
|
|
}
|
|
|
|
// Else actually update the real one
|
|
m_pAllObjects.swap(AllObjects);
|
|
}
|
|
|
|
bool CGUI::ObjectExists(const CStr& Name) const
|
|
{
|
|
return m_pAllObjects.count(Name) != 0;
|
|
}
|
|
|
|
IGUIObject* CGUI::FindObjectByName(const CStr& Name) const
|
|
{
|
|
map_pObjects::const_iterator it = m_pAllObjects.find(Name);
|
|
if (it == m_pAllObjects.end())
|
|
return NULL;
|
|
else
|
|
return it->second;
|
|
}
|
|
|
|
IGUIObject* CGUI::FindObjectUnderMouse() const
|
|
{
|
|
IGUIObject* pNearest = NULL;
|
|
GUI<IGUIObject*>::RecurseObject(GUIRR_HIDDEN | GUIRR_GHOST, m_BaseObject,
|
|
&IGUIObject::ChooseMouseOverAndClosest,
|
|
pNearest);
|
|
return pNearest;
|
|
}
|
|
|
|
void CGUI::SetFocusedObject(IGUIObject* pObject)
|
|
{
|
|
if (pObject == m_FocusedObject)
|
|
return;
|
|
|
|
if (m_FocusedObject)
|
|
m_FocusedObject->HandleMessage(SGUIMessage(GUIM_LOST_FOCUS));
|
|
|
|
m_FocusedObject = pObject;
|
|
|
|
if (m_FocusedObject)
|
|
m_FocusedObject->HandleMessage(SGUIMessage(GUIM_GOT_FOCUS));
|
|
}
|
|
|
|
// private struct used only in GenerateText(...)
|
|
struct SGenerateTextImage
|
|
{
|
|
float m_YFrom, // The image's starting location in Y
|
|
m_YTo, // The image's end location in Y
|
|
m_Indentation; // The image width in other words
|
|
|
|
// Some help functions
|
|
// TODO Gee: CRect => CPoint ?
|
|
void SetupSpriteCall(const bool Left, SGUIText::SSpriteCall &SpriteCall,
|
|
const float width, const float y,
|
|
const CSize &Size, const CStr& TextureName,
|
|
const float BufferZone, const int CellID)
|
|
{
|
|
// TODO Gee: Temp hardcoded values
|
|
SpriteCall.m_Area.top = y+BufferZone;
|
|
SpriteCall.m_Area.bottom = y+BufferZone + Size.cy;
|
|
|
|
if (Left)
|
|
{
|
|
SpriteCall.m_Area.left = BufferZone;
|
|
SpriteCall.m_Area.right = Size.cx+BufferZone;
|
|
}
|
|
else
|
|
{
|
|
SpriteCall.m_Area.left = width-BufferZone - Size.cx;
|
|
SpriteCall.m_Area.right = width-BufferZone;
|
|
}
|
|
|
|
SpriteCall.m_CellID = CellID;
|
|
SpriteCall.m_Sprite = TextureName;
|
|
|
|
m_YFrom = SpriteCall.m_Area.top-BufferZone;
|
|
m_YTo = SpriteCall.m_Area.bottom+BufferZone;
|
|
m_Indentation = Size.cx+BufferZone*2;
|
|
}
|
|
};
|
|
|
|
SGUIText CGUI::GenerateText(const CGUIString &string,
|
|
const CStr& Font, const float &Width, const float &BufferZone,
|
|
const IGUIObject *pObject)
|
|
{
|
|
SGUIText Text; // object we're generating
|
|
|
|
if (string.m_Words.size() == 0)
|
|
return Text;
|
|
|
|
float x=BufferZone, y=BufferZone; // drawing pointer
|
|
int from=0;
|
|
bool done=false;
|
|
|
|
bool FirstLine = true; // Necessary because text in the first line is shorter
|
|
// (it doesn't count the line spacing)
|
|
|
|
// Images on the left or the right side.
|
|
std::vector<SGenerateTextImage> Images[2];
|
|
int pos_last_img=-1; // Position in the string where last img (either left or right) were encountered.
|
|
// in order to avoid duplicate processing.
|
|
|
|
// Easier to read.
|
|
bool WordWrapping = (Width != 0);
|
|
|
|
// Go through string word by word
|
|
for (int i=0; i<(int)string.m_Words.size()-1 && !done; ++i)
|
|
{
|
|
// Pre-process each line one time, so we know which floating images
|
|
// will be added for that line.
|
|
|
|
// Generated stuff is stored in Feedback.
|
|
CGUIString::SFeedback Feedback;
|
|
|
|
// Preliminary line_height, used for word-wrapping with floating images.
|
|
float prelim_line_height=0.f;
|
|
|
|
// Width and height of all text calls generated.
|
|
string.GenerateTextCall(Feedback, Font,
|
|
string.m_Words[i], string.m_Words[i+1],
|
|
FirstLine);
|
|
|
|
// Loop through our images queues, to see if images has been added.
|
|
|
|
// Check if this has already been processed.
|
|
// Also, floating images are only applicable if Word-Wrapping is on
|
|
if (WordWrapping && i > pos_last_img)
|
|
{
|
|
// Loop left/right
|
|
for (int j=0; j<2; ++j)
|
|
{
|
|
for (std::vector<CStr>::const_iterator it = Feedback.m_Images[j].begin();
|
|
it != Feedback.m_Images[j].end();
|
|
++it)
|
|
{
|
|
SGUIText::SSpriteCall SpriteCall;
|
|
SGenerateTextImage Image;
|
|
|
|
// Y is if no other floating images is above, y. Else it is placed
|
|
// after the last image, like a stack downwards.
|
|
float _y;
|
|
if (Images[j].size() > 0)
|
|
_y = std::max(y, Images[j].back().m_YTo);
|
|
else
|
|
_y = y;
|
|
|
|
// Get Size from Icon database
|
|
SGUIIcon icon = GetIcon(*it);
|
|
|
|
CSize size = icon.m_Size;
|
|
Image.SetupSpriteCall((j==CGUIString::SFeedback::Left), SpriteCall, Width, _y, size, icon.m_SpriteName, BufferZone, icon.m_CellID);
|
|
|
|
// Check if image is the lowest thing.
|
|
Text.m_Size.cy = std::max(Text.m_Size.cy, Image.m_YTo);
|
|
|
|
Images[j].push_back(Image);
|
|
Text.m_SpriteCalls.push_back(SpriteCall);
|
|
}
|
|
}
|
|
}
|
|
|
|
pos_last_img = std::max(pos_last_img, i);
|
|
|
|
x += Feedback.m_Size.cx;
|
|
prelim_line_height = std::max(prelim_line_height, Feedback.m_Size.cy);
|
|
|
|
// If Width is 0, then there's no word-wrapping, disable NewLine.
|
|
if ((WordWrapping && (x > Width-BufferZone || Feedback.m_NewLine)) || i == (int)string.m_Words.size()-2)
|
|
{
|
|
// Change 'from' to 'i', but first keep a copy of its value.
|
|
int temp_from = from;
|
|
from = i;
|
|
|
|
static const int From=0, To=1;
|
|
//int width_from=0, width_to=width;
|
|
float width_range[2];
|
|
width_range[From] = BufferZone;
|
|
width_range[To] = Width - BufferZone;
|
|
|
|
// Floating images are only applicable if word-wrapping is enabled.
|
|
if (WordWrapping)
|
|
{
|
|
// Decide width of the line. We need to iterate our floating images.
|
|
// this won't be exact because we're assuming the line_height
|
|
// will be as our preliminary calculation said. But that may change,
|
|
// although we'd have to add a couple of more loops to try straightening
|
|
// this problem out, and it is very unlikely to happen noticeably if one
|
|
// structures his text in a stylistically pure fashion. Even if not, it
|
|
// is still quite unlikely it will happen.
|
|
// Loop through left and right side, from and to.
|
|
for (int j=0; j<2; ++j)
|
|
{
|
|
for (std::vector<SGenerateTextImage>::const_iterator it = Images[j].begin();
|
|
it != Images[j].end();
|
|
++it)
|
|
{
|
|
// We're working with two intervals here, the image's and the line height's.
|
|
// let's find the union of these two.
|
|
float union_from, union_to;
|
|
|
|
union_from = std::max(y, it->m_YFrom);
|
|
union_to = std::min(y+prelim_line_height, it->m_YTo);
|
|
|
|
// The union is not empty
|
|
if (union_to > union_from)
|
|
{
|
|
if (j == From)
|
|
width_range[From] = std::max(width_range[From], it->m_Indentation);
|
|
else
|
|
width_range[To] = std::min(width_range[To], Width - it->m_Indentation);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Reset X for the next loop
|
|
x = width_range[From];
|
|
|
|
// Now we'll do another loop to figure out the height of
|
|
// the line (the height of the largest character). This
|
|
// couldn't be determined in the first loop (main loop)
|
|
// because it didn't regard images, so we don't know
|
|
// if all characters processed, will actually be involved
|
|
// in that line.
|
|
float line_height=0.f;
|
|
for (int j=temp_from; j<=i; ++j)
|
|
{
|
|
// We don't want to use Feedback now, so we'll have to use
|
|
// another.
|
|
CGUIString::SFeedback Feedback2;
|
|
|
|
// Don't attach object, it'll suppress the errors
|
|
// we want them to be reported in the final GenerateTextCall()
|
|
// so that we don't get duplicates.
|
|
string.GenerateTextCall(Feedback2, Font,
|
|
string.m_Words[j], string.m_Words[j+1],
|
|
FirstLine);
|
|
|
|
// Append X value.
|
|
x += Feedback2.m_Size.cx;
|
|
|
|
if (WordWrapping && x > width_range[To] && j!=temp_from && !Feedback2.m_NewLine)
|
|
break;
|
|
|
|
// Let line_height be the maximum m_Height we encounter.
|
|
line_height = std::max(line_height, Feedback2.m_Size.cy);
|
|
|
|
if (WordWrapping && Feedback2.m_NewLine)
|
|
break;
|
|
}
|
|
|
|
// Reset x once more
|
|
x = width_range[From];
|
|
// Move down, because font drawing starts from the baseline
|
|
y += line_height;
|
|
|
|
// Do the real processing now
|
|
for (int j=temp_from; j<=i; ++j)
|
|
{
|
|
// We don't want to use Feedback now, so we'll have to use
|
|
// another one.
|
|
CGUIString::SFeedback Feedback2;
|
|
|
|
// Defaults
|
|
string.GenerateTextCall(Feedback2, Font,
|
|
string.m_Words[j], string.m_Words[j+1],
|
|
FirstLine, pObject);
|
|
|
|
// Iterate all and set X/Y values
|
|
// Since X values are not set, we need to make an internal
|
|
// iteration with an increment that will append the internal
|
|
// x, that is what x_pointer is for.
|
|
float x_pointer=0.f;
|
|
|
|
std::vector<SGUIText::STextCall>::iterator it;
|
|
for (it = Feedback2.m_TextCalls.begin(); it != Feedback2.m_TextCalls.end(); ++it)
|
|
{
|
|
it->m_Pos = CPos(x + x_pointer, y);
|
|
|
|
x_pointer += it->m_Size.cx;
|
|
|
|
if (it->m_pSpriteCall)
|
|
{
|
|
it->m_pSpriteCall->m_Area += it->m_Pos - CSize(0,it->m_pSpriteCall->m_Area.GetHeight());
|
|
}
|
|
}
|
|
|
|
// Append X value.
|
|
x += Feedback2.m_Size.cx;
|
|
|
|
Text.m_Size.cx = std::max(Text.m_Size.cx, x+BufferZone);
|
|
|
|
// The first word overrides the width limit, what we
|
|
// do, in those cases, are just drawing that word even
|
|
// though it'll extend the object.
|
|
if (WordWrapping) // only if word-wrapping is applicable
|
|
{
|
|
if (Feedback2.m_NewLine)
|
|
{
|
|
from = j+1;
|
|
|
|
// Sprite call can exist within only a newline segment,
|
|
// therefore we need this.
|
|
Text.m_SpriteCalls.insert(Text.m_SpriteCalls.end(), Feedback2.m_SpriteCalls.begin(), Feedback2.m_SpriteCalls.end());
|
|
break;
|
|
}
|
|
else
|
|
if (x > width_range[To] && j==temp_from)
|
|
{
|
|
from = j+1;
|
|
// do not break, since we want it to be added to m_TextCalls
|
|
}
|
|
else
|
|
if (x > width_range[To])
|
|
{
|
|
from = j;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Add the whole Feedback2.m_TextCalls to our m_TextCalls.
|
|
Text.m_TextCalls.insert(Text.m_TextCalls.end(), Feedback2.m_TextCalls.begin(), Feedback2.m_TextCalls.end());
|
|
Text.m_SpriteCalls.insert(Text.m_SpriteCalls.end(), Feedback2.m_SpriteCalls.begin(), Feedback2.m_SpriteCalls.end());
|
|
|
|
if (j == (int)string.m_Words.size()-2)
|
|
done = true;
|
|
}
|
|
|
|
// Reset X
|
|
x = 0.f;
|
|
|
|
// Update height of all
|
|
Text.m_Size.cy = std::max(Text.m_Size.cy, y+BufferZone);
|
|
|
|
FirstLine = false;
|
|
|
|
// Now if we entered as from = i, then we want
|
|
// i being one minus that, so that it will become
|
|
// the same i in the next loop. The difference is that
|
|
// we're on a new line now.
|
|
i = from-1;
|
|
}
|
|
}
|
|
|
|
return Text;
|
|
}
|
|
|
|
void CGUI::DrawText(SGUIText &Text, const CColor &DefaultColor,
|
|
const CPos &pos, const float &z, const CRect &clipping)
|
|
{
|
|
// TODO Gee: All these really necessary? Some
|
|
// are defaults and if you changed them
|
|
// the opposite value at the end of the functions,
|
|
// some things won't be drawn correctly.
|
|
glEnable(GL_TEXTURE_2D);
|
|
glDisable(GL_CULL_FACE);
|
|
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
glEnable(GL_BLEND);
|
|
glDisable(GL_ALPHA_TEST);
|
|
|
|
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
|
|
|
if (clipping != CRect())
|
|
{
|
|
double eq[4][4] =
|
|
{
|
|
{ 0.0, 1.0, 0.0, -clipping.top },
|
|
{ 1.0, 0.0, 0.0, -clipping.left },
|
|
{ 0.0, -1.0, 0.0, clipping.bottom },
|
|
{ -1.0, 0.0, 0.0, clipping.right }
|
|
};
|
|
|
|
for (int i=0; i<4; ++i)
|
|
{
|
|
glClipPlane(GL_CLIP_PLANE0+i, eq[i]);
|
|
glEnable(GL_CLIP_PLANE0+i);
|
|
}
|
|
}
|
|
|
|
CFont* font = NULL;
|
|
CStrW LastFontName;
|
|
|
|
for (std::vector<SGUIText::STextCall>::const_iterator it = Text.m_TextCalls.begin();
|
|
it != Text.m_TextCalls.end();
|
|
++it)
|
|
{
|
|
// If this is just a placeholder for a sprite call, continue
|
|
if (it->m_pSpriteCall)
|
|
continue;
|
|
|
|
// Switch fonts when necessary, but remember the last one used
|
|
if (it->m_Font != LastFontName)
|
|
{
|
|
delete font;
|
|
font = new CFont(it->m_Font);
|
|
font->Bind();
|
|
LastFontName = it->m_Font;
|
|
}
|
|
|
|
CColor color = it->m_UseCustomColor ? it->m_Color : DefaultColor;
|
|
|
|
glPushMatrix();
|
|
|
|
// TODO Gee: (2004-09-04) Why are font corrupted if inputted float value?
|
|
glTranslatef((GLfloat)int(pos.x+it->m_Pos.x), (GLfloat)int(pos.y+it->m_Pos.y), z);
|
|
glColor4fv(color.FloatArray());
|
|
glwprintf(L"%ls", it->m_String.c_str()); // "%ls" is necessary in case m_String contains % symbols
|
|
|
|
glPopMatrix();
|
|
|
|
}
|
|
|
|
if (font)
|
|
delete font;
|
|
|
|
for (std::list<SGUIText::SSpriteCall>::iterator it=Text.m_SpriteCalls.begin();
|
|
it!=Text.m_SpriteCalls.end();
|
|
++it)
|
|
{
|
|
DrawSprite(it->m_Sprite, it->m_CellID, z, it->m_Area + pos);
|
|
}
|
|
|
|
// TODO To whom it may concern: Thing were not reset, so
|
|
// I added this line, modify if incorrect --
|
|
if (clipping != CRect())
|
|
{
|
|
for (int i=0; i<4; ++i)
|
|
glDisable(GL_CLIP_PLANE0+i);
|
|
}
|
|
glDisable(GL_TEXTURE_2D);
|
|
// -- GL
|
|
}
|
|
|
|
bool CGUI::GetPreDefinedColor(const CStr& name, CColor &Output)
|
|
{
|
|
if (m_PreDefinedColors.count(name) == 0)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
Output = m_PreDefinedColors[name];
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @callgraph
|
|
*/
|
|
void CGUI::LoadXmlFile(const VfsPath& Filename, std::set<VfsPath>& Paths)
|
|
{
|
|
Paths.insert(Filename);
|
|
|
|
CXeromyces XeroFile;
|
|
if (XeroFile.Load(g_VFS, Filename) != PSRETURN_OK)
|
|
// Fail silently
|
|
return;
|
|
|
|
XMBElement node = XeroFile.GetRoot();
|
|
|
|
// Check root element's (node) name so we know what kind of
|
|
// data we'll be expecting
|
|
CStr root_name (XeroFile.GetElementString(node.GetNodeName()));
|
|
|
|
try
|
|
{
|
|
|
|
if (root_name == "objects")
|
|
{
|
|
Xeromyces_ReadRootObjects(node, &XeroFile, Paths);
|
|
|
|
// Re-cache all values so these gets cached too.
|
|
//UpdateResolution();
|
|
}
|
|
else
|
|
if (root_name == "sprites")
|
|
{
|
|
Xeromyces_ReadRootSprites(node, &XeroFile);
|
|
}
|
|
else
|
|
if (root_name == "styles")
|
|
{
|
|
Xeromyces_ReadRootStyles(node, &XeroFile);
|
|
}
|
|
else
|
|
if (root_name == "setup")
|
|
{
|
|
Xeromyces_ReadRootSetup(node, &XeroFile);
|
|
}
|
|
else
|
|
{
|
|
debug_warn(L"CGUI::LoadXmlFile error");
|
|
// TODO Gee: Output in log
|
|
}
|
|
}
|
|
catch (PSERROR_GUI& e)
|
|
{
|
|
LOG(CLogger::Error, LOG_CATEGORY, L"Errors loading GUI file %ls (%d)", Filename.string().c_str(), e.getCode());
|
|
return;
|
|
}
|
|
}
|
|
|
|
//===================================================================
|
|
// XML Reading Xeromyces Specific Sub-Routines
|
|
//===================================================================
|
|
|
|
void CGUI::Xeromyces_ReadRootObjects(XMBElement Element, CXeromyces* pFile, std::set<VfsPath>& Paths)
|
|
{
|
|
int el_script = pFile->GetElementID("script");
|
|
|
|
std::vector<std::pair<CStr, CStr> > subst;
|
|
|
|
// Iterate main children
|
|
// they should all be <object> or <script> elements
|
|
XMBElementList children = Element.GetChildNodes();
|
|
for (int i=0; i<children.Count; ++i)
|
|
{
|
|
//debug_printf(L"Object %d\n", i);
|
|
XMBElement child = children.Item(i);
|
|
|
|
if (child.GetNodeName() == el_script)
|
|
// Execute the inline script
|
|
Xeromyces_ReadScript(child, pFile, Paths);
|
|
else
|
|
// Read in this whole object into the GUI
|
|
Xeromyces_ReadObject(child, pFile, m_BaseObject, subst, Paths);
|
|
}
|
|
}
|
|
|
|
void CGUI::Xeromyces_ReadRootSprites(XMBElement Element, CXeromyces* pFile)
|
|
{
|
|
// Iterate main children
|
|
// they should all be <sprite> elements
|
|
XMBElementList children = Element.GetChildNodes();
|
|
for (int i=0; i<children.Count; ++i)
|
|
{
|
|
XMBElement child = children.Item(i);
|
|
|
|
// Read in this whole object into the GUI
|
|
Xeromyces_ReadSprite(child, pFile);
|
|
}
|
|
}
|
|
|
|
void CGUI::Xeromyces_ReadRootStyles(XMBElement Element, CXeromyces* pFile)
|
|
{
|
|
// Iterate main children
|
|
// they should all be <styles> elements
|
|
XMBElementList children = Element.GetChildNodes();
|
|
for (int i=0; i<children.Count; ++i)
|
|
{
|
|
XMBElement child = children.Item(i);
|
|
|
|
// Read in this whole object into the GUI
|
|
Xeromyces_ReadStyle(child, pFile);
|
|
}
|
|
}
|
|
|
|
void CGUI::Xeromyces_ReadRootSetup(XMBElement Element, CXeromyces* pFile)
|
|
{
|
|
// Iterate main children
|
|
// they should all be <icon>, <scrollbar> or <tooltip>.
|
|
XMBElementList children = Element.GetChildNodes();
|
|
for (int i=0; i<children.Count; ++i)
|
|
{
|
|
XMBElement child = children.Item(i);
|
|
|
|
// Read in this whole object into the GUI
|
|
|
|
CStr name (pFile->GetElementString(child.GetNodeName()));
|
|
|
|
if (name == "scrollbar")
|
|
{
|
|
Xeromyces_ReadScrollBarStyle(child, pFile);
|
|
}
|
|
else
|
|
if (name == "icon")
|
|
{
|
|
Xeromyces_ReadIcon(child, pFile);
|
|
}
|
|
else
|
|
if (name == "tooltip")
|
|
{
|
|
Xeromyces_ReadTooltip(child, pFile);
|
|
}
|
|
else
|
|
if (name == "color")
|
|
{
|
|
Xeromyces_ReadColor(child, pFile);
|
|
}
|
|
else
|
|
{
|
|
debug_warn(L"Invalid data - DTD shouldn't allow this");
|
|
}
|
|
}
|
|
}
|
|
|
|
void CGUI::Xeromyces_ReadObject(XMBElement Element, CXeromyces* pFile, IGUIObject *pParent, const std::vector<std::pair<CStr, CStr> >& NameSubst, std::set<VfsPath>& Paths)
|
|
{
|
|
debug_assert(pParent);
|
|
int i;
|
|
|
|
// Our object we are going to create
|
|
IGUIObject *object = NULL;
|
|
|
|
XMBAttributeList attributes = Element.GetAttributes();
|
|
|
|
// Well first of all we need to determine the type
|
|
CStr type (attributes.GetNamedItem(pFile->GetAttributeID("type")));
|
|
if (type.empty())
|
|
type = "empty";
|
|
|
|
// Construct object from specified type
|
|
// henceforth, we need to do a rollback before aborting.
|
|
// i.e. releasing this object
|
|
object = ConstructObject(type);
|
|
|
|
if (!object)
|
|
{
|
|
// Report error that object was unsuccessfully loaded
|
|
LOGERROR(L"GUI: Unrecognized object type \"%hs\"", type.c_str());
|
|
return;
|
|
}
|
|
|
|
// Cache some IDs for element attribute names, to avoid string comparisons
|
|
#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
|
|
#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
|
|
ELMT(object);
|
|
ELMT(action);
|
|
ELMT(repeat);
|
|
ATTR(style);
|
|
ATTR(type);
|
|
ATTR(name);
|
|
ATTR(hotkey);
|
|
ATTR(z);
|
|
ATTR(on);
|
|
ATTR(file);
|
|
|
|
//
|
|
// Read Style and set defaults
|
|
//
|
|
// If the setting "style" is set, try loading that setting.
|
|
//
|
|
// Always load default (if it's available) first!
|
|
//
|
|
CStr argStyle (attributes.GetNamedItem(attr_style));
|
|
|
|
if (m_Styles.count("default") == 1)
|
|
object->LoadStyle(*this, "default");
|
|
|
|
if (! argStyle.empty())
|
|
{
|
|
// additional check
|
|
if (m_Styles.count(argStyle) == 0)
|
|
{
|
|
LOGERROR(L"GUI: Trying to use style '%hs' that doesn't exist.", argStyle.c_str());
|
|
}
|
|
else object->LoadStyle(*this, argStyle);
|
|
}
|
|
|
|
|
|
//
|
|
// Read Attributes
|
|
//
|
|
|
|
bool NameSet = false;
|
|
bool ManuallySetZ = false; // if z has been manually set, this turn true
|
|
|
|
CStr hotkeyTag;
|
|
|
|
// Now we can iterate all attributes and store
|
|
for (i=0; i<attributes.Count; ++i)
|
|
{
|
|
XMBAttribute attr = attributes.Item(i);
|
|
|
|
// If value is "null", then it is equivalent as never being entered
|
|
if (CStr(attr.Value) == "null")
|
|
continue;
|
|
|
|
// Ignore "type" and "style", we've already checked it
|
|
if (attr.Name == attr_type || attr.Name == attr_style)
|
|
continue;
|
|
|
|
// Also the name needs some special attention
|
|
if (attr.Name == attr_name)
|
|
{
|
|
CStr name (attr.Value);
|
|
|
|
// Apply the requested substitutions
|
|
for (size_t j = 0; j < NameSubst.size(); ++j)
|
|
name.Replace(NameSubst[j].first, NameSubst[j].second);
|
|
|
|
object->SetName(name);
|
|
NameSet = true;
|
|
continue;
|
|
}
|
|
|
|
// Wire up the hotkey tag, if it has one
|
|
if (attr.Name == attr_hotkey)
|
|
hotkeyTag = attr.Value;
|
|
|
|
if (attr.Name == attr_z)
|
|
ManuallySetZ = true;
|
|
|
|
// Try setting the value
|
|
if (object->SetSetting(pFile->GetAttributeString(attr.Name), CStrW(attr.Value), true) != PSRETURN_OK)
|
|
{
|
|
LOGERROR(L"GUI: (object: %hs) Can't set \"%hs\" to \"%ls\"", object->GetPresentableName().c_str(), pFile->GetAttributeString(attr.Name).c_str(), CStrW(attr.Value).c_str());
|
|
|
|
// This is not a fatal error
|
|
}
|
|
}
|
|
|
|
// Check if name isn't set, generate an internal name in that case.
|
|
if (!NameSet)
|
|
{
|
|
object->SetName(CStr("__internal(") + CStr(m_InternalNameNumber) + CStr(")"));
|
|
++m_InternalNameNumber;
|
|
}
|
|
|
|
// Attempt to register the hotkey tag, if one was provided
|
|
if (! hotkeyTag.empty())
|
|
m_HotkeyObjects[hotkeyTag].push_back(object);
|
|
|
|
CStrW caption (Element.GetText());
|
|
if (! caption.empty())
|
|
{
|
|
// Set the setting caption to this
|
|
object->SetSetting("caption", caption, true);
|
|
|
|
// There is no harm if the object didn't have a "caption"
|
|
}
|
|
|
|
|
|
//
|
|
// Read Children
|
|
//
|
|
|
|
// Iterate children
|
|
XMBElementList children = Element.GetChildNodes();
|
|
|
|
for (i=0; i<children.Count; ++i)
|
|
{
|
|
// Get node
|
|
XMBElement child = children.Item(i);
|
|
|
|
// Check what name the elements got
|
|
int element_name = child.GetNodeName();
|
|
|
|
if (element_name == elmt_object)
|
|
{
|
|
// Call this function on the child
|
|
Xeromyces_ReadObject(child, pFile, object, NameSubst, Paths);
|
|
}
|
|
else if (element_name == elmt_action)
|
|
{
|
|
// Scripted <action> element
|
|
|
|
// Check for a 'file' parameter
|
|
CStrW filename (child.GetAttributes().GetNamedItem(attr_file));
|
|
|
|
CStr code;
|
|
|
|
// If there is a file, open it and use it as the code
|
|
if (! filename.empty())
|
|
{
|
|
Paths.insert(filename);
|
|
CVFSFile scriptfile;
|
|
if (scriptfile.Load(g_VFS, filename) != PSRETURN_OK)
|
|
{
|
|
LOGERROR(L"Error opening GUI script action file '%ls'", filename.c_str());
|
|
throw PSERROR_GUI_JSOpenFailed();
|
|
}
|
|
|
|
code = scriptfile.GetAsString();
|
|
}
|
|
|
|
// Read the inline code (concatenating to the file code, if both are specified)
|
|
code += CStr(child.GetText());
|
|
|
|
CStr action = CStr(child.GetAttributes().GetNamedItem(attr_on));
|
|
object->RegisterScriptHandler(action.LowerCase(), code, this);
|
|
}
|
|
else if (element_name == elmt_repeat)
|
|
{
|
|
Xeromyces_ReadRepeat(child, pFile, object, Paths);
|
|
}
|
|
else
|
|
{
|
|
// Try making the object read the tag.
|
|
if (!object->HandleAdditionalChildren(child, pFile))
|
|
{
|
|
LOGERROR(L"GUI: (object: %hs) Reading unknown children for its type", object->GetPresentableName().c_str());
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check if Z wasn't manually set
|
|
//
|
|
if (!ManuallySetZ)
|
|
{
|
|
// Set it automatically to 10 plus its parents
|
|
bool absolute;
|
|
GUI<bool>::GetSetting(object, "absolute", absolute);
|
|
|
|
// If the object is absolute, we'll have to get the parent's Z buffered,
|
|
// and add to that!
|
|
if (absolute)
|
|
{
|
|
GUI<float>::SetSetting(object, "z", pParent->GetBufferedZ() + 10.f, true);
|
|
}
|
|
else
|
|
// If the object is relative, then we'll just store Z as "10"
|
|
{
|
|
GUI<float>::SetSetting(object, "z", 10.f, true);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Input Child
|
|
//
|
|
|
|
try
|
|
{
|
|
if (pParent == m_BaseObject)
|
|
AddObject(object);
|
|
else
|
|
pParent->AddChild(object);
|
|
}
|
|
catch (PSERROR_GUI& e)
|
|
{
|
|
LOGERROR(L"GUI error: %hs", e.what());
|
|
}
|
|
}
|
|
|
|
void CGUI::Xeromyces_ReadRepeat(XMBElement Element, CXeromyces* pFile, IGUIObject *pParent, std::set<VfsPath>& Paths)
|
|
{
|
|
#define ELMT(x) int elmt_##x = pFile->GetElementID(#x)
|
|
#define ATTR(x) int attr_##x = pFile->GetAttributeID(#x)
|
|
ELMT(object);
|
|
ATTR(count);
|
|
|
|
XMBAttributeList attributes = Element.GetAttributes();
|
|
|
|
int count = CStr(attributes.GetNamedItem(attr_count)).ToInt();
|
|
|
|
for (int n = 0; n < count; ++n)
|
|
{
|
|
std::vector<std::pair<CStr, CStr> > subst;
|
|
subst.push_back(std::make_pair(CStr("[n]"), "[" + CStr(n) + "]"));
|
|
|
|
XERO_ITER_EL(Element, child)
|
|
{
|
|
if (child.GetNodeName() == elmt_object)
|
|
{
|
|
Xeromyces_ReadObject(child, pFile, pParent, subst, Paths);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CGUI::Xeromyces_ReadScript(XMBElement Element, CXeromyces* pFile, std::set<VfsPath>& Paths)
|
|
{
|
|
// Check for a 'file' parameter
|
|
CStrW file (Element.GetAttributes().GetNamedItem( pFile->GetAttributeID("file") ));
|
|
|
|
// If there is a file specified, open and execute it
|
|
if (! file.empty())
|
|
{
|
|
Paths.insert(file);
|
|
try
|
|
{
|
|
g_ScriptingHost.RunScript(file, m_ScriptObject);
|
|
}
|
|
catch (PSERROR_Scripting& e)
|
|
{
|
|
LOGERROR(L"GUI: Error executing script %ls: %hs", file.c_str(), e.what());
|
|
}
|
|
}
|
|
|
|
// Execute inline scripts
|
|
try
|
|
{
|
|
CStr code (Element.GetText());
|
|
if (! code.empty())
|
|
g_ScriptingHost.RunMemScript(code.c_str(), code.length(), "Some XML file", Element.GetLineNumber(), m_ScriptObject);
|
|
}
|
|
catch (PSERROR_Scripting& e)
|
|
{
|
|
LOGERROR(L"GUI: Error executing inline script: %hs", e.what());
|
|
}
|
|
}
|
|
|
|
void CGUI::Xeromyces_ReadSprite(XMBElement Element, CXeromyces* pFile)
|
|
{
|
|
// Sprite object we're adding
|
|
CGUISprite sprite;
|
|
|
|
// and what will be its reference name
|
|
CStr name;
|
|
|
|
//
|
|
// Read Attributes
|
|
//
|
|
|
|
// Get name, we know it exists because of DTD requirements
|
|
name = Element.GetAttributes().GetNamedItem( pFile->GetAttributeID("name") );
|
|
|
|
if (m_Sprites.find(name) != m_Sprites.end())
|
|
LOGWARNING(L"GUI sprite name '%hs' used more than once; first definition will be discarded", name.c_str());
|
|
|
|
//
|
|
// Read Children (the images)
|
|
//
|
|
|
|
SGUIImageEffects* effects = NULL;
|
|
|
|
// Iterate children
|
|
XMBElementList children = Element.GetChildNodes();
|
|
|
|
for (int i=0; i<children.Count; ++i)
|
|
{
|
|
// Get node
|
|
XMBElement child = children.Item(i);
|
|
|
|
CStr ElementName (pFile->GetElementString(child.GetNodeName()));
|
|
|
|
if (ElementName == "image")
|
|
{
|
|
Xeromyces_ReadImage(child, pFile, sprite);
|
|
}
|
|
else if (ElementName == "effect")
|
|
{
|
|
if (effects)
|
|
{
|
|
LOGERROR(L"GUI <sprite> must not have more than one <effect>");
|
|
}
|
|
else
|
|
{
|
|
effects = new SGUIImageEffects;
|
|
Xeromyces_ReadEffects(child, pFile, *effects);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
debug_warn(L"Invalid data - DTD shouldn't allow this");
|
|
}
|
|
}
|
|
|
|
// Apply the effects to every image (unless the image overrides it with
|
|
// different effects)
|
|
if (effects)
|
|
for (std::vector<SGUIImage>::iterator it = sprite.m_Images.begin(); it != sprite.m_Images.end(); ++it)
|
|
if (! it->m_Effects)
|
|
it->m_Effects = new SGUIImageEffects(*effects); // do a copy just so it can be deleted correctly later
|
|
|
|
delete effects;
|
|
|
|
//
|
|
// Add Sprite
|
|
//
|
|
|
|
m_Sprites[name] = sprite;
|
|
}
|
|
|
|
void CGUI::Xeromyces_ReadImage(XMBElement Element, CXeromyces* pFile, CGUISprite &parent)
|
|
{
|
|
|
|
// Image object we're adding
|
|
SGUIImage image;
|
|
|
|
// Set defaults to "0 0 100% 100%"
|
|
image.m_TextureSize = CClientArea(CRect(0, 0, 0, 0), CRect(0, 0, 100, 100));
|
|
image.m_Size = CClientArea(CRect(0, 0, 0, 0), CRect(0, 0, 100, 100));
|
|
|
|
// TODO Gee: Setup defaults here (or maybe they are in the SGUIImage ctor)
|
|
|
|
//
|
|
// Read Attributes
|
|
//
|
|
|
|
// Now we can iterate all attributes and store
|
|
XMBAttributeList attributes = Element.GetAttributes();
|
|
for (int i=0; i<attributes.Count; ++i)
|
|
{
|
|
XMBAttribute attr = attributes.Item(i);
|
|
CStr attr_name (pFile->GetAttributeString(attr.Name));
|
|
CStr attr_value (attr.Value);
|
|
|
|
if (attr_name == "texture")
|
|
{
|
|
image.m_TextureName = VfsPath(L"art/textures/ui")/wstring_from_utf8(attr_value);
|
|
}
|
|
else
|
|
if (attr_name == "size")
|
|
{
|
|
CClientArea ca;
|
|
if (!GUI<CClientArea>::ParseString(attr_value, ca))
|
|
LOGERROR(L"GUI: Error parsing '%hs' (\"%hs\")", attr_name.c_str(), attr_value.c_str());
|
|
else image.m_Size = ca;
|
|
}
|
|
else
|
|
if (attr_name == "texture_size")
|
|
{
|
|
CClientArea ca;
|
|
if (!GUI<CClientArea>::ParseString(attr_value, ca))
|
|
LOGERROR(L"GUI: Error parsing '%hs' (\"%hs\")", attr_name.c_str(), attr_value.c_str());
|
|
else image.m_TextureSize = ca;
|
|
}
|
|
else
|
|
if (attr_name == "real_texture_placement")
|
|
{
|
|
CRect rect;
|
|
if (!GUI<CRect>::ParseString(attr_value, rect))
|
|
LOGERROR(L"GUI: Error parsing '%hs' (\"%hs\")", attr_name.c_str(), attr_value.c_str());
|
|
else image.m_TexturePlacementInFile = rect;
|
|
}
|
|
else
|
|
if (attr_name == "cell_size")
|
|
{
|
|
CSize size;
|
|
if (!GUI<CSize>::ParseString(attr_value, size))
|
|
LOGERROR(L"GUI: Error parsing '%hs' (\"%hs\")", attr_name.c_str(), attr_value.c_str());
|
|
else image.m_CellSize = size;
|
|
}
|
|
else
|
|
if (attr_name == "z_level")
|
|
{
|
|
float z_level;
|
|
if (!GUI<float>::ParseString(attr_value, z_level))
|
|
LOGERROR(L"GUI: Error parsing '%hs' (\"%hs\")", attr_name.c_str(), attr_value.c_str());
|
|
else image.m_DeltaZ = z_level/100.f;
|
|
}
|
|
else
|
|
if (attr_name == "backcolor")
|
|
{
|
|
CColor color;
|
|
if (!GUI<CColor>::ParseString(attr_value, color))
|
|
LOGERROR(L"GUI: Error parsing '%hs' (\"%hs\")", attr_name.c_str(), attr_value.c_str());
|
|
else image.m_BackColor = color;
|
|
}
|
|
else
|
|
if (attr_name == "bordercolor")
|
|
{
|
|
CColor color;
|
|
if (!GUI<CColor>::ParseString(attr_value, color))
|
|
LOGERROR(L"GUI: Error parsing '%hs' (\"%hs\")", attr_name.c_str(), attr_value.c_str());
|
|
else image.m_BorderColor = color;
|
|
}
|
|
else
|
|
if (attr_name == "border")
|
|
{
|
|
bool b;
|
|
if (!GUI<bool>::ParseString(attr_value, b))
|
|
LOGERROR(L"GUI: Error parsing '%hs' (\"%hs\")", attr_name.c_str(), attr_value.c_str());
|
|
else image.m_Border = b;
|
|
}
|
|
else
|
|
{
|
|
debug_warn(L"Invalid data - DTD shouldn't allow this");
|
|
}
|
|
}
|
|
|
|
// Look for effects
|
|
XMBElementList children = Element.GetChildNodes();
|
|
for (int i=0; i<children.Count; ++i)
|
|
{
|
|
XMBElement child = children.Item(i);
|
|
CStr ElementName (pFile->GetElementString(child.GetNodeName()));
|
|
if (ElementName == "effect")
|
|
{
|
|
if (image.m_Effects)
|
|
{
|
|
LOGERROR(L"GUI <image> must not have more than one <effect>");
|
|
}
|
|
else
|
|
{
|
|
image.m_Effects = new SGUIImageEffects;
|
|
Xeromyces_ReadEffects(child, pFile, *image.m_Effects);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
debug_warn(L"Invalid data - DTD shouldn't allow this");
|
|
}
|
|
}
|
|
|
|
//
|
|
// Input
|
|
//
|
|
|
|
parent.AddImage(image);
|
|
}
|
|
|
|
void CGUI::Xeromyces_ReadEffects(XMBElement Element, CXeromyces* pFile, SGUIImageEffects &effects)
|
|
{
|
|
XMBAttributeList attributes = Element.GetAttributes();
|
|
for (int i=0; i<attributes.Count; ++i)
|
|
{
|
|
XMBAttribute attr = attributes.Item(i);
|
|
CStr attr_name (pFile->GetAttributeString(attr.Name));
|
|
CStr attr_value (attr.Value);
|
|
|
|
#define COLOR(xml, mem, alpha) \
|
|
if (attr_name == xml) \
|
|
{ \
|
|
CColor color; \
|
|
if (!GUI<int>::ParseColor(attr_value, color, alpha)) \
|
|
LOGERROR(L"GUI: Error parsing '%hs' (\"%hs\")", attr_name.c_str(), attr_value.c_str()); \
|
|
else effects.m_##mem = color; \
|
|
} \
|
|
else
|
|
|
|
|
|
#define BOOL(xml, mem) \
|
|
if (attr_name == xml) \
|
|
{ \
|
|
effects.m_##mem = true; \
|
|
} \
|
|
else
|
|
|
|
COLOR("add_color", AddColor, 0.f)
|
|
COLOR("multiply_color", MultiplyColor, 255.f)
|
|
BOOL("grayscale", Greyscale)
|
|
|
|
{
|
|
debug_warn(L"Invalid data - DTD shouldn't allow this");
|
|
}
|
|
}
|
|
}
|
|
|
|
void CGUI::Xeromyces_ReadStyle(XMBElement Element, CXeromyces* pFile)
|
|
{
|
|
// style object we're adding
|
|
SGUIStyle style;
|
|
CStr name;
|
|
|
|
//
|
|
// Read Attributes
|
|
//
|
|
|
|
// Now we can iterate all attributes and store
|
|
XMBAttributeList attributes = Element.GetAttributes();
|
|
for (int i=0; i<attributes.Count; ++i)
|
|
{
|
|
XMBAttribute attr = attributes.Item(i);
|
|
CStr attr_name (pFile->GetAttributeString(attr.Name));
|
|
CStr attr_value (attr.Value);
|
|
|
|
// The "name" setting is actually the name of the style
|
|
// and not a new default
|
|
if (attr_name == "name")
|
|
name = attr_value;
|
|
else
|
|
style.m_SettingsDefaults[attr_name] = attr_value;
|
|
}
|
|
|
|
//
|
|
// Add to CGUI
|
|
//
|
|
|
|
m_Styles[name] = style;
|
|
}
|
|
|
|
void CGUI::Xeromyces_ReadScrollBarStyle(XMBElement Element, CXeromyces* pFile)
|
|
{
|
|
// style object we're adding
|
|
SGUIScrollBarStyle scrollbar;
|
|
CStr name;
|
|
|
|
//
|
|
// Read Attributes
|
|
//
|
|
|
|
// Now we can iterate all attributes and store
|
|
XMBAttributeList attributes = Element.GetAttributes();
|
|
for (int i=0; i<attributes.Count; ++i)
|
|
{
|
|
XMBAttribute attr = attributes.Item(i);
|
|
CStr attr_name = pFile->GetAttributeString(attr.Name);
|
|
CStr attr_value (attr.Value);
|
|
|
|
if (attr_value == "null")
|
|
continue;
|
|
|
|
if (attr_name == "name")
|
|
name = attr_value;
|
|
else
|
|
if (attr_name == "width")
|
|
{
|
|
float f;
|
|
if (!GUI<float>::ParseString(attr_value, f))
|
|
LOGERROR(L"GUI: Error parsing '%hs' (\"%hs\")", attr_name.c_str(), attr_value.c_str());
|
|
else
|
|
scrollbar.m_Width = f;
|
|
}
|
|
else
|
|
if (attr_name == "minimum_bar_size")
|
|
{
|
|
float f;
|
|
if (!GUI<float>::ParseString(attr_value, f))
|
|
LOGERROR(L"GUI: Error parsing '%hs' (\"%hs\")", attr_name.c_str(), attr_value.c_str());
|
|
else
|
|
scrollbar.m_MinimumBarSize = f;
|
|
}
|
|
else
|
|
if (attr_name == "sprite_button_top")
|
|
scrollbar.m_SpriteButtonTop = attr_value;
|
|
else
|
|
if (attr_name == "sprite_button_top_pressed")
|
|
scrollbar.m_SpriteButtonTopPressed = attr_value;
|
|
else
|
|
if (attr_name == "sprite_button_top_disabled")
|
|
scrollbar.m_SpriteButtonTopDisabled = attr_value;
|
|
else
|
|
if (attr_name == "sprite_button_top_over")
|
|
scrollbar.m_SpriteButtonTopOver = attr_value;
|
|
else
|
|
if (attr_name == "sprite_button_bottom")
|
|
scrollbar.m_SpriteButtonBottom = attr_value;
|
|
else
|
|
if (attr_name == "sprite_button_bottom_pressed")
|
|
scrollbar.m_SpriteButtonBottomPressed = attr_value;
|
|
else
|
|
if (attr_name == "sprite_button_bottom_disabled")
|
|
scrollbar.m_SpriteButtonBottomDisabled = attr_value;
|
|
else
|
|
if (attr_name == "sprite_button_bottom_over")
|
|
scrollbar.m_SpriteButtonBottomOver = attr_value;
|
|
else
|
|
if (attr_name == "sprite_back_vertical")
|
|
scrollbar.m_SpriteBackVertical = attr_value;
|
|
else
|
|
if (attr_name == "sprite_bar_vertical")
|
|
scrollbar.m_SpriteBarVertical = attr_value;
|
|
else
|
|
if (attr_name == "sprite_bar_vertical_over")
|
|
scrollbar.m_SpriteBarVerticalOver = attr_value;
|
|
else
|
|
if (attr_name == "sprite_bar_vertical_pressed")
|
|
scrollbar.m_SpriteBarVerticalPressed = attr_value;
|
|
}
|
|
|
|
//
|
|
// Add to CGUI
|
|
//
|
|
|
|
m_ScrollBarStyles[name] = scrollbar;
|
|
}
|
|
|
|
void CGUI::Xeromyces_ReadIcon(XMBElement Element, CXeromyces* pFile)
|
|
{
|
|
// Icon we're adding
|
|
SGUIIcon icon;
|
|
CStr name;
|
|
|
|
XMBAttributeList attributes = Element.GetAttributes();
|
|
for (int i=0; i<attributes.Count; ++i)
|
|
{
|
|
XMBAttribute attr = attributes.Item(i);
|
|
CStr attr_name (pFile->GetAttributeString(attr.Name));
|
|
CStr attr_value (attr.Value);
|
|
|
|
if (attr_value == "null")
|
|
continue;
|
|
|
|
if (attr_name == "name")
|
|
name = attr_value;
|
|
else
|
|
if (attr_name == "sprite")
|
|
icon.m_SpriteName = attr_value;
|
|
else
|
|
if (attr_name == "size")
|
|
{
|
|
CSize size;
|
|
if (!GUI<CSize>::ParseString(attr_value, size))
|
|
LOGERROR(L"Error parsing '%hs' (\"%hs\") inside <icon>.", attr_name.c_str(), attr_value.c_str());
|
|
else
|
|
icon.m_Size = size;
|
|
}
|
|
else
|
|
if (attr_name == "cell_id")
|
|
{
|
|
int cell_id;
|
|
if (!GUI<int>::ParseString(attr_value, cell_id))
|
|
LOGERROR(L"GUI: Error parsing '%hs' (\"%hs\") inside <icon>.", attr_name.c_str(), attr_value.c_str());
|
|
else
|
|
icon.m_CellID = cell_id;
|
|
}
|
|
else
|
|
{
|
|
debug_warn(L"Invalid data - DTD shouldn't allow this");
|
|
}
|
|
}
|
|
|
|
m_Icons[name] = icon;
|
|
}
|
|
|
|
void CGUI::Xeromyces_ReadTooltip(XMBElement Element, CXeromyces* pFile)
|
|
{
|
|
// Read the tooltip, and store it as a specially-named object
|
|
|
|
IGUIObject* object = new CTooltip;
|
|
|
|
XMBAttributeList attributes = Element.GetAttributes();
|
|
for (int i=0; i<attributes.Count; ++i)
|
|
{
|
|
XMBAttribute attr = attributes.Item(i);
|
|
CStr attr_name (pFile->GetAttributeString(attr.Name));
|
|
CStr attr_value (attr.Value);
|
|
|
|
if (attr_name == "name")
|
|
{
|
|
object->SetName("__tooltip_" + attr_value);
|
|
}
|
|
else
|
|
{
|
|
object->SetSetting(attr_name, attr_value);
|
|
}
|
|
}
|
|
|
|
AddObject(object);
|
|
}
|
|
|
|
// Reads Custom Color
|
|
void CGUI::Xeromyces_ReadColor(XMBElement Element, CXeromyces* pFile)
|
|
{
|
|
// Read the color and stor in m_PreDefinedColors
|
|
|
|
XMBAttributeList attributes = Element.GetAttributes();
|
|
|
|
//IGUIObject* object = new CTooltip;
|
|
CColor color;
|
|
CStr name = attributes.GetNamedItem(pFile->GetAttributeID("name"));
|
|
|
|
// Try parsing value
|
|
CStr value (Element.GetText());
|
|
if (! value.empty())
|
|
{
|
|
// Try setting color to value
|
|
if (!color.ParseString(value, 255.f))
|
|
{
|
|
LOGERROR(L"GUI: Unable to create custom color '%hs'. Invalid color syntax.", name.c_str());
|
|
}
|
|
else
|
|
{
|
|
// input color
|
|
m_PreDefinedColors[name] = color;
|
|
}
|
|
}
|
|
}
|