src/plugins/litehtml_viewer/litehtml/element.h

   1 #ifndef LH_ELEMENT_H
   2 #define LH_ELEMENT_H
   3
   4 #include <memory>
   5 #include <tuple>
   6 #include <list>
   7 #include "stylesheet.h"
   8 #include "css_offsets.h"
   9 #include "css_margins.h"
  10 #include "css_properties.h"
  11
  12 namespace litehtml
  13 {
  14         class line_box;
  15         class dumper;
  16         class render_item;
  17
  18         class element : public std::enable_shared_from_this<element>
  19         {
  20                 friend class line_box;
  21                 friend class html_tag;
  22                 friend class el_table;
  23                 friend class document;
  24         public:
  25                 typedef std::shared_ptr<element>                ptr;
  26                 typedef std::shared_ptr<const element>  const_ptr;
  27                 typedef std::weak_ptr<element>                  weak_ptr;
  28         protected:
  29                 std::weak_ptr<element>                                  m_parent;
  30                 std::weak_ptr<document>                                 m_doc;
  31                 elements_list                                                   m_children;
  32                 css_properties                                                  m_css;
  33                 std::list<std::weak_ptr<render_item>>   m_renders;
  34                 used_selector::vector                                   m_used_styles;
  35
  36                 virtual void select_all(const css_selector& selector, elements_list& res);
  37                 element::ptr _add_before_after(int type, const style& style);
  38         public:
  39                 explicit element(const std::shared_ptr<document>& doc);
  40                 virtual ~element() = default;
  41
  42                 const css_properties&           css() const;
  43                 css_properties&                         css_w();
  44
  45                 bool                                            in_normal_flow()                        const;
  46                 bool                                            is_inline()                                     const;  // returns true if element is inline
  47                 bool                                            is_inline_box()                         const;  // returns true if element is inline box (inline-table, inline-box, inline-flex)
  48                 bool                                            is_block_box()                          const;
  49                 position                                        get_placement()                         const;
  50                 bool                                            is_positioned()                         const;
  51                 bool                                            is_float()                                      const;
  52                 bool                                            is_block_formatting_context() const;
  53
  54                 bool                                            is_root() const;
  55                 element::ptr                            parent() const;
  56                 void                                            parent(const element::ptr& par);
  57                 // returns true for elements inside a table (but outside cells) that don't participate in table rendering
  58                 bool                                            is_table_skip() const;
  59
  60                 std::shared_ptr<document>       get_document() const;
  61                 const std::list<std::shared_ptr<element>>& children() const;
  62
  63                 virtual elements_list           select_all(const string& selector);
  64                 virtual elements_list           select_all(const css_selector& selector);
  65
  66                 virtual element::ptr            select_one(const string& selector);
  67                 virtual element::ptr            select_one(const css_selector& selector);
  68
  69                 virtual bool                            appendChild(const ptr &el);
  70                 virtual bool                            removeChild(const ptr &el);
  71                 virtual void                            clearRecursive();
  72
  73                 virtual string_id                       id() const;
  74                 virtual string_id                       tag() const;
  75                 virtual const char*                     get_tagName() const;
  76                 virtual void                            set_tagName(const char* tag);
  77                 virtual void                            set_data(const char* data);
  78
  79                 virtual void                            set_attr(const char* name, const char* val);
  80                 virtual const char*                     get_attr(const char* name, const char* def = nullptr) const;
  81                 virtual void                            apply_stylesheet(const litehtml::css& stylesheet);
  82                 virtual void                            refresh_styles();
  83                 virtual bool                            is_white_space() const;
  84                 virtual bool                            is_space() const;
  85                 virtual bool                            is_comment() const;
  86                 virtual bool                            is_body() const;
  87                 virtual bool                            is_break() const;
  88                 virtual bool                            is_text() const;
  89
  90                 virtual bool                            on_mouse_over();
  91                 virtual bool                            on_mouse_leave();
  92                 virtual bool                            on_lbutton_down();
  93                 virtual bool                            on_lbutton_up();
  94                 virtual void                            on_click();
  95                 virtual bool                            set_pseudo_class(string_id cls, bool add);
  96                 virtual bool                            set_class(const char* pclass, bool add);
  97                 virtual bool                            is_replaced() const;
  98                 virtual void                            compute_styles(bool recursive = true);
  99                 virtual void                            draw(uint_ptr hdc, int x, int y, const position *clip, const std::shared_ptr<render_item>& ri);
 100                 virtual void                            draw_background(uint_ptr hdc, int x, int y, const position *clip, const std::shared_ptr<render_item> &ri);
 101                 virtual int                                     get_enum_property  (string_id name, bool inherited, int           default_value, uint_ptr css_properties_member_offset) const;
 102                 virtual css_length                      get_length_property(string_id name, bool inherited, css_length    default_value, uint_ptr css_properties_member_offset) const;
 103                 virtual web_color                       get_color_property (string_id name, bool inherited, web_color     default_value, uint_ptr css_properties_member_offset) const;
 104                 virtual string                          get_string_property(string_id name, bool inherited, const string& default_value, uint_ptr css_properties_member_offset) const;
 105                 virtual float                           get_number_property(string_id name, bool inherited, float         default_value, uint_ptr css_properties_member_offset) const;
 106                 virtual string_vector           get_string_vector_property(string_id name, bool inherited, const string_vector& default_value, uint_ptr css_properties_member_offset) const;
 107                 virtual int_vector                      get_int_vector_property   (string_id name, bool inherited, const int_vector&    default_value, uint_ptr css_properties_member_offset) const;
 108                 virtual length_vector           get_length_vector_property(string_id name, bool inherited, const length_vector& default_value, uint_ptr css_properties_member_offset) const;
 109                 virtual size_vector                     get_size_vector_property  (string_id name, bool inherited, const size_vector&   default_value, uint_ptr css_properties_member_offset) const;
 110                 virtual string                          get_custom_property(string_id name, const string& default_value) const;
 111
 112                 virtual void                            get_text(string& text);
 113                 virtual void                            parse_attributes();
 114                 virtual int                                     select(const string& selector);
 115                 virtual int                                     select(const css_selector& selector, bool apply_pseudo = true);
 116                 virtual int                                     select(const css_element_selector& selector, bool apply_pseudo = true);
 117                 virtual element::ptr            find_ancestor(const css_selector& selector, bool apply_pseudo = true, bool* is_pseudo = nullptr);
 118                 virtual bool                            is_ancestor(const ptr &el) const;
 119                 virtual element::ptr            find_adjacent_sibling(const element::ptr& el, const css_selector& selector, bool apply_pseudo = true, bool* is_pseudo = nullptr);
 120                 virtual element::ptr            find_sibling(const element::ptr& el, const css_selector& selector, bool apply_pseudo = true, bool* is_pseudo = nullptr);
 121                 virtual void                            get_content_size(size& sz, int max_width);
 122                 virtual bool                            is_nth_child(const element::ptr& el, int num, int off, bool of_type) const;
 123                 virtual bool                            is_nth_last_child(const element::ptr& el, int num, int off, bool of_type) const;
 124                 virtual bool                            is_only_child(const element::ptr& el, bool of_type) const;
 125                 virtual void                            add_style(const style& style);
 126                 virtual const background*       get_background(bool own_only = false);
 127
 128                 virtual string                          dump_get_name();
 129                 virtual std::vector<std::tuple<string, string>> dump_get_attrs();
 130                 void                                            dump(litehtml::dumper& cout);
 131
 132                 std::tuple<element::ptr, element::ptr, element::ptr> split_inlines();
 133                 virtual std::shared_ptr<render_item> create_render_item(const std::shared_ptr<render_item>& parent_ri);
 134                 bool requires_styles_update();
 135                 void add_render(const std::shared_ptr<render_item>& ri);
 136                 bool find_styles_changes( position::vector& redraw_boxes);
 137                 element::ptr add_pseudo_before(const style& style)
 138                 {
 139                         return _add_before_after(0, style);
 140                 }
 141                 element::ptr add_pseudo_after(const style& style)
 142                 {
 143                         return _add_before_after(1, style);
 144                 }
 145         };
 146
 147         //////////////////////////////////////////////////////////////////////////
 148         //                                                      INLINE FUNCTIONS                                                        //
 149         //////////////////////////////////////////////////////////////////////////
 150
 151         inline bool litehtml::element::in_normal_flow() const
 152         {
 153                 if(css().get_position() != element_position_absolute && css().get_display() != display_none)
 154                 {
 155                         return true;
 156                 }
 157                 return false;
 158         }
 159
 160         inline bool litehtml::element::is_root() const
 161         {
 162                 return m_parent.expired();
 163         }
 164
 165         inline element::ptr litehtml::element::parent() const
 166         {
 167                 return m_parent.lock();
 168         }
 169
 170         inline void litehtml::element::parent(const element::ptr& par)
 171         {
 172                 m_parent = par;
 173         }
 174
 175         inline bool litehtml::element::is_positioned()  const
 176         {
 177                 return (css().get_position() > element_position_static);
 178         }
 179
 180         inline bool litehtml::element::is_float()       const
 181         {
 182                 return (css().get_float() != float_none);
 183         }
 184
 185         inline std::shared_ptr<document> element::get_document() const
 186         {
 187                 return m_doc.lock();
 188         }
 189
 190         inline const css_properties& element::css() const
 191         {
 192                 return m_css;
 193         }
 194
 195         inline css_properties& element::css_w()
 196         {
 197                 return m_css;
 198         }
 199
 200         inline bool element::is_block_box() const
 201         {
 202                 if (css().get_display() == display_block ||
 203                         css().get_display() == display_flex ||
 204                         css().get_display() == display_table ||
 205                         css().get_display() == display_list_item ||
 206                         css().get_display() == display_flex)
 207                 {
 208                         return true;
 209                 }
 210                 return false;
 211         }
 212
 213         inline const std::list<std::shared_ptr<element>>& element::children() const
 214         {
 215                 return m_children;
 216         }
 217 }
 218
 219 #endif  // LH_ELEMENT_H