src/plugins/litehtml_viewer/litehtml/render_item.h

   1 #ifndef LH_RENDER_ITEM_H
   2 #define LH_RENDER_ITEM_H
   3
   4 #include <memory>
   5 #include <utility>
   6 #include <list>
   7 #include <tuple>
   8 #include "types.h"
   9 #include "line_box.h"
  10 #include "table.h"
  11 #include "formatting_context.h"
  12
  13 namespace litehtml
  14 {
  15     class element;
  16
  17     class render_item : public std::enable_shared_from_this<render_item>
  18     {
  19     protected:
  20         std::shared_ptr<element>                    m_element;
  21         std::weak_ptr<render_item>                  m_parent;
  22         std::list<std::shared_ptr<render_item>>     m_children;
  23         margins                                                         m_margins;
  24         margins                                                         m_padding;
  25         margins                                                         m_borders;
  26         position                                                        m_pos;
  27         bool                                        m_skip;
  28         std::vector<std::shared_ptr<render_item>>   m_positioned;
  29
  30                 containing_block_context calculate_containing_block_context(const containing_block_context& cb_context);
  31                 void calc_cb_length(const css_length& len, int percent_base, containing_block_context::typed_int& out_value) const;
  32                 virtual int _render(int x, int y, const containing_block_context& containing_block_size, formatting_context* fmt_ctx, bool second_pass = false)
  33                 {
  34                         return 0;
  35                 }
  36
  37     public:
  38         explicit render_item(std::shared_ptr<element>  src_el);
  39
  40         virtual ~render_item() = default;
  41
  42         std::list<std::shared_ptr<render_item>>& children()
  43         {
  44             return m_children;
  45         }
  46
  47         position& pos()
  48         {
  49             return m_pos;
  50         }
  51
  52         bool skip() const
  53         {
  54             return m_skip;
  55         }
  56
  57         void skip(bool val)
  58         {
  59             m_skip = val;
  60         }
  61
  62         int right() const
  63         {
  64             return left() + width();
  65         }
  66
  67         int left() const
  68         {
  69             return m_pos.left() - m_margins.left - m_padding.left - m_borders.left;
  70         }
  71
  72         int top() const
  73         {
  74             return m_pos.top() - m_margins.top - m_padding.top - m_borders.top;
  75         }
  76
  77         int bottom() const
  78         {
  79             return top() + height();
  80         }
  81
  82         int height() const
  83         {
  84             return m_pos.height + m_margins.height() + m_padding.height() + m_borders.height();
  85         }
  86
  87         int width() const
  88         {
  89             return m_pos.width + m_margins.left + m_margins.right + m_padding.width() + m_borders.width();
  90         }
  91
  92         int padding_top() const
  93         {
  94             return m_padding.top;
  95         }
  96
  97         int padding_bottom() const
  98         {
  99             return m_padding.bottom;
 100         }
 101
 102         int padding_left() const
 103         {
 104             return m_padding.left;
 105         }
 106
 107         int padding_right() const
 108         {
 109             return m_padding.right;
 110         }
 111
 112         int border_top() const
 113         {
 114             return m_borders.top;
 115         }
 116
 117         int border_bottom() const
 118         {
 119             return m_borders.bottom;
 120         }
 121
 122         int border_left() const
 123         {
 124             return m_borders.left;
 125         }
 126
 127         int border_right() const
 128         {
 129             return m_borders.right;
 130         }
 131
 132         int margin_top() const
 133         {
 134             return m_margins.top;
 135         }
 136
 137         int margin_bottom() const
 138         {
 139             return m_margins.bottom;
 140         }
 141
 142         int margin_left() const
 143         {
 144             return m_margins.left;
 145         }
 146
 147         int margin_right() const
 148         {
 149             return m_margins.right;
 150         }
 151
 152         std::shared_ptr<render_item> parent() const
 153         {
 154             return m_parent.lock();
 155         }
 156
 157         margins& get_margins()
 158         {
 159             return m_margins;
 160         }
 161
 162         margins& get_paddings()
 163         {
 164             return m_padding;
 165         }
 166
 167                 void set_paddings(const margins& val)
 168                 {
 169                         m_padding = val;
 170                 }
 171
 172         margins& get_borders()
 173         {
 174             return m_borders;
 175         }
 176
 177                 /**
 178                  * Top offset to the element content. Includes paddings, margins and borders.
 179                  */
 180         int content_offset_top() const
 181         {
 182             return m_margins.top + m_padding.top + m_borders.top;
 183         }
 184
 185                 /**
 186                  * Bottom offset to the element content. Includes paddings, margins and borders.
 187                  */
 188         inline int content_offset_bottom() const
 189         {
 190             return m_margins.bottom + m_padding.bottom + m_borders.bottom;
 191         }
 192
 193                 /**
 194                  * Left offset to the element content. Includes paddings, margins and borders.
 195                  */
 196         int content_offset_left() const
 197         {
 198             return m_margins.left + m_padding.left + m_borders.left;
 199         }
 200
 201                 /**
 202                  * Right offset to the element content. Includes paddings, margins and borders.
 203                  */
 204         int content_offset_right() const
 205         {
 206             return m_margins.right + m_padding.right + m_borders.right;
 207         }
 208
 209                 /**
 210                  * Sum of left and right offsets to the element content. Includes paddings, margins and borders.
 211                  */
 212         int content_offset_width() const
 213         {
 214             return content_offset_left() + content_offset_right();
 215         }
 216
 217                 /**
 218                  * Sum of top and bottom offsets to the element content. Includes paddings, margins and borders.
 219                  */
 220         int content_offset_height() const
 221         {
 222             return content_offset_top() + content_offset_bottom();
 223         }
 224
 225                 int box_sizing_left() const
 226                 {
 227                         return m_padding.left + m_borders.left;
 228                 }
 229
 230                 int box_sizing_right() const
 231                 {
 232                         return m_padding.right + m_borders.right;
 233                 }
 234
 235                 int box_sizing_width() const
 236                 {
 237                         return box_sizing_left() + box_sizing_left();
 238                 }
 239
 240                 int box_sizing_top() const
 241                 {
 242                         return m_padding.top + m_borders.top;
 243                 }
 244
 245                 int box_sizing_bottom() const
 246                 {
 247                         return m_padding.bottom + m_borders.bottom;
 248                 }
 249
 250                 int box_sizing_height() const
 251                 {
 252                         return box_sizing_top() + box_sizing_bottom();
 253                 }
 254
 255         void parent(const std::shared_ptr<render_item>& par)
 256         {
 257             m_parent = par;
 258         }
 259
 260         const std::shared_ptr<element>& src_el() const
 261         {
 262             return m_element;
 263         }
 264
 265                 const css_properties& css() const
 266                 {
 267                         return m_element->css();
 268                 }
 269
 270         void add_child(const std::shared_ptr<render_item>& ri)
 271         {
 272             m_children.push_back(ri);
 273             ri->parent(shared_from_this());
 274         }
 275
 276                 bool is_root() const
 277                 {
 278                         return m_parent.expired();
 279                 }
 280
 281         bool collapse_top_margin() const
 282         {
 283             return !m_borders.top &&
 284                    !m_padding.top &&
 285                    m_element->in_normal_flow() &&
 286                    m_element->css().get_float() == float_none &&
 287                    m_margins.top >= 0 &&
 288                    !is_root();
 289         }
 290
 291         bool collapse_bottom_margin() const
 292         {
 293             return !m_borders.bottom &&
 294                    !m_padding.bottom &&
 295                    m_element->in_normal_flow() &&
 296                    m_element->css().get_float() == float_none &&
 297                    m_margins.bottom >= 0 &&
 298                    !is_root();
 299         }
 300
 301         bool is_visible() const
 302         {
 303             return !(m_skip || src_el()->css().get_display() == display_none || src_el()->css().get_visibility() != visibility_visible);
 304         }
 305
 306                 int render(int x, int y, const containing_block_context& containing_block_size, formatting_context* fmt_ctx, bool second_pass = false);
 307         int calc_width(int defVal, int containing_block_width) const;
 308         bool get_predefined_height(int& p_height, int containing_block_height) const;
 309         void apply_relative_shift(const containing_block_context &containing_block_size);
 310         void calc_outlines( int parent_width );
 311         int calc_auto_margins(int parent_width);        // returns left margin
 312
 313         virtual std::shared_ptr<render_item> init();
 314         virtual void apply_vertical_align() {}
 315         virtual int get_base_line() { return 0; }
 316         virtual std::shared_ptr<render_item> clone()
 317         {
 318             return std::make_shared<render_item>(src_el());
 319         }
 320         std::tuple<
 321                 std::shared_ptr<litehtml::render_item>,
 322                 std::shared_ptr<litehtml::render_item>,
 323                 std::shared_ptr<litehtml::render_item>
 324                 > split_inlines();
 325         bool fetch_positioned();
 326         void render_positioned(render_type rt = render_all);
 327         void add_positioned(const std::shared_ptr<litehtml::render_item> &el);
 328         void get_redraw_box(litehtml::position& pos, int x = 0, int y = 0);
 329         void calc_document_size( litehtml::size& sz, litehtml::size& content_size, int x = 0, int y = 0 );
 330                 virtual void get_inline_boxes( position::vector& boxes ) const {};
 331                 virtual void set_inline_boxes( position::vector& boxes ) {};
 332                 virtual void add_inline_box( const position& box ) {};
 333                 virtual void clear_inline_boxes() {};
 334         void draw_stacking_context( uint_ptr hdc, int x, int y, const position* clip, bool with_positioned );
 335         virtual void draw_children( uint_ptr hdc, int x, int y, const position* clip, draw_flag flag, int zindex );
 336         virtual int get_draw_vertical_offset() { return 0; }
 337         virtual std::shared_ptr<element> get_child_by_point(int x, int y, int client_x, int client_y, draw_flag flag, int zindex);
 338         std::shared_ptr<element> get_element_by_point(int x, int y, int client_x, int client_y);
 339         bool is_point_inside( int x, int y );
 340         void dump(litehtml::dumper& cout);
 341         position get_placement() const;
 342         /**
 343          * Returns the boxes of rendering element. All coordinates are absolute
 344          *
 345          * @param redraw_boxes [out] resulting rendering boxes
 346          * @return
 347          */
 348         void get_rendering_boxes( position::vector& redraw_boxes);
 349         };
 350 }
 351
 352 #endif //LH_RENDER_ITEM_H