Refactoring

This commit is contained in:
Yuri Kobets 2021-11-11 00:12:38 +03:00
parent 5193a0af5c
commit 6617ab7188
74 changed files with 731 additions and 906 deletions

View File

@ -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);
};
}

View File

@ -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;

View File

@ -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;
};
}

View File

@ -12,10 +12,7 @@ namespace litehtml
css_length top;
css_length bottom;
css_margins()
{
}
css_margins() = default;
css_margins(const css_margins& val)
{

View File

@ -12,10 +12,7 @@ namespace litehtml
css_length right;
css_length bottom;
css_offsets()
{
}
css_offsets() = default;
css_offsets(const css_offsets& val)
{

View File

@ -12,10 +12,7 @@ namespace litehtml
css_length width;
css_length height;
css_position()
{
}
css_position() = default;
css_position(const css_position& val)
{

View File

@ -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;

View File

@ -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);

View File

@ -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;
};
}

View File

@ -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;
};
}

View File

@ -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)
{
}

View File

@ -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;
};
}

View File

@ -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;
};
}

View File

@ -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;
};
}

View File

@ -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;
};
}

View File

@ -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;
};
}

View File

@ -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;
};
}

View File

@ -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;

View File

@ -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;
};
}

View File

@ -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;
};
}

View File

@ -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;
};
}

View File

@ -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;
};
}

View File

@ -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;
};
}

View File

@ -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;
};
}

View File

@ -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;
};
}

View File

@ -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;
};
}

View File

@ -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;
};
}

View File

@ -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;
};
}

View File

@ -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;
}

View File

@ -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;

View File

@ -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();
};
/************************************************************************/

View File

@ -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);

View File

@ -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);

View File

@ -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);

View File

@ -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;

View File

@ -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
{

View File

@ -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;
}

View File

@ -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;
}
}
}

View File

@ -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();
}

View File

@ -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

View File

@ -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++;

View File

@ -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);

View File

@ -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"));

View File

@ -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")));

View File

@ -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

View File

@ -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;

View File

@ -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;

View File

@ -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;

View File

@ -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;

View File

@ -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"));

View File

@ -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;
}
}

View File

@ -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);
}
}
}

View File

@ -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)

View File

@ -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;

View File

@ -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();

View File

@ -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

View File

@ -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();

View File

@ -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)

View File

@ -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();

View File

@ -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();
}

View File

@ -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 {};
}

View File

@ -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;

View File

@ -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();
}

View File

@ -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)

View File

@ -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));

View File

@ -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;

View File

@ -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;
}
}

View File

@ -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;
}
}

View File

@ -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;

View File

@ -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) )

View File

@ -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())
{

View File

@ -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++)
{

View File

@ -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);

View File

@ -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