Line data Source code
1 : /* Copyright (C) 2021 Wildfire Games.
2 : * This file is part of 0 A.D.
3 : *
4 : * 0 A.D. is free software: you can redistribute it and/or modify
5 : * it under the terms of the GNU General Public License as published by
6 : * the Free Software Foundation, either version 2 of the License, or
7 : * (at your option) any later version.
8 : *
9 : * 0 A.D. is distributed in the hope that it will be useful,
10 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 : * GNU General Public License for more details.
13 : *
14 : * You should have received a copy of the GNU General Public License
15 : * along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
16 : */
17 :
18 : #include "precompiled.h"
19 :
20 : #include "gui/CGUI.h"
21 : #include "gui/SettingTypes/CGUIString.h"
22 : #include "ps/CLogger.h"
23 :
24 : class CGUIList;
25 : class CGUISeries;
26 :
27 : template <>
28 0 : bool CGUI::ParseString<bool>(const CGUI* UNUSED(pGUI), const CStrW& Value, bool& Output)
29 : {
30 0 : if (Value == L"true")
31 0 : Output = true;
32 0 : else if (Value == L"false")
33 0 : Output = false;
34 : else
35 0 : return false;
36 :
37 0 : return true;
38 : }
39 :
40 : template <>
41 0 : bool CGUI::ParseString<i32>(const CGUI* UNUSED(pGUI), const CStrW& Value, int& Output)
42 : {
43 0 : Output = Value.ToInt();
44 0 : return true;
45 : }
46 :
47 : template <>
48 0 : bool CGUI::ParseString<u32>(const CGUI* UNUSED(pGUI), const CStrW& Value, u32& Output)
49 : {
50 0 : Output = Value.ToUInt();
51 0 : return true;
52 : }
53 :
54 : template <>
55 0 : bool CGUI::ParseString<float>(const CGUI* UNUSED(pGUI), const CStrW& Value, float& Output)
56 : {
57 0 : Output = Value.ToFloat();
58 0 : return true;
59 : }
60 :
61 : template <>
62 4 : bool CGUI::ParseString<CRect>(const CGUI* UNUSED(pGUI), const CStrW& Value, CRect& Output)
63 : {
64 4 : const unsigned int NUM_COORDS = 4;
65 : float coords[NUM_COORDS];
66 8 : std::wstringstream stream;
67 4 : stream.str(Value);
68 : // Parse each coordinate
69 16 : for (unsigned int i = 0; i < NUM_COORDS; ++i)
70 : {
71 14 : if (stream.eof())
72 : {
73 1 : LOGWARNING("Too few CRect parameters (min %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
74 1 : return false;
75 : }
76 13 : stream >> coords[i];
77 13 : if ((stream.rdstate() & std::wstringstream::failbit) != 0)
78 : {
79 1 : LOGWARNING("Unable to parse CRect parameters. Your input: '%s'", Value.ToUTF8().c_str());
80 1 : return false;
81 : }
82 : }
83 :
84 2 : if (!stream.eof())
85 : {
86 1 : LOGWARNING("Too many CRect parameters (max %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
87 1 : return false;
88 : }
89 :
90 : // Finally the rectangle values
91 1 : Output = CRect(coords[0], coords[1], coords[2], coords[3]);
92 :
93 1 : return true;
94 : }
95 :
96 : template <>
97 0 : bool CGUI::ParseString<CGUISize>(const CGUI* UNUSED(pGUI), const CStrW& Value, CGUISize& Output)
98 : {
99 0 : return Output.FromString(Value.ToUTF8());
100 : }
101 :
102 : template <>
103 0 : bool CGUI::ParseString<CGUIColor>(const CGUI* pGUI, const CStrW& Value, CGUIColor& Output)
104 : {
105 0 : return Output.ParseString(*pGUI, Value.ToUTF8());
106 : }
107 :
108 : template <>
109 4 : bool CGUI::ParseString<CSize2D>(const CGUI* UNUSED(pGUI), const CStrW& Value, CSize2D& Output)
110 : {
111 4 : const unsigned int NUM_COORDS = 2;
112 : float coords[NUM_COORDS];
113 8 : std::wstringstream stream;
114 4 : stream.str(Value);
115 : // Parse each coordinate
116 10 : for (unsigned int i = 0; i < NUM_COORDS; ++i)
117 : {
118 8 : if (stream.eof())
119 : {
120 1 : LOGWARNING("Too few CSize2D parameters (min %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
121 1 : return false;
122 : }
123 7 : stream >> coords[i];
124 7 : if ((stream.rdstate() & std::wstringstream::failbit) != 0)
125 : {
126 1 : LOGWARNING("Unable to parse CSize2D parameters. Your input: '%s'", Value.ToUTF8().c_str());
127 1 : return false;
128 : }
129 : }
130 :
131 2 : Output.Width = coords[0];
132 2 : Output.Height = coords[1];
133 :
134 2 : if (!stream.eof())
135 : {
136 1 : LOGWARNING("Too many CSize2D parameters (max %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
137 1 : return false;
138 : }
139 :
140 1 : return true;
141 : }
142 :
143 : template <>
144 4 : bool CGUI::ParseString<CVector2D>(const CGUI* UNUSED(pGUI), const CStrW& Value, CVector2D& Output)
145 : {
146 4 : const unsigned int NUM_COORDS = 2;
147 : float coords[NUM_COORDS];
148 8 : std::wstringstream stream;
149 4 : stream.str(Value);
150 : // Parse each coordinate
151 10 : for (unsigned int i = 0; i < NUM_COORDS; ++i)
152 : {
153 8 : if (stream.eof())
154 : {
155 1 : LOGWARNING("Too few CVector2D parameters (min %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
156 1 : return false;
157 : }
158 7 : stream >> coords[i];
159 7 : if ((stream.rdstate() & std::wstringstream::failbit) != 0)
160 : {
161 1 : LOGWARNING("Unable to parse CVector2D parameters. Your input: '%s'", Value.ToUTF8().c_str());
162 1 : return false;
163 : }
164 : }
165 :
166 2 : Output.X = coords[0];
167 2 : Output.Y = coords[1];
168 :
169 2 : if (!stream.eof())
170 : {
171 1 : LOGWARNING("Too many CVector2D parameters (max %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
172 1 : return false;
173 : }
174 :
175 1 : return true;
176 : }
177 :
178 : template <>
179 0 : bool CGUI::ParseString<EAlign>(const CGUI* UNUSED(pGUI), const CStrW& Value, EAlign& Output)
180 : {
181 0 : if (Value == L"left")
182 0 : Output = EAlign::LEFT;
183 0 : else if (Value == L"center")
184 0 : Output = EAlign::CENTER;
185 0 : else if (Value == L"right")
186 0 : Output = EAlign::RIGHT;
187 : else
188 0 : return false;
189 :
190 0 : return true;
191 : }
192 :
193 : template <>
194 0 : bool CGUI::ParseString<EVAlign>(const CGUI* UNUSED(pGUI), const CStrW& Value, EVAlign& Output)
195 : {
196 0 : if (Value == L"top")
197 0 : Output = EVAlign::TOP;
198 0 : else if (Value == L"center")
199 0 : Output = EVAlign::CENTER;
200 0 : else if (Value == L"bottom")
201 0 : Output = EVAlign::BOTTOM;
202 : else
203 0 : return false;
204 :
205 0 : return true;
206 : }
207 :
208 : template <>
209 0 : bool CGUI::ParseString<CGUIString>(const CGUI* UNUSED(pGUI), const CStrW& Value, CGUIString& Output)
210 : {
211 0 : Output.SetValue(Value);
212 0 : return true;
213 : }
214 :
215 : template <>
216 0 : bool CGUI::ParseString<CStr>(const CGUI* UNUSED(pGUI), const CStrW& Value, CStr& Output)
217 : {
218 0 : Output = Value.ToUTF8();
219 0 : return true;
220 : }
221 :
222 : template <>
223 0 : bool CGUI::ParseString<CStrW>(const CGUI* UNUSED(pGUI), const CStrW& Value, CStrW& Output)
224 : {
225 0 : Output = Value;
226 0 : return true;
227 : }
228 :
229 : template <>
230 0 : bool CGUI::ParseString<CGUISpriteInstance>(const CGUI* UNUSED(pGUI), const CStrW& Value, CGUISpriteInstance& Output)
231 : {
232 0 : Output = CGUISpriteInstance(Value.ToUTF8());
233 0 : return true;
234 : }
235 :
236 : template <>
237 0 : bool CGUI::ParseString<CGUISeries>(const CGUI* UNUSED(pGUI), const CStrW& UNUSED(Value), CGUISeries& UNUSED(Output))
238 : {
239 0 : return false;
240 : }
241 :
242 : template <>
243 0 : bool CGUI::ParseString<CGUIList>(const CGUI* UNUSED(pGUI), const CStrW& UNUSED(Value), CGUIList& UNUSED(Output))
244 : {
245 0 : return false;
246 : }
|
