nel/src/gui/css_background.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010-2021  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program 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 Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "stdpch.h"
  18
  19 #include <string>
  20 #include "nel/gui/libwww.h"
  21 #include "nel/gui/css_length.h"
  22 #include "nel/gui/css_background.h"
  23
  24 using namespace NLMISC;
  25
  26 #ifdef DEBUG_NEW
  27 #define new DEBUG_NEW
  28 #endif
  29
  30 namespace NLGUI
  31 {
  32
  33 void CSSBackground::setImage(const std::string &value)
  34 {
  35         image = value;
  36 }
  37
  38 void CSSBackground::setPosition(const std::string &value)
  39 {
  40         std::vector<std::string> parts;
  41         splitString(toLowerAscii(value), " ", parts);
  42
  43         if (parts.empty() || parts.size() > 4)
  44                 return;
  45
  46         switch(parts.size())
  47         {
  48                 case 1:
  49                         positionFromOne(parts);
  50                         break;
  51                 case 2:
  52                         positionFromTwo(parts);
  53                         break;
  54                 case 3:
  55                         positionFromThree(parts);
  56                         break;
  57                 case 4:
  58                         positionFromFour(parts);
  59                         break;
  60                 default:
  61                         return;
  62         }
  63 }
  64
  65 void CSSBackground::setSize(const std::string &value)
  66 {
  67         std::vector<std::string> parts;
  68         splitString(toLowerAscii(value), " ", parts);
  69         if (parts.size() > 2)
  70                 return;
  71
  72         if (parts.size() == 1 && (parts[0] == "cover" || parts[0] == "contain"))
  73         {
  74                 if (parts[0] == "cover")
  75                         size = CSS_VALUE_COVER;
  76                 else
  77                         size = CSS_VALUE_CONTAIN;
  78
  79                 width.setAuto();
  80                 height.setAuto();
  81                 return;
  82         }
  83
  84         // height will default to 'auto' if not set
  85         if (parts.size() == 1)
  86                 parts.push_back("auto");
  87
  88         if (parts[0] == "auto" && parts[1] == "auto")
  89         {
  90                 size = CSS_VALUE_AUTO;
  91                 width.setAuto();
  92                 height.setAuto();
  93                 return;
  94         }
  95
  96         CSSLength newW, newH;
  97         bool success = true;
  98         if (parts[0] == "auto")
  99         {
 100                 newW.setAuto();
 101         }
 102         else
 103         {
 104                 float fval;
 105                 std::string unit;
 106                 if (!getCssLength(fval, unit, parts[0]))
 107                 {
 108                         nlwarning("Failed to parse background-size[0] '%s'", parts[0].c_str());
 109                         return;
 110                 }
 111                 newW.setFloatValue(fval, unit);
 112         }
 113
 114         if (parts[1] == "auto")
 115         {
 116                 newH.setAuto();
 117         }
 118         else
 119         {
 120                 float fval;
 121                 std::string unit;
 122                 if (!getCssLength(fval, unit, parts[1]))
 123                 {
 124                         nlwarning("Failed to parse background-size[1] '%s'", parts[1].c_str());
 125                         return;
 126                 }
 127                 newH.setFloatValue(fval, unit);
 128         }
 129
 130         size = CSS_VALUE_LENGTH;
 131         width = newW;
 132         height = newH;
 133 }
 134
 135 void CSSBackground::setRepeat(const std::string &value)
 136 {
 137         std::vector<std::string> parts;
 138         splitString(toLowerAscii(value), " ", parts);
 139         if (parts.size() == 0 || parts.size() > 2)
 140                 return;
 141
 142         if (parts.size() == 1)
 143         {
 144                 if (parts[0] == "repeat-x")
 145                         parts.push_back("no-repeat");
 146                 else if (parts[0] == "repeat-y")
 147                         parts.insert(parts.begin(), "no-repeat");
 148                 else //repeat, space, round, no-repeat
 149                         parts.push_back(parts[0]);
 150         }
 151
 152
 153         if (parts[0] == "repeat") repeatX = CSS_VALUE_REPEAT;
 154         else if (parts[0] == "no-repeat") repeatX = CSS_VALUE_NOREPEAT;
 155         else if (parts[0] == "space") repeatX = CSS_VALUE_SPACE;
 156         else if (parts[0] == "round") repeatX = CSS_VALUE_ROUND;
 157         else repeatX = CSS_VALUE_REPEAT;
 158
 159         if (parts[1] == "repeat") repeatY = CSS_VALUE_REPEAT;
 160         else if (parts[1] == "no-repeat") repeatY = CSS_VALUE_NOREPEAT;
 161         else if (parts[1] == "space") repeatY = CSS_VALUE_SPACE;
 162         else if (parts[1] == "round") repeatY = CSS_VALUE_ROUND;
 163         else repeatY = CSS_VALUE_REPEAT;
 164 }
 165
 166 void CSSBackground::setOrigin(const std::string &value)
 167 {
 168         if (value == "border-box") origin = CSS_VALUE_BORDER_BOX;
 169         else if (value == "padding-box") origin = CSS_VALUE_PADDING_BOX;
 170         else if (value == "content-box") origin = CSS_VALUE_CONTENT_BOX;
 171         else origin = CSS_VALUE_PADDING_BOX;
 172 }
 173
 174 void CSSBackground::setClip(const std::string &value)
 175 {
 176         if (value == "border-box") clip = CSS_VALUE_BORDER_BOX;
 177         else if (value == "padding-box") clip = CSS_VALUE_PADDING_BOX;
 178         else if (value == "content-box") clip = CSS_VALUE_CONTENT_BOX;
 179         //else if (value == "text") clip = CSSValueType::Text;
 180         else clip = CSS_VALUE_PADDING_BOX;
 181 }
 182
 183 void CSSBackground::setAttachment(const std::string &value)
 184 {
 185         if (value == "fixed") attachment = CSS_VALUE_FIXED;
 186         else if (value == "local") attachment = CSS_VALUE_LOCAL;
 187         else if (value == "scroll") attachment = CSS_VALUE_SCROLL;
 188         else attachment = CSS_VALUE_SCROLL;
 189 }
 190
 191 void CSSBackground::setColor(const std::string &value)
 192 {
 193         NLMISC::CRGBA tmp;
 194         if (scanHTMLColor(value.c_str(), tmp))
 195                 color = tmp;
 196 }
 197
 198 static bool isHorizontalKeyword(const std::string &val)
 199 {
 200         return val == "left" || val == "right";
 201 }
 202
 203 static bool isVerticalKeyword(const std::string &val)
 204 {
 205         return val == "top" || val == "bottom";
 206 }
 207
 208 void CSSBackground::positionFromOne(const std::vector<std::string> &parts)
 209 {
 210         CSSValueType newH = CSS_VALUE_LEFT;
 211         CSSValueType newV = CSS_VALUE_TOP;
 212         CSSLength newX, newY;
 213         newX.setFloatValue(0, "%");
 214         newY.setFloatValue(0, "%");
 215
 216         uint index = 0;
 217         float fval;
 218         std::string unit;
 219         if (isHorizontalKeyword(parts[index]))
 220         {
 221                 newH = parts[index] == "left" ? CSS_VALUE_LEFT : CSS_VALUE_RIGHT;
 222                 newV = CSS_VALUE_CENTER;
 223         }
 224         else if (isVerticalKeyword(parts[index]))
 225         {
 226                 newH = CSS_VALUE_CENTER;
 227                 newV = parts[index] == "top" ? CSS_VALUE_TOP : CSS_VALUE_BOTTOM;
 228         }
 229         else if (parts[index] == "center")
 230         {
 231                 newH = CSS_VALUE_CENTER;
 232                 newV = CSS_VALUE_CENTER;
 233         }
 234         else if (getCssLength(fval, unit, parts[index], true))
 235         {
 236                 newX.setFloatValue(fval, unit);
 237                 newV = CSS_VALUE_CENTER;
 238         }
 239         else
 240         {
 241                 return;
 242         }
 243
 244         xAnchor = newH;
 245         yAnchor = newV;
 246         xPosition = newX;
 247         yPosition = newY;
 248 }
 249
 250 void CSSBackground::positionFromTwo(const std::vector<std::string> &parts)
 251 {
 252         CSSValueType newH = CSS_VALUE_LEFT;
 253         CSSValueType newV = CSS_VALUE_TOP;
 254         CSSLength newX, newY;
 255         newX.setFloatValue(0, "%");
 256         newY.setFloatValue(0, "%");
 257
 258         float fval;
 259         std::string unit;
 260         uint index = 0;
 261         bool hasCenter = false;
 262         bool hasX = false;
 263         bool hasY = false;
 264         for (uint index = 0; index < parts.size(); index++)
 265         {
 266                 if (parts[index] == "center")
 267                 {
 268                         hasCenter = true;
 269                 }
 270                 else if (isHorizontalKeyword(parts[index]))
 271                 {
 272                         if (hasX) return;
 273                         hasX = true;
 274                         newH = parts[index] == "left" ? CSS_VALUE_LEFT : CSS_VALUE_RIGHT;
 275                 }
 276                 else if (isVerticalKeyword(parts[index]))
 277                 {
 278                         if (hasY) return;
 279                         hasY = true;
 280                         newV = parts[index] == "top" ? CSS_VALUE_TOP : CSS_VALUE_BOTTOM;
 281                 }
 282                 else if (getCssLength(fval, unit, parts[index], true))
 283                 {
 284                         // invalid: 'top 50%';
 285                         if (hasY) return;
 286                         if (!hasX)
 287                         {
 288                                 hasX = true;
 289                                 newX.setFloatValue(fval, unit);
 290                         }
 291                         else
 292                         {
 293                                 hasY = true;
 294                                 newY.setFloatValue(fval, unit);
 295                         }
 296                 }
 297                 else
 298                 {
 299                         return;
 300                 }
 301         }
 302
 303         if (hasCenter)
 304         {
 305                 if (!hasX)
 306                         newH = CSS_VALUE_CENTER;
 307                 if (!hasY)
 308                         newV = CSS_VALUE_CENTER;
 309         }
 310
 311         xAnchor = newH;
 312         yAnchor = newV;
 313         xPosition = newX;
 314         yPosition = newY;
 315 }
 316
 317 void CSSBackground::positionFromThree(const std::vector<std::string> &parts)
 318 {
 319         CSSValueType newH = CSS_VALUE_LEFT;
 320         CSSValueType newV = CSS_VALUE_TOP;
 321         CSSLength newX, newY;
 322         newX.setFloatValue(0, "%");
 323         newY.setFloatValue(0, "%");
 324
 325         float fval;
 326         std::string unit;
 327         bool hasCenter = false;
 328         bool hasX = false;
 329         bool hasY = false;
 330         for(uint index = 0; index < 3; index++)
 331         {
 332                 if (parts[index] == "center")
 333                 {
 334                         if (hasCenter) return;
 335                         hasCenter = true;
 336                 }
 337                 else if (isHorizontalKeyword(parts[index]))
 338                 {
 339                         if (hasX) return;
 340                         hasX = true;
 341                         newH = parts[index] == "left" ? CSS_VALUE_LEFT : CSS_VALUE_RIGHT;
 342                         if ((index+1) < parts.size() && getCssLength(fval, unit, parts[index+1], true))
 343                         {
 344                                 newX.setFloatValue(fval, unit);
 345                                 index++;
 346                         }
 347                 }
 348                 else if (isVerticalKeyword(parts[index]))
 349                 {
 350                         if (hasY) return;
 351                         hasY = true;
 352                         newV = parts[index] == "top" ? CSS_VALUE_TOP : CSS_VALUE_BOTTOM;
 353                         if ((index+1) < parts.size() && getCssLength(fval, unit, parts[index+1], true))
 354                         {
 355                                 newY.setFloatValue(fval, unit);
 356                                 index++;
 357                         }
 358                 }
 359                 else
 360                 {
 361                         return;
 362                 }
 363         }
 364         if (hasCenter)
 365         {
 366                 if (hasX && hasY)
 367                         return;
 368
 369                 if (!hasX)
 370                         newH = CSS_VALUE_CENTER;
 371                 else
 372                         newV = CSS_VALUE_CENTER;
 373         }
 374
 375         xAnchor = newH;
 376         yAnchor = newV;
 377         xPosition = newX;
 378         yPosition = newY;
 379 }
 380
 381 void CSSBackground::positionFromFour(const std::vector<std::string> &parts)
 382 {
 383         CSSValueType newH = CSS_VALUE_LEFT;
 384         CSSValueType newV = CSS_VALUE_TOP;
 385         CSSLength newX, newY;
 386         newX.setFloatValue(0, "%");
 387         newY.setFloatValue(0, "%");
 388
 389         float fval;
 390         std::string unit;
 391         bool hasX = false;
 392         bool hasY = false;
 393         for(uint index = 0; index<4; index+=2)
 394         {
 395                 if (parts[index] == "center")
 396                         return;
 397
 398                 if (isHorizontalKeyword(parts[index]))
 399                 {
 400                         if (hasX) return;
 401                         hasX = true;
 402                         if (!getCssLength(fval, unit, parts[index+1], true)) return;
 403                         newH = parts[index] == "left" ? CSS_VALUE_LEFT : CSS_VALUE_RIGHT;
 404                         newX.setFloatValue(fval, unit);
 405                 }
 406                 else if (isVerticalKeyword(parts[index]))
 407                 {
 408                         if (hasY) return;
 409                         hasY = true;
 410                         if (!getCssLength(fval, unit, parts[index+1], true)) return;
 411                         newV = parts[index] == "top" ? CSS_VALUE_TOP : CSS_VALUE_BOTTOM;
 412                         newY.setFloatValue(fval, unit);
 413                 }
 414                 else
 415                 {
 416                         return;
 417                 }
 418         }
 419
 420         xAnchor = newH;
 421         yAnchor = newV;
 422         xPosition = newX;
 423         yPosition = newY;
 424 }
 425
 426 } // namespace
 427