griffkid4/0ad
1
0
Fork 0
forked from 0ad/0ad
Code Pull Requests Activity

Move GUI string parsing specializations to a separate file and remove __ParseString proxy.

Browse Source 
Differential Revision: https://code.wildfiregames.com/D2194
This was SVN commit r22696.
This commit is contained in:
elexis 2019-08-19 19:43:13 +00:00
parent 77b81d8761
commit 8b6eee672b
4 changed files with 260 additions and 245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

247
source/gui/GUIStringConversions.cpp Normal file
View File

@ -0,0 +1,247 @@
/* Copyright (C) 2019 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/>.
*/
#include "precompiled.h"
#include "GUIutil.h"
#include "gui/CGUIString.h"
#include "ps/CLogger.h"
class CGUIList;
class CGUISeries;
template <>
bool GUI<bool>::ParseString(const CGUI* UNUSED(pGUI), const CStrW& Value, bool& Output)
{
if (Value == L"true")
Output = true;
else if (Value == L"false")
Output = false;
else
return false;
return true;
}
template <>
bool GUI<i32>::ParseString(const CGUI* UNUSED(pGUI), const CStrW& Value, int& Output)
{
Output = Value.ToInt();
return true;
}
template <>
bool GUI<u32>::ParseString(const CGUI* UNUSED(pGUI), const CStrW& Value, u32& Output)
{
Output = Value.ToUInt();
return true;
}
template <>
bool GUI<float>::ParseString(const CGUI* UNUSED(pGUI), const CStrW& Value, float& Output)
{
Output = Value.ToFloat();
return true;
}
template <>
bool GUI<CRect>::ParseString(const CGUI* UNUSED(pGUI), const CStrW& Value, CRect& Output)
{
const unsigned int NUM_COORDS = 4;
float coords[NUM_COORDS];
std::wstringstream stream;
stream.str(Value);
// Parse each coordinate
for (unsigned int i = 0; i < NUM_COORDS; ++i)
{
if (stream.eof())
{
LOGWARNING("Too few CRect parameters (min %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
return false;
}
stream >> coords[i];
if ((stream.rdstate() & std::wstringstream::failbit) != 0)
{
LOGWARNING("Unable to parse CRect parameters. Your input: '%s'", Value.ToUTF8().c_str());
return false;
}
}
if (!stream.eof())
{
LOGWARNING("Too many CRect parameters (max %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
return false;
}
// Finally the rectangle values
Output = CRect(coords[0], coords[1], coords[2], coords[3]);
return true;
}
template <>
bool GUI<CClientArea>::ParseString(const CGUI* UNUSED(pGUI), const CStrW& Value, CClientArea& Output)
{
return Output.SetClientArea(Value.ToUTF8());
}
template <>
bool GUI<CGUIColor>::ParseString(const CGUI* pGUI, const CStrW& Value, CGUIColor& Output)
{
return Output.ParseString(pGUI, Value.ToUTF8());
}
template <>
bool GUI<CSize>::ParseString(const CGUI* UNUSED(pGUI), const CStrW& Value, CSize& Output)
{
const unsigned int NUM_COORDS = 2;
float coords[NUM_COORDS];
std::wstringstream stream;
stream.str(Value);
// Parse each coordinate
for (unsigned int i = 0; i < NUM_COORDS; ++i)
{
if (stream.eof())
{
LOGWARNING("Too few CSize parameters (min %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
return false;
}
stream >> coords[i];
if ((stream.rdstate() & std::wstringstream::failbit) != 0)
{
LOGWARNING("Unable to parse CSize parameters. Your input: '%s'", Value.ToUTF8().c_str());
return false;
}
}
Output.cx = coords[0];
Output.cy = coords[1];
if (!stream.eof())
{
LOGWARNING("Too many CSize parameters (max %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
return false;
}
return true;
}
template <>
bool GUI<CPos>::ParseString(const CGUI* UNUSED(pGUI), const CStrW& Value, CPos& Output)
{
const unsigned int NUM_COORDS = 2;
float coords[NUM_COORDS];
std::wstringstream stream;
stream.str(Value);
// Parse each coordinate
for (unsigned int i = 0; i < NUM_COORDS; ++i)
{
if (stream.eof())
{
LOGWARNING("Too few CPos parameters (min %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
return false;
}
stream >> coords[i];
if ((stream.rdstate() & std::wstringstream::failbit) != 0)
{
LOGWARNING("Unable to parse CPos parameters. Your input: '%s'", Value.ToUTF8().c_str());
return false;
}
}
Output.x = coords[0];
Output.y = coords[1];
if (!stream.eof())
{
LOGWARNING("Too many CPos parameters (max %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
return false;
}
return true;
}
template <>
bool GUI<EAlign>::ParseString(const CGUI* UNUSED(pGUI), const CStrW& Value, EAlign& Output)
{
if (Value == L"left")
Output = EAlign_Left;
else if (Value == L"center")
Output = EAlign_Center;
else if (Value == L"right")
Output = EAlign_Right;
else
return false;
return true;
}
template <>
bool GUI<EVAlign>::ParseString(const CGUI* UNUSED(pGUI), const CStrW& Value, EVAlign& Output)
{
if (Value == L"top")
Output = EVAlign_Top;
else if (Value == L"center")
Output = EVAlign_Center;
else if (Value == L"bottom")
Output = EVAlign_Bottom;
else
return false;
return true;
}
template <>
bool GUI<CGUIString>::ParseString(const CGUI* UNUSED(pGUI), const CStrW& Value, CGUIString& Output)
{
Output.SetValue(Value);
return true;
}
template <>
bool GUI<CStr>::ParseString(const CGUI* UNUSED(pGUI), const CStrW& Value, CStr& Output)
{
Output = Value.ToUTF8();
return true;
}
template <>
bool GUI<CStrW>::ParseString(const CGUI* UNUSED(pGUI), const CStrW& Value, CStrW& Output)
{
Output = Value;
return true;
}
template <>
bool GUI<CGUISpriteInstance>::ParseString(const CGUI* UNUSED(pGUI), const CStrW& Value, CGUISpriteInstance& Output)
{
Output = CGUISpriteInstance(Value.ToUTF8());
return true;
}
template <>
bool GUI<CGUISeries>::ParseString(const CGUI* UNUSED(pGUI), const CStrW& UNUSED(Value), CGUISeries& UNUSED(Output))
{
return false;
}
template <>
bool GUI<CGUIList>::ParseString(const CGUI* UNUSED(pGUI), const CStrW& UNUSED(Value), CGUIList& UNUSED(Output))
{
return false;
}

221
source/gui/GUIutil.cpp
View File

@ -81,227 +81,6 @@ void CGUISetting<T>::ToJSVal(JSContext* cx, JS::MutableHandleValue Value)
ScriptInterface::ToJSVal<T>(cx, Value, m_pSetting);
};
template <>
bool __ParseString<bool>(const CGUI* UNUSED(pGUI), const CStrW& Value, bool& Output)
{
if (Value == L"true")
Output = true;
else if (Value == L"false")
Output = false;
else
return false;
return true;
}
template <>
bool __ParseString<int>(const CGUI* UNUSED(pGUI), const CStrW& Value, int& Output)
{
Output = Value.ToInt();
return true;
}
template <>
bool __ParseString<u32>(const CGUI* UNUSED(pGUI), const CStrW& Value, u32& Output)
{
Output = Value.ToUInt();
return true;
}
template <>
bool __ParseString<float>(const CGUI* UNUSED(pGUI), const CStrW& Value, float& Output)
{
Output = Value.ToFloat();
return true;
}
template <>
bool __ParseString<CRect>(const CGUI* UNUSED(pGUI), const CStrW& Value, CRect& Output)
{
const unsigned int NUM_COORDS = 4;
float coords[NUM_COORDS];
std::wstringstream stream;
stream.str(Value);
// Parse each coordinate
for (unsigned int i = 0; i < NUM_COORDS; ++i)
{
if (stream.eof())
{
LOGWARNING("Too few CRect parameters (min %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
return false;
}
stream >> coords[i];
if ((stream.rdstate() & std::wstringstream::failbit) != 0)
{
LOGWARNING("Unable to parse CRect parameters. Your input: '%s'", Value.ToUTF8().c_str());
return false;
}
}
if (!stream.eof())
{
LOGWARNING("Too many CRect parameters (max %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
return false;
}
// Finally the rectangle values
Output = CRect(coords[0], coords[1], coords[2], coords[3]);
return true;
}
template <>
bool __ParseString<CClientArea>(const CGUI* UNUSED(pGUI), const CStrW& Value, CClientArea& Output)
{
return Output.SetClientArea(Value.ToUTF8());
}
template <>
bool __ParseString<CGUIColor>(const CGUI* pGUI, const CStrW& Value, CGUIColor& Output)
{
return Output.ParseString(pGUI, Value.ToUTF8());
}
template <>
bool __ParseString<CSize>(const CGUI* UNUSED(pGUI), const CStrW& Value, CSize& Output)
{
const unsigned int NUM_COORDS = 2;
float coords[NUM_COORDS];
std::wstringstream stream;
stream.str(Value);
// Parse each coordinate
for (unsigned int i = 0; i < NUM_COORDS; ++i)
{
if (stream.eof())
{
LOGWARNING("Too few CSize parameters (min %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
return false;
}
stream >> coords[i];
if ((stream.rdstate() & std::wstringstream::failbit) != 0)
{
LOGWARNING("Unable to parse CSize parameters. Your input: '%s'", Value.ToUTF8().c_str());
return false;
}
}
Output.cx = coords[0];
Output.cy = coords[1];
if (!stream.eof())
{
LOGWARNING("Too many CSize parameters (max %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
return false;
}
return true;
}
template <>
bool __ParseString<CPos>(const CGUI* UNUSED(pGUI), const CStrW& Value, CPos& Output)
{
const unsigned int NUM_COORDS = 2;
float coords[NUM_COORDS];
std::wstringstream stream;
stream.str(Value);
// Parse each coordinate
for (unsigned int i = 0; i < NUM_COORDS; ++i)
{
if (stream.eof())
{
LOGWARNING("Too few CPos parameters (min %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
return false;
}
stream >> coords[i];
if ((stream.rdstate() & std::wstringstream::failbit) != 0)
{
LOGWARNING("Unable to parse CPos parameters. Your input: '%s'", Value.ToUTF8().c_str());
return false;
}
}
Output.x = coords[0];
Output.y = coords[1];
if (!stream.eof())
{
LOGWARNING("Too many CPos parameters (max %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
return false;
}
return true;
}
template <>
bool __ParseString<EAlign>(const CGUI* UNUSED(pGUI), const CStrW& Value, EAlign& Output)
{
if (Value == L"left")
Output = EAlign_Left;
else if (Value == L"center")
Output = EAlign_Center;
else if (Value == L"right")
Output = EAlign_Right;
else
return false;
return true;
}
template <>
bool __ParseString<EVAlign>(const CGUI* UNUSED(pGUI), const CStrW& Value, EVAlign& Output)
{
if (Value == L"top")
Output = EVAlign_Top;
else if (Value == L"center")
Output = EVAlign_Center;
else if (Value == L"bottom")
Output = EVAlign_Bottom;
else
return false;
return true;
}
template <>
bool __ParseString<CGUIString>(const CGUI* UNUSED(pGUI), const CStrW& Value, CGUIString& Output)
{
Output.SetValue(Value);
return true;
}
template <>
bool __ParseString<CStr>(const CGUI* UNUSED(pGUI), const CStrW& Value, CStr& Output)
{
Output = Value.ToUTF8();
return true;
}
template <>
bool __ParseString<CStrW>(const CGUI* UNUSED(pGUI), const CStrW& Value, CStrW& Output)
{
Output = Value;
return true;
}
template <>
bool __ParseString<CGUISpriteInstance>(const CGUI* UNUSED(pGUI), const CStrW& Value, CGUISpriteInstance& Output)
{
Output = CGUISpriteInstance(Value.ToUTF8());
return true;
}
template <>
bool __ParseString<CGUIList>(const CGUI* UNUSED(pGUI), const CStrW& UNUSED(Value), CGUIList& UNUSED(Output))
{
return false;
}
template <>
bool __ParseString<CGUISeries>(const CGUI* UNUSED(pGUI), const CStrW& UNUSED(Value), CGUISeries& UNUSED(Output))
{
return false;
}
template <typename T>
PSRETURN GUI<T>::GetSettingPointer(const IGUIObject* pObject, const CStr& Setting, T*& Value)
{

13
source/gui/GUIutil.h
View File

@ -110,9 +110,6 @@ private:
T m_pSetting;
};
template <typename T>
bool __ParseString(const CGUI* pGUI, const CStrW& Value, T& tOutput);
struct SGUIMessage;
/**
@ -180,19 +177,11 @@ public:
* Sets a value by setting and object name using a real
* datatype as input.
*
* This is just a wrapper for __ParseString() which really
* works the magic.
*
* @param Value The value in string form, like "0 0 100% 100%"
* @param tOutput Parsed value of type T
* @return True at success.
*
* @see __ParseString()
*/
static bool ParseString(const CGUI* pGUI, const CStrW& Value, T& tOutput)
{
return __ParseString<T>(pGUI, Value, tOutput);
}
static bool ParseString(const CGUI* pGUI, const CStrW& Value, T& tOutput);
private:

24
source/gui/tests/test_ParseString.h
View File

@ -68,12 +68,12 @@ public:
TestLogger nolog;
CRect test;
TS_ASSERT(__ParseString(nullptr, CStrW(L"0.0 10.0 20.0 30.0"), test));
TS_ASSERT(GUI<CRect>::ParseString(nullptr, CStrW(L"0.0 10.0 20.0 30.0"), test));
TS_ASSERT_EQUALS(CRect(0.0, 10.0, 20.0, 30.0), test);
TS_ASSERT(!__ParseString(nullptr, CStrW(L"0 10 20"), test));
TS_ASSERT(!__ParseString(nullptr, CStrW(L"0 10 20 30 40"), test));
TS_ASSERT(!__ParseString(nullptr, CStrW(L"0,0 10,0 20,0 30,0"), test));
TS_ASSERT(!GUI<CRect>::ParseString(nullptr, CStrW(L"0 10 20"), test));
TS_ASSERT(!GUI<CRect>::ParseString(nullptr, CStrW(L"0 10 20 30 40"), test));
TS_ASSERT(!GUI<CRect>::ParseString(nullptr, CStrW(L"0,0 10,0 20,0 30,0"), test));
}
void test_size()
@ -81,12 +81,12 @@ public:
TestLogger nolog;
CSize test;
TS_ASSERT(__ParseString(nullptr, CStrW(L"0.0 10.0"), test));
TS_ASSERT(GUI<CSize>::ParseString(nullptr, CStrW(L"0.0 10.0"), test));
TS_ASSERT_EQUALS(CSize(0.0, 10.0), test);
TS_ASSERT(!__ParseString(nullptr, CStrW(L"0"), test));
TS_ASSERT(!__ParseString(nullptr, CStrW(L"0 10 20"), test));
TS_ASSERT(!__ParseString(nullptr, CStrW(L"0,0 10,0"), test));
TS_ASSERT(!GUI<CSize>::ParseString(nullptr, CStrW(L"0"), test));
TS_ASSERT(!GUI<CSize>::ParseString(nullptr, CStrW(L"0 10 20"), test));
TS_ASSERT(!GUI<CSize>::ParseString(nullptr, CStrW(L"0,0 10,0"), test));
}
void test_pos()
@ -94,11 +94,11 @@ public:
TestLogger nolog;
CPos test;
TS_ASSERT(__ParseString(nullptr, CStrW(L"0.0 10.0"), test));
TS_ASSERT(GUI<CPos>::ParseString(nullptr, CStrW(L"0.0 10.0"), test));
TS_ASSERT_EQUALS(CPos(0.0, 10.0), test);
TS_ASSERT(!__ParseString(nullptr, CStrW(L"0"), test));
TS_ASSERT(!__ParseString(nullptr, CStrW(L"0 10 20"), test));
TS_ASSERT(!__ParseString(nullptr, CStrW(L"0,0 10,0"), test));
TS_ASSERT(!GUI<CPos>::ParseString(nullptr, CStrW(L"0"), test));
TS_ASSERT(!GUI<CPos>::ParseString(nullptr, CStrW(L"0 10 20"), test));
TS_ASSERT(!GUI<CPos>::ParseString(nullptr, CStrW(L"0,0 10,0"), test));
}
};