src/plugins/litehtml_viewer/litehtml/borders.h

   1 #ifndef LH_BORDERS_H
   2 #define LH_BORDERS_H
   3
   4 #include "css_length.h"
   5 #include "types.h"
   6 #include "web_color.h"
   7
   8 namespace litehtml
   9 {
  10         struct css_border
  11         {
  12                 css_length              width;
  13                 border_style    style;
  14                 web_color               color;
  15
  16                 css_border()
  17                 {
  18                         style = border_style_none;
  19                 }
  20
  21                 css_border(const css_border& val)
  22                 {
  23                         width   = val.width;
  24                         style   = val.style;
  25                         color   = val.color;
  26                 }
  27
  28                 css_border& operator=(const css_border& val)
  29                 {
  30                         width   = val.width;
  31                         style   = val.style;
  32                         color   = val.color;
  33                         return *this;
  34                 }
  35
  36                 string to_string() const;
  37         };
  38
  39         struct border
  40         {
  41                 int                             width;
  42                 border_style    style;
  43                 web_color               color;
  44
  45                 border()
  46                 {
  47                         width = 0;
  48                 }
  49                 border(const border& val)
  50                 {
  51                         width = val.width;
  52                         style = val.style;
  53                         color = val.color;
  54                 }
  55                 border(const css_border& val)
  56                 {
  57                         width = (int) val.width.val();
  58                         style = val.style;
  59                         color = val.color;
  60                 }
  61                 border& operator=(const border& val)
  62                 {
  63                         width = val.width;
  64                         style = val.style;
  65                         color = val.color;
  66                         return *this;
  67                 }
  68                 border& operator=(const css_border& val)
  69                 {
  70                         width = (int) val.width.val();
  71                         style = val.style;
  72                         color = val.color;
  73                         return *this;
  74                 }
  75         };
  76
  77         struct border_radiuses
  78         {
  79                 int     top_left_x;
  80                 int     top_left_y;
  81
  82                 int     top_right_x;
  83                 int     top_right_y;
  84
  85                 int     bottom_right_x;
  86                 int     bottom_right_y;
  87
  88                 int     bottom_left_x;
  89                 int     bottom_left_y;
  90
  91                 border_radiuses()
  92                 {
  93                         top_left_x = 0;
  94                         top_left_y = 0;
  95                         top_right_x = 0;
  96                         top_right_y = 0;
  97                         bottom_right_x = 0;
  98                         bottom_right_y = 0;
  99                         bottom_left_x = 0;
 100                         bottom_left_y = 0;
 101                 }
 102                 border_radiuses(const border_radiuses& val)
 103                 {
 104                         top_left_x = val.top_left_x;
 105                         top_left_y = val.top_left_y;
 106                         top_right_x = val.top_right_x;
 107                         top_right_y = val.top_right_y;
 108                         bottom_right_x = val.bottom_right_x;
 109                         bottom_right_y = val.bottom_right_y;
 110                         bottom_left_x = val.bottom_left_x;
 111                         bottom_left_y = val.bottom_left_y;
 112                 }
 113                 border_radiuses& operator = (const border_radiuses& val)
 114                 {
 115                         top_left_x = val.top_left_x;
 116                         top_left_y = val.top_left_y;
 117                         top_right_x = val.top_right_x;
 118                         top_right_y = val.top_right_y;
 119                         bottom_right_x = val.bottom_right_x;
 120                         bottom_right_y = val.bottom_right_y;
 121                         bottom_left_x = val.bottom_left_x;
 122                         bottom_left_y = val.bottom_left_y;
 123                         return *this;
 124                 }
 125                 void operator += (const margins& mg)
 126                 {
 127                         top_left_x += mg.left;
 128                         top_left_y += mg.top;
 129                         top_right_x += mg.right;
 130                         top_right_y += mg.top;
 131                         bottom_right_x += mg.right;
 132                         bottom_right_y += mg.bottom;
 133                         bottom_left_x += mg.left;
 134                         bottom_left_y += mg.bottom;
 135                         fix_values();
 136                 }
 137                 void operator -= (const margins& mg)
 138                 {
 139                         top_left_x -= mg.left;
 140                         top_left_y -= mg.top;
 141                         top_right_x -= mg.right;
 142                         top_right_y -= mg.top;
 143                         bottom_right_x -= mg.right;
 144                         bottom_right_y -= mg.bottom;
 145                         bottom_left_x -= mg.left;
 146                         bottom_left_y -= mg.bottom;
 147                         fix_values();
 148                 }
 149                 void fix_values()
 150                 {
 151                         if (top_left_x < 0)     top_left_x = 0;
 152                         if (top_left_y < 0)     top_left_y = 0;
 153                         if (top_right_x < 0) top_right_x = 0;
 154                         if (top_right_y < 0) top_right_y = 0;
 155                         if (bottom_right_x < 0) bottom_right_x = 0;
 156                         if (bottom_right_y < 0) bottom_right_y = 0;
 157                         if (bottom_left_x < 0) bottom_left_x = 0;
 158                         if (bottom_left_y < 0) bottom_left_y = 0;
 159                 }
 160         };
 161
 162         struct css_border_radius
 163         {
 164                 css_length      top_left_x;
 165                 css_length      top_left_y;
 166
 167                 css_length      top_right_x;
 168                 css_length      top_right_y;
 169
 170                 css_length      bottom_right_x;
 171                 css_length      bottom_right_y;
 172
 173                 css_length      bottom_left_x;
 174                 css_length      bottom_left_y;
 175
 176                 css_border_radius()
 177                 {
 178
 179                 }
 180
 181                 css_border_radius(const css_border_radius& val)
 182                 {
 183                         top_left_x              = val.top_left_x;
 184                         top_left_y              = val.top_left_y;
 185                         top_right_x             = val.top_right_x;
 186                         top_right_y             = val.top_right_y;
 187                         bottom_left_x   = val.bottom_left_x;
 188                         bottom_left_y   = val.bottom_left_y;
 189                         bottom_right_x  = val.bottom_right_x;
 190                         bottom_right_y  = val.bottom_right_y;
 191                 }
 192
 193                 css_border_radius& operator=(const css_border_radius& val)
 194                 {
 195                         top_left_x              = val.top_left_x;
 196                         top_left_y              = val.top_left_y;
 197                         top_right_x             = val.top_right_x;
 198                         top_right_y             = val.top_right_y;
 199                         bottom_left_x   = val.bottom_left_x;
 200                         bottom_left_y   = val.bottom_left_y;
 201                         bottom_right_x  = val.bottom_right_x;
 202                         bottom_right_y  = val.bottom_right_y;
 203                         return *this;
 204                 }
 205                 border_radiuses calc_percents(int width, int height) const
 206                 {
 207                         border_radiuses ret;
 208                         ret.bottom_left_x = bottom_left_x.calc_percent(width);
 209                         ret.bottom_left_y = bottom_left_y.calc_percent(height);
 210                         ret.top_left_x = top_left_x.calc_percent(width);
 211                         ret.top_left_y = top_left_y.calc_percent(height);
 212                         ret.top_right_x = top_right_x.calc_percent(width);
 213                         ret.top_right_y = top_right_y.calc_percent(height);
 214                         ret.bottom_right_x = bottom_right_x.calc_percent(width);
 215                         ret.bottom_right_y = bottom_right_y.calc_percent(height);
 216                         return ret;
 217                 }
 218         };
 219
 220         struct css_borders
 221         {
 222                 css_border                      left;
 223                 css_border                      top;
 224                 css_border                      right;
 225                 css_border                      bottom;
 226                 css_border_radius       radius;
 227
 228                 css_borders() = default;
 229
 230                 bool is_visible() const
 231                 {
 232                         return left.width.val() != 0 || right.width.val() != 0 || top.width.val() != 0 || bottom.width.val() != 0;
 233                 }
 234
 235                 css_borders(const css_borders& val)
 236                 {
 237                         left    = val.left;
 238                         right   = val.right;
 239                         top             = val.top;
 240                         bottom  = val.bottom;
 241                         radius  = val.radius;
 242                 }
 243
 244                 css_borders& operator=(const css_borders& val)
 245                 {
 246                         left    = val.left;
 247                         right   = val.right;
 248                         top             = val.top;
 249                         bottom  = val.bottom;
 250                         radius  = val.radius;
 251                         return *this;
 252                 }
 253                 string to_string() const
 254                 {
 255                         return  "left: " + left.to_string() +
 256                                         ", top: " + top.to_string() +
 257                                         ", right: " + top.to_string() +
 258                                         ", bottom: " + bottom.to_string();
 259                 }
 260         };
 261
 262         struct borders
 263         {
 264                 border                  left;
 265                 border                  top;
 266                 border                  right;
 267                 border                  bottom;
 268                 border_radiuses radius;
 269
 270                 borders() = default;
 271
 272                 borders(const borders& val)
 273                 {
 274                         left = val.left;
 275                         right = val.right;
 276                         top = val.top;
 277                         bottom = val.bottom;
 278                         radius = val.radius;
 279                 }
 280
 281                 borders(const css_borders& val)
 282                 {
 283                         left = val.left;
 284                         right = val.right;
 285                         top = val.top;
 286                         bottom = val.bottom;
 287                 }
 288
 289                 bool is_visible() const
 290                 {
 291                         return left.width != 0 || right.width != 0 || top.width != 0 || bottom.width != 0;
 292                 }
 293
 294                 borders& operator=(const borders& val)
 295                 {
 296                         left = val.left;
 297                         right = val.right;
 298                         top = val.top;
 299                         bottom = val.bottom;
 300                         radius = val.radius;
 301                         return *this;
 302                 }
 303
 304                 borders& operator=(const css_borders& val)
 305                 {
 306                         left = val.left;
 307                         right = val.right;
 308                         top = val.top;
 309                         bottom = val.bottom;
 310                         return *this;
 311                 }
 312         };
 313 }
 314
 315 #endif  // LH_BORDERS_H