Refactoring
This commit is contained in:
parent
5193a0af5c
commit
6617ab7188
@ -24,9 +24,9 @@ namespace litehtml
|
||||
css_border_radius m_radius;
|
||||
|
||||
public:
|
||||
background(void);
|
||||
background();
|
||||
background(const background& val);
|
||||
~background(void);
|
||||
~background() = default;
|
||||
|
||||
background& operator=(const background& val);
|
||||
};
|
||||
@ -50,7 +50,7 @@ namespace litehtml
|
||||
public:
|
||||
background_paint();
|
||||
background_paint(const background_paint& val);
|
||||
void operator=(const background& val);
|
||||
background_paint& operator=(const background& val);
|
||||
};
|
||||
|
||||
}
|
||||
|
@ -222,10 +222,12 @@ namespace litehtml
|
||||
css_border bottom;
|
||||
css_border_radius radius;
|
||||
|
||||
css_borders()
|
||||
{
|
||||
css_borders() = default;
|
||||
|
||||
}
|
||||
bool is_visible() const
|
||||
{
|
||||
return left.width.val() != 0 || right.width.val() != 0 || top.width.val() != 0 || bottom.width.val() != 0;
|
||||
}
|
||||
|
||||
css_borders(const css_borders& val)
|
||||
{
|
||||
@ -255,10 +257,7 @@ namespace litehtml
|
||||
border bottom;
|
||||
border_radiuses radius;
|
||||
|
||||
borders()
|
||||
{
|
||||
|
||||
}
|
||||
borders() = default;
|
||||
|
||||
borders(const borders& val)
|
||||
{
|
||||
@ -277,6 +276,11 @@ namespace litehtml
|
||||
bottom = val.bottom;
|
||||
}
|
||||
|
||||
bool is_visible() const
|
||||
{
|
||||
return left.width != 0 || right.width != 0 || top.width != 0 || bottom.width != 0;
|
||||
}
|
||||
|
||||
borders& operator=(const borders& val)
|
||||
{
|
||||
left = val.left;
|
||||
|
@ -27,24 +27,24 @@ namespace litehtml
|
||||
m_box_left = left;
|
||||
m_box_right = right;
|
||||
}
|
||||
virtual ~box() {}
|
||||
virtual ~box() = default;
|
||||
|
||||
int bottom() { return m_box_top + height(); }
|
||||
int top() { return m_box_top; }
|
||||
int right() { return m_box_left + width(); }
|
||||
int left() { return m_box_left; }
|
||||
int bottom() const { return m_box_top + height(); }
|
||||
int top() const { return m_box_top; }
|
||||
int right() const { return m_box_left + width(); }
|
||||
int left() const { return m_box_left; }
|
||||
|
||||
virtual litehtml::box_type get_type() = 0;
|
||||
virtual int height() = 0;
|
||||
virtual int width() = 0;
|
||||
virtual litehtml::box_type get_type() const = 0;
|
||||
virtual int height() const = 0;
|
||||
virtual int width() const = 0;
|
||||
virtual void add_element(const element::ptr &el) = 0;
|
||||
virtual bool can_hold(const element::ptr &el, white_space ws) = 0;
|
||||
virtual bool can_hold(const element::ptr &el, white_space ws) const = 0;
|
||||
virtual void finish(bool last_box = false) = 0;
|
||||
virtual bool is_empty() = 0;
|
||||
virtual int baseline() = 0;
|
||||
virtual bool is_empty() const = 0;
|
||||
virtual int baseline() const = 0;
|
||||
virtual void get_elements(elements_vector& els) = 0;
|
||||
virtual int top_margin() = 0;
|
||||
virtual int bottom_margin() = 0;
|
||||
virtual int top_margin() const = 0;
|
||||
virtual int bottom_margin() const = 0;
|
||||
virtual void y_shift(int shift) = 0;
|
||||
virtual void new_width(int left, int right, elements_vector& els) = 0;
|
||||
};
|
||||
@ -57,22 +57,22 @@ namespace litehtml
|
||||
public:
|
||||
block_box(int top, int left, int right) : box(top, left, right)
|
||||
{
|
||||
m_element = 0;
|
||||
m_element = nullptr;
|
||||
}
|
||||
|
||||
virtual litehtml::box_type get_type();
|
||||
virtual int height();
|
||||
virtual int width();
|
||||
virtual void add_element(const element::ptr &el);
|
||||
virtual bool can_hold(const element::ptr &el, white_space ws);
|
||||
virtual void finish(bool last_box = false);
|
||||
virtual bool is_empty();
|
||||
virtual int baseline();
|
||||
virtual void get_elements(elements_vector& els);
|
||||
virtual int top_margin();
|
||||
virtual int bottom_margin();
|
||||
virtual void y_shift(int shift);
|
||||
virtual void new_width(int left, int right, elements_vector& els);
|
||||
litehtml::box_type get_type() const override;
|
||||
int height() const override;
|
||||
int width() const override;
|
||||
void add_element(const element::ptr &el) override;
|
||||
bool can_hold(const element::ptr &el, white_space ws) const override;
|
||||
void finish(bool last_box = false) override;
|
||||
bool is_empty() const override;
|
||||
int baseline() const override;
|
||||
void get_elements(elements_vector& els) override;
|
||||
int top_margin() const override;
|
||||
int bottom_margin() const override;
|
||||
void y_shift(int shift) override;
|
||||
void new_width(int left, int right, elements_vector& els) override;
|
||||
};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
@ -97,23 +97,23 @@ namespace litehtml
|
||||
m_text_align = align;
|
||||
}
|
||||
|
||||
virtual litehtml::box_type get_type();
|
||||
virtual int height();
|
||||
virtual int width();
|
||||
virtual void add_element(const element::ptr &el);
|
||||
virtual bool can_hold(const element::ptr &el, white_space ws);
|
||||
virtual void finish(bool last_box = false);
|
||||
virtual bool is_empty();
|
||||
virtual int baseline();
|
||||
virtual void get_elements(elements_vector& els);
|
||||
virtual int top_margin();
|
||||
virtual int bottom_margin();
|
||||
virtual void y_shift(int shift);
|
||||
virtual void new_width(int left, int right, elements_vector& els);
|
||||
litehtml::box_type get_type() const override;
|
||||
int height() const override;
|
||||
int width() const override;
|
||||
void add_element(const element::ptr &el) override;
|
||||
bool can_hold(const element::ptr &el, white_space ws) const override;
|
||||
void finish(bool last_box = false) override;
|
||||
bool is_empty() const override;
|
||||
int baseline() const override;
|
||||
void get_elements(elements_vector& els) override;
|
||||
int top_margin() const override;
|
||||
int bottom_margin() const override;
|
||||
void y_shift(int shift) override;
|
||||
void new_width(int left, int right, elements_vector& els) override;
|
||||
|
||||
private:
|
||||
bool have_last_space();
|
||||
bool is_break_only();
|
||||
bool have_last_space() const;
|
||||
bool is_break_only() const;
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -12,10 +12,7 @@ namespace litehtml
|
||||
css_length top;
|
||||
css_length bottom;
|
||||
|
||||
css_margins()
|
||||
{
|
||||
|
||||
}
|
||||
css_margins() = default;
|
||||
|
||||
css_margins(const css_margins& val)
|
||||
{
|
||||
|
@ -12,10 +12,7 @@ namespace litehtml
|
||||
css_length right;
|
||||
css_length bottom;
|
||||
|
||||
css_offsets()
|
||||
{
|
||||
|
||||
}
|
||||
css_offsets() = default;
|
||||
|
||||
css_offsets(const css_offsets& val)
|
||||
{
|
||||
|
@ -12,10 +12,7 @@ namespace litehtml
|
||||
css_length width;
|
||||
css_length height;
|
||||
|
||||
css_position()
|
||||
{
|
||||
|
||||
}
|
||||
css_position() = default;
|
||||
|
||||
css_position(const css_position& val)
|
||||
{
|
||||
|
@ -15,7 +15,7 @@ namespace litehtml
|
||||
int c;
|
||||
int d;
|
||||
|
||||
selector_specificity(int va = 0, int vb = 0, int vc = 0, int vd = 0)
|
||||
explicit selector_specificity(int va = 0, int vb = 0, int vc = 0, int vd = 0)
|
||||
{
|
||||
a = va;
|
||||
b = vb;
|
||||
@ -183,26 +183,24 @@ namespace litehtml
|
||||
int m_order;
|
||||
media_query_list::ptr m_media_query;
|
||||
public:
|
||||
css_selector(media_query_list::ptr media)
|
||||
explicit css_selector(const media_query_list::ptr& media)
|
||||
{
|
||||
m_media_query = media;
|
||||
m_combinator = combinator_descendant;
|
||||
m_order = 0;
|
||||
}
|
||||
|
||||
~css_selector()
|
||||
{
|
||||
}
|
||||
~css_selector() = default;
|
||||
|
||||
css_selector(const css_selector& val)
|
||||
{
|
||||
m_right = val.m_right;
|
||||
if(val.m_left)
|
||||
{
|
||||
m_left = std::make_shared<css_selector>(*val.m_left);
|
||||
m_left = std::make_shared<css_selector>(*val.m_left);
|
||||
} else
|
||||
{
|
||||
m_left = 0;
|
||||
m_left = nullptr;
|
||||
}
|
||||
m_combinator = val.m_combinator;
|
||||
m_specificity = val.m_specificity;
|
||||
|
@ -15,9 +15,7 @@ namespace litehtml
|
||||
tstring baseurl;
|
||||
tstring media;
|
||||
|
||||
css_text()
|
||||
{
|
||||
}
|
||||
css_text() = default;
|
||||
|
||||
css_text(const tchar_t* txt, const tchar_t* url, const tchar_t* media_str)
|
||||
{
|
||||
@ -34,18 +32,6 @@ namespace litehtml
|
||||
}
|
||||
};
|
||||
|
||||
struct stop_tags_t
|
||||
{
|
||||
const litehtml::tchar_t* tags;
|
||||
const litehtml::tchar_t* stop_parent;
|
||||
};
|
||||
|
||||
struct ommited_end_tags_t
|
||||
{
|
||||
const litehtml::tchar_t* tag;
|
||||
const litehtml::tchar_t* followed_tags;
|
||||
};
|
||||
|
||||
class html_tag;
|
||||
|
||||
class document : public std::enable_shared_from_this<document>
|
||||
@ -78,7 +64,7 @@ namespace litehtml
|
||||
int render(int max_width, render_type rt = render_all);
|
||||
void draw(uint_ptr hdc, int x, int y, const position* clip);
|
||||
web_color get_def_color() { return m_def_color; }
|
||||
int cvt_units(const tchar_t* str, int fontSize, bool* is_percent = 0) const;
|
||||
int cvt_units(const tchar_t* str, int fontSize, bool* is_percent = nullptr) const;
|
||||
int cvt_units(css_length& val, int fontSize, int size = 0) const;
|
||||
int width() const;
|
||||
int height() const;
|
||||
@ -91,18 +77,18 @@ namespace litehtml
|
||||
element::ptr root();
|
||||
void get_fixed_boxes(position::vector& fixed_boxes);
|
||||
void add_fixed_box(const position& pos);
|
||||
void add_media_list(media_query_list::ptr list);
|
||||
void add_media_list(const media_query_list::ptr& list);
|
||||
bool media_changed();
|
||||
bool lang_changed();
|
||||
bool match_lang(const tstring & lang);
|
||||
void add_tabular(const element::ptr& el);
|
||||
const element::const_ptr get_over_element() const { return m_over_element; }
|
||||
element::const_ptr get_over_element() const { return m_over_element; }
|
||||
|
||||
void append_children_from_string(element& parent, const tchar_t* str);
|
||||
void append_children_from_utf8(element& parent, const char* str);
|
||||
|
||||
static litehtml::document::ptr createFromString(const tchar_t* str, litehtml::document_container* objPainter, litehtml::context* ctx, litehtml::css* user_styles = 0);
|
||||
static litehtml::document::ptr createFromUTF8(const char* str, litehtml::document_container* objPainter, litehtml::context* ctx, litehtml::css* user_styles = 0);
|
||||
static litehtml::document::ptr createFromString(const tchar_t* str, litehtml::document_container* objPainter, litehtml::context* ctx, litehtml::css* user_styles = nullptr);
|
||||
static litehtml::document::ptr createFromUTF8(const char* str, litehtml::document_container* objPainter, litehtml::context* ctx, litehtml::css* user_styles = nullptr);
|
||||
|
||||
private:
|
||||
litehtml::uint_ptr add_font(const tchar_t* name, int size, const tchar_t* weight, const tchar_t* style, const tchar_t* decoration, font_metrics* fm);
|
||||
|
@ -8,11 +8,10 @@ namespace litehtml
|
||||
class el_anchor : public html_tag
|
||||
{
|
||||
public:
|
||||
el_anchor(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_anchor();
|
||||
explicit el_anchor(const std::shared_ptr<litehtml::document>& doc);
|
||||
|
||||
virtual void on_click() override;
|
||||
virtual void apply_stylesheet(const litehtml::css& stylesheet) override;
|
||||
void on_click() override;
|
||||
void apply_stylesheet(const litehtml::css& stylesheet) override;
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -8,10 +8,9 @@ namespace litehtml
|
||||
class el_base : public html_tag
|
||||
{
|
||||
public:
|
||||
el_base(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_base();
|
||||
explicit el_base(const std::shared_ptr<litehtml::document>& doc);
|
||||
|
||||
virtual void parse_attributes() override;
|
||||
void parse_attributes() override;
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -9,20 +9,19 @@ namespace litehtml
|
||||
{
|
||||
public:
|
||||
el_before_after_base(const std::shared_ptr<litehtml::document>& doc, bool before);
|
||||
virtual ~el_before_after_base();
|
||||
|
||||
virtual void add_style(const litehtml::style& st) override;
|
||||
virtual void apply_stylesheet(const litehtml::css& stylesheet) override;
|
||||
void add_style(const litehtml::style& st) override;
|
||||
void apply_stylesheet(const litehtml::css& stylesheet) override;
|
||||
private:
|
||||
void add_text(const tstring& txt);
|
||||
void add_function(const tstring& fnc, const tstring& params);
|
||||
tstring convert_escape(const tchar_t* txt);
|
||||
static tstring convert_escape(const tchar_t* txt);
|
||||
};
|
||||
|
||||
class el_before : public el_before_after_base
|
||||
{
|
||||
public:
|
||||
el_before(const std::shared_ptr<litehtml::document>& doc) : el_before_after_base(doc, true)
|
||||
explicit el_before(const std::shared_ptr<litehtml::document>& doc) : el_before_after_base(doc, true)
|
||||
{
|
||||
|
||||
}
|
||||
@ -31,7 +30,7 @@ namespace litehtml
|
||||
class el_after : public el_before_after_base
|
||||
{
|
||||
public:
|
||||
el_after(const std::shared_ptr<litehtml::document>& doc) : el_before_after_base(doc, false)
|
||||
explicit el_after(const std::shared_ptr<litehtml::document>& doc) : el_before_after_base(doc, false)
|
||||
{
|
||||
|
||||
}
|
||||
|
@ -8,10 +8,9 @@ namespace litehtml
|
||||
class el_body : public html_tag
|
||||
{
|
||||
public:
|
||||
el_body(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_body();
|
||||
explicit el_body(const std::shared_ptr<litehtml::document>& doc);
|
||||
|
||||
virtual bool is_body() const override;
|
||||
bool is_body() const override;
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -8,10 +8,9 @@ namespace litehtml
|
||||
class el_break : public html_tag
|
||||
{
|
||||
public:
|
||||
el_break(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_break();
|
||||
explicit el_break(const std::shared_ptr<litehtml::document>& doc);
|
||||
|
||||
virtual bool is_break() const override;
|
||||
bool is_break() const override;
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -9,11 +9,10 @@ namespace litehtml
|
||||
{
|
||||
tstring m_text;
|
||||
public:
|
||||
el_cdata(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_cdata();
|
||||
explicit el_cdata(const std::shared_ptr<litehtml::document>& doc);
|
||||
|
||||
virtual void get_text(tstring& text) override;
|
||||
virtual void set_data(const tchar_t* data) override;
|
||||
void get_text(tstring& text) override;
|
||||
void set_data(const tchar_t* data) override;
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -9,11 +9,10 @@ namespace litehtml
|
||||
{
|
||||
tstring m_text;
|
||||
public:
|
||||
el_comment(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_comment();
|
||||
explicit el_comment(const std::shared_ptr<litehtml::document>& doc);
|
||||
|
||||
virtual void get_text(tstring& text) override;
|
||||
virtual void set_data(const tchar_t* data) override;
|
||||
void get_text(tstring& text) override;
|
||||
void set_data(const tchar_t* data) override;
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -8,10 +8,9 @@ namespace litehtml
|
||||
class el_div : public html_tag
|
||||
{
|
||||
public:
|
||||
el_div(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_div();
|
||||
explicit el_div(const std::shared_ptr<litehtml::document>& doc);
|
||||
|
||||
virtual void parse_attributes() override;
|
||||
void parse_attributes() override;
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -8,10 +8,9 @@ namespace litehtml
|
||||
class el_font : public html_tag
|
||||
{
|
||||
public:
|
||||
el_font(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_font();
|
||||
explicit el_font(const std::shared_ptr<litehtml::document>& doc);
|
||||
|
||||
virtual void parse_attributes() override;
|
||||
void parse_attributes() override;
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -8,10 +8,9 @@ namespace litehtml
|
||||
class el_li : public html_tag
|
||||
{
|
||||
public:
|
||||
el_li(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_li();
|
||||
explicit el_li(const std::shared_ptr<litehtml::document>& doc);
|
||||
|
||||
virtual int render(int x, int y, int max_width, bool second_pass = false) override;
|
||||
int render(int x, int y, int max_width, bool second_pass = false) override;
|
||||
|
||||
private:
|
||||
bool m_index_initialized = false;
|
||||
|
@ -8,11 +8,10 @@ namespace litehtml
|
||||
class el_link : public html_tag
|
||||
{
|
||||
public:
|
||||
el_link(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_link();
|
||||
explicit el_link(const std::shared_ptr<litehtml::document>& doc);
|
||||
|
||||
protected:
|
||||
virtual void parse_attributes() override;
|
||||
void parse_attributes() override;
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -8,10 +8,9 @@ namespace litehtml
|
||||
class el_para : public html_tag
|
||||
{
|
||||
public:
|
||||
el_para(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_para();
|
||||
explicit el_para(const std::shared_ptr<litehtml::document>& doc);
|
||||
|
||||
virtual void parse_attributes() override;
|
||||
void parse_attributes() override;
|
||||
|
||||
};
|
||||
}
|
||||
|
@ -9,12 +9,11 @@ namespace litehtml
|
||||
{
|
||||
tstring m_text;
|
||||
public:
|
||||
el_script(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_script();
|
||||
explicit el_script(const std::shared_ptr<litehtml::document>& doc);
|
||||
|
||||
virtual void parse_attributes() override;
|
||||
virtual bool appendChild(const ptr &el) override;
|
||||
virtual const tchar_t* get_tagName() const override;
|
||||
void parse_attributes() override;
|
||||
bool appendChild(const ptr &el) override;
|
||||
const tchar_t* get_tagName() const override;
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -10,10 +10,9 @@ namespace litehtml
|
||||
{
|
||||
public:
|
||||
el_space(const tchar_t* text, const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_space();
|
||||
|
||||
virtual bool is_white_space() const override;
|
||||
virtual bool is_break() const override;
|
||||
bool is_white_space() const override;
|
||||
bool is_break() const override;
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -9,12 +9,11 @@ namespace litehtml
|
||||
{
|
||||
elements_vector m_children;
|
||||
public:
|
||||
el_style(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_style();
|
||||
explicit el_style(const std::shared_ptr<litehtml::document>& doc);
|
||||
|
||||
virtual void parse_attributes() override;
|
||||
virtual bool appendChild(const ptr &el) override;
|
||||
virtual const tchar_t* get_tagName() const override;
|
||||
void parse_attributes() override;
|
||||
bool appendChild(const ptr &el) override;
|
||||
const tchar_t* get_tagName() const override;
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -15,12 +15,11 @@ namespace litehtml
|
||||
class el_table : public html_tag
|
||||
{
|
||||
public:
|
||||
el_table(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_table();
|
||||
explicit el_table(const std::shared_ptr<litehtml::document>& doc);
|
||||
|
||||
virtual bool appendChild(const litehtml::element::ptr& el) override;
|
||||
virtual void parse_styles(bool is_reparse = false) override;
|
||||
virtual void parse_attributes() override;
|
||||
bool appendChild(const litehtml::element::ptr& el) override;
|
||||
void parse_styles(bool is_reparse = false) override;
|
||||
void parse_attributes() override;
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -8,10 +8,9 @@ namespace litehtml
|
||||
class el_td : public html_tag
|
||||
{
|
||||
public:
|
||||
el_td(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_td();
|
||||
explicit el_td(const std::shared_ptr<litehtml::document>& doc);
|
||||
|
||||
virtual void parse_attributes() override;
|
||||
void parse_attributes() override;
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -16,22 +16,21 @@ namespace litehtml
|
||||
bool m_draw_spaces;
|
||||
public:
|
||||
el_text(const tchar_t* text, const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_text();
|
||||
|
||||
virtual void get_text(tstring& text) override;
|
||||
virtual const tchar_t* get_style_property(const tchar_t* name, bool inherited, const tchar_t* def = 0) override;
|
||||
virtual void parse_styles(bool is_reparse) override;
|
||||
virtual int get_base_line() override;
|
||||
virtual void draw(uint_ptr hdc, int x, int y, const position* clip) override;
|
||||
virtual int line_height() const override;
|
||||
virtual uint_ptr get_font(font_metrics* fm = 0) override;
|
||||
virtual style_display get_display() const override;
|
||||
virtual white_space get_white_space() const override;
|
||||
virtual element_position get_element_position(css_offsets* offsets = 0) const override;
|
||||
virtual css_offsets get_css_offsets() const override;
|
||||
void get_text(tstring& text) override;
|
||||
const tchar_t* get_style_property(const tchar_t* name, bool inherited, const tchar_t* def = nullptr) override;
|
||||
void parse_styles(bool is_reparse) override;
|
||||
int get_base_line() override;
|
||||
void draw(uint_ptr hdc, int x, int y, const position* clip) override;
|
||||
int line_height() const override;
|
||||
uint_ptr get_font(font_metrics* fm = nullptr) override;
|
||||
style_display get_display() const override;
|
||||
white_space get_white_space() const override;
|
||||
element_position get_element_position(css_offsets* offsets = nullptr) const override;
|
||||
css_offsets get_css_offsets() const override;
|
||||
|
||||
protected:
|
||||
virtual void get_content_size(size& sz, int max_width) override;
|
||||
void get_content_size(size& sz, int max_width) override;
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -8,11 +8,10 @@ namespace litehtml
|
||||
class el_title : public html_tag
|
||||
{
|
||||
public:
|
||||
el_title(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_title();
|
||||
explicit el_title(const std::shared_ptr<litehtml::document>& doc);
|
||||
|
||||
protected:
|
||||
virtual void parse_attributes() override;
|
||||
void parse_attributes() override;
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -8,11 +8,10 @@ namespace litehtml
|
||||
class el_tr : public html_tag
|
||||
{
|
||||
public:
|
||||
el_tr(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~el_tr();
|
||||
explicit el_tr(const std::shared_ptr<litehtml::document>& doc);
|
||||
|
||||
virtual void parse_attributes() override;
|
||||
virtual void get_inline_boxes(position::vector& boxes) override;
|
||||
void parse_attributes() override;
|
||||
void get_inline_boxes(position::vector& boxes) override;
|
||||
};
|
||||
}
|
||||
|
||||
|
@ -17,9 +17,9 @@ namespace litehtml
|
||||
friend class el_table;
|
||||
friend class document;
|
||||
public:
|
||||
typedef std::shared_ptr<litehtml::element> ptr;
|
||||
typedef std::shared_ptr<const litehtml::element> const_ptr;
|
||||
typedef std::weak_ptr<litehtml::element> weak_ptr;
|
||||
typedef std::shared_ptr<litehtml::element> ptr;
|
||||
typedef std::shared_ptr<const litehtml::element> const_ptr;
|
||||
typedef std::weak_ptr<litehtml::element> weak_ptr;
|
||||
protected:
|
||||
std::weak_ptr<element> m_parent;
|
||||
std::weak_ptr<litehtml::document> m_doc;
|
||||
@ -33,8 +33,8 @@ namespace litehtml
|
||||
|
||||
virtual void select_all(const css_selector& selector, elements_vector& res);
|
||||
public:
|
||||
element(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~element();
|
||||
explicit element(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~element() = default;
|
||||
|
||||
// returns refer to m_pos member;
|
||||
position& get_position();
|
||||
@ -79,11 +79,11 @@ namespace litehtml
|
||||
bool collapse_bottom_margin() const;
|
||||
bool is_positioned() const;
|
||||
|
||||
bool skip();
|
||||
bool skip() const;
|
||||
void skip(bool val);
|
||||
bool have_parent() const;
|
||||
element::ptr parent() const;
|
||||
void parent(element::ptr par);
|
||||
void parent(const element::ptr& par);
|
||||
bool is_visible() const;
|
||||
int calc_width(int defVal) const;
|
||||
int get_inline_shift_left();
|
||||
@ -131,7 +131,7 @@ namespace litehtml
|
||||
virtual css_length get_css_height() const;
|
||||
|
||||
virtual void set_attr(const tchar_t* name, const tchar_t* val);
|
||||
virtual const tchar_t* get_attr(const tchar_t* name, const tchar_t* def = 0) const;
|
||||
virtual const tchar_t* get_attr(const tchar_t* name, const tchar_t* def = nullptr) const;
|
||||
virtual void apply_stylesheet(const litehtml::css& stylesheet);
|
||||
virtual void refresh_styles();
|
||||
virtual bool is_white_space() const;
|
||||
@ -154,22 +154,22 @@ namespace litehtml
|
||||
virtual white_space get_white_space() const;
|
||||
virtual style_display get_display() const;
|
||||
virtual visibility get_visibility() const;
|
||||
virtual element_position get_element_position(css_offsets* offsets = 0) const;
|
||||
virtual element_position get_element_position(css_offsets* offsets = nullptr) const;
|
||||
virtual void get_inline_boxes(position::vector& boxes);
|
||||
virtual void parse_styles(bool is_reparse = false);
|
||||
virtual void draw(uint_ptr hdc, int x, int y, const position* clip);
|
||||
virtual void draw_background( uint_ptr hdc, int x, int y, const position* clip );
|
||||
virtual const tchar_t* get_style_property(const tchar_t* name, bool inherited, const tchar_t* def = 0);
|
||||
virtual uint_ptr get_font(font_metrics* fm = 0);
|
||||
virtual const tchar_t* get_style_property(const tchar_t* name, bool inherited, const tchar_t* def = nullptr);
|
||||
virtual uint_ptr get_font(font_metrics* fm = nullptr);
|
||||
virtual int get_font_size() const;
|
||||
virtual void get_text(tstring& text);
|
||||
virtual void parse_attributes();
|
||||
virtual int select(const css_selector& selector, bool apply_pseudo = true);
|
||||
virtual int select(const css_element_selector& selector, bool apply_pseudo = true);
|
||||
virtual element::ptr find_ancestor(const css_selector& selector, bool apply_pseudo = true, bool* is_pseudo = 0);
|
||||
virtual element::ptr find_ancestor(const css_selector& selector, bool apply_pseudo = true, bool* is_pseudo = nullptr);
|
||||
virtual bool is_ancestor(const ptr &el) const;
|
||||
virtual element::ptr find_adjacent_sibling(const element::ptr& el, const css_selector& selector, bool apply_pseudo = true, bool* is_pseudo = 0);
|
||||
virtual element::ptr find_sibling(const element::ptr& el, const css_selector& selector, bool apply_pseudo = true, bool* is_pseudo = 0);
|
||||
virtual element::ptr find_adjacent_sibling(const element::ptr& el, const css_selector& selector, bool apply_pseudo = true, bool* is_pseudo = nullptr);
|
||||
virtual element::ptr find_sibling(const element::ptr& el, const css_selector& selector, bool apply_pseudo = true, bool* is_pseudo = nullptr);
|
||||
virtual bool is_first_child_inline(const element::ptr& el) const;
|
||||
virtual bool is_last_child_inline(const element::ptr& el);
|
||||
virtual bool have_inline_child() const;
|
||||
@ -324,7 +324,7 @@ namespace litehtml
|
||||
return m_borders.right;
|
||||
}
|
||||
|
||||
inline bool litehtml::element::skip()
|
||||
inline bool litehtml::element::skip() const
|
||||
{
|
||||
return m_skip;
|
||||
}
|
||||
@ -344,7 +344,7 @@ namespace litehtml
|
||||
return m_parent.lock();
|
||||
}
|
||||
|
||||
inline void litehtml::element::parent(element::ptr par)
|
||||
inline void litehtml::element::parent(const element::ptr& par)
|
||||
{
|
||||
m_parent = par;
|
||||
}
|
||||
|
@ -65,7 +65,7 @@ namespace litehtml
|
||||
virtual void get_media_features(litehtml::media_features& media) const = 0;
|
||||
virtual void get_language(litehtml::tstring& language, litehtml::tstring & culture) const = 0;
|
||||
virtual litehtml::tstring resolve_color(const litehtml::tstring& /*color*/) const { return litehtml::tstring(); }
|
||||
virtual void split_text(const char* text, std::function<void(const tchar_t*)> on_word, std::function<void(const tchar_t*)> on_space);
|
||||
virtual void split_text(const char* text, const std::function<void(const tchar_t*)>& on_word, const std::function<void(const tchar_t*)>& on_space);
|
||||
|
||||
protected:
|
||||
~document_container() = default;
|
||||
|
@ -20,7 +20,7 @@ namespace litehtml
|
||||
int left;
|
||||
int right;
|
||||
|
||||
int width()
|
||||
int width() const
|
||||
{
|
||||
return right - left;
|
||||
}
|
||||
@ -95,145 +95,144 @@ namespace litehtml
|
||||
int m_border_spacing_y;
|
||||
border_collapse m_border_collapse;
|
||||
|
||||
virtual void select_all(const css_selector& selector, elements_vector& res) override;
|
||||
void select_all(const css_selector& selector, elements_vector& res) override;
|
||||
|
||||
public:
|
||||
html_tag(const std::shared_ptr<litehtml::document>& doc);
|
||||
virtual ~html_tag();
|
||||
explicit html_tag(const std::shared_ptr<litehtml::document>& doc);
|
||||
|
||||
/* render functions */
|
||||
|
||||
virtual int render(int x, int y, int max_width, bool second_pass = false) override;
|
||||
int render(int x, int y, int max_width, bool second_pass = false) override;
|
||||
|
||||
virtual int render_inline(const element::ptr &container, int max_width) override;
|
||||
virtual int place_element(const element::ptr &el, int max_width) override;
|
||||
virtual bool fetch_positioned() override;
|
||||
virtual void render_positioned(render_type rt = render_all) override;
|
||||
int render_inline(const element::ptr &container, int max_width) override;
|
||||
int place_element(const element::ptr &el, int max_width) override;
|
||||
bool fetch_positioned() override;
|
||||
void render_positioned(render_type rt = render_all) override;
|
||||
|
||||
int new_box(const element::ptr &el, int max_width, line_context& line_ctx);
|
||||
int new_box(const element::ptr &el, int max_width, line_context& line_ctx);
|
||||
|
||||
int get_cleared_top(const element::ptr &el, int line_top) const;
|
||||
int finish_last_box(bool end_of_render = false);
|
||||
int get_cleared_top(const element::ptr &el, int line_top) const;
|
||||
int finish_last_box(bool end_of_render = false);
|
||||
|
||||
virtual bool appendChild(const element::ptr &el) override;
|
||||
virtual bool removeChild(const element::ptr &el) override;
|
||||
virtual void clearRecursive() override;
|
||||
virtual const tchar_t* get_tagName() const override;
|
||||
virtual void set_tagName(const tchar_t* tag) override;
|
||||
virtual void set_data(const tchar_t* data) override;
|
||||
virtual element_float get_float() const override;
|
||||
virtual vertical_align get_vertical_align() const override;
|
||||
virtual css_length get_css_left() const override;
|
||||
virtual css_length get_css_right() const override;
|
||||
virtual css_length get_css_top() const override;
|
||||
virtual css_length get_css_bottom() const override;
|
||||
virtual css_length get_css_width() const override;
|
||||
virtual css_offsets get_css_offsets() const override;
|
||||
virtual void set_css_width(css_length& w) override;
|
||||
virtual css_length get_css_height() const override;
|
||||
virtual element_clear get_clear() const override;
|
||||
virtual size_t get_children_count() const override;
|
||||
virtual element::ptr get_child(int idx) const override;
|
||||
virtual element_position get_element_position(css_offsets* offsets = 0) const override;
|
||||
virtual overflow get_overflow() const override;
|
||||
bool appendChild(const element::ptr &el) override;
|
||||
bool removeChild(const element::ptr &el) override;
|
||||
void clearRecursive() override;
|
||||
const tchar_t* get_tagName() const override;
|
||||
void set_tagName(const tchar_t* tag) override;
|
||||
void set_data(const tchar_t* data) override;
|
||||
element_float get_float() const override;
|
||||
vertical_align get_vertical_align() const override;
|
||||
css_length get_css_left() const override;
|
||||
css_length get_css_right() const override;
|
||||
css_length get_css_top() const override;
|
||||
css_length get_css_bottom() const override;
|
||||
css_length get_css_width() const override;
|
||||
css_offsets get_css_offsets() const override;
|
||||
void set_css_width(css_length& w) override;
|
||||
css_length get_css_height() const override;
|
||||
element_clear get_clear() const override;
|
||||
size_t get_children_count() const override;
|
||||
element::ptr get_child(int idx) const override;
|
||||
element_position get_element_position(css_offsets* offsets = nullptr) const override;
|
||||
overflow get_overflow() const override;
|
||||
|
||||
virtual void set_attr(const tchar_t* name, const tchar_t* val) override;
|
||||
virtual const tchar_t* get_attr(const tchar_t* name, const tchar_t* def = 0) const override;
|
||||
virtual void apply_stylesheet(const litehtml::css& stylesheet) override;
|
||||
virtual void refresh_styles() override;
|
||||
void set_attr(const tchar_t* name, const tchar_t* val) override;
|
||||
const tchar_t* get_attr(const tchar_t* name, const tchar_t* def = nullptr) const override;
|
||||
void apply_stylesheet(const litehtml::css& stylesheet) override;
|
||||
void refresh_styles() override;
|
||||
|
||||
virtual bool is_white_space() const override;
|
||||
virtual bool is_body() const override;
|
||||
virtual bool is_break() const override;
|
||||
virtual int get_base_line() override;
|
||||
virtual bool on_mouse_over() override;
|
||||
virtual bool on_mouse_leave() override;
|
||||
virtual bool on_lbutton_down() override;
|
||||
virtual bool on_lbutton_up() override;
|
||||
virtual void on_click() override;
|
||||
virtual bool find_styles_changes(position::vector& redraw_boxes, int x, int y) override;
|
||||
virtual const tchar_t* get_cursor() override;
|
||||
virtual void init_font() override;
|
||||
virtual bool set_pseudo_class(const tchar_t* pclass, bool add) override;
|
||||
virtual bool set_class(const tchar_t* pclass, bool add) override;
|
||||
virtual bool is_replaced() const override;
|
||||
virtual int line_height() const override;
|
||||
virtual white_space get_white_space() const override;
|
||||
virtual style_display get_display() const override;
|
||||
virtual visibility get_visibility() const override;
|
||||
virtual void parse_styles(bool is_reparse = false) override;
|
||||
virtual void draw(uint_ptr hdc, int x, int y, const position* clip) override;
|
||||
virtual void draw_background(uint_ptr hdc, int x, int y, const position* clip) override;
|
||||
bool is_white_space() const override;
|
||||
bool is_body() const override;
|
||||
bool is_break() const override;
|
||||
int get_base_line() override;
|
||||
bool on_mouse_over() override;
|
||||
bool on_mouse_leave() override;
|
||||
bool on_lbutton_down() override;
|
||||
bool on_lbutton_up() override;
|
||||
void on_click() override;
|
||||
bool find_styles_changes(position::vector& redraw_boxes, int x, int y) override;
|
||||
const tchar_t* get_cursor() override;
|
||||
void init_font() override;
|
||||
bool set_pseudo_class(const tchar_t* pclass, bool add) override;
|
||||
bool set_class(const tchar_t* pclass, bool add) override;
|
||||
bool is_replaced() const override;
|
||||
int line_height() const override;
|
||||
white_space get_white_space() const override;
|
||||
style_display get_display() const override;
|
||||
visibility get_visibility() const override;
|
||||
void parse_styles(bool is_reparse = false) override;
|
||||
void draw(uint_ptr hdc, int x, int y, const position* clip) override;
|
||||
void draw_background(uint_ptr hdc, int x, int y, const position* clip) override;
|
||||
|
||||
virtual const tchar_t* get_style_property(const tchar_t* name, bool inherited, const tchar_t* def = 0) override;
|
||||
virtual uint_ptr get_font(font_metrics* fm = 0) override;
|
||||
virtual int get_font_size() const override;
|
||||
const tchar_t* get_style_property(const tchar_t* name, bool inherited, const tchar_t* def = nullptr) override;
|
||||
uint_ptr get_font(font_metrics* fm = nullptr) override;
|
||||
int get_font_size() const override;
|
||||
|
||||
elements_vector& children();
|
||||
virtual void calc_outlines(int parent_width) override;
|
||||
virtual void calc_auto_margins(int parent_width) override;
|
||||
void calc_outlines(int parent_width) override;
|
||||
void calc_auto_margins(int parent_width) override;
|
||||
|
||||
virtual int select(const css_selector& selector, bool apply_pseudo = true) override;
|
||||
virtual int select(const css_element_selector& selector, bool apply_pseudo = true) override;
|
||||
int select(const css_selector& selector, bool apply_pseudo = true) override;
|
||||
int select(const css_element_selector& selector, bool apply_pseudo = true) override;
|
||||
|
||||
virtual elements_vector select_all(const tstring& selector) override;
|
||||
virtual elements_vector select_all(const css_selector& selector) override;
|
||||
elements_vector select_all(const tstring& selector) override;
|
||||
elements_vector select_all(const css_selector& selector) override;
|
||||
|
||||
virtual element::ptr select_one(const tstring& selector) override;
|
||||
virtual element::ptr select_one(const css_selector& selector) override;
|
||||
element::ptr select_one(const tstring& selector) override;
|
||||
element::ptr select_one(const css_selector& selector) override;
|
||||
|
||||
virtual element::ptr find_ancestor(const css_selector& selector, bool apply_pseudo = true, bool* is_pseudo = 0) override;
|
||||
virtual element::ptr find_adjacent_sibling(const element::ptr& el, const css_selector& selector, bool apply_pseudo = true, bool* is_pseudo = 0) override;
|
||||
virtual element::ptr find_sibling(const element::ptr& el, const css_selector& selector, bool apply_pseudo = true, bool* is_pseudo = 0) override;
|
||||
virtual void get_text(tstring& text) override;
|
||||
virtual void parse_attributes() override;
|
||||
element::ptr find_ancestor(const css_selector& selector, bool apply_pseudo = true, bool* is_pseudo = nullptr) override;
|
||||
element::ptr find_adjacent_sibling(const element::ptr& el, const css_selector& selector, bool apply_pseudo = true, bool* is_pseudo = nullptr) override;
|
||||
element::ptr find_sibling(const element::ptr& el, const css_selector& selector, bool apply_pseudo = true, bool* is_pseudo = nullptr) override;
|
||||
void get_text(tstring& text) override;
|
||||
void parse_attributes() override;
|
||||
|
||||
virtual bool is_first_child_inline(const element::ptr& el) const override;
|
||||
virtual bool is_last_child_inline(const element::ptr& el) override;
|
||||
virtual bool have_inline_child() const override;
|
||||
virtual void get_content_size(size& sz, int max_width) override;
|
||||
virtual void init() override;
|
||||
virtual void get_inline_boxes(position::vector& boxes) override;
|
||||
virtual bool is_floats_holder() const override;
|
||||
virtual int get_floats_height(element_float el_float = float_none) const override;
|
||||
virtual int get_left_floats_height() const override;
|
||||
virtual int get_right_floats_height() const override;
|
||||
virtual int get_line_left(int y) override;
|
||||
virtual int get_line_right(int y, int def_right) override;
|
||||
virtual void get_line_left_right(int y, int def_right, int& ln_left, int& ln_right) override;
|
||||
virtual void add_float(const element::ptr &el, int x, int y) override;
|
||||
virtual void update_floats(int dy, const element::ptr &parent) override;
|
||||
virtual void add_positioned(const element::ptr &el) override;
|
||||
virtual int find_next_line_top(int top, int width, int def_right) override;
|
||||
virtual void apply_vertical_align() override;
|
||||
virtual void draw_children(uint_ptr hdc, int x, int y, const position* clip, draw_flag flag, int zindex) override;
|
||||
virtual int get_zindex() const override;
|
||||
virtual void draw_stacking_context(uint_ptr hdc, int x, int y, const position* clip, bool with_positioned) override;
|
||||
virtual void calc_document_size(litehtml::size& sz, int x = 0, int y = 0) override;
|
||||
virtual void get_redraw_box(litehtml::position& pos, int x = 0, int y = 0) override;
|
||||
virtual void add_style(const litehtml::style& st) override;
|
||||
virtual element::ptr get_element_by_point(int x, int y, int client_x, int client_y) override;
|
||||
virtual element::ptr get_child_by_point(int x, int y, int client_x, int client_y, draw_flag flag, int zindex) override;
|
||||
bool is_first_child_inline(const element::ptr& el) const override;
|
||||
bool is_last_child_inline(const element::ptr& el) override;
|
||||
bool have_inline_child() const override;
|
||||
void get_content_size(size& sz, int max_width) override;
|
||||
void init() override;
|
||||
void get_inline_boxes(position::vector& boxes) override;
|
||||
bool is_floats_holder() const override;
|
||||
int get_floats_height(element_float el_float = float_none) const override;
|
||||
int get_left_floats_height() const override;
|
||||
int get_right_floats_height() const override;
|
||||
int get_line_left(int y) override;
|
||||
int get_line_right(int y, int def_right) override;
|
||||
void get_line_left_right(int y, int def_right, int& ln_left, int& ln_right) override;
|
||||
void add_float(const element::ptr &el, int x, int y) override;
|
||||
void update_floats(int dy, const element::ptr &parent) override;
|
||||
void add_positioned(const element::ptr &el) override;
|
||||
int find_next_line_top(int top, int width, int def_right) override;
|
||||
void apply_vertical_align() override;
|
||||
void draw_children(uint_ptr hdc, int x, int y, const position* clip, draw_flag flag, int zindex) override;
|
||||
int get_zindex() const override;
|
||||
void draw_stacking_context(uint_ptr hdc, int x, int y, const position* clip, bool with_positioned) override;
|
||||
void calc_document_size(litehtml::size& sz, int x = 0, int y = 0) override;
|
||||
void get_redraw_box(litehtml::position& pos, int x = 0, int y = 0) override;
|
||||
void add_style(const litehtml::style& st) override;
|
||||
element::ptr get_element_by_point(int x, int y, int client_x, int client_y) override;
|
||||
element::ptr get_child_by_point(int x, int y, int client_x, int client_y, draw_flag flag, int zindex) override;
|
||||
|
||||
virtual bool is_nth_child(const element::ptr& el, int num, int off, bool of_type) const override;
|
||||
virtual bool is_nth_last_child(const element::ptr& el, int num, int off, bool of_type) const override;
|
||||
virtual bool is_only_child(const element::ptr& el, bool of_type) const override;
|
||||
virtual const background* get_background(bool own_only = false) override;
|
||||
bool is_nth_child(const element::ptr& el, int num, int off, bool of_type) const override;
|
||||
bool is_nth_last_child(const element::ptr& el, int num, int off, bool of_type) const override;
|
||||
bool is_only_child(const element::ptr& el, bool of_type) const override;
|
||||
const background* get_background(bool own_only = false) override;
|
||||
|
||||
protected:
|
||||
void draw_children_box(uint_ptr hdc, int x, int y, const position* clip, draw_flag flag, int zindex);
|
||||
void draw_children_table(uint_ptr hdc, int x, int y, const position* clip, draw_flag flag, int zindex);
|
||||
int render_box(int x, int y, int max_width, bool second_pass = false);
|
||||
int render_table(int x, int y, int max_width, bool second_pass = false);
|
||||
int fix_line_width(int max_width, element_float flt);
|
||||
void parse_background();
|
||||
void init_background_paint( position pos, background_paint &bg_paint, const background* bg );
|
||||
void draw_list_marker( uint_ptr hdc, const position &pos );
|
||||
tstring get_list_marker_text(int index);
|
||||
void parse_nth_child_params( tstring param, int &num, int &off );
|
||||
void remove_before_after();
|
||||
litehtml::element::ptr get_element_before();
|
||||
litehtml::element::ptr get_element_after();
|
||||
void draw_children_box(uint_ptr hdc, int x, int y, const position* clip, draw_flag flag, int zindex);
|
||||
void draw_children_table(uint_ptr hdc, int x, int y, const position* clip, draw_flag flag, int zindex);
|
||||
int render_box(int x, int y, int max_width, bool second_pass = false);
|
||||
int render_table(int x, int y, int max_width, bool second_pass = false);
|
||||
int fix_line_width(int max_width, element_float flt);
|
||||
void parse_background();
|
||||
void init_background_paint( position pos, background_paint &bg_paint, const background* bg );
|
||||
void draw_list_marker( uint_ptr hdc, const position &pos );
|
||||
tstring get_list_marker_text(int index);
|
||||
static void parse_nth_child_params( const tstring& param, int &num, int &off );
|
||||
void remove_before_after();
|
||||
litehtml::element::ptr get_element_before();
|
||||
litehtml::element::ptr get_element_after();
|
||||
};
|
||||
|
||||
/************************************************************************/
|
||||
|
@ -23,9 +23,8 @@ namespace litehtml
|
||||
{
|
||||
int idx;
|
||||
element::ptr el;
|
||||
stack_item()
|
||||
stack_item() : idx(0)
|
||||
{
|
||||
|
||||
}
|
||||
stack_item(const stack_item& val)
|
||||
{
|
||||
@ -54,10 +53,7 @@ namespace litehtml
|
||||
m_select = select;
|
||||
}
|
||||
|
||||
~elements_iterator()
|
||||
{
|
||||
|
||||
}
|
||||
~elements_iterator() = default;
|
||||
|
||||
element::ptr next(bool ret_parent = true);
|
||||
|
||||
|
@ -46,13 +46,13 @@ namespace litehtml
|
||||
props_map m_properties;
|
||||
static string_map m_valid_values;
|
||||
public:
|
||||
style();
|
||||
style() = default;
|
||||
style(const style& val);
|
||||
virtual ~style();
|
||||
|
||||
void operator=(const style& val)
|
||||
style& operator=(const style& val)
|
||||
{
|
||||
m_properties = val.m_properties;
|
||||
return *this;
|
||||
}
|
||||
|
||||
void add(const tchar_t* txt, const tchar_t* baseurl)
|
||||
@ -66,13 +66,13 @@ namespace litehtml
|
||||
{
|
||||
if(name)
|
||||
{
|
||||
props_map::const_iterator f = m_properties.find(name);
|
||||
auto f = m_properties.find(name);
|
||||
if(f != m_properties.end())
|
||||
{
|
||||
return f->second.m_value.c_str();
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void combine(const litehtml::style& src);
|
||||
|
@ -12,15 +12,8 @@ namespace litehtml
|
||||
{
|
||||
css_selector::vector m_selectors;
|
||||
public:
|
||||
css()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
~css()
|
||||
{
|
||||
|
||||
}
|
||||
css() = default;
|
||||
~css() = default;
|
||||
|
||||
const css_selector::vector& selectors() const
|
||||
{
|
||||
@ -38,12 +31,12 @@ namespace litehtml
|
||||
|
||||
private:
|
||||
void parse_atrule(const tstring& text, const tchar_t* baseurl, const std::shared_ptr<document>& doc, const media_query_list::ptr& media);
|
||||
void add_selector(css_selector::ptr selector);
|
||||
void add_selector(const css_selector::ptr& selector);
|
||||
bool parse_selectors(const tstring& txt, const litehtml::style::ptr& styles, const media_query_list::ptr& media);
|
||||
|
||||
};
|
||||
|
||||
inline void litehtml::css::add_selector( css_selector::ptr selector )
|
||||
inline void litehtml::css::add_selector( const css_selector::ptr& selector )
|
||||
{
|
||||
selector->m_order = (int) m_selectors.size();
|
||||
m_selectors.push_back(selector);
|
||||
|
@ -55,7 +55,7 @@ namespace litehtml
|
||||
el_row = val.el_row;
|
||||
}
|
||||
|
||||
table_row(table_row&& val)
|
||||
table_row(table_row&& val) noexcept
|
||||
{
|
||||
min_height = val.min_height;
|
||||
top = val.top;
|
||||
@ -185,8 +185,8 @@ namespace litehtml
|
||||
borders = val.borders;
|
||||
}
|
||||
|
||||
table_cell(const table_cell&& val)
|
||||
{
|
||||
table_cell(table_cell&& val) noexcept
|
||||
{
|
||||
el = std::move(val.el);
|
||||
colspan = val.colspan;
|
||||
rowspan = val.rowspan;
|
||||
|
@ -721,7 +721,20 @@ namespace litehtml
|
||||
int color_index; // The number of entries in the color lookup table of the output device. If the device does not use a color lookup table, the value is zero.
|
||||
int monochrome; // The number of bits per pixel in a monochrome frame buffer. If the device is not a monochrome device, the output device value will be 0.
|
||||
int resolution; // The resolution of the output device (in DPI)
|
||||
};
|
||||
|
||||
media_features()
|
||||
{
|
||||
type = media_type::media_type_none,
|
||||
width =0;
|
||||
height = 0;
|
||||
device_width = 0;
|
||||
device_height = 0;
|
||||
color = 0;
|
||||
color_index = 0;
|
||||
monochrome = 0;
|
||||
resolution = 0;
|
||||
}
|
||||
};
|
||||
|
||||
enum render_type
|
||||
{
|
||||
|
@ -1,7 +1,7 @@
|
||||
#include "html.h"
|
||||
#include "background.h"
|
||||
|
||||
litehtml::background::background(void)
|
||||
litehtml::background::background()
|
||||
{
|
||||
m_attachment = background_attachment_scroll;
|
||||
m_repeat = background_repeat_repeat;
|
||||
@ -25,10 +25,6 @@ litehtml::background::background( const background& val )
|
||||
m_origin = val.m_origin;
|
||||
}
|
||||
|
||||
litehtml::background::~background(void)
|
||||
{
|
||||
}
|
||||
|
||||
litehtml::background& litehtml::background::operator=( const background& val )
|
||||
{
|
||||
m_image = val.m_image;
|
||||
@ -69,11 +65,12 @@ litehtml::background_paint::background_paint( const background_paint& val )
|
||||
is_root = val.is_root;
|
||||
}
|
||||
|
||||
void litehtml::background_paint::operator=( const background& val )
|
||||
litehtml::background_paint& litehtml::background_paint::operator=( const background& val )
|
||||
{
|
||||
attachment = val.m_attachment;
|
||||
baseurl = val.m_baseurl;
|
||||
image = val.m_image;
|
||||
repeat = val.m_repeat;
|
||||
color = val.m_color;
|
||||
return *this;
|
||||
}
|
||||
|
42
src/box.cpp
42
src/box.cpp
@ -3,17 +3,17 @@
|
||||
#include "html_tag.h"
|
||||
|
||||
|
||||
litehtml::box_type litehtml::block_box::get_type()
|
||||
litehtml::box_type litehtml::block_box::get_type() const
|
||||
{
|
||||
return box_block;
|
||||
}
|
||||
|
||||
int litehtml::block_box::height()
|
||||
int litehtml::block_box::height() const
|
||||
{
|
||||
return m_element->height();
|
||||
}
|
||||
|
||||
int litehtml::block_box::width()
|
||||
int litehtml::block_box::width() const
|
||||
{
|
||||
return m_element->width();
|
||||
}
|
||||
@ -30,7 +30,7 @@ void litehtml::block_box::finish(bool last_box)
|
||||
m_element->apply_relative_shift(m_box_right - m_box_left);
|
||||
}
|
||||
|
||||
bool litehtml::block_box::can_hold(const element::ptr &el, white_space ws)
|
||||
bool litehtml::block_box::can_hold(const element::ptr &el, white_space ws) const
|
||||
{
|
||||
if(m_element || el->is_inline_box())
|
||||
{
|
||||
@ -39,7 +39,7 @@ bool litehtml::block_box::can_hold(const element::ptr &el, white_space ws)
|
||||
return true;
|
||||
}
|
||||
|
||||
bool litehtml::block_box::is_empty()
|
||||
bool litehtml::block_box::is_empty() const
|
||||
{
|
||||
if(m_element)
|
||||
{
|
||||
@ -48,7 +48,7 @@ bool litehtml::block_box::is_empty()
|
||||
return true;
|
||||
}
|
||||
|
||||
int litehtml::block_box::baseline()
|
||||
int litehtml::block_box::baseline() const
|
||||
{
|
||||
if(m_element)
|
||||
{
|
||||
@ -62,7 +62,7 @@ void litehtml::block_box::get_elements( elements_vector& els )
|
||||
els.push_back(m_element);
|
||||
}
|
||||
|
||||
int litehtml::block_box::top_margin()
|
||||
int litehtml::block_box::top_margin() const
|
||||
{
|
||||
if(m_element && m_element->collapse_top_margin())
|
||||
{
|
||||
@ -71,7 +71,7 @@ int litehtml::block_box::top_margin()
|
||||
return 0;
|
||||
}
|
||||
|
||||
int litehtml::block_box::bottom_margin()
|
||||
int litehtml::block_box::bottom_margin() const
|
||||
{
|
||||
if(m_element && m_element->collapse_bottom_margin())
|
||||
{
|
||||
@ -96,17 +96,17 @@ void litehtml::block_box::new_width( int left, int right, elements_vector& els )
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
litehtml::box_type litehtml::line_box::get_type()
|
||||
litehtml::box_type litehtml::line_box::get_type() const
|
||||
{
|
||||
return box_line;
|
||||
}
|
||||
|
||||
int litehtml::line_box::height()
|
||||
int litehtml::line_box::height() const
|
||||
{
|
||||
return m_height;
|
||||
}
|
||||
|
||||
int litehtml::line_box::width()
|
||||
int litehtml::line_box::width() const
|
||||
{
|
||||
return m_width;
|
||||
}
|
||||
@ -114,7 +114,7 @@ int litehtml::line_box::width()
|
||||
void litehtml::line_box::add_element(const element::ptr &el)
|
||||
{
|
||||
el->m_skip = false;
|
||||
el->m_box = 0;
|
||||
el->m_box = nullptr;
|
||||
bool add = true;
|
||||
if( (m_items.empty() && el->is_white_space()) || el->is_break() )
|
||||
{
|
||||
@ -252,8 +252,6 @@ void litehtml::line_box::finish(bool last_box)
|
||||
}
|
||||
}
|
||||
|
||||
css_offsets offsets;
|
||||
|
||||
for (const auto& el : m_items)
|
||||
{
|
||||
el->m_pos.y -= y1;
|
||||
@ -295,7 +293,7 @@ void litehtml::line_box::finish(bool last_box)
|
||||
m_baseline = (base_line - y1) - (m_height - line_height);
|
||||
}
|
||||
|
||||
bool litehtml::line_box::can_hold(const element::ptr &el, white_space ws)
|
||||
bool litehtml::line_box::can_hold(const element::ptr &el, white_space ws) const
|
||||
{
|
||||
if(!el->is_inline_box()) return false;
|
||||
|
||||
@ -317,7 +315,7 @@ bool litehtml::line_box::can_hold(const element::ptr &el, white_space ws)
|
||||
return true;
|
||||
}
|
||||
|
||||
bool litehtml::line_box::have_last_space()
|
||||
bool litehtml::line_box::have_last_space() const
|
||||
{
|
||||
bool ret = false;
|
||||
for (auto i = m_items.rbegin(); i != m_items.rend() && !ret; i++)
|
||||
@ -333,7 +331,7 @@ bool litehtml::line_box::have_last_space()
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool litehtml::line_box::is_empty()
|
||||
bool litehtml::line_box::is_empty() const
|
||||
{
|
||||
if(m_items.empty()) return true;
|
||||
for (auto i = m_items.rbegin(); i != m_items.rend(); i++)
|
||||
@ -346,7 +344,7 @@ bool litehtml::line_box::is_empty()
|
||||
return true;
|
||||
}
|
||||
|
||||
int litehtml::line_box::baseline()
|
||||
int litehtml::line_box::baseline() const
|
||||
{
|
||||
return m_baseline;
|
||||
}
|
||||
@ -356,12 +354,12 @@ void litehtml::line_box::get_elements( elements_vector& els )
|
||||
els.insert(els.begin(), m_items.begin(), m_items.end());
|
||||
}
|
||||
|
||||
int litehtml::line_box::top_margin()
|
||||
int litehtml::line_box::top_margin() const
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int litehtml::line_box::bottom_margin()
|
||||
int litehtml::line_box::bottom_margin() const
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
@ -375,7 +373,7 @@ void litehtml::line_box::y_shift( int shift )
|
||||
}
|
||||
}
|
||||
|
||||
bool litehtml::line_box::is_break_only()
|
||||
bool litehtml::line_box::is_break_only() const
|
||||
{
|
||||
if(m_items.empty()) return true;
|
||||
|
||||
@ -426,7 +424,7 @@ void litehtml::line_box::new_width( int left, int right, elements_vector& els )
|
||||
|
||||
for(const auto& el : els)
|
||||
{
|
||||
el->m_box = 0;
|
||||
el->m_box = nullptr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -7,6 +7,6 @@ void litehtml::context::load_master_stylesheet( const tchar_t* str )
|
||||
{
|
||||
media_query_list::ptr media;
|
||||
|
||||
m_master_css.parse_stylesheet(str, 0, std::shared_ptr<litehtml::document>(), media_query_list::ptr());
|
||||
m_master_css.parse_stylesheet(str, nullptr, std::shared_ptr<litehtml::document>(), media_query_list::ptr());
|
||||
m_master_css.sort_selectors();
|
||||
}
|
||||
|
@ -11,7 +11,7 @@ void litehtml::css_length::fromString( const tstring& str, const tstring& predef
|
||||
return;
|
||||
}
|
||||
|
||||
int predef = value_index(str.c_str(), predefs.c_str(), -1);
|
||||
int predef = value_index(str, predefs, -1);
|
||||
if(predef >= 0)
|
||||
{
|
||||
m_is_predefined = true;
|
||||
@ -23,13 +23,13 @@ void litehtml::css_length::fromString( const tstring& str, const tstring& predef
|
||||
tstring num;
|
||||
tstring un;
|
||||
bool is_unit = false;
|
||||
for(tstring::const_iterator chr = str.begin(); chr != str.end(); chr++)
|
||||
for(char chr : str)
|
||||
{
|
||||
if(!is_unit)
|
||||
{
|
||||
if(t_isdigit(*chr) || *chr == _t('.') || *chr == _t('+') || *chr == _t('-'))
|
||||
if(t_isdigit(chr) || chr == _t('.') || chr == _t('+') || chr == _t('-'))
|
||||
{
|
||||
num += *chr;
|
||||
num += chr;
|
||||
} else
|
||||
{
|
||||
is_unit = true;
|
||||
@ -37,13 +37,13 @@ void litehtml::css_length::fromString( const tstring& str, const tstring& predef
|
||||
}
|
||||
if(is_unit)
|
||||
{
|
||||
un += *chr;
|
||||
un += chr;
|
||||
}
|
||||
}
|
||||
if(!num.empty())
|
||||
{
|
||||
m_value = (float) t_strtod(num.c_str(), 0);
|
||||
m_units = (css_units) value_index(un.c_str(), css_units_strings, css_units_none);
|
||||
m_value = (float) t_strtod(num.c_str(), nullptr);
|
||||
m_units = (css_units) value_index(un, css_units_strings, css_units_none);
|
||||
} else
|
||||
{
|
||||
// not a number so it is predefined
|
||||
|
@ -43,10 +43,6 @@ void litehtml::css_element_selector::parse( const tstring& txt )
|
||||
if(pos != tstring::npos)
|
||||
{
|
||||
pos++;
|
||||
} else
|
||||
{
|
||||
int iii = 0;
|
||||
iii++;
|
||||
}
|
||||
}
|
||||
if(pos != tstring::npos)
|
||||
@ -125,7 +121,7 @@ void litehtml::css_element_selector::parse( const tstring& txt )
|
||||
{
|
||||
if(txt[pos] == _t('"'))
|
||||
{
|
||||
tstring::size_type pos2 = txt.find_first_of(_t("\""), pos + 1);
|
||||
tstring::size_type pos2 = txt.find_first_of(_t('\"'), pos + 1);
|
||||
attribute.val = txt.substr(pos + 1, pos2 == tstring::npos ? pos2 : (pos2 - pos - 1));
|
||||
pos = pos2 == tstring::npos ? pos2 : (pos2 + 1);
|
||||
} else if(txt[pos] == _t(']'))
|
||||
@ -133,7 +129,7 @@ void litehtml::css_element_selector::parse( const tstring& txt )
|
||||
pos ++;
|
||||
} else
|
||||
{
|
||||
tstring::size_type pos2 = txt.find_first_of(_t("]"), pos + 1);
|
||||
tstring::size_type pos2 = txt.find_first_of(_t(']'), pos + 1);
|
||||
attribute.val = txt.substr(pos, pos2 == tstring::npos ? pos2 : (pos2 - pos));
|
||||
trim(attribute.val);
|
||||
pos = pos2 == tstring::npos ? pos2 : (pos2 + 1);
|
||||
@ -183,9 +179,9 @@ bool litehtml::css_selector::parse( const tstring& text )
|
||||
tokens.pop_back();
|
||||
}
|
||||
|
||||
for(string_vector::const_iterator i = tokens.begin(); i != tokens.end(); i++)
|
||||
for(const auto & token : tokens)
|
||||
{
|
||||
left += *i;
|
||||
left += token;
|
||||
}
|
||||
|
||||
trim(left);
|
||||
@ -214,11 +210,11 @@ bool litehtml::css_selector::parse( const tstring& text )
|
||||
break;
|
||||
}
|
||||
|
||||
m_left = 0;
|
||||
m_left = nullptr;
|
||||
|
||||
if(!left.empty())
|
||||
{
|
||||
m_left = std::make_shared<css_selector>(media_query_list::ptr(0));
|
||||
m_left = std::make_shared<css_selector>(media_query_list::ptr(nullptr));
|
||||
if(!m_left->parse(left))
|
||||
{
|
||||
return false;
|
||||
@ -234,16 +230,16 @@ void litehtml::css_selector::calc_specificity()
|
||||
{
|
||||
m_specificity.d = 1;
|
||||
}
|
||||
for(css_attribute_selector::vector::iterator i = m_right.m_attrs.begin(); i != m_right.m_attrs.end(); i++)
|
||||
for(const auto& attr : m_right.m_attrs)
|
||||
{
|
||||
if(i->attribute == _t("id"))
|
||||
if(attr.attribute == _t("id"))
|
||||
{
|
||||
m_specificity.b++;
|
||||
} else
|
||||
{
|
||||
if(i->attribute == _t("class"))
|
||||
if(attr.attribute == _t("class"))
|
||||
{
|
||||
m_specificity.c += (int) i->class_val.size();
|
||||
m_specificity.c += (int) attr.class_val.size();
|
||||
} else
|
||||
{
|
||||
m_specificity.c++;
|
||||
|
@ -22,8 +22,8 @@
|
||||
#include "el_font.h"
|
||||
#include "el_tr.h"
|
||||
#include "el_li.h"
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <cmath>
|
||||
#include <cstdio>
|
||||
#include <algorithm>
|
||||
#include <functional>
|
||||
#include "gumbo.h"
|
||||
@ -37,12 +37,12 @@ litehtml::document::document(litehtml::document_container* objContainer, litehtm
|
||||
|
||||
litehtml::document::~document()
|
||||
{
|
||||
m_over_element = 0;
|
||||
m_over_element = nullptr;
|
||||
if(m_container)
|
||||
{
|
||||
for(fonts_map::iterator f = m_fonts.begin(); f != m_fonts.end(); f++)
|
||||
for(auto & m_font : m_fonts)
|
||||
{
|
||||
m_container->delete_font(f->second.font);
|
||||
m_container->delete_font(m_font.second.font);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -83,17 +83,17 @@ litehtml::document::ptr litehtml::document::createFromUTF8(const char* str, lite
|
||||
|
||||
// parse style sheets linked in document
|
||||
media_query_list::ptr media;
|
||||
for (css_text::vector::iterator css = doc->m_css.begin(); css != doc->m_css.end(); css++)
|
||||
for (const auto& css : doc->m_css)
|
||||
{
|
||||
if (!css->media.empty())
|
||||
if (!css.media.empty())
|
||||
{
|
||||
media = media_query_list::create_from_string(css->media, doc);
|
||||
media = media_query_list::create_from_string(css.media, doc);
|
||||
}
|
||||
else
|
||||
{
|
||||
media = 0;
|
||||
media = nullptr;
|
||||
}
|
||||
doc->m_styles.parse_stylesheet(css->text.c_str(), css->baseurl.c_str(), doc, media);
|
||||
doc->m_styles.parse_stylesheet(css.text.c_str(), css.baseurl.c_str(), doc, media);
|
||||
}
|
||||
// Sort css selectors using CSS rules.
|
||||
doc->m_styles.sort_selectors();
|
||||
@ -132,7 +132,7 @@ litehtml::uint_ptr litehtml::document::add_font( const tchar_t* name, int size,
|
||||
{
|
||||
uint_ptr ret = 0;
|
||||
|
||||
if( !name || (name && !t_strcasecmp(name, _t("inherit"))) )
|
||||
if(!name || !t_strcasecmp(name, _t("inherit")))
|
||||
{
|
||||
name = m_container->get_default_font_name();
|
||||
}
|
||||
@ -191,15 +191,15 @@ litehtml::uint_ptr litehtml::document::add_font( const tchar_t* name, int size,
|
||||
{
|
||||
std::vector<tstring> tokens;
|
||||
split_string(decoration, tokens, _t(" "));
|
||||
for(std::vector<tstring>::iterator i = tokens.begin(); i != tokens.end(); i++)
|
||||
for(auto & token : tokens)
|
||||
{
|
||||
if(!t_strcasecmp(i->c_str(), _t("underline")))
|
||||
if(!t_strcasecmp(token.c_str(), _t("underline")))
|
||||
{
|
||||
decor |= font_decoration_underline;
|
||||
} else if(!t_strcasecmp(i->c_str(), _t("line-through")))
|
||||
} else if(!t_strcasecmp(token.c_str(), _t("line-through")))
|
||||
{
|
||||
decor |= font_decoration_linethrough;
|
||||
} else if(!t_strcasecmp(i->c_str(), _t("overline")))
|
||||
} else if(!t_strcasecmp(token.c_str(), _t("overline")))
|
||||
{
|
||||
decor |= font_decoration_overline;
|
||||
}
|
||||
@ -221,7 +221,7 @@ litehtml::uint_ptr litehtml::document::add_font( const tchar_t* name, int size,
|
||||
|
||||
litehtml::uint_ptr litehtml::document::get_font( const tchar_t* name, int size, const tchar_t* weight, const tchar_t* style, const tchar_t* decoration, font_metrics* fm )
|
||||
{
|
||||
if( !name || (name && !t_strcasecmp(name, _t("inherit"))) )
|
||||
if(!name || !t_strcasecmp(name, _t("inherit")))
|
||||
{
|
||||
name = m_container->get_default_font_name();
|
||||
}
|
||||
@ -244,7 +244,7 @@ litehtml::uint_ptr litehtml::document::get_font( const tchar_t* name, int size,
|
||||
key += _t(":");
|
||||
key += decoration;
|
||||
|
||||
fonts_map::iterator el = m_fonts.find(key);
|
||||
auto el = m_fonts.find(key);
|
||||
|
||||
if(el != m_fonts.end())
|
||||
{
|
||||
@ -310,14 +310,14 @@ int litehtml::document::cvt_units( css_length& val, int fontSize, int size ) con
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
int ret = 0;
|
||||
int ret;
|
||||
switch(val.units())
|
||||
{
|
||||
case css_units_percentage:
|
||||
ret = val.calc_percent(size);
|
||||
break;
|
||||
case css_units_em:
|
||||
ret = round_f(val.val() * fontSize);
|
||||
ret = round_f(val.val() * (float) fontSize);
|
||||
val.set_value((float) ret, css_units_px);
|
||||
break;
|
||||
case css_units_pt:
|
||||
@ -400,7 +400,7 @@ bool litehtml::document::on_mouse_over( int x, int y, int client_x, int client_y
|
||||
m_over_element = over_el;
|
||||
}
|
||||
|
||||
const tchar_t* cursor = 0;
|
||||
const tchar_t* cursor = nullptr;
|
||||
|
||||
if(m_over_element)
|
||||
{
|
||||
@ -466,7 +466,7 @@ bool litehtml::document::on_lbutton_down( int x, int y, int client_x, int client
|
||||
}
|
||||
}
|
||||
|
||||
const tchar_t* cursor = 0;
|
||||
const tchar_t* cursor = nullptr;
|
||||
|
||||
if(m_over_element)
|
||||
{
|
||||
@ -570,9 +570,9 @@ litehtml::element::ptr litehtml::document::create_element(const tchar_t* tag_nam
|
||||
if(newTag)
|
||||
{
|
||||
newTag->set_tagName(tag_name);
|
||||
for (string_map::const_iterator iter = attributes.begin(); iter != attributes.end(); iter++)
|
||||
for (const auto & attribute : attributes)
|
||||
{
|
||||
newTag->set_attr(iter->first.c_str(), iter->second.c_str());
|
||||
newTag->set_attr(attribute.first.c_str(), attribute.second.c_str());
|
||||
}
|
||||
}
|
||||
|
||||
@ -628,9 +628,9 @@ bool litehtml::document::lang_changed()
|
||||
bool litehtml::document::update_media_lists(const media_features& features)
|
||||
{
|
||||
bool update_styles = false;
|
||||
for(media_query_list::vector::iterator iter = m_media_lists.begin(); iter != m_media_lists.end(); iter++)
|
||||
for(auto & m_media_list : m_media_lists)
|
||||
{
|
||||
if((*iter)->apply_media_features(features))
|
||||
if(m_media_list->apply_media_features(features))
|
||||
{
|
||||
update_styles = true;
|
||||
}
|
||||
@ -638,7 +638,7 @@ bool litehtml::document::update_media_lists(const media_features& features)
|
||||
return update_styles;
|
||||
}
|
||||
|
||||
void litehtml::document::add_media_list( media_query_list::ptr list )
|
||||
void litehtml::document::add_media_list( const media_query_list::ptr& list )
|
||||
{
|
||||
if(list)
|
||||
{
|
||||
@ -651,7 +651,7 @@ void litehtml::document::add_media_list( media_query_list::ptr list )
|
||||
|
||||
void litehtml::document::create_node(void* gnode, elements_vector& elements, bool parseTextNode)
|
||||
{
|
||||
GumboNode* node = (GumboNode*)gnode;
|
||||
auto* node = (GumboNode*)gnode;
|
||||
switch (node->type)
|
||||
{
|
||||
case GUMBO_NODE_ELEMENT:
|
||||
@ -709,7 +709,7 @@ void litehtml::document::create_node(void* gnode, elements_vector& elements, boo
|
||||
std::wstring str_in = (const wchar_t*) (utf8_to_wchar(node->v.text.text));
|
||||
if (!parseTextNode)
|
||||
{
|
||||
elements.push_back(std::make_shared<el_text>(litehtml_from_wchar(str_in.c_str()), shared_from_this()));
|
||||
elements.push_back(std::make_shared<el_text>(litehtml_from_wchar(str_in), shared_from_this()));
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -794,14 +794,14 @@ void litehtml::document::fix_tables_layout()
|
||||
void litehtml::document::fix_table_children(element::ptr& el_ptr, style_display disp, const tchar_t* disp_str)
|
||||
{
|
||||
elements_vector tmp;
|
||||
elements_vector::iterator first_iter = el_ptr->m_children.begin();
|
||||
elements_vector::iterator cur_iter = el_ptr->m_children.begin();
|
||||
auto first_iter = el_ptr->m_children.begin();
|
||||
auto cur_iter = el_ptr->m_children.begin();
|
||||
|
||||
auto flush_elements = [&]()
|
||||
{
|
||||
element::ptr annon_tag = std::make_shared<html_tag>(shared_from_this());
|
||||
style st;
|
||||
st.add_property(_t("display"), disp_str, 0, false);
|
||||
st.add_property(_t("display"), disp_str, nullptr, false);
|
||||
annon_tag->add_style(st);
|
||||
annon_tag->parent(el_ptr);
|
||||
annon_tag->parse_styles();
|
||||
@ -859,7 +859,7 @@ void litehtml::document::fix_table_parent(element::ptr& el_ptr, style_display di
|
||||
|
||||
if (parent->get_display() != disp)
|
||||
{
|
||||
elements_vector::iterator this_element = std::find_if(parent->m_children.begin(), parent->m_children.end(),
|
||||
auto this_element = std::find_if(parent->m_children.begin(), parent->m_children.end(),
|
||||
[&](element::ptr& el)
|
||||
{
|
||||
if (el == el_ptr)
|
||||
@ -872,9 +872,9 @@ void litehtml::document::fix_table_parent(element::ptr& el_ptr, style_display di
|
||||
if (this_element != parent->m_children.end())
|
||||
{
|
||||
style_display el_disp = el_ptr->get_display();
|
||||
elements_vector::iterator first = this_element;
|
||||
elements_vector::iterator last = this_element;
|
||||
elements_vector::iterator cur = this_element;
|
||||
auto first = this_element;
|
||||
auto last = this_element;
|
||||
auto cur = this_element;
|
||||
|
||||
// find first element with same display
|
||||
while (true)
|
||||
@ -911,7 +911,7 @@ void litehtml::document::fix_table_parent(element::ptr& el_ptr, style_display di
|
||||
// extract elements with the same display and wrap them with anonymous object
|
||||
element::ptr annon_tag = std::make_shared<html_tag>(shared_from_this());
|
||||
style st;
|
||||
st.add_property(_t("display"), disp_str, 0, false);
|
||||
st.add_property(_t("display"), disp_str, nullptr, false);
|
||||
annon_tag->add_style(st);
|
||||
annon_tag->parent(parent);
|
||||
annon_tag->parse_styles();
|
||||
@ -951,7 +951,7 @@ void litehtml::document::append_children_from_utf8(element& parent, const char*
|
||||
gumbo_destroy_output(&kGumboDefaultOptions, output);
|
||||
|
||||
// Let's process created elements tree
|
||||
for (litehtml::element::ptr child : child_elements)
|
||||
for (const auto& child : child_elements)
|
||||
{
|
||||
// Add the child element to parent
|
||||
parent.appendChild(child);
|
||||
|
@ -6,11 +6,6 @@ litehtml::el_anchor::el_anchor(const std::shared_ptr<litehtml::document>& doc) :
|
||||
{
|
||||
}
|
||||
|
||||
litehtml::el_anchor::~el_anchor()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void litehtml::el_anchor::on_click()
|
||||
{
|
||||
const tchar_t* href = get_attr(_t("href"));
|
||||
|
@ -7,11 +7,6 @@ litehtml::el_base::el_base(const std::shared_ptr<litehtml::document>& doc) : htm
|
||||
|
||||
}
|
||||
|
||||
litehtml::el_base::~el_base()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void litehtml::el_base::parse_attributes()
|
||||
{
|
||||
get_document()->container()->set_base_url(get_attr(_t("href")));
|
||||
|
@ -9,18 +9,13 @@ litehtml::el_before_after_base::el_before_after_base(const std::shared_ptr<liteh
|
||||
{
|
||||
if(before)
|
||||
{
|
||||
set_tagName(_t("::before"));
|
||||
m_tag = _t("::before");
|
||||
} else
|
||||
{
|
||||
set_tagName(_t("::after"));
|
||||
m_tag = _t("::after");
|
||||
}
|
||||
}
|
||||
|
||||
litehtml::el_before_after_base::~el_before_after_base()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void litehtml::el_before_after_base::add_style(const litehtml::style& st)
|
||||
{
|
||||
html_tag::add_style(st);
|
||||
@ -28,7 +23,7 @@ void litehtml::el_before_after_base::add_style(const litehtml::style& st)
|
||||
tstring content = get_style_property(_t("content"), false, _t(""));
|
||||
if(!content.empty())
|
||||
{
|
||||
int idx = value_index(content.c_str(), content_property_string);
|
||||
int idx = value_index(content, content_property_string);
|
||||
if(idx < 0)
|
||||
{
|
||||
tstring fnc;
|
||||
@ -133,7 +128,7 @@ void litehtml::el_before_after_base::add_text( const tstring& txt )
|
||||
|
||||
void litehtml::el_before_after_base::add_function( const tstring& fnc, const tstring& params )
|
||||
{
|
||||
int idx = value_index(fnc.c_str(), _t("attr;counter;url"));
|
||||
int idx = value_index(fnc, _t("attr;counter;url"));
|
||||
switch(idx)
|
||||
{
|
||||
// attr
|
||||
|
@ -6,11 +6,6 @@ litehtml::el_body::el_body(const std::shared_ptr<litehtml::document>& doc) : lit
|
||||
{
|
||||
}
|
||||
|
||||
litehtml::el_body::~el_body()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
bool litehtml::el_body::is_body() const
|
||||
{
|
||||
return true;
|
||||
|
@ -6,11 +6,6 @@ litehtml::el_break::el_break(const std::shared_ptr<litehtml::document>& doc) : h
|
||||
|
||||
}
|
||||
|
||||
litehtml::el_break::~el_break()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
bool litehtml::el_break::is_break() const
|
||||
{
|
||||
return true;
|
||||
|
@ -6,11 +6,6 @@ litehtml::el_cdata::el_cdata(const std::shared_ptr<litehtml::document>& doc) : l
|
||||
m_skip = true;
|
||||
}
|
||||
|
||||
litehtml::el_cdata::~el_cdata()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void litehtml::el_cdata::get_text( tstring& text )
|
||||
{
|
||||
text += m_text;
|
||||
|
@ -6,11 +6,6 @@ litehtml::el_comment::el_comment(const std::shared_ptr<litehtml::document>& doc)
|
||||
m_skip = true;
|
||||
}
|
||||
|
||||
litehtml::el_comment::~el_comment()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void litehtml::el_comment::get_text( tstring& text )
|
||||
{
|
||||
text += m_text;
|
||||
|
@ -7,11 +7,6 @@ litehtml::el_div::el_div(const std::shared_ptr<litehtml::document>& doc) : html_
|
||||
|
||||
}
|
||||
|
||||
litehtml::el_div::~el_div()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void litehtml::el_div::parse_attributes()
|
||||
{
|
||||
const tchar_t* str = get_attr(_t("align"));
|
||||
|
@ -7,23 +7,18 @@ litehtml::el_font::el_font(const std::shared_ptr<litehtml::document>& doc) : htm
|
||||
|
||||
}
|
||||
|
||||
litehtml::el_font::~el_font()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void litehtml::el_font::parse_attributes()
|
||||
{
|
||||
const tchar_t* str = get_attr(_t("color"));
|
||||
if(str)
|
||||
{
|
||||
m_style.add_property(_t("color"), str, 0, false);
|
||||
m_style.add_property(_t("color"), str, nullptr, false);
|
||||
}
|
||||
|
||||
str = get_attr(_t("face"));
|
||||
if(str)
|
||||
{
|
||||
m_style.add_property(_t("font-face"), str, 0, false);
|
||||
m_style.add_property(_t("font-face"), str, nullptr, false);
|
||||
}
|
||||
|
||||
str = get_attr(_t("size"));
|
||||
@ -32,25 +27,25 @@ void litehtml::el_font::parse_attributes()
|
||||
int sz = t_atoi(str);
|
||||
if(sz <= 1)
|
||||
{
|
||||
m_style.add_property(_t("font-size"), _t("x-small"), 0, false);
|
||||
m_style.add_property(_t("font-size"), _t("x-small"), nullptr, false);
|
||||
} else if(sz >= 6)
|
||||
{
|
||||
m_style.add_property(_t("font-size"), _t("xx-large"), 0, false);
|
||||
m_style.add_property(_t("font-size"), _t("xx-large"), nullptr, false);
|
||||
} else
|
||||
{
|
||||
switch(sz)
|
||||
{
|
||||
case 2:
|
||||
m_style.add_property(_t("font-size"), _t("small"), 0, false);
|
||||
m_style.add_property(_t("font-size"), _t("small"), nullptr, false);
|
||||
break;
|
||||
case 3:
|
||||
m_style.add_property(_t("font-size"), _t("medium"), 0, false);
|
||||
m_style.add_property(_t("font-size"), _t("medium"), nullptr, false);
|
||||
break;
|
||||
case 4:
|
||||
m_style.add_property(_t("font-size"), _t("large"), 0, false);
|
||||
m_style.add_property(_t("font-size"), _t("large"), nullptr, false);
|
||||
break;
|
||||
case 5:
|
||||
m_style.add_property(_t("font-size"), _t("x-large"), 0, false);
|
||||
m_style.add_property(_t("font-size"), _t("x-large"), nullptr, false);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -252,7 +252,7 @@ void litehtml::el_image::draw( uint_ptr hdc, int x, int y, const position* clip
|
||||
borders bdr = m_css_borders;
|
||||
bdr.radius = m_css_borders.radius.calc_percents(border_box.width, border_box.height);
|
||||
|
||||
get_document()->container()->draw_borders(hdc, bdr, border_box, have_parent() ? false : true);
|
||||
get_document()->container()->draw_borders(hdc, bdr, border_box, !have_parent());
|
||||
}
|
||||
}
|
||||
|
||||
@ -264,10 +264,10 @@ void litehtml::el_image::parse_styles( bool is_reparse /*= false*/ )
|
||||
{
|
||||
if(!m_css_height.is_predefined() && !m_css_width.is_predefined())
|
||||
{
|
||||
get_document()->container()->load_image(m_src.c_str(), 0, true);
|
||||
get_document()->container()->load_image(m_src.c_str(), nullptr, true);
|
||||
} else
|
||||
{
|
||||
get_document()->container()->load_image(m_src.c_str(), 0, false);
|
||||
get_document()->container()->load_image(m_src.c_str(), nullptr, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -6,11 +6,6 @@ litehtml::el_li::el_li(const std::shared_ptr<litehtml::document>& doc) : litehtm
|
||||
{
|
||||
}
|
||||
|
||||
litehtml::el_li::~el_li()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
int litehtml::el_li::render(int x, int y, int max_width, bool second_pass)
|
||||
{
|
||||
if (m_list_style_type >= list_style_type_armenian && !m_index_initialized)
|
||||
|
@ -8,11 +8,6 @@ litehtml::el_link::el_link(const std::shared_ptr<litehtml::document>& doc) : lit
|
||||
|
||||
}
|
||||
|
||||
litehtml::el_link::~el_link()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void litehtml::el_link::parse_attributes()
|
||||
{
|
||||
bool processed = false;
|
||||
|
@ -6,17 +6,12 @@ litehtml::el_para::el_para(const std::shared_ptr<litehtml::document>& doc) : lit
|
||||
{
|
||||
}
|
||||
|
||||
litehtml::el_para::~el_para()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void litehtml::el_para::parse_attributes()
|
||||
{
|
||||
const tchar_t* str = get_attr(_t("align"));
|
||||
if(str)
|
||||
{
|
||||
m_style.add_property(_t("text-align"), str, 0, false);
|
||||
m_style.add_property(_t("text-align"), str, nullptr, false);
|
||||
}
|
||||
|
||||
html_tag::parse_attributes();
|
||||
|
@ -8,11 +8,6 @@ litehtml::el_script::el_script(const std::shared_ptr<litehtml::document>& doc) :
|
||||
|
||||
}
|
||||
|
||||
litehtml::el_script::~el_script()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void litehtml::el_script::parse_attributes()
|
||||
{
|
||||
//TODO: pass script text to document container
|
||||
|
@ -6,11 +6,6 @@ litehtml::el_space::el_space(const tchar_t* text, const std::shared_ptr<litehtml
|
||||
{
|
||||
}
|
||||
|
||||
litehtml::el_space::~el_space()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
bool litehtml::el_space::is_white_space() const
|
||||
{
|
||||
white_space ws = get_white_space();
|
||||
|
@ -8,11 +8,6 @@ litehtml::el_style::el_style(const std::shared_ptr<litehtml::document>& doc) : l
|
||||
|
||||
}
|
||||
|
||||
litehtml::el_style::~el_style()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void litehtml::el_style::parse_attributes()
|
||||
{
|
||||
tstring text;
|
||||
@ -21,7 +16,7 @@ void litehtml::el_style::parse_attributes()
|
||||
{
|
||||
el->get_text(text);
|
||||
}
|
||||
get_document()->add_stylesheet( text.c_str(), 0, get_attr(_t("media")) );
|
||||
get_document()->add_stylesheet( text.c_str(), nullptr, get_attr(_t("media")) );
|
||||
}
|
||||
|
||||
bool litehtml::el_style::appendChild(const ptr &el)
|
||||
|
@ -2,7 +2,6 @@
|
||||
#include "el_table.h"
|
||||
#include "document.h"
|
||||
#include "iterators.h"
|
||||
#include <algorithm>
|
||||
|
||||
|
||||
litehtml::el_table::el_table(const std::shared_ptr<litehtml::document>& doc) : html_tag(doc)
|
||||
@ -13,11 +12,6 @@ litehtml::el_table::el_table(const std::shared_ptr<litehtml::document>& doc) : h
|
||||
}
|
||||
|
||||
|
||||
litehtml::el_table::~el_table()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
bool litehtml::el_table::appendChild(const litehtml::element::ptr& el)
|
||||
{
|
||||
if(!el) return false;
|
||||
@ -66,7 +60,7 @@ void litehtml::el_table::parse_attributes()
|
||||
const tchar_t* str = get_attr(_t("width"));
|
||||
if(str)
|
||||
{
|
||||
m_style.add_property(_t("width"), str, 0, false);
|
||||
m_style.add_property(_t("width"), str, nullptr, false);
|
||||
}
|
||||
|
||||
str = get_attr(_t("align"));
|
||||
@ -76,12 +70,12 @@ void litehtml::el_table::parse_attributes()
|
||||
switch(align)
|
||||
{
|
||||
case 1:
|
||||
m_style.add_property(_t("margin-left"), _t("auto"), 0, false);
|
||||
m_style.add_property(_t("margin-right"), _t("auto"), 0, false);
|
||||
m_style.add_property(_t("margin-left"), _t("auto"), nullptr, false);
|
||||
m_style.add_property(_t("margin-right"), _t("auto"), nullptr, false);
|
||||
break;
|
||||
case 2:
|
||||
m_style.add_property(_t("margin-left"), _t("auto"), 0, false);
|
||||
m_style.add_property(_t("margin-right"), _t("0"), 0, false);
|
||||
m_style.add_property(_t("margin-left"), _t("auto"), nullptr, false);
|
||||
m_style.add_property(_t("margin-right"), _t("0"), nullptr, false);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -92,19 +86,19 @@ void litehtml::el_table::parse_attributes()
|
||||
tstring val = str;
|
||||
val += _t(" ");
|
||||
val += str;
|
||||
m_style.add_property(_t("border-spacing"), val.c_str(), 0, false);
|
||||
m_style.add_property(_t("border-spacing"), val.c_str(), nullptr, false);
|
||||
}
|
||||
|
||||
str = get_attr(_t("border"));
|
||||
if(str)
|
||||
{
|
||||
m_style.add_property(_t("border-width"), str, 0, false);
|
||||
m_style.add_property(_t("border-width"), str, nullptr, false);
|
||||
}
|
||||
|
||||
str = get_attr(_t("bgcolor"));
|
||||
if (str)
|
||||
{
|
||||
m_style.add_property(_t("background-color"), str, 0, false);
|
||||
m_style.add_property(_t("background-color"), str, nullptr, false);
|
||||
}
|
||||
|
||||
html_tag::parse_attributes();
|
||||
|
@ -7,17 +7,12 @@ litehtml::el_td::el_td(const std::shared_ptr<litehtml::document>& doc) : html_ta
|
||||
|
||||
}
|
||||
|
||||
litehtml::el_td::~el_td()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void litehtml::el_td::parse_attributes()
|
||||
{
|
||||
const tchar_t* str = get_attr(_t("width"));
|
||||
if(str)
|
||||
{
|
||||
m_style.add_property(_t("width"), str, 0, false);
|
||||
m_style.add_property(_t("width"), str, nullptr, false);
|
||||
}
|
||||
str = get_attr(_t("background"));
|
||||
if(str)
|
||||
@ -25,24 +20,24 @@ void litehtml::el_td::parse_attributes()
|
||||
tstring url = _t("url('");
|
||||
url += str;
|
||||
url += _t("')");
|
||||
m_style.add_property(_t("background-image"), url.c_str(), 0, false);
|
||||
m_style.add_property(_t("background-image"), url.c_str(), nullptr, false);
|
||||
}
|
||||
str = get_attr(_t("align"));
|
||||
if(str)
|
||||
{
|
||||
m_style.add_property(_t("text-align"), str, 0, false);
|
||||
m_style.add_property(_t("text-align"), str, nullptr, false);
|
||||
}
|
||||
|
||||
str = get_attr(_t("bgcolor"));
|
||||
if (str)
|
||||
{
|
||||
m_style.add_property(_t("background-color"), str, 0, false);
|
||||
m_style.add_property(_t("background-color"), str, nullptr, false);
|
||||
}
|
||||
|
||||
str = get_attr(_t("valign"));
|
||||
if(str)
|
||||
{
|
||||
m_style.add_property(_t("vertical-align"), str, 0, false);
|
||||
m_style.add_property(_t("vertical-align"), str, nullptr, false);
|
||||
}
|
||||
html_tag::parse_attributes();
|
||||
}
|
||||
|
@ -13,11 +13,6 @@ litehtml::el_text::el_text(const tchar_t* text, const std::shared_ptr<litehtml::
|
||||
m_draw_spaces = true;
|
||||
}
|
||||
|
||||
litehtml::el_text::~el_text()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void litehtml::el_text::get_content_size( size& sz, int max_width )
|
||||
{
|
||||
sz = m_size;
|
||||
@ -184,5 +179,5 @@ litehtml::css_offsets litehtml::el_text::get_css_offsets() const
|
||||
}
|
||||
p = p->parent();
|
||||
}
|
||||
return css_offsets();
|
||||
return {};
|
||||
}
|
||||
|
@ -7,11 +7,6 @@ litehtml::el_title::el_title(const std::shared_ptr<litehtml::document>& doc) : l
|
||||
|
||||
}
|
||||
|
||||
litehtml::el_title::~el_title()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void litehtml::el_title::parse_attributes()
|
||||
{
|
||||
tstring text;
|
||||
|
@ -7,27 +7,22 @@ litehtml::el_tr::el_tr(const std::shared_ptr<litehtml::document>& doc) : html_ta
|
||||
|
||||
}
|
||||
|
||||
litehtml::el_tr::~el_tr()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void litehtml::el_tr::parse_attributes()
|
||||
{
|
||||
const tchar_t* str = get_attr(_t("align"));
|
||||
if(str)
|
||||
{
|
||||
m_style.add_property(_t("text-align"), str, 0, false);
|
||||
m_style.add_property(_t("text-align"), str, nullptr, false);
|
||||
}
|
||||
str = get_attr(_t("valign"));
|
||||
if(str)
|
||||
{
|
||||
m_style.add_property(_t("vertical-align"), str, 0, false);
|
||||
m_style.add_property(_t("vertical-align"), str, nullptr, false);
|
||||
}
|
||||
str = get_attr(_t("bgcolor"));
|
||||
if (str)
|
||||
{
|
||||
m_style.add_property(_t("background-color"), str, 0, false);
|
||||
m_style.add_property(_t("background-color"), str, nullptr, false);
|
||||
}
|
||||
html_tag::parse_attributes();
|
||||
}
|
||||
|
@ -7,16 +7,10 @@
|
||||
|
||||
litehtml::element::element(const std::shared_ptr<litehtml::document>& doc) : m_doc(doc)
|
||||
{
|
||||
m_box = 0;
|
||||
m_box = nullptr;
|
||||
m_skip = false;
|
||||
}
|
||||
|
||||
litehtml::element::~element()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
|
||||
bool litehtml::element::is_point_inside( int x, int y )
|
||||
{
|
||||
if(get_display() != display_inline && get_display() != display_table_row)
|
||||
@ -35,9 +29,9 @@ bool litehtml::element::is_point_inside( int x, int y )
|
||||
{
|
||||
position::vector boxes;
|
||||
get_inline_boxes(boxes);
|
||||
for(position::vector::iterator box = boxes.begin(); box != boxes.end(); box++)
|
||||
for(auto & box : boxes)
|
||||
{
|
||||
if(box->is_point_inside(x, y))
|
||||
if(box.is_point_inside(x, y))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
@ -48,7 +42,7 @@ bool litehtml::element::is_point_inside( int x, int y )
|
||||
|
||||
litehtml::web_color litehtml::element::get_color( const tchar_t* prop_name, bool inherited, const litehtml::web_color& def_color )
|
||||
{
|
||||
const tchar_t* clrstr = get_style_property(prop_name, inherited, 0);
|
||||
const tchar_t* clrstr = get_style_property(prop_name, inherited, nullptr);
|
||||
if(!clrstr)
|
||||
{
|
||||
return def_color;
|
||||
@ -312,18 +306,18 @@ void litehtml::element::apply_relative_shift(int parent_width)
|
||||
}
|
||||
|
||||
void litehtml::element::calc_auto_margins(int parent_width) LITEHTML_EMPTY_FUNC
|
||||
const litehtml::background* litehtml::element::get_background(bool own_only) LITEHTML_RETURN_FUNC(0)
|
||||
litehtml::element::ptr litehtml::element::get_element_by_point(int x, int y, int client_x, int client_y) LITEHTML_RETURN_FUNC(0)
|
||||
litehtml::element::ptr litehtml::element::get_child_by_point(int x, int y, int client_x, int client_y, draw_flag flag, int zindex) LITEHTML_RETURN_FUNC(0)
|
||||
const litehtml::background* litehtml::element::get_background(bool own_only) LITEHTML_RETURN_FUNC(nullptr)
|
||||
litehtml::element::ptr litehtml::element::get_element_by_point(int x, int y, int client_x, int client_y) LITEHTML_RETURN_FUNC(nullptr)
|
||||
litehtml::element::ptr litehtml::element::get_child_by_point(int x, int y, int client_x, int client_y, draw_flag flag, int zindex) LITEHTML_RETURN_FUNC(nullptr)
|
||||
void litehtml::element::get_line_left_right( int y, int def_right, int& ln_left, int& ln_right ) LITEHTML_EMPTY_FUNC
|
||||
void litehtml::element::add_style( const litehtml::style& st ) LITEHTML_EMPTY_FUNC
|
||||
void litehtml::element::select_all(const css_selector& selector, litehtml::elements_vector& res) LITEHTML_EMPTY_FUNC
|
||||
litehtml::elements_vector litehtml::element::select_all(const litehtml::css_selector& selector) LITEHTML_RETURN_FUNC(litehtml::elements_vector())
|
||||
litehtml::elements_vector litehtml::element::select_all(const litehtml::tstring& selector) LITEHTML_RETURN_FUNC(litehtml::elements_vector())
|
||||
litehtml::element::ptr litehtml::element::select_one( const css_selector& selector ) LITEHTML_RETURN_FUNC(0)
|
||||
litehtml::element::ptr litehtml::element::select_one( const tstring& selector ) LITEHTML_RETURN_FUNC(0)
|
||||
litehtml::element::ptr litehtml::element::find_adjacent_sibling(const element::ptr& el, const css_selector& selector, bool apply_pseudo /*= true*/, bool* is_pseudo /*= 0*/) LITEHTML_RETURN_FUNC(0)
|
||||
litehtml::element::ptr litehtml::element::find_sibling(const element::ptr& el, const css_selector& selector, bool apply_pseudo /*= true*/, bool* is_pseudo /*= 0*/) LITEHTML_RETURN_FUNC(0)
|
||||
litehtml::element::ptr litehtml::element::select_one( const css_selector& selector ) LITEHTML_RETURN_FUNC(nullptr)
|
||||
litehtml::element::ptr litehtml::element::select_one( const tstring& selector ) LITEHTML_RETURN_FUNC(nullptr)
|
||||
litehtml::element::ptr litehtml::element::find_adjacent_sibling(const element::ptr& el, const css_selector& selector, bool apply_pseudo /*= true*/, bool* is_pseudo /*= 0*/) LITEHTML_RETURN_FUNC(nullptr)
|
||||
litehtml::element::ptr litehtml::element::find_sibling(const element::ptr& el, const css_selector& selector, bool apply_pseudo /*= true*/, bool* is_pseudo /*= 0*/) LITEHTML_RETURN_FUNC(nullptr)
|
||||
bool litehtml::element::is_nth_last_child(const element::ptr& el, int num, int off, bool of_type) const LITEHTML_RETURN_FUNC(false)
|
||||
bool litehtml::element::is_nth_child(const element::ptr&, int num, int off, bool of_type) const LITEHTML_RETURN_FUNC(false)
|
||||
bool litehtml::element::is_only_child(const element::ptr& el, bool of_type) const LITEHTML_RETURN_FUNC(false)
|
||||
@ -336,7 +330,7 @@ bool litehtml::element::fetch_positioned() LITEHTML_RETURN_FUNC(false)
|
||||
litehtml::visibility litehtml::element::get_visibility() const LITEHTML_RETURN_FUNC(visibility_visible)
|
||||
void litehtml::element::apply_vertical_align() LITEHTML_EMPTY_FUNC
|
||||
void litehtml::element::set_css_width( css_length& w ) LITEHTML_EMPTY_FUNC
|
||||
litehtml::element::ptr litehtml::element::get_child( int idx ) const LITEHTML_RETURN_FUNC(0)
|
||||
litehtml::element::ptr litehtml::element::get_child( int idx ) const LITEHTML_RETURN_FUNC(nullptr)
|
||||
size_t litehtml::element::get_children_count() const LITEHTML_RETURN_FUNC(0)
|
||||
void litehtml::element::calc_outlines( int parent_width ) LITEHTML_EMPTY_FUNC
|
||||
litehtml::css_length litehtml::element::get_css_width() const LITEHTML_RETURN_FUNC(css_length())
|
||||
@ -377,7 +371,7 @@ void litehtml::element::on_click() LITEHTML_EMPTY_FUNC
|
||||
void litehtml::element::init_font() LITEHTML_EMPTY_FUNC
|
||||
void litehtml::element::get_inline_boxes( position::vector& boxes ) LITEHTML_EMPTY_FUNC
|
||||
void litehtml::element::parse_styles( bool is_reparse /*= false*/ ) LITEHTML_EMPTY_FUNC
|
||||
const litehtml::tchar_t* litehtml::element::get_attr( const tchar_t* name, const tchar_t* def /*= 0*/ ) const LITEHTML_RETURN_FUNC(def)
|
||||
const litehtml::tchar_t* litehtml::element::get_attr( const tchar_t* name, const tchar_t* def /*= 0*/ ) const LITEHTML_RETURN_FUNC(def)
|
||||
bool litehtml::element::is_white_space() const LITEHTML_RETURN_FUNC(false)
|
||||
bool litehtml::element::is_body() const LITEHTML_RETURN_FUNC(false)
|
||||
bool litehtml::element::is_break() const LITEHTML_RETURN_FUNC(false)
|
||||
@ -387,7 +381,7 @@ bool litehtml::element::on_mouse_leave() LITEHTML_RETURN_FUNC(false)
|
||||
bool litehtml::element::on_lbutton_down() LITEHTML_RETURN_FUNC(false)
|
||||
bool litehtml::element::on_lbutton_up() LITEHTML_RETURN_FUNC(false)
|
||||
bool litehtml::element::find_styles_changes( position::vector& redraw_boxes, int x, int y ) LITEHTML_RETURN_FUNC(false)
|
||||
const litehtml::tchar_t* litehtml::element::get_cursor() LITEHTML_RETURN_FUNC(0)
|
||||
const litehtml::tchar_t* litehtml::element::get_cursor() LITEHTML_RETURN_FUNC(nullptr)
|
||||
litehtml::white_space litehtml::element::get_white_space() const LITEHTML_RETURN_FUNC(white_space_normal)
|
||||
litehtml::style_display litehtml::element::get_display() const LITEHTML_RETURN_FUNC(display_none)
|
||||
bool litehtml::element::set_pseudo_class( const tchar_t* pclass, bool add ) LITEHTML_RETURN_FUNC(false)
|
||||
@ -397,14 +391,14 @@ bool litehtml::element::is_replaced() const LITEHTML_RETURN_FUNC(false
|
||||
int litehtml::element::line_height() const LITEHTML_RETURN_FUNC(0)
|
||||
void litehtml::element::draw( uint_ptr hdc, int x, int y, const position* clip ) LITEHTML_EMPTY_FUNC
|
||||
void litehtml::element::draw_background( uint_ptr hdc, int x, int y, const position* clip ) LITEHTML_EMPTY_FUNC
|
||||
const litehtml::tchar_t* litehtml::element::get_style_property( const tchar_t* name, bool inherited, const tchar_t* def /*= 0*/ ) LITEHTML_RETURN_FUNC(0)
|
||||
const litehtml::tchar_t* litehtml::element::get_style_property( const tchar_t* name, bool inherited, const tchar_t* def /*= 0*/ ) LITEHTML_RETURN_FUNC(nullptr)
|
||||
litehtml::uint_ptr litehtml::element::get_font( font_metrics* fm /*= 0*/ ) LITEHTML_RETURN_FUNC(0)
|
||||
int litehtml::element::get_font_size() const LITEHTML_RETURN_FUNC(0)
|
||||
void litehtml::element::get_text( tstring& text ) LITEHTML_EMPTY_FUNC
|
||||
void litehtml::element::parse_attributes() LITEHTML_EMPTY_FUNC
|
||||
int litehtml::element::select( const css_selector& selector, bool apply_pseudo) LITEHTML_RETURN_FUNC(select_no_match)
|
||||
int litehtml::element::select( const css_element_selector& selector, bool apply_pseudo /*= true*/ ) LITEHTML_RETURN_FUNC(select_no_match)
|
||||
litehtml::element::ptr litehtml::element::find_ancestor(const css_selector& selector, bool apply_pseudo, bool* is_pseudo) LITEHTML_RETURN_FUNC(0)
|
||||
litehtml::element::ptr litehtml::element::find_ancestor(const css_selector& selector, bool apply_pseudo, bool* is_pseudo) LITEHTML_RETURN_FUNC(nullptr)
|
||||
bool litehtml::element::is_first_child_inline(const element::ptr& el) const LITEHTML_RETURN_FUNC(false)
|
||||
bool litehtml::element::is_last_child_inline(const element::ptr& el) LITEHTML_RETURN_FUNC(false)
|
||||
bool litehtml::element::have_inline_child() const LITEHTML_RETURN_FUNC(false)
|
||||
|
11
src/html.cpp
11
src/html.cpp
@ -1,6 +1,5 @@
|
||||
#include "html.h"
|
||||
#include "types.h"
|
||||
#include "html_tag.h"
|
||||
#include "utf8_strings.h"
|
||||
|
||||
void litehtml::trim(tstring &s)
|
||||
@ -19,9 +18,9 @@ void litehtml::trim(tstring &s)
|
||||
|
||||
void litehtml::lcase(tstring &s)
|
||||
{
|
||||
for(tstring::iterator i = s.begin(); i != s.end(); i++)
|
||||
for(char & i : s)
|
||||
{
|
||||
(*i) = t_tolower(*i);
|
||||
i = t_tolower(i);
|
||||
}
|
||||
}
|
||||
|
||||
@ -55,7 +54,7 @@ int litehtml::value_index( const tstring& val, const tstring& strings, int defVa
|
||||
int idx = 0;
|
||||
tstring::size_type delim_start = 0;
|
||||
tstring::size_type delim_end = strings.find(delim, delim_start);
|
||||
tstring::size_type item_len = 0;
|
||||
tstring::size_type item_len;
|
||||
while(true)
|
||||
{
|
||||
if(delim_end == tstring::npos)
|
||||
@ -103,7 +102,7 @@ void litehtml::split_string(const tstring& str, string_vector& tokens, const tst
|
||||
|
||||
tstring::size_type token_start = 0;
|
||||
tstring::size_type token_end = str.find_first_of(all_delims, token_start);
|
||||
tstring::size_type token_len = 0;
|
||||
tstring::size_type token_len;
|
||||
tstring token;
|
||||
while(true)
|
||||
{
|
||||
@ -203,7 +202,7 @@ int litehtml::t_strncasecmp(const litehtml::tchar_t *s1, const litehtml::tchar_t
|
||||
return 0;
|
||||
}
|
||||
|
||||
void litehtml::document_container::split_text(const char* text, std::function<void(const tchar_t*)> on_word, std::function<void(const tchar_t*)> on_space)
|
||||
void litehtml::document_container::split_text(const char* text, const std::function<void(const tchar_t*)>& on_word, const std::function<void(const tchar_t*)>& on_space)
|
||||
{
|
||||
std::wstring str;
|
||||
std::wstring str_in = (const wchar_t*)(utf8_to_wchar(text));
|
||||
|
335
src/html_tag.cpp
335
src/html_tag.cpp
@ -14,7 +14,7 @@ litehtml::html_tag::html_tag(const std::shared_ptr<litehtml::document>& doc) : l
|
||||
m_box_sizing = box_sizing_content_box;
|
||||
m_z_index = 0;
|
||||
m_overflow = overflow_visible;
|
||||
m_box = 0;
|
||||
m_box = nullptr;
|
||||
m_text_align = text_align_left;
|
||||
m_el_position = element_position_static;
|
||||
m_display = display_inline;
|
||||
@ -34,11 +34,6 @@ litehtml::html_tag::html_tag(const std::shared_ptr<litehtml::document>& doc) : l
|
||||
m_border_collapse = border_collapse_separate;
|
||||
}
|
||||
|
||||
litehtml::html_tag::~html_tag()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
bool litehtml::html_tag::appendChild(const element::ptr &el)
|
||||
{
|
||||
if(el)
|
||||
@ -82,9 +77,9 @@ void litehtml::html_tag::set_attr( const tchar_t* name, const tchar_t* val )
|
||||
if(name && val)
|
||||
{
|
||||
tstring s_val = name;
|
||||
for(size_t i = 0; i < s_val.length(); i++)
|
||||
for(char& i : s_val)
|
||||
{
|
||||
s_val[i] = std::tolower(s_val[i], std::locale::classic());
|
||||
i = std::tolower(i, std::locale::classic());
|
||||
}
|
||||
m_attrs[s_val] = val;
|
||||
|
||||
@ -98,7 +93,7 @@ void litehtml::html_tag::set_attr( const tchar_t* name, const tchar_t* val )
|
||||
|
||||
const litehtml::tchar_t* litehtml::html_tag::get_attr( const tchar_t* name, const tchar_t* def ) const
|
||||
{
|
||||
string_map::const_iterator attr = m_attrs.find(name);
|
||||
auto attr = m_attrs.find(name);
|
||||
if(attr != m_attrs.end())
|
||||
{
|
||||
return attr->second.c_str();
|
||||
@ -108,7 +103,7 @@ const litehtml::tchar_t* litehtml::html_tag::get_attr( const tchar_t* name, cons
|
||||
|
||||
litehtml::elements_vector litehtml::html_tag::select_all( const tstring& selector )
|
||||
{
|
||||
css_selector sel(media_query_list::ptr(0));
|
||||
css_selector sel(media_query_list::ptr(nullptr));
|
||||
sel.parse(selector);
|
||||
|
||||
return select_all(sel);
|
||||
@ -137,7 +132,7 @@ void litehtml::html_tag::select_all(const css_selector& selector, elements_vecto
|
||||
|
||||
litehtml::element::ptr litehtml::html_tag::select_one( const tstring& selector )
|
||||
{
|
||||
css_selector sel(media_query_list::ptr(0));
|
||||
css_selector sel(media_query_list::ptr(nullptr));
|
||||
sel.parse(selector);
|
||||
|
||||
return select_one(sel);
|
||||
@ -158,7 +153,7 @@ litehtml::element::ptr litehtml::html_tag::select_one( const css_selector& selec
|
||||
return res;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void litehtml::html_tag::apply_stylesheet( const litehtml::css& stylesheet )
|
||||
@ -313,7 +308,7 @@ void litehtml::html_tag::parse_styles(bool is_reparse)
|
||||
|
||||
if(style)
|
||||
{
|
||||
m_style.add(style, NULL);
|
||||
m_style.add(style, nullptr);
|
||||
}
|
||||
|
||||
init_font();
|
||||
@ -329,7 +324,7 @@ void litehtml::html_tag::parse_styles(bool is_reparse)
|
||||
|
||||
if(m_el_position != element_position_static)
|
||||
{
|
||||
const tchar_t* val = get_style_property(_t("z-index"), false, 0);
|
||||
const tchar_t* val = get_style_property(_t("z-index"), false, nullptr);
|
||||
if(val)
|
||||
{
|
||||
m_z_index = t_atoi(val);
|
||||
@ -474,7 +469,7 @@ void litehtml::html_tag::parse_styles(bool is_reparse)
|
||||
m_lh_predefined = true;
|
||||
} else if(line_height.units() == css_units_none)
|
||||
{
|
||||
m_line_height = (int) (line_height.val() * m_font_size);
|
||||
m_line_height = (int) (line_height.val() * (float) m_font_size);
|
||||
m_lh_predefined = false;
|
||||
} else
|
||||
{
|
||||
@ -491,13 +486,13 @@ void litehtml::html_tag::parse_styles(bool is_reparse)
|
||||
const tchar_t* list_pos = get_style_property(_t("list-style-position"), true, _t("outside"));
|
||||
m_list_style_position = (list_style_position) value_index(list_pos, list_style_position_strings, list_style_position_outside);
|
||||
|
||||
const tchar_t* list_image = get_style_property(_t("list-style-image"), true, 0);
|
||||
const tchar_t* list_image = get_style_property(_t("list-style-image"), true, nullptr);
|
||||
if(list_image && list_image[0])
|
||||
{
|
||||
tstring url;
|
||||
css::parse_css_url(list_image, url);
|
||||
|
||||
const tchar_t* list_image_baseurl = get_style_property(_t("list-style-image-baseurl"), true, 0);
|
||||
const tchar_t* list_image_baseurl = get_style_property(_t("list-style-image-baseurl"), true, nullptr);
|
||||
doc->container()->load_image(url.c_str(), list_image_baseurl, true);
|
||||
}
|
||||
|
||||
@ -699,10 +694,10 @@ int litehtml::html_tag::select(const css_element_selector& selector, bool apply_
|
||||
int res = select_match;
|
||||
element::ptr el_parent = parent();
|
||||
|
||||
for(css_attribute_selector::vector::const_iterator i = selector.m_attrs.begin(); i != selector.m_attrs.end(); i++)
|
||||
for(const auto& attr : selector.m_attrs)
|
||||
{
|
||||
const tchar_t* attr_value = get_attr(i->attribute.c_str());
|
||||
switch(i->condition)
|
||||
const tchar_t* attr_value = get_attr(attr.attribute.c_str());
|
||||
switch(attr.condition)
|
||||
{
|
||||
case select_exists:
|
||||
if(!attr_value)
|
||||
@ -716,17 +711,17 @@ int litehtml::html_tag::select(const css_element_selector& selector, bool apply_
|
||||
return select_no_match;
|
||||
} else
|
||||
{
|
||||
if(i->attribute == _t("class"))
|
||||
if(attr.attribute == _t("class"))
|
||||
{
|
||||
const string_vector & tokens1 = m_class_values;
|
||||
const string_vector & tokens2 = i->class_val;
|
||||
const string_vector & tokens2 = attr.class_val;
|
||||
bool found = true;
|
||||
for(string_vector::const_iterator str1 = tokens2.begin(); str1 != tokens2.end() && found; str1++)
|
||||
for(const auto& str1 : tokens2)
|
||||
{
|
||||
bool f = false;
|
||||
for(string_vector::const_iterator str2 = tokens1.begin(); str2 != tokens1.end() && !f; str2++)
|
||||
for(const auto& str2 : tokens1)
|
||||
{
|
||||
if( !t_strcasecmp(str1->c_str(), str2->c_str()) )
|
||||
if( !t_strcasecmp(str1.c_str(), str2.c_str()) )
|
||||
{
|
||||
f = true;
|
||||
}
|
||||
@ -742,7 +737,7 @@ int litehtml::html_tag::select(const css_element_selector& selector, bool apply_
|
||||
}
|
||||
} else
|
||||
{
|
||||
if( t_strcasecmp(i->val.c_str(), attr_value) )
|
||||
if( t_strcasecmp(attr.val.c_str(), attr_value) )
|
||||
{
|
||||
return select_no_match;
|
||||
}
|
||||
@ -750,19 +745,13 @@ int litehtml::html_tag::select(const css_element_selector& selector, bool apply_
|
||||
}
|
||||
break;
|
||||
case select_contain_str:
|
||||
if(!attr_value)
|
||||
{
|
||||
return select_no_match;
|
||||
} else if(!t_strstr(attr_value, i->val.c_str()))
|
||||
if(!attr_value || !t_strstr(attr_value, attr.val.c_str()))
|
||||
{
|
||||
return select_no_match;
|
||||
}
|
||||
break;
|
||||
case select_start_str:
|
||||
if(!attr_value)
|
||||
{
|
||||
return select_no_match;
|
||||
} else if(t_strncmp(attr_value, i->val.c_str(), i->val.length()))
|
||||
if(!attr_value || t_strncmp(attr_value, attr.val.c_str(), attr.val.length()))
|
||||
{
|
||||
return select_no_match;
|
||||
}
|
||||
@ -771,24 +760,24 @@ int litehtml::html_tag::select(const css_element_selector& selector, bool apply_
|
||||
if(!attr_value)
|
||||
{
|
||||
return select_no_match;
|
||||
} else if(t_strncmp(attr_value, i->val.c_str(), i->val.length()))
|
||||
} else if(t_strncmp(attr_value, attr.val.c_str(), attr.val.length()))
|
||||
{
|
||||
const tchar_t* s = attr_value + t_strlen(attr_value) - i->val.length() - 1;
|
||||
const tchar_t* s = attr_value + t_strlen(attr_value) - attr.val.length() - 1;
|
||||
if(s < attr_value)
|
||||
{
|
||||
return select_no_match;
|
||||
}
|
||||
if(i->val != s)
|
||||
if(attr.val != s)
|
||||
{
|
||||
return select_no_match;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case select_pseudo_element:
|
||||
if(i->val == _t("after"))
|
||||
if(attr.val == _t("after"))
|
||||
{
|
||||
res |= select_match_with_after;
|
||||
} else if(i->val == _t("before"))
|
||||
} else if(attr.val == _t("before"))
|
||||
{
|
||||
res |= select_match_with_before;
|
||||
} else
|
||||
@ -804,24 +793,24 @@ int litehtml::html_tag::select(const css_element_selector& selector, bool apply_
|
||||
tstring selector_param;
|
||||
tstring selector_name;
|
||||
|
||||
tstring::size_type begin = i->val.find_first_of(_t('('));
|
||||
tstring::size_type end = (begin == tstring::npos) ? tstring::npos : find_close_bracket(i->val, begin);
|
||||
tstring::size_type begin = attr.val.find_first_of(_t('('));
|
||||
tstring::size_type end = (begin == tstring::npos) ? tstring::npos : find_close_bracket(attr.val, begin);
|
||||
if(begin != tstring::npos && end != tstring::npos)
|
||||
{
|
||||
selector_param = i->val.substr(begin + 1, end - begin - 1);
|
||||
selector_param = attr.val.substr(begin + 1, end - begin - 1);
|
||||
}
|
||||
if(begin != tstring::npos)
|
||||
{
|
||||
selector_name = i->val.substr(0, begin);
|
||||
selector_name = attr.val.substr(0, begin);
|
||||
litehtml::trim(selector_name);
|
||||
} else
|
||||
{
|
||||
selector_name = i->val;
|
||||
selector_name = attr.val;
|
||||
}
|
||||
|
||||
int selector = value_index(selector_name.c_str(), pseudo_class_strings);
|
||||
int pseudo_selector = value_index(selector_name, pseudo_class_strings);
|
||||
|
||||
switch(selector)
|
||||
switch(pseudo_selector)
|
||||
{
|
||||
case pseudo_class_only_child:
|
||||
if (!el_parent->is_only_child(shared_from_this(), false))
|
||||
@ -871,7 +860,7 @@ int litehtml::html_tag::select(const css_element_selector& selector, bool apply_
|
||||
|
||||
parse_nth_child_params(selector_param, num, off);
|
||||
if(!num && !off) return select_no_match;
|
||||
switch(selector)
|
||||
switch(pseudo_selector)
|
||||
{
|
||||
case pseudo_class_nth_child:
|
||||
if (!el_parent->is_nth_child(shared_from_this(), num, off, false))
|
||||
@ -922,7 +911,7 @@ int litehtml::html_tag::select(const css_element_selector& selector, bool apply_
|
||||
}
|
||||
break;
|
||||
default:
|
||||
if(std::find(m_pseudo_classes.begin(), m_pseudo_classes.end(), i->val) == m_pseudo_classes.end())
|
||||
if(std::find(m_pseudo_classes.begin(), m_pseudo_classes.end(), attr.val) == m_pseudo_classes.end())
|
||||
{
|
||||
return select_no_match;
|
||||
}
|
||||
@ -1230,9 +1219,9 @@ int litehtml::html_tag::fix_line_width( int max_width, element_float flt )
|
||||
{
|
||||
m_boxes.pop_back();
|
||||
|
||||
for(elements_vector::iterator i = els.begin(); i != els.end(); i++)
|
||||
for(const auto& el : els)
|
||||
{
|
||||
int rw = place_element((*i), max_width);
|
||||
int rw = place_element(el, max_width);
|
||||
if(rw > ret_width)
|
||||
{
|
||||
ret_width = rw;
|
||||
@ -1264,9 +1253,9 @@ int litehtml::html_tag::fix_line_width( int max_width, element_float flt )
|
||||
if(m_css_text_indent.val() != 0)
|
||||
{
|
||||
bool line_box_found = false;
|
||||
for(box::vector::iterator iter = m_boxes.begin(); iter < m_boxes.end(); iter++)
|
||||
for(const auto& box : m_boxes)
|
||||
{
|
||||
if((*iter)->get_type() == box_line)
|
||||
if(box->get_type() == box_line)
|
||||
{
|
||||
line_box_found = true;
|
||||
break;
|
||||
@ -1280,7 +1269,7 @@ int litehtml::html_tag::fix_line_width( int max_width, element_float flt )
|
||||
|
||||
}
|
||||
|
||||
elements_vector els;
|
||||
els.clear();
|
||||
m_boxes.back()->new_width(line_left, line_right, els);
|
||||
for(auto& el : els)
|
||||
{
|
||||
@ -1317,7 +1306,7 @@ void litehtml::html_tag::add_float(const element::ptr &el, int x, int y)
|
||||
} else
|
||||
{
|
||||
bool inserted = false;
|
||||
for(floated_box::vector::iterator i = m_floats_left.begin(); i != m_floats_left.end(); i++)
|
||||
for(auto i = m_floats_left.begin(); i != m_floats_left.end(); i++)
|
||||
{
|
||||
if(fb.pos.right() > i->pos.right())
|
||||
{
|
||||
@ -1340,7 +1329,7 @@ void litehtml::html_tag::add_float(const element::ptr &el, int x, int y)
|
||||
} else
|
||||
{
|
||||
bool inserted = false;
|
||||
for(floated_box::vector::iterator i = m_floats_right.begin(); i != m_floats_right.end(); i++)
|
||||
for(auto i = m_floats_right.begin(); i != m_floats_right.end(); i++)
|
||||
{
|
||||
if(fb.pos.left() < i->pos.left())
|
||||
{
|
||||
@ -1449,15 +1438,15 @@ void litehtml::html_tag::parse_background()
|
||||
{
|
||||
string_vector res;
|
||||
split_string(str, res, _t(" \t"));
|
||||
if(res.size() > 0)
|
||||
if(!res.empty())
|
||||
{
|
||||
if(res.size() == 1)
|
||||
{
|
||||
if( value_in_list(res[0].c_str(), _t("left;right;center")) )
|
||||
if( value_in_list(res[0], _t("left;right;center")) )
|
||||
{
|
||||
m_bg.m_position.x.fromString(res[0], _t("left;right;center"));
|
||||
m_bg.m_position.y.set_value(50, css_units_percentage);
|
||||
} else if( value_in_list(res[0].c_str(), _t("top;bottom;center")) )
|
||||
} else if( value_in_list(res[0], _t("top;bottom;center")) )
|
||||
{
|
||||
m_bg.m_position.y.fromString(res[0], _t("top;bottom;center"));
|
||||
m_bg.m_position.x.set_value(50, css_units_percentage);
|
||||
@ -1468,19 +1457,19 @@ void litehtml::html_tag::parse_background()
|
||||
}
|
||||
} else
|
||||
{
|
||||
if(value_in_list(res[0].c_str(), _t("left;right")))
|
||||
if(value_in_list(res[0], _t("left;right")))
|
||||
{
|
||||
m_bg.m_position.x.fromString(res[0], _t("left;right;center"));
|
||||
m_bg.m_position.y.fromString(res[1], _t("top;bottom;center"));
|
||||
} else if(value_in_list(res[0].c_str(), _t("top;bottom")))
|
||||
} else if(value_in_list(res[0], _t("top;bottom")))
|
||||
{
|
||||
m_bg.m_position.x.fromString(res[1], _t("left;right;center"));
|
||||
m_bg.m_position.y.fromString(res[0], _t("top;bottom;center"));
|
||||
} else if(value_in_list(res[1].c_str(), _t("left;right")))
|
||||
} else if(value_in_list(res[1], _t("left;right")))
|
||||
{
|
||||
m_bg.m_position.x.fromString(res[1], _t("left;right;center"));
|
||||
m_bg.m_position.y.fromString(res[0], _t("top;bottom;center"));
|
||||
}else if(value_in_list(res[1].c_str(), _t("top;bottom")))
|
||||
}else if(value_in_list(res[1], _t("top;bottom")))
|
||||
{
|
||||
m_bg.m_position.x.fromString(res[0], _t("left;right;center"));
|
||||
m_bg.m_position.y.fromString(res[1], _t("top;bottom;center"));
|
||||
@ -1591,7 +1580,7 @@ void litehtml::html_tag::parse_background()
|
||||
|
||||
if(!m_bg.m_image.empty())
|
||||
{
|
||||
doc->container()->load_image(m_bg.m_image.c_str(), m_bg.m_baseurl.empty() ? 0 : m_bg.m_baseurl.c_str(), true);
|
||||
doc->container()->load_image(m_bg.m_image.c_str(), m_bg.m_baseurl.empty() ? nullptr : m_bg.m_baseurl.c_str(), true);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1689,7 +1678,7 @@ void litehtml::html_tag::set_data( const tchar_t* /*data*/ )
|
||||
|
||||
void litehtml::html_tag::get_inline_boxes( position::vector& boxes )
|
||||
{
|
||||
litehtml::box* old_box = 0;
|
||||
litehtml::box* old_box = nullptr;
|
||||
position pos;
|
||||
for(auto& el : m_children)
|
||||
{
|
||||
@ -1785,14 +1774,15 @@ bool litehtml::html_tag::find_styles_changes( position::vector& redraw_boxes, in
|
||||
|
||||
bool ret = false;
|
||||
bool apply = false;
|
||||
for (used_selector::vector::iterator iter = m_used_styles.begin(); iter != m_used_styles.end() && !apply; iter++)
|
||||
for (const auto& used_style : m_used_styles)
|
||||
{
|
||||
if((*iter)->m_selector->is_media_valid())
|
||||
if(used_style->m_selector->is_media_valid())
|
||||
{
|
||||
int res = select(*((*iter)->m_selector), true);
|
||||
if( (res == select_no_match && (*iter)->m_used) || (res == select_match && !(*iter)->m_used) )
|
||||
int res = select(*(used_style->m_selector), true);
|
||||
if( (res == select_no_match && used_style->m_used) || (res == select_match && !used_style->m_used) )
|
||||
{
|
||||
apply = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1803,11 +1793,11 @@ bool litehtml::html_tag::find_styles_changes( position::vector& redraw_boxes, in
|
||||
{
|
||||
position::vector boxes;
|
||||
get_inline_boxes(boxes);
|
||||
for(position::vector::iterator pos = boxes.begin(); pos != boxes.end(); pos++)
|
||||
for(auto & box : boxes)
|
||||
{
|
||||
pos->x += x;
|
||||
pos->y += y;
|
||||
redraw_boxes.push_back(*pos);
|
||||
box.x += x;
|
||||
box.y += y;
|
||||
redraw_boxes.push_back(box);
|
||||
}
|
||||
} else
|
||||
{
|
||||
@ -1919,7 +1909,7 @@ void litehtml::html_tag::on_click()
|
||||
|
||||
const litehtml::tchar_t* litehtml::html_tag::get_cursor()
|
||||
{
|
||||
return get_style_property(_t("cursor"), true, 0);
|
||||
return get_style_property(_t("cursor"), true, nullptr);
|
||||
}
|
||||
|
||||
static const int font_size_table[8][7] =
|
||||
@ -1938,7 +1928,7 @@ static const int font_size_table[8][7] =
|
||||
void litehtml::html_tag::init_font()
|
||||
{
|
||||
// initialize font size
|
||||
const tchar_t* str = get_style_property(_t("font-size"), false, 0);
|
||||
const tchar_t* str = get_style_property(_t("font-size"), false, nullptr);
|
||||
|
||||
int parent_sz = 0;
|
||||
int doc_font_size = get_document()->container()->get_default_font_size();
|
||||
@ -2032,9 +2022,9 @@ bool litehtml::html_tag::is_break() const
|
||||
void litehtml::html_tag::set_tagName( const tchar_t* tag )
|
||||
{
|
||||
tstring s_val = tag;
|
||||
for(size_t i = 0; i < s_val.length(); i++)
|
||||
for(char& i : s_val)
|
||||
{
|
||||
s_val[i] = std::tolower(s_val[i], std::locale::classic());
|
||||
i = std::tolower(i, std::locale::classic());
|
||||
}
|
||||
m_tag = s_val;
|
||||
}
|
||||
@ -2073,9 +2063,11 @@ void litehtml::html_tag::draw_background( uint_ptr hdc, int x, int y, const posi
|
||||
border_box += m_borders;
|
||||
|
||||
borders bdr = m_css_borders;
|
||||
bdr.radius = m_css_borders.radius.calc_percents(border_box.width, border_box.height);
|
||||
|
||||
get_document()->container()->draw_borders(hdc, bdr, border_box, have_parent() ? false : true);
|
||||
if(bdr.is_visible())
|
||||
{
|
||||
bdr.radius = m_css_borders.radius.calc_percents(border_box.width, border_box.height);
|
||||
get_document()->container()->draw_borders(hdc, bdr, border_box, !have_parent());
|
||||
}
|
||||
}
|
||||
} else
|
||||
{
|
||||
@ -2087,7 +2079,7 @@ void litehtml::html_tag::draw_background( uint_ptr hdc, int x, int y, const posi
|
||||
background_paint bg_paint;
|
||||
position content_box;
|
||||
|
||||
for(position::vector::iterator box = boxes.begin(); box != boxes.end(); box++)
|
||||
for(auto box = boxes.begin(); box != boxes.end(); box++)
|
||||
{
|
||||
box->x += x;
|
||||
box->y += y;
|
||||
@ -2135,16 +2127,18 @@ void litehtml::html_tag::draw_background( uint_ptr hdc, int x, int y, const posi
|
||||
bdr.right = m_css_borders.right;
|
||||
}
|
||||
|
||||
|
||||
if(bg)
|
||||
{
|
||||
bg_paint.border_radius = bdr.radius.calc_percents(bg_paint.border_box.width, bg_paint.border_box.width);
|
||||
get_document()->container()->draw_background(hdc, bg_paint);
|
||||
}
|
||||
borders b = bdr;
|
||||
b.radius = bdr.radius.calc_percents(box->width, box->height);
|
||||
get_document()->container()->draw_borders(hdc, b, *box, false);
|
||||
}
|
||||
if(bdr.is_visible())
|
||||
{
|
||||
borders b = bdr;
|
||||
b.radius = bdr.radius.calc_percents(box->width, box->height);
|
||||
get_document()->container()->draw_borders(hdc, b, *box, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -2313,7 +2307,7 @@ int litehtml::html_tag::place_element(const element::ptr &el, int max_width)
|
||||
break;
|
||||
default:
|
||||
{
|
||||
line_context line_ctx;
|
||||
line_context line_ctx = {0};
|
||||
line_ctx.top = 0;
|
||||
if (!m_boxes.empty())
|
||||
{
|
||||
@ -2456,7 +2450,7 @@ bool litehtml::html_tag::set_pseudo_class( const tchar_t* pclass, bool add )
|
||||
}
|
||||
} else
|
||||
{
|
||||
string_vector::iterator pi = std::find(m_pseudo_classes.begin(), m_pseudo_classes.end(), pclass);
|
||||
auto pi = std::find(m_pseudo_classes.begin(), m_pseudo_classes.end(), pclass);
|
||||
if(pi != m_pseudo_classes.end())
|
||||
{
|
||||
m_pseudo_classes.erase(pi);
|
||||
@ -2578,9 +2572,9 @@ int litehtml::html_tag::new_box(const element::ptr &el, int max_width, line_cont
|
||||
if(m_css_text_indent.val() != 0)
|
||||
{
|
||||
bool line_box_found = false;
|
||||
for(box::vector::iterator iter = m_boxes.begin(); iter != m_boxes.end(); iter++)
|
||||
for(auto & box : m_boxes)
|
||||
{
|
||||
if((*iter)->get_type() == box_line)
|
||||
if(box->get_type() == box_line)
|
||||
{
|
||||
line_box_found = true;
|
||||
break;
|
||||
@ -2821,9 +2815,9 @@ void litehtml::html_tag::apply_vertical_align()
|
||||
|
||||
if(add)
|
||||
{
|
||||
for(size_t i = 0; i < m_boxes.size(); i++)
|
||||
for(auto & box : m_boxes)
|
||||
{
|
||||
m_boxes[i]->y_shift(add);
|
||||
box->y_shift(add);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -2938,9 +2932,9 @@ void litehtml::html_tag::init_background_paint(position pos, background_paint &b
|
||||
}
|
||||
|
||||
}
|
||||
bg_paint.border_radius = m_css_borders.radius.calc_percents(border_box.width, border_box.height);;
|
||||
bg_paint.border_radius = m_css_borders.radius.calc_percents(border_box.width, border_box.height);
|
||||
bg_paint.border_box = border_box;
|
||||
bg_paint.is_root = have_parent() ? false : true;
|
||||
bg_paint.is_root = !have_parent();
|
||||
}
|
||||
|
||||
litehtml::visibility litehtml::html_tag::get_visibility() const
|
||||
@ -2952,16 +2946,16 @@ void litehtml::html_tag::draw_list_marker( uint_ptr hdc, const position &pos )
|
||||
{
|
||||
list_marker lm;
|
||||
|
||||
const tchar_t* list_image = get_style_property(_t("list-style-image"), true, 0);
|
||||
const tchar_t* list_image = get_style_property(_t("list-style-image"), true, nullptr);
|
||||
size img_size;
|
||||
if(list_image)
|
||||
{
|
||||
css::parse_css_url(list_image, lm.image);
|
||||
lm.baseurl = get_style_property(_t("list-style-image-baseurl"), true, 0);
|
||||
lm.baseurl = get_style_property(_t("list-style-image-baseurl"), true, nullptr);
|
||||
get_document()->container()->get_image_size(lm.image.c_str(), lm.baseurl, img_size);
|
||||
} else
|
||||
{
|
||||
lm.baseurl = 0;
|
||||
lm.baseurl = nullptr;
|
||||
}
|
||||
|
||||
int ln_height = line_height();
|
||||
@ -2976,7 +2970,7 @@ void litehtml::html_tag::draw_list_marker( uint_ptr hdc, const position &pos )
|
||||
{
|
||||
lm.pos.y = pos.y;
|
||||
lm.pos.height = pos.height;
|
||||
lm.index = get_attr(_t("list_index"), _t(""))[0];
|
||||
lm.index = (unsigned char) get_attr(_t("list_index"), _t(""))[0];
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -3065,22 +3059,22 @@ litehtml::tstring litehtml::html_tag::get_list_marker_text(int index)
|
||||
return num_cvt::to_roman_lower(index);
|
||||
case litehtml::list_style_type_upper_roman:
|
||||
return num_cvt::to_roman_upper(index);
|
||||
case litehtml::list_style_type_armenian:
|
||||
break;
|
||||
case litehtml::list_style_type_georgian:
|
||||
break;
|
||||
case litehtml::list_style_type_hebrew:
|
||||
break;
|
||||
case litehtml::list_style_type_hiragana:
|
||||
break;
|
||||
case litehtml::list_style_type_hiragana_iroha:
|
||||
break;
|
||||
case litehtml::list_style_type_katakana:
|
||||
break;
|
||||
case litehtml::list_style_type_katakana_iroha:
|
||||
break;
|
||||
}
|
||||
return _t("");
|
||||
default:
|
||||
return _t("");
|
||||
// case litehtml::list_style_type_armenian:
|
||||
// case litehtml::list_style_type_georgian:
|
||||
// case litehtml::list_style_type_hebrew:
|
||||
// case litehtml::list_style_type_hiragana:
|
||||
// case litehtml::list_style_type_hiragana_iroha:
|
||||
// case litehtml::list_style_type_katakana:
|
||||
// case litehtml::list_style_type_katakana_iroha:
|
||||
// case litehtml::list_style_type_none:
|
||||
// case litehtml::list_style_type_circle:
|
||||
// case litehtml::list_style_type_disc:
|
||||
// case litehtml::list_style_type_square:
|
||||
// case litehtml::list_style_type_cjk_ideographic:
|
||||
// break;
|
||||
}
|
||||
}
|
||||
|
||||
void litehtml::html_tag::draw_children( uint_ptr hdc, int x, int y, const position* clip, draw_flag flag, int zindex )
|
||||
@ -3329,9 +3323,9 @@ void litehtml::html_tag::render_positioned(render_type rt)
|
||||
|
||||
if(!m_positioned.empty())
|
||||
{
|
||||
std::stable_sort(m_positioned.begin(), m_positioned.end(), [](const litehtml::element::ptr& _Left, const litehtml::element::ptr& _Right)
|
||||
std::stable_sort(m_positioned.begin(), m_positioned.end(), [](const litehtml::element::ptr& Left, const litehtml::element::ptr& Right)
|
||||
{
|
||||
return (_Left->get_zindex() < _Right->get_zindex());
|
||||
return (Left->get_zindex() < Right->get_zindex());
|
||||
});
|
||||
}
|
||||
}
|
||||
@ -3340,19 +3334,19 @@ void litehtml::html_tag::draw_stacking_context( uint_ptr hdc, int x, int y, cons
|
||||
{
|
||||
if(!is_visible()) return;
|
||||
|
||||
std::map<int, bool> zindexes;
|
||||
std::map<int, bool> z_indexes;
|
||||
if(with_positioned)
|
||||
{
|
||||
for(elements_vector::iterator i = m_positioned.begin(); i != m_positioned.end(); i++)
|
||||
for(const auto& idx : m_positioned)
|
||||
{
|
||||
zindexes[(*i)->get_zindex()];
|
||||
z_indexes[idx->get_zindex()];
|
||||
}
|
||||
|
||||
for(std::map<int, bool>::iterator idx = zindexes.begin(); idx != zindexes.end(); idx++)
|
||||
for(const auto& idx : z_indexes)
|
||||
{
|
||||
if(idx->first < 0)
|
||||
if(idx.first < 0)
|
||||
{
|
||||
draw_children(hdc, x, y, clip, draw_positioned, idx->first);
|
||||
draw_children(hdc, x, y, clip, draw_positioned, idx.first);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -3361,19 +3355,19 @@ void litehtml::html_tag::draw_stacking_context( uint_ptr hdc, int x, int y, cons
|
||||
draw_children(hdc, x, y, clip, draw_inlines, 0);
|
||||
if(with_positioned)
|
||||
{
|
||||
for(std::map<int, bool>::iterator idx = zindexes.begin(); idx != zindexes.end(); idx++)
|
||||
for(auto& z_index : z_indexes)
|
||||
{
|
||||
if(idx->first == 0)
|
||||
if(z_index.first == 0)
|
||||
{
|
||||
draw_children(hdc, x, y, clip, draw_positioned, idx->first);
|
||||
draw_children(hdc, x, y, clip, draw_positioned, z_index.first);
|
||||
}
|
||||
}
|
||||
|
||||
for(std::map<int, bool>::iterator idx = zindexes.begin(); idx != zindexes.end(); idx++)
|
||||
for(auto& z_index : z_indexes)
|
||||
{
|
||||
if(idx->first > 0)
|
||||
if(z_index.first > 0)
|
||||
{
|
||||
draw_children(hdc, x, y, clip, draw_positioned, idx->first);
|
||||
draw_children(hdc, x, y, clip, draw_positioned, z_index.first);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -3419,7 +3413,7 @@ bool litehtml::html_tag::is_nth_child(const element::ptr& el, int num, int off,
|
||||
bool litehtml::html_tag::is_nth_last_child(const element::ptr& el, int num, int off, bool of_type) const
|
||||
{
|
||||
int idx = 1;
|
||||
for(elements_vector::const_reverse_iterator child = m_children.rbegin(); child != m_children.rend(); child++)
|
||||
for(auto child = m_children.rbegin(); child != m_children.rend(); child++)
|
||||
{
|
||||
if((*child)->get_display() != display_inline_text)
|
||||
{
|
||||
@ -3448,7 +3442,7 @@ bool litehtml::html_tag::is_nth_last_child(const element::ptr& el, int num, int
|
||||
return false;
|
||||
}
|
||||
|
||||
void litehtml::html_tag::parse_nth_child_params( tstring param, int &num, int &off )
|
||||
void litehtml::html_tag::parse_nth_child_params( const tstring& param, int &num, int &off )
|
||||
{
|
||||
if(param == _t("odd"))
|
||||
{
|
||||
@ -3467,15 +3461,15 @@ void litehtml::html_tag::parse_nth_child_params( tstring param, int &num, int &o
|
||||
tstring s_off;
|
||||
|
||||
tstring s_int;
|
||||
for(string_vector::iterator tok = tokens.begin(); tok != tokens.end(); tok++)
|
||||
for(const auto& token : tokens)
|
||||
{
|
||||
if((*tok) == _t("n"))
|
||||
if(token == _t("n"))
|
||||
{
|
||||
s_num = s_int;
|
||||
s_int.clear();
|
||||
} else
|
||||
{
|
||||
s_int += (*tok);
|
||||
s_int += token;
|
||||
}
|
||||
}
|
||||
s_off = s_int;
|
||||
@ -3557,19 +3551,19 @@ litehtml::element::ptr litehtml::html_tag::find_adjacent_sibling( const element:
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
return nullptr;
|
||||
} else
|
||||
{
|
||||
ret = e;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
litehtml::element::ptr litehtml::html_tag::find_sibling(const element::ptr& el, const css_selector& selector, bool apply_pseudo /*= true*/, bool* is_pseudo /*= 0*/)
|
||||
{
|
||||
element::ptr ret = 0;
|
||||
element::ptr ret = nullptr;
|
||||
for(auto& e : m_children)
|
||||
{
|
||||
if(e->get_display() != display_inline_text)
|
||||
@ -3597,7 +3591,7 @@ litehtml::element::ptr litehtml::html_tag::find_sibling(const element::ptr& el,
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool litehtml::html_tag::is_only_child(const element::ptr& el, bool of_type) const
|
||||
@ -3626,7 +3620,7 @@ void litehtml::html_tag::update_floats(int dy, const element::ptr &parent)
|
||||
if(is_floats_holder())
|
||||
{
|
||||
bool reset_cache = false;
|
||||
for(floated_box::vector::reverse_iterator fb = m_floats_left.rbegin(); fb != m_floats_left.rend(); fb++)
|
||||
for(auto fb = m_floats_left.rbegin(); fb != m_floats_left.rend(); fb++)
|
||||
{
|
||||
if(fb->el->is_ancestor(parent))
|
||||
{
|
||||
@ -3639,7 +3633,7 @@ void litehtml::html_tag::update_floats(int dy, const element::ptr &parent)
|
||||
m_cahe_line_left.invalidate();
|
||||
}
|
||||
reset_cache = false;
|
||||
for(floated_box::vector::reverse_iterator fb = m_floats_right.rbegin(); fb != m_floats_right.rend(); fb++)
|
||||
for(auto fb = m_floats_right.rbegin(); fb != m_floats_right.rend(); fb++)
|
||||
{
|
||||
if(fb->el->is_ancestor(parent))
|
||||
{
|
||||
@ -3803,7 +3797,7 @@ void litehtml::html_tag::refresh_styles()
|
||||
|
||||
litehtml::element::ptr litehtml::html_tag::get_child_by_point(int x, int y, int client_x, int client_y, draw_flag flag, int zindex)
|
||||
{
|
||||
element::ptr ret = 0;
|
||||
element::ptr ret = nullptr;
|
||||
|
||||
if(m_overflow > overflow_visible)
|
||||
{
|
||||
@ -3817,7 +3811,7 @@ litehtml::element::ptr litehtml::html_tag::get_child_by_point(int x, int y, int
|
||||
pos.x = x - pos.x;
|
||||
pos.y = y - pos.y;
|
||||
|
||||
for(elements_vector::reverse_iterator i = m_children.rbegin(); i != m_children.rend() && !ret; i++)
|
||||
for(auto i = m_children.rbegin(); i != m_children.rend() && !ret; i++)
|
||||
{
|
||||
element::ptr el = (*i);
|
||||
|
||||
@ -3843,7 +3837,7 @@ litehtml::element::ptr litehtml::html_tag::get_child_by_point(int x, int y, int
|
||||
ret = (*i);
|
||||
}
|
||||
}
|
||||
el = 0;
|
||||
el = nullptr;
|
||||
}
|
||||
break;
|
||||
case draw_block:
|
||||
@ -3864,7 +3858,7 @@ litehtml::element::ptr litehtml::html_tag::get_child_by_point(int x, int y, int
|
||||
{
|
||||
ret = (*i);
|
||||
}
|
||||
el = 0;
|
||||
el = nullptr;
|
||||
}
|
||||
break;
|
||||
case draw_inlines:
|
||||
@ -3873,7 +3867,7 @@ litehtml::element::ptr litehtml::html_tag::get_child_by_point(int x, int y, int
|
||||
if(el->get_display() == display_inline_block)
|
||||
{
|
||||
ret = el->get_element_by_point(pos.x, pos.y, client_x, client_y);
|
||||
el = 0;
|
||||
el = nullptr;
|
||||
}
|
||||
if(!ret && (*i)->is_point_inside(pos.x, pos.y))
|
||||
{
|
||||
@ -3915,31 +3909,33 @@ litehtml::element::ptr litehtml::html_tag::get_child_by_point(int x, int y, int
|
||||
|
||||
litehtml::element::ptr litehtml::html_tag::get_element_by_point(int x, int y, int client_x, int client_y)
|
||||
{
|
||||
if(!is_visible()) return 0;
|
||||
if(!is_visible()) return nullptr;
|
||||
|
||||
element::ptr ret;
|
||||
|
||||
std::map<int, bool> zindexes;
|
||||
std::map<int, bool> z_indexes;
|
||||
|
||||
for(elements_vector::iterator i = m_positioned.begin(); i != m_positioned.end(); i++)
|
||||
for(const auto& i : m_positioned)
|
||||
{
|
||||
zindexes[(*i)->get_zindex()];
|
||||
z_indexes[i->get_zindex()];
|
||||
}
|
||||
|
||||
for(std::map<int, bool>::iterator idx = zindexes.begin(); idx != zindexes.end() && !ret; idx++)
|
||||
for(const auto& zindex : z_indexes)
|
||||
{
|
||||
if(idx->first > 0)
|
||||
if(zindex.first > 0)
|
||||
{
|
||||
ret = get_child_by_point(x, y, client_x, client_y, draw_positioned, idx->first);
|
||||
ret = get_child_by_point(x, y, client_x, client_y, draw_positioned, zindex.first);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(ret) return ret;
|
||||
|
||||
for(std::map<int, bool>::iterator idx = zindexes.begin(); idx != zindexes.end() && !ret; idx++)
|
||||
for(const auto& z_index : z_indexes)
|
||||
{
|
||||
if(idx->first == 0)
|
||||
if(z_index.first == 0)
|
||||
{
|
||||
ret = get_child_by_point(x, y, client_x, client_y, draw_positioned, idx->first);
|
||||
ret = get_child_by_point(x, y, client_x, client_y, draw_positioned, z_index.first);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(ret) return ret;
|
||||
@ -3954,11 +3950,12 @@ litehtml::element::ptr litehtml::html_tag::get_element_by_point(int x, int y, in
|
||||
if(ret) return ret;
|
||||
|
||||
|
||||
for(std::map<int, bool>::iterator idx = zindexes.begin(); idx != zindexes.end() && !ret; idx++)
|
||||
for(const auto& z_index : z_indexes)
|
||||
{
|
||||
if(idx->first < 0)
|
||||
if(z_index.first < 0)
|
||||
{
|
||||
ret = get_child_by_point(x, y, client_x, client_y, draw_positioned, idx->first);
|
||||
ret = get_child_by_point(x, y, client_x, client_y, draw_positioned, z_index.first);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(ret) return ret;
|
||||
@ -3987,7 +3984,7 @@ const litehtml::background* litehtml::html_tag::get_background(bool own_only)
|
||||
// return own background with check for empty one
|
||||
if(m_bg.m_image.empty() && !m_bg.m_color.alpha)
|
||||
{
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
return &m_bg;
|
||||
}
|
||||
@ -4006,7 +4003,7 @@ const litehtml::background* litehtml::html_tag::get_background(bool own_only)
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if(is_body())
|
||||
@ -4017,7 +4014,7 @@ const litehtml::background* litehtml::html_tag::get_background(bool own_only)
|
||||
if (!el_parent->get_background(true))
|
||||
{
|
||||
// parent of body will draw background for body
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -4101,9 +4098,9 @@ int litehtml::html_tag::render_box(int x, int y, int max_width, bool second_pass
|
||||
|
||||
bool was_space = false;
|
||||
|
||||
for (auto el : m_children)
|
||||
for (const auto& el : m_children)
|
||||
{
|
||||
// we don't need process absolute and fixed positioned element on the second pass
|
||||
// we don't need to process absolute and fixed positioned element on the second pass
|
||||
if (second_pass)
|
||||
{
|
||||
el_position = el->get_element_position();
|
||||
@ -4218,14 +4215,14 @@ int litehtml::html_tag::render_box(int x, int y, int max_width, bool second_pass
|
||||
|
||||
if (m_display == display_list_item)
|
||||
{
|
||||
const tchar_t* list_image = get_style_property(_t("list-style-image"), true, 0);
|
||||
const tchar_t* list_image = get_style_property(_t("list-style-image"), true, nullptr);
|
||||
if (list_image)
|
||||
{
|
||||
tstring url;
|
||||
css::parse_css_url(list_image, url);
|
||||
|
||||
size sz;
|
||||
const tchar_t* list_image_baseurl = get_style_property(_t("list-style-image-baseurl"), true, 0);
|
||||
const tchar_t* list_image_baseurl = get_style_property(_t("list-style-image-baseurl"), true, nullptr);
|
||||
get_document()->container()->get_image_size(url.c_str(), list_image_baseurl, sz);
|
||||
if (min_height < sz.height)
|
||||
{
|
||||
@ -4691,9 +4688,6 @@ void litehtml::html_tag::draw_children_box(uint_ptr hdc, int x, int y, const pos
|
||||
doc->container()->set_clip(pos, bdr_radius, true, true);
|
||||
}
|
||||
|
||||
position browser_wnd;
|
||||
doc->container()->get_client_rect(browser_wnd);
|
||||
|
||||
element::ptr el;
|
||||
for (auto& item : m_children)
|
||||
{
|
||||
@ -4707,6 +4701,9 @@ void litehtml::html_tag::draw_children_box(uint_ptr hdc, int x, int y, const pos
|
||||
{
|
||||
if (el->get_element_position() == element_position_fixed)
|
||||
{
|
||||
position browser_wnd;
|
||||
doc->container()->get_client_rect(browser_wnd);
|
||||
|
||||
el->draw(hdc, browser_wnd.x, browser_wnd.y, clip);
|
||||
el->draw_stacking_context(hdc, browser_wnd.x, browser_wnd.y, clip, true);
|
||||
}
|
||||
@ -4715,7 +4712,7 @@ void litehtml::html_tag::draw_children_box(uint_ptr hdc, int x, int y, const pos
|
||||
el->draw(hdc, pos.x, pos.y, clip);
|
||||
el->draw_stacking_context(hdc, pos.x, pos.y, clip, true);
|
||||
}
|
||||
el = 0;
|
||||
el = nullptr;
|
||||
}
|
||||
break;
|
||||
case draw_block:
|
||||
@ -4729,7 +4726,7 @@ void litehtml::html_tag::draw_children_box(uint_ptr hdc, int x, int y, const pos
|
||||
{
|
||||
el->draw(hdc, pos.x, pos.y, clip);
|
||||
el->draw_stacking_context(hdc, pos.x, pos.y, clip, false);
|
||||
el = 0;
|
||||
el = nullptr;
|
||||
}
|
||||
break;
|
||||
case draw_inlines:
|
||||
@ -4739,7 +4736,7 @@ void litehtml::html_tag::draw_children_box(uint_ptr hdc, int x, int y, const pos
|
||||
if (el->get_display() == display_inline_block)
|
||||
{
|
||||
el->draw_stacking_context(hdc, pos.x, pos.y, clip, false);
|
||||
el = 0;
|
||||
el = nullptr;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
@ -24,7 +24,7 @@ litehtml::element::ptr litehtml::elements_iterator::next(bool ret_parent)
|
||||
next_idx();
|
||||
} else
|
||||
{
|
||||
if( !m_select || (m_select && m_select->select(m_el->get_child(m_idx))) )
|
||||
if(!m_select || m_select->select(m_el->get_child(m_idx)))
|
||||
{
|
||||
return m_el->get_child(m_idx);
|
||||
} else
|
||||
@ -34,20 +34,19 @@ litehtml::element::ptr litehtml::elements_iterator::next(bool ret_parent)
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void litehtml::elements_iterator::next_idx()
|
||||
{
|
||||
m_idx++;
|
||||
while(m_idx >= (int) m_el->get_children_count() && m_stack.size())
|
||||
while(m_idx >= (int) m_el->get_children_count() && !m_stack.empty())
|
||||
{
|
||||
stack_item si = m_stack.back();
|
||||
m_stack.pop_back();
|
||||
m_idx = si.idx;
|
||||
m_el = si.el;
|
||||
m_idx++;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -23,21 +23,21 @@ litehtml::media_query::ptr litehtml::media_query::create_from_string(const tstri
|
||||
string_vector tokens;
|
||||
split_string(str, tokens, _t(" \t\r\n"), _t(""), _t("("));
|
||||
|
||||
for(string_vector::iterator tok = tokens.begin(); tok != tokens.end(); tok++)
|
||||
for(auto & token : tokens)
|
||||
{
|
||||
if((*tok) == _t("not"))
|
||||
if(token == _t("not"))
|
||||
{
|
||||
query->m_not = true;
|
||||
} else if(tok->at(0) == _t('('))
|
||||
} else if(token.at(0) == _t('('))
|
||||
{
|
||||
tok->erase(0, 1);
|
||||
if(tok->at(tok->length() - 1) == _t(')'))
|
||||
token.erase(0, 1);
|
||||
if(token.at(token.length() - 1) == _t(')'))
|
||||
{
|
||||
tok->erase(tok->length() - 1, 1);
|
||||
token.erase(token.length() - 1, 1);
|
||||
}
|
||||
media_query_expression expr;
|
||||
string_vector expr_tokens;
|
||||
split_string((*tok), expr_tokens, _t(":"));
|
||||
split_string(token, expr_tokens, _t(":"));
|
||||
if(!expr_tokens.empty())
|
||||
{
|
||||
trim(expr_tokens[0]);
|
||||
@ -69,10 +69,7 @@ litehtml::media_query::ptr litehtml::media_query::create_from_string(const tstri
|
||||
{
|
||||
css_length length;
|
||||
length.fromString(expr_tokens[1]);
|
||||
if(length.units() == css_units_dpcm)
|
||||
{
|
||||
expr.val = (int) (length.val() * 2.54);
|
||||
} else if(length.units() == css_units_dpi)
|
||||
if(length.units() == css_units_dpcm || length.units() == css_units_dpi)
|
||||
{
|
||||
expr.val = (int) (length.val() * 2.54);
|
||||
} else
|
||||
@ -91,7 +88,7 @@ litehtml::media_query::ptr litehtml::media_query::create_from_string(const tstri
|
||||
}
|
||||
} else
|
||||
{
|
||||
query->m_media_type = (media_type) value_index((*tok), media_type_strings, media_type_all);
|
||||
query->m_media_type = (media_type) value_index(token, media_type_strings, media_type_all);
|
||||
|
||||
}
|
||||
}
|
||||
@ -105,11 +102,12 @@ bool litehtml::media_query::check( const media_features& features ) const
|
||||
if(m_media_type == media_type_all || m_media_type == features.type)
|
||||
{
|
||||
res = true;
|
||||
for(media_query_expression::vector::const_iterator expr = m_expressions.begin(); expr != m_expressions.end() && res; expr++)
|
||||
for(auto m_expression : m_expressions)
|
||||
{
|
||||
if(!expr->check(features))
|
||||
if(!m_expression.check(features))
|
||||
{
|
||||
res = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -131,12 +129,12 @@ litehtml::media_query_list::ptr litehtml::media_query_list::create_from_string(c
|
||||
string_vector tokens;
|
||||
split_string(str, tokens, _t(","));
|
||||
|
||||
for(string_vector::iterator tok = tokens.begin(); tok != tokens.end(); tok++)
|
||||
for(auto & token : tokens)
|
||||
{
|
||||
trim(*tok);
|
||||
lcase(*tok);
|
||||
trim(token);
|
||||
lcase(token);
|
||||
|
||||
litehtml::media_query::ptr query = media_query::create_from_string(*tok, doc);
|
||||
litehtml::media_query::ptr query = media_query::create_from_string(token, doc);
|
||||
if(query)
|
||||
{
|
||||
list->m_queries.push_back(query);
|
||||
@ -144,7 +142,7 @@ litehtml::media_query_list::ptr litehtml::media_query_list::create_from_string(c
|
||||
}
|
||||
if(list->m_queries.empty())
|
||||
{
|
||||
list = 0;
|
||||
list = nullptr;
|
||||
}
|
||||
|
||||
return list;
|
||||
@ -154,11 +152,12 @@ bool litehtml::media_query_list::apply_media_features( const media_features& fea
|
||||
{
|
||||
bool apply = false;
|
||||
|
||||
for(media_query::vector::iterator iter = m_queries.begin(); iter != m_queries.end() && !apply; iter++)
|
||||
for(auto & query : m_queries)
|
||||
{
|
||||
if((*iter)->check(features))
|
||||
if(query->check(features))
|
||||
{
|
||||
apply = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1,5 +1,4 @@
|
||||
#include "num_cvt.h"
|
||||
#include "types.h"
|
||||
#include "utf8_strings.h"
|
||||
#include <vector>
|
||||
|
||||
@ -66,7 +65,7 @@ litehtml::tstring litehtml::num_cvt::to_roman_lower(int value)
|
||||
{ 10, _t("x") }, { 9, _t("ix") },
|
||||
{ 5, _t("v") }, { 4, _t("iv") },
|
||||
{ 1, _t("i") },
|
||||
{ 0, NULL } // end marker
|
||||
{ 0, nullptr } // end marker
|
||||
};
|
||||
|
||||
litehtml::tstring result;
|
||||
@ -93,7 +92,7 @@ litehtml::tstring litehtml::num_cvt::to_roman_upper(int value)
|
||||
{ 10, _t("X") }, { 9, _t("IX") },
|
||||
{ 5, _t("V") }, { 4, _t("IV") },
|
||||
{ 1, _t("I") },
|
||||
{ 0, NULL } // end marker
|
||||
{ 0, nullptr } // end marker
|
||||
};
|
||||
|
||||
litehtml::tstring result;
|
||||
|
164
src/style.cpp
164
src/style.cpp
@ -1,7 +1,5 @@
|
||||
#include "html.h"
|
||||
#include "style.h"
|
||||
#include <functional>
|
||||
#include <algorithm>
|
||||
#ifndef WINCE
|
||||
#include <locale>
|
||||
#endif
|
||||
@ -11,34 +9,25 @@ litehtml::string_map litehtml::style::m_valid_values =
|
||||
{ _t("white-space"), white_space_strings }
|
||||
};
|
||||
|
||||
litehtml::style::style()
|
||||
{
|
||||
}
|
||||
|
||||
litehtml::style::style( const style& val )
|
||||
{
|
||||
m_properties = val.m_properties;
|
||||
}
|
||||
|
||||
litehtml::style::~style()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void litehtml::style::parse( const tchar_t* txt, const tchar_t* baseurl )
|
||||
{
|
||||
std::vector<tstring> properties;
|
||||
split_string(txt, properties, _t(";"), _t(""), _t("\"'"));
|
||||
|
||||
for(std::vector<tstring>::const_iterator i = properties.begin(); i != properties.end(); i++)
|
||||
for(const auto & property : properties)
|
||||
{
|
||||
parse_property(*i, baseurl);
|
||||
parse_property(property, baseurl);
|
||||
}
|
||||
}
|
||||
|
||||
void litehtml::style::parse_property( const tstring& txt, const tchar_t* baseurl )
|
||||
{
|
||||
tstring::size_type pos = txt.find_first_of(_t(":"));
|
||||
tstring::size_type pos = txt.find_first_of(_t(':'));
|
||||
if(pos != tstring::npos)
|
||||
{
|
||||
tstring name = txt.substr(0, pos);
|
||||
@ -66,9 +55,9 @@ void litehtml::style::parse_property( const tstring& txt, const tchar_t* baseurl
|
||||
|
||||
void litehtml::style::combine( const litehtml::style& src )
|
||||
{
|
||||
for(props_map::const_iterator i = src.m_properties.begin(); i != src.m_properties.end(); i++)
|
||||
for(const auto& property : src.m_properties)
|
||||
{
|
||||
add_parsed_property(i->first.c_str(), i->second.m_value.c_str(), i->second.m_important);
|
||||
add_parsed_property(property.first, property.second.m_value, property.second.m_important);
|
||||
}
|
||||
}
|
||||
|
||||
@ -96,12 +85,12 @@ void litehtml::style::add_property( const tchar_t* name, const tchar_t* val, con
|
||||
split_string(val, tokens, _t(" "));
|
||||
if(tokens.size() == 1)
|
||||
{
|
||||
add_parsed_property(_t("-litehtml-border-spacing-x"), tokens[0].c_str(), important);
|
||||
add_parsed_property(_t("-litehtml-border-spacing-y"), tokens[0].c_str(), important);
|
||||
add_parsed_property(_t("-litehtml-border-spacing-x"), tokens[0], important);
|
||||
add_parsed_property(_t("-litehtml-border-spacing-y"), tokens[0], important);
|
||||
} else if(tokens.size() == 2)
|
||||
{
|
||||
add_parsed_property(_t("-litehtml-border-spacing-x"), tokens[0].c_str(), important);
|
||||
add_parsed_property(_t("-litehtml-border-spacing-y"), tokens[1].c_str(), important);
|
||||
add_parsed_property(_t("-litehtml-border-spacing-x"), tokens[0], important);
|
||||
add_parsed_property(_t("-litehtml-border-spacing-y"), tokens[1], important);
|
||||
}
|
||||
} else
|
||||
|
||||
@ -113,31 +102,31 @@ void litehtml::style::add_property( const tchar_t* name, const tchar_t* val, con
|
||||
split_string(val, tokens, _t(" "), _t(""), _t("("));
|
||||
int idx;
|
||||
tstring str;
|
||||
for(string_vector::const_iterator tok = tokens.begin(); tok != tokens.end(); tok++)
|
||||
for(const auto& token : tokens)
|
||||
{
|
||||
idx = value_index(tok->c_str(), border_style_strings, -1);
|
||||
idx = value_index(token, border_style_strings, -1);
|
||||
if(idx >= 0)
|
||||
{
|
||||
add_property(_t("border-left-style"), tok->c_str(), baseurl, important);
|
||||
add_property(_t("border-right-style"), tok->c_str(), baseurl, important);
|
||||
add_property(_t("border-top-style"), tok->c_str(), baseurl, important);
|
||||
add_property(_t("border-bottom-style"), tok->c_str(), baseurl, important);
|
||||
add_property(_t("border-left-style"), token.c_str(), baseurl, important);
|
||||
add_property(_t("border-right-style"), token.c_str(), baseurl, important);
|
||||
add_property(_t("border-top-style"), token.c_str(), baseurl, important);
|
||||
add_property(_t("border-bottom-style"), token.c_str(), baseurl, important);
|
||||
} else
|
||||
{
|
||||
if (t_isdigit((*tok)[0]) || (*tok)[0] == _t('.') ||
|
||||
value_in_list((*tok), _t("thin;medium;thick")))
|
||||
if (t_isdigit(token[0]) || token[0] == _t('.') ||
|
||||
value_in_list(token, _t("thin;medium;thick")))
|
||||
{
|
||||
add_property(_t("border-left-width"), tok->c_str(), baseurl, important);
|
||||
add_property(_t("border-right-width"), tok->c_str(), baseurl, important);
|
||||
add_property(_t("border-top-width"), tok->c_str(), baseurl, important);
|
||||
add_property(_t("border-bottom-width"), tok->c_str(), baseurl, important);
|
||||
add_property(_t("border-left-width"), token.c_str(), baseurl, important);
|
||||
add_property(_t("border-right-width"), token.c_str(), baseurl, important);
|
||||
add_property(_t("border-top-width"), token.c_str(), baseurl, important);
|
||||
add_property(_t("border-bottom-width"), token.c_str(), baseurl, important);
|
||||
}
|
||||
else
|
||||
{
|
||||
add_property(_t("border-left-color"), tok->c_str(), baseurl, important);
|
||||
add_property(_t("border-right-color"), tok->c_str(), baseurl, important);
|
||||
add_property(_t("border-top-color"), tok->c_str(), baseurl, important);
|
||||
add_property(_t("border-bottom-color"), tok->c_str(), baseurl, important);
|
||||
add_property(_t("border-left-color"), token.c_str(), baseurl, important);
|
||||
add_property(_t("border-right-color"), token.c_str(), baseurl, important);
|
||||
add_property(_t("border-top-color"), token.c_str(), baseurl, important);
|
||||
add_property(_t("border-bottom-color"), token.c_str(), baseurl, important);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -150,26 +139,26 @@ void litehtml::style::add_property( const tchar_t* name, const tchar_t* val, con
|
||||
split_string(val, tokens, _t(" "), _t(""), _t("("));
|
||||
int idx;
|
||||
tstring str;
|
||||
for(string_vector::const_iterator tok = tokens.begin(); tok != tokens.end(); tok++)
|
||||
for(const auto& token : tokens)
|
||||
{
|
||||
idx = value_index(tok->c_str(), border_style_strings, -1);
|
||||
idx = value_index(token, border_style_strings, -1);
|
||||
if(idx >= 0)
|
||||
{
|
||||
str = name;
|
||||
str += _t("-style");
|
||||
add_property(str.c_str(), tok->c_str(), baseurl, important);
|
||||
add_property(str.c_str(), token.c_str(), baseurl, important);
|
||||
} else
|
||||
{
|
||||
if(web_color::is_color(tok->c_str()))
|
||||
if(web_color::is_color(token.c_str()))
|
||||
{
|
||||
str = name;
|
||||
str += _t("-color");
|
||||
add_property(str.c_str(), tok->c_str(), baseurl, important);
|
||||
add_property(str.c_str(), token.c_str(), baseurl, important);
|
||||
} else
|
||||
{
|
||||
str = name;
|
||||
str += _t("-width");
|
||||
add_property(str.c_str(), tok->c_str(), baseurl, important);
|
||||
add_property(str.c_str(), token.c_str(), baseurl, important);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -319,21 +308,21 @@ void litehtml::style::add_property( const tchar_t* name, const tchar_t* val, con
|
||||
|
||||
string_vector tokens;
|
||||
split_string(val, tokens, _t(" "), _t(""), _t("("));
|
||||
for(string_vector::iterator tok = tokens.begin(); tok != tokens.end(); tok++)
|
||||
for(const auto& token : tokens)
|
||||
{
|
||||
int idx = value_index(tok->c_str(), list_style_type_strings, -1);
|
||||
int idx = value_index(token, list_style_type_strings, -1);
|
||||
if(idx >= 0)
|
||||
{
|
||||
add_parsed_property(_t("list-style-type"), *tok, important);
|
||||
add_parsed_property(_t("list-style-type"), token, important);
|
||||
} else
|
||||
{
|
||||
idx = value_index(tok->c_str(), list_style_position_strings, -1);
|
||||
idx = value_index(token, list_style_position_strings, -1);
|
||||
if(idx >= 0)
|
||||
{
|
||||
add_parsed_property(_t("list-style-position"), *tok, important);
|
||||
add_parsed_property(_t("list-style-position"), token, important);
|
||||
} else if(!t_strncmp(val, _t("url"), 3))
|
||||
{
|
||||
add_parsed_property(_t("list-style-image"), *tok, important);
|
||||
add_parsed_property(_t("list-style-image"), token, important);
|
||||
if(baseurl)
|
||||
{
|
||||
add_parsed_property(_t("list-style-image-baseurl"), baseurl, important);
|
||||
@ -460,7 +449,7 @@ void litehtml::style::parse_short_border( const tstring& prefix, const tstring&
|
||||
add_parsed_property(prefix + _t("-color"), tokens[2], important);
|
||||
} else if(tokens.size() == 2)
|
||||
{
|
||||
if(iswdigit(tokens[0][0]) || value_index(val.c_str(), border_width_strings) >= 0)
|
||||
if(iswdigit(tokens[0][0]) || value_index(val, border_width_strings) >= 0)
|
||||
{
|
||||
add_parsed_property(prefix + _t("-width"), tokens[0], important);
|
||||
add_parsed_property(prefix + _t("-style"), tokens[1], important);
|
||||
@ -490,48 +479,48 @@ void litehtml::style::parse_short_background( const tstring& val, const tchar_t*
|
||||
string_vector tokens;
|
||||
split_string(val, tokens, _t(" "), _t(""), _t("("));
|
||||
bool origin_found = false;
|
||||
for(string_vector::iterator tok = tokens.begin(); tok != tokens.end(); tok++)
|
||||
for(const auto& token : tokens)
|
||||
{
|
||||
if(tok->substr(0, 3) == _t("url"))
|
||||
if(token.substr(0, 3) == _t("url"))
|
||||
{
|
||||
add_parsed_property(_t("background-image"), *tok, important);
|
||||
add_parsed_property(_t("background-image"), token, important);
|
||||
if(baseurl)
|
||||
{
|
||||
add_parsed_property(_t("background-image-baseurl"), baseurl, important);
|
||||
}
|
||||
|
||||
} else if( value_in_list(tok->c_str(), background_repeat_strings) )
|
||||
} else if( value_in_list(token, background_repeat_strings) )
|
||||
{
|
||||
add_parsed_property(_t("background-repeat"), *tok, important);
|
||||
} else if( value_in_list(tok->c_str(), background_attachment_strings) )
|
||||
add_parsed_property(_t("background-repeat"), token, important);
|
||||
} else if( value_in_list(token, background_attachment_strings) )
|
||||
{
|
||||
add_parsed_property(_t("background-attachment"), *tok, important);
|
||||
} else if( value_in_list(tok->c_str(), background_box_strings) )
|
||||
add_parsed_property(_t("background-attachment"), token, important);
|
||||
} else if( value_in_list(token, background_box_strings) )
|
||||
{
|
||||
if(!origin_found)
|
||||
{
|
||||
add_parsed_property(_t("background-origin"), *tok, important);
|
||||
add_parsed_property(_t("background-origin"), token, important);
|
||||
origin_found = true;
|
||||
} else
|
||||
{
|
||||
add_parsed_property(_t("background-clip"),*tok, important);
|
||||
add_parsed_property(_t("background-clip"), token, important);
|
||||
}
|
||||
} else if( value_in_list(tok->c_str(), _t("left;right;top;bottom;center")) ||
|
||||
iswdigit((*tok)[0]) ||
|
||||
(*tok)[0] == _t('-') ||
|
||||
(*tok)[0] == _t('.') ||
|
||||
(*tok)[0] == _t('+'))
|
||||
} else if( value_in_list(token, _t("left;right;top;bottom;center")) ||
|
||||
iswdigit(token[0]) ||
|
||||
token[0] == _t('-') ||
|
||||
token[0] == _t('.') ||
|
||||
token[0] == _t('+'))
|
||||
{
|
||||
if(m_properties.find(_t("background-position")) != m_properties.end())
|
||||
{
|
||||
m_properties[_t("background-position")].m_value = m_properties[_t("background-position")].m_value + _t(" ") + *tok;
|
||||
m_properties[_t("background-position")].m_value = m_properties[_t("background-position")].m_value + _t(" ") + token;
|
||||
} else
|
||||
{
|
||||
add_parsed_property(_t("background-position"), *tok, important);
|
||||
add_parsed_property(_t("background-position"), token, important);
|
||||
}
|
||||
} else if (web_color::is_color(tok->c_str()))
|
||||
} else if (web_color::is_color(token.c_str()))
|
||||
{
|
||||
add_parsed_property(_t("background-color"), *tok, important);
|
||||
add_parsed_property(_t("background-color"), token, important);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -547,40 +536,39 @@ void litehtml::style::parse_short_font( const tstring& val, bool important )
|
||||
string_vector tokens;
|
||||
split_string(val, tokens, _t(" "), _t(""), _t("\""));
|
||||
|
||||
int idx = 0;
|
||||
bool was_normal = false;
|
||||
int idx;
|
||||
bool is_family = false;
|
||||
tstring font_family;
|
||||
for(string_vector::iterator tok = tokens.begin(); tok != tokens.end(); tok++)
|
||||
for(const auto& token : tokens)
|
||||
{
|
||||
idx = value_index(tok->c_str(), font_style_strings);
|
||||
idx = value_index(token, font_style_strings);
|
||||
if(!is_family)
|
||||
{
|
||||
if(idx >= 0)
|
||||
{
|
||||
if(idx == 0 && !was_normal)
|
||||
if(idx == 0)
|
||||
{
|
||||
add_parsed_property(_t("font-weight"), *tok, important);
|
||||
add_parsed_property(_t("font-variant"), *tok, important);
|
||||
add_parsed_property(_t("font-style"), *tok, important);
|
||||
add_parsed_property(_t("font-weight"), token, important);
|
||||
add_parsed_property(_t("font-variant"), token, important);
|
||||
add_parsed_property(_t("font-style"), token, important);
|
||||
} else
|
||||
{
|
||||
add_parsed_property(_t("font-style"), *tok, important);
|
||||
add_parsed_property(_t("font-style"), token, important);
|
||||
}
|
||||
} else
|
||||
{
|
||||
if(value_in_list(tok->c_str(), font_weight_strings))
|
||||
if(value_in_list(token, font_weight_strings))
|
||||
{
|
||||
add_parsed_property(_t("font-weight"), *tok, important);
|
||||
add_parsed_property(_t("font-weight"), token, important);
|
||||
} else
|
||||
{
|
||||
if(value_in_list(tok->c_str(), font_variant_strings))
|
||||
if(value_in_list(token, font_variant_strings))
|
||||
{
|
||||
add_parsed_property(_t("font-variant"), *tok, important);
|
||||
} else if( iswdigit((*tok)[0]) )
|
||||
add_parsed_property(_t("font-variant"), token, important);
|
||||
} else if( iswdigit(token[0]) )
|
||||
{
|
||||
string_vector szlh;
|
||||
split_string(*tok, szlh, _t("/"));
|
||||
split_string(token, szlh, _t("/"));
|
||||
|
||||
if(szlh.size() == 1)
|
||||
{
|
||||
@ -593,13 +581,13 @@ void litehtml::style::parse_short_font( const tstring& val, bool important )
|
||||
} else
|
||||
{
|
||||
is_family = true;
|
||||
font_family += *tok;
|
||||
font_family += token;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else
|
||||
{
|
||||
font_family += *tok;
|
||||
font_family += token;
|
||||
}
|
||||
}
|
||||
add_parsed_property(_t("font-family"), font_family, important);
|
||||
@ -608,7 +596,7 @@ void litehtml::style::parse_short_font( const tstring& val, bool important )
|
||||
void litehtml::style::add_parsed_property( const tstring& name, const tstring& val, bool important )
|
||||
{
|
||||
bool is_valid = true;
|
||||
string_map::iterator vals = m_valid_values.find(name);
|
||||
auto vals = m_valid_values.find(name);
|
||||
if (vals != m_valid_values.end())
|
||||
{
|
||||
if (!value_in_list(val, vals->second))
|
||||
@ -619,7 +607,7 @@ void litehtml::style::add_parsed_property( const tstring& name, const tstring& v
|
||||
|
||||
if (is_valid)
|
||||
{
|
||||
props_map::iterator prop = m_properties.find(name);
|
||||
auto prop = m_properties.find(name);
|
||||
if (prop != m_properties.end())
|
||||
{
|
||||
if (!prop->second.m_important || (important && prop->second.m_important))
|
||||
@ -637,7 +625,7 @@ void litehtml::style::add_parsed_property( const tstring& name, const tstring& v
|
||||
|
||||
void litehtml::style::remove_property( const tstring& name, bool important )
|
||||
{
|
||||
props_map::iterator prop = m_properties.find(name);
|
||||
auto prop = m_properties.find(name);
|
||||
if(prop != m_properties.end())
|
||||
{
|
||||
if( !prop->second.m_important || (important && prop->second.m_important) )
|
||||
|
@ -47,8 +47,8 @@ void litehtml::css::parse_stylesheet(const tchar_t* str, const tchar_t* baseurl,
|
||||
break;
|
||||
}
|
||||
|
||||
tstring::size_type style_start = text.find(_t("{"), pos);
|
||||
tstring::size_type style_end = text.find(_t("}"), pos);
|
||||
tstring::size_type style_start = text.find(_t('{'), pos);
|
||||
tstring::size_type style_end = text.find(_t('}'), pos);
|
||||
if(style_start != tstring::npos && style_end != tstring::npos)
|
||||
{
|
||||
style::ptr st = std::make_shared<style>();
|
||||
@ -108,15 +108,15 @@ bool litehtml::css::parse_selectors( const tstring& txt, const litehtml::style::
|
||||
|
||||
bool added_something = false;
|
||||
|
||||
for(string_vector::iterator tok = tokens.begin(); tok != tokens.end(); tok++)
|
||||
for(auto & token : tokens)
|
||||
{
|
||||
css_selector::ptr selector = std::make_shared<css_selector>(media);
|
||||
selector->m_style = styles;
|
||||
trim(*tok);
|
||||
if(selector->parse(*tok))
|
||||
css_selector::ptr new_selector = std::make_shared<css_selector>(media);
|
||||
new_selector->m_style = styles;
|
||||
trim(token);
|
||||
if(new_selector->parse(token))
|
||||
{
|
||||
selector->calc_specificity();
|
||||
add_selector(selector);
|
||||
new_selector->calc_specificity();
|
||||
add_selector(new_selector);
|
||||
added_something = true;
|
||||
}
|
||||
}
|
||||
@ -175,7 +175,7 @@ void litehtml::css::parse_atrule(const tstring& text, const tchar_t* baseurl, co
|
||||
if(!tokens.empty())
|
||||
{
|
||||
tstring media_str;
|
||||
for(string_vector::iterator iter = tokens.begin(); iter != tokens.end(); iter++)
|
||||
for(auto iter = tokens.begin(); iter != tokens.end(); iter++)
|
||||
{
|
||||
if(iter != tokens.begin())
|
||||
{
|
||||
|
@ -56,16 +56,16 @@ void litehtml::table_grid::finish()
|
||||
{
|
||||
m_rows_count = (int) m_cells.size();
|
||||
m_cols_count = 0;
|
||||
for(int i = 0; i < (int) m_cells.size(); i++)
|
||||
for(auto& cell : m_cells)
|
||||
{
|
||||
m_cols_count = std::max(m_cols_count, (int) m_cells[i].size());
|
||||
m_cols_count = std::max(m_cols_count, (int) cell.size());
|
||||
}
|
||||
for(int i = 0; i < (int) m_cells.size(); i++)
|
||||
for(auto& cell : m_cells)
|
||||
{
|
||||
for(int j = (int) m_cells[i].size(); j < m_cols_count; j++)
|
||||
for(int j = (int) cell.size(); j < m_cols_count; j++)
|
||||
{
|
||||
table_cell empty_cell;
|
||||
m_cells[i].push_back(empty_cell);
|
||||
cell.push_back(empty_cell);
|
||||
}
|
||||
}
|
||||
|
||||
@ -143,7 +143,7 @@ litehtml::table_cell* litehtml::table_grid::cell( int t_col, int t_row )
|
||||
{
|
||||
return &m_cells[t_row][t_col];
|
||||
}
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void litehtml::table_grid::distribute_max_width( int width, int start, int end )
|
||||
@ -243,25 +243,25 @@ void litehtml::table_grid::distribute_width( int width, int start, int end )
|
||||
if(!distribute_columns.empty() || step == 2)
|
||||
{
|
||||
int cols_width = 0;
|
||||
for(std::vector<table_column*>::iterator col = distribute_columns.begin(); col != distribute_columns.end(); col++)
|
||||
for(const auto& column : distribute_columns)
|
||||
{
|
||||
cols_width += (*col)->max_width - (*col)->min_width;
|
||||
cols_width += column->max_width - column->min_width;
|
||||
}
|
||||
|
||||
if(cols_width)
|
||||
{
|
||||
int add = width / (int) distribute_columns.size();
|
||||
for(std::vector<table_column*>::iterator col = distribute_columns.begin(); col != distribute_columns.end(); col++)
|
||||
for(const auto& column : distribute_columns)
|
||||
{
|
||||
add = round_f( (float) width * ((float) ((*col)->max_width - (*col)->min_width) / (float) cols_width) );
|
||||
if((*col)->width + add >= (*col)->min_width)
|
||||
add = round_f( (float) width * ((float) (column->max_width - column->min_width) / (float) cols_width) );
|
||||
if(column->width + add >= column->min_width)
|
||||
{
|
||||
(*col)->width += add;
|
||||
column->width += add;
|
||||
added_width += add;
|
||||
} else
|
||||
{
|
||||
added_width += ((*col)->width - (*col)->min_width) * (add / abs(add));
|
||||
(*col)->width = (*col)->min_width;
|
||||
added_width += (column->width - column->min_width) * (add / abs(add));
|
||||
column->width = column->min_width;
|
||||
}
|
||||
}
|
||||
if(added_width < width && step)
|
||||
@ -359,7 +359,7 @@ int litehtml::table_grid::calc_table_width(int block_width, bool is_auto, int& m
|
||||
fixed_width += m_columns[col].width;
|
||||
}
|
||||
}
|
||||
float scale = (float) (100.0 / percent);
|
||||
auto scale = (float) (100.0 / percent);
|
||||
cur_width = 0;
|
||||
for(int col = 0; col < m_cols_count; col++)
|
||||
{
|
||||
|
@ -62,8 +62,8 @@ tstring url_path_append(const tstring& base, const tstring& path)
|
||||
|
||||
// Only append a separator if both base and path are not empty and if the
|
||||
// last character of base is not already a separator.
|
||||
if (result.size() > 0 && path.size() > 0 && result.back() != _t('/')) {
|
||||
result.append(1, '/');
|
||||
if (!result.empty() && !path.empty() && result.back() != _t('/')) {
|
||||
result.append(1, _t('/'));
|
||||
}
|
||||
|
||||
result.append(path);
|
||||
|
@ -1,6 +1,6 @@
|
||||
#include "html.h"
|
||||
#include "web_color.h"
|
||||
#include <string.h>
|
||||
#include <cstring>
|
||||
|
||||
litehtml::def_color litehtml::g_def_colors[] =
|
||||
{
|
||||
@ -150,7 +150,7 @@ litehtml::def_color litehtml::g_def_colors[] =
|
||||
{_t("WhiteSmoke"),_t("#F5F5F5")},
|
||||
{_t("Yellow"),_t("#FFFF00")},
|
||||
{_t("YellowGreen"),_t("#9ACD32")},
|
||||
{0,0}
|
||||
{nullptr,nullptr}
|
||||
};
|
||||
|
||||
|
||||
@ -162,9 +162,9 @@ litehtml::web_color litehtml::web_color::from_string(const tchar_t* str, litehtm
|
||||
}
|
||||
if(str[0] == _t('#'))
|
||||
{
|
||||
tstring red = _t("");
|
||||
tstring green = _t("");
|
||||
tstring blue = _t("");
|
||||
tstring red;
|
||||
tstring green;
|
||||
tstring blue;
|
||||
if(t_strlen(str + 1) == 3)
|
||||
{
|
||||
red += str[1];
|
||||
@ -182,7 +182,7 @@ litehtml::web_color litehtml::web_color::from_string(const tchar_t* str, litehtm
|
||||
blue += str[5];
|
||||
blue += str[6];
|
||||
}
|
||||
tchar_t* sss = 0;
|
||||
tchar_t* sss = nullptr;
|
||||
web_color clr;
|
||||
clr.red = (byte) t_strtol(red.c_str(), &sss, 16);
|
||||
clr.green = (byte) t_strtol(green.c_str(), &sss, 16);
|
||||
@ -192,12 +192,12 @@ litehtml::web_color litehtml::web_color::from_string(const tchar_t* str, litehtm
|
||||
{
|
||||
tstring s = str;
|
||||
|
||||
tstring::size_type pos = s.find_first_of(_t("("));
|
||||
tstring::size_type pos = s.find_first_of(_t('('));
|
||||
if(pos != tstring::npos)
|
||||
{
|
||||
s.erase(s.begin(), s.begin() + pos + 1);
|
||||
}
|
||||
pos = s.find_last_of(_t(")"));
|
||||
pos = s.find_last_of(_t(')'));
|
||||
if(pos != tstring::npos)
|
||||
{
|
||||
s.erase(s.begin() + pos, s.end());
|
||||
@ -211,7 +211,7 @@ litehtml::web_color litehtml::web_color::from_string(const tchar_t* str, litehtm
|
||||
if(tokens.size() >= 1) clr.red = (byte) t_atoi(tokens[0].c_str());
|
||||
if(tokens.size() >= 2) clr.green = (byte) t_atoi(tokens[1].c_str());
|
||||
if(tokens.size() >= 3) clr.blue = (byte) t_atoi(tokens[2].c_str());
|
||||
if(tokens.size() >= 4) clr.alpha = (byte) (t_strtod(tokens[3].c_str(), 0) * 255.0);
|
||||
if(tokens.size() >= 4) clr.alpha = (byte) (t_strtod(tokens[3].c_str(), nullptr) * 255.0);
|
||||
|
||||
return clr;
|
||||
} else
|
||||
|
Loading…
Reference in New Issue
Block a user