LCOV - code coverage report
Current view: top level - source/gui - GUIStringConversions.cpp (source / functions) Hit Total Coverage
Test: 0 A.D. test coverage report Lines: 54 102 52.9 %
Date: 2022-06-14 00:41:00 Functions: 3 17 17.6 %

          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             :         return false;
      36             : 
      37             :     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           4 :     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          28 :         if (stream.eof())
      72             :         {
      73           2 :             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          26 :         if ((stream.rdstate() & std::wstringstream::failbit) != 0)
      78             :         {
      79           2 :             LOGWARNING("Unable to parse CRect parameters. Your input: '%s'", Value.ToUTF8().c_str());
      80           1 :             return false;
      81             :         }
      82             :     }
      83             : 
      84           4 :     if (!stream.eof())
      85             :     {
      86           2 :         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           4 :     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          16 :         if (stream.eof())
     119             :         {
     120           2 :             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          14 :         if ((stream.rdstate() & std::wstringstream::failbit) != 0)
     125             :         {
     126           2 :             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           4 :     if (!stream.eof())
     135             :     {
     136           2 :         LOGWARNING("Too many CSize2D parameters (max %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
     137           1 :         return false;
     138             :     }
     139             : 
     140             :     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           4 :     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          16 :         if (stream.eof())
     154             :         {
     155           2 :             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          14 :         if ((stream.rdstate() & std::wstringstream::failbit) != 0)
     160             :         {
     161           2 :             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           4 :     if (!stream.eof())
     170             :     {
     171           2 :         LOGWARNING("Too many CVector2D parameters (max %i). Your input: '%s'", NUM_COORDS, Value.ToUTF8().c_str());
     172           1 :         return false;
     173             :     }
     174             : 
     175             :     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             :         return false;
     189             : 
     190             :     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             :         return false;
     204             : 
     205             :     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             : }

Generated by: LCOV version 1.13