ZaStoGram_desktop/Telegram/SourceFiles/tgw/tgw_cursor.cpp

561 lines
14 KiB
C++

/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.
For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#include "tgw/tgw_cursor.h"
#include "core/src/computed_style.h"
#include "core/src/renderer.h"
#include "twidget/gesture_policy.h"
#include <litehtml.h>
namespace Tgw {
namespace {
using Elements = std::unordered_map<int64, std::shared_ptr<litehtml::element>>;
using Chain = std::vector<std::shared_ptr<litehtml::element>>;
constexpr auto kFontHandle = litehtml::uint_ptr(1);
constexpr auto kDefaultFontSize = 16;
constexpr auto kDefaultFontName = "-apple-system, system-ui, sans-serif";
constexpr auto kLanguage = "en";
constexpr auto kCssDpi = 96.f;
constexpr auto kPointsPerInch = 72.f;
constexpr auto kColorBits = 8;
constexpr auto kColorIndex = 256;
constexpr auto kPointerCursor = "pointer";
constexpr auto kIdAttribute = "data-twid";
constexpr auto kIdSelector = "[data-twid]";
constexpr auto kSerializedId = std::string_view(" data-twid=\"");
constexpr auto kRawTextTag = std::string_view("style");
constexpr auto kVoidTags = std::array<std::string_view, 14>{
"area",
"base",
"br",
"col",
"embed",
"hr",
"img",
"input",
"link",
"meta",
"param",
"source",
"track",
"wbr",
};
[[nodiscard]] std::shared_ptr<litehtml::element> Lookup(
const Elements &elements,
int64 id) {
const auto i = elements.find(id);
return (i != end(elements)) ? i->second : nullptr;
}
[[nodiscard]] bool MarkChain(
std::shared_ptr<litehtml::element> element,
litehtml::string_id pseudo,
bool add) {
auto result = false;
while (element) {
result = element->set_pseudo_class(pseudo, add) || result;
element = element->parent();
}
return result;
}
[[nodiscard]] bool Retarget(
const Elements &elements,
int64 &applied,
int64 wanted,
litehtml::string_id pseudo) {
if (applied == wanted) {
return false;
}
const auto cleared = MarkChain(Lookup(elements, applied), pseudo, false);
const auto marked = MarkChain(Lookup(elements, wanted), pseudo, true);
applied = wanted;
return cleared || marked;
}
[[nodiscard]] Chain ChainOf(std::shared_ptr<litehtml::element> element) {
auto result = Chain();
while (element) {
result.push_back(element);
element = element->parent();
}
return result;
}
// The core's own parents, as it nests them: a parse may move elements.
[[nodiscard]] std::vector<int64> ShadowChain(
const std::string &html,
int64 id) {
auto open = std::vector<int64>();
for (auto at = html.find('<'); at != std::string::npos;) {
const auto tag = std::string_view(html).substr(at + 1);
if (tag.starts_with('/')) {
if (!open.empty()) {
open.pop_back();
}
} else if (!tag.starts_with('!')) {
const auto name = tag.substr(0, tag.find_first_of(" >"));
const auto attributes = tag.substr(name.size());
const auto own = attributes.starts_with(kSerializedId)
? int64(std::strtoll(
attributes.data() + kSerializedId.size(),
nullptr,
10))
: int64(0);
if (!id || own == id) {
auto result = std::vector<int64>{ own };
result.insert(end(result), rbegin(open), rend(open));
return result;
} else if (!ranges::contains(kVoidTags, name)) {
open.push_back(own);
}
if (name == kRawTextTag) {
at = html.find("</", at);
continue;
}
}
at = html.find('<', at + 1);
}
return {};
}
[[nodiscard]] bool Reconcile(
const Elements &elements,
const Chain &marked,
int64 &applied,
litehtml::string_id pseudo) {
if (ChainOf(Lookup(elements, applied)) == marked) {
return false;
}
applied = 0;
auto result = false;
for (const auto &element : marked) {
result = element->set_pseudo_class(pseudo, false) || result;
}
return result;
}
} // namespace
class CursorStyles::Container final : public litehtml::document_container {
public:
explicit Container(double dpr);
void resize(double width, int height);
litehtml::uint_ptr create_font(
const litehtml::font_description &descr,
const litehtml::document *doc,
litehtml::font_metrics *fm) override;
void delete_font(litehtml::uint_ptr font) override;
litehtml::pixel_t text_width(
const char *text,
litehtml::uint_ptr font) override;
void draw_text(
litehtml::uint_ptr hdc,
const char *text,
litehtml::uint_ptr font,
litehtml::web_color color,
const litehtml::position &pos) override;
litehtml::pixel_t pt_to_px(float pt) const override;
litehtml::pixel_t get_default_font_size() const override;
const char *get_default_font_name() const override;
void draw_list_marker(
litehtml::uint_ptr hdc,
const litehtml::list_marker &marker) override;
void load_image(
const char *src,
const char *baseurl,
bool redraw_on_ready) override;
void get_image_size(
const char *src,
const char *baseurl,
litehtml::size &sz) override;
void draw_image(
litehtml::uint_ptr hdc,
const litehtml::background_layer &layer,
const std::string &url,
const std::string &base_url) override;
void draw_solid_fill(
litehtml::uint_ptr hdc,
const litehtml::background_layer &layer,
const litehtml::web_color &color) override;
void draw_linear_gradient(
litehtml::uint_ptr hdc,
const litehtml::background_layer &layer,
const litehtml::background_layer::linear_gradient &gradient) override;
void draw_radial_gradient(
litehtml::uint_ptr hdc,
const litehtml::background_layer &layer,
const litehtml::background_layer::radial_gradient &gradient) override;
void draw_conic_gradient(
litehtml::uint_ptr hdc,
const litehtml::background_layer &layer,
const litehtml::background_layer::conic_gradient &gradient) override;
void draw_borders(
litehtml::uint_ptr hdc,
const litehtml::borders &borders,
const litehtml::position &draw_pos,
bool root) override;
void set_caption(const char *caption) override;
void set_base_url(const char *base_url) override;
void link(
const std::shared_ptr<litehtml::document> &doc,
const litehtml::element::ptr &el) override;
void on_anchor_click(
const char *url,
const litehtml::element::ptr &el) override;
void on_mouse_event(
const litehtml::element::ptr &el,
litehtml::mouse_event event) override;
void set_cursor(const char *cursor) override;
void transform_text(
std::string &text,
litehtml::text_transform tt) override;
void import_css(
std::string &text,
const std::string &url,
std::string &baseurl) override;
void set_clip(
const litehtml::position &pos,
const litehtml::border_radiuses &radiuses) override;
void del_clip() override;
void get_viewport(litehtml::position &viewport) const override;
litehtml::element::ptr create_element(
const char *tag_name,
const litehtml::string_map &attributes,
const std::shared_ptr<litehtml::document> &doc) override;
void get_media_features(litehtml::media_features &media) const override;
void get_language(
std::string &language,
std::string &culture) const override;
private:
const double _dpr = 1.;
double _width = 0.;
int _height = 0;
};
CursorStyles::Container::Container(double dpr)
: _dpr(dpr) {
}
void CursorStyles::Container::resize(double width, int height) {
_width = width;
_height = height;
}
litehtml::uint_ptr CursorStyles::Container::create_font(
const litehtml::font_description &descr,
const litehtml::document*,
litehtml::font_metrics *fm) {
if (fm) {
const auto size = descr.size.value();
fm->font_size = descr.size;
fm->height = fm->ascent = litehtml::pixel_t(size);
fm->descent = litehtml::pixel_t(0.f);
fm->x_height = fm->ch_width = litehtml::pixel_t(size / 2.f);
}
return kFontHandle;
}
void CursorStyles::Container::delete_font(litehtml::uint_ptr) {
}
litehtml::pixel_t CursorStyles::Container::text_width(
const char*,
litehtml::uint_ptr) {
return litehtml::pixel_t(0.f);
}
void CursorStyles::Container::draw_text(
litehtml::uint_ptr,
const char*,
litehtml::uint_ptr,
litehtml::web_color,
const litehtml::position&) {
}
litehtml::pixel_t CursorStyles::Container::pt_to_px(float pt) const {
return litehtml::pixel_t(pt * kCssDpi / kPointsPerInch);
}
litehtml::pixel_t CursorStyles::Container::get_default_font_size() const {
return litehtml::pixel_t(kDefaultFontSize);
}
const char *CursorStyles::Container::get_default_font_name() const {
return kDefaultFontName;
}
void CursorStyles::Container::draw_list_marker(
litehtml::uint_ptr,
const litehtml::list_marker&) {
}
void CursorStyles::Container::load_image(const char*, const char*, bool) {
}
void CursorStyles::Container::get_image_size(
const char*,
const char*,
litehtml::size &sz) {
sz = litehtml::size();
}
void CursorStyles::Container::draw_image(
litehtml::uint_ptr,
const litehtml::background_layer&,
const std::string&,
const std::string&) {
}
void CursorStyles::Container::draw_solid_fill(
litehtml::uint_ptr,
const litehtml::background_layer&,
const litehtml::web_color&) {
}
void CursorStyles::Container::draw_linear_gradient(
litehtml::uint_ptr,
const litehtml::background_layer&,
const litehtml::background_layer::linear_gradient&) {
}
void CursorStyles::Container::draw_radial_gradient(
litehtml::uint_ptr,
const litehtml::background_layer&,
const litehtml::background_layer::radial_gradient&) {
}
void CursorStyles::Container::draw_conic_gradient(
litehtml::uint_ptr,
const litehtml::background_layer&,
const litehtml::background_layer::conic_gradient&) {
}
void CursorStyles::Container::draw_borders(
litehtml::uint_ptr,
const litehtml::borders&,
const litehtml::position&,
bool) {
}
void CursorStyles::Container::set_caption(const char*) {
}
void CursorStyles::Container::set_base_url(const char*) {
}
void CursorStyles::Container::link(
const std::shared_ptr<litehtml::document>&,
const litehtml::element::ptr&) {
}
void CursorStyles::Container::on_anchor_click(
const char*,
const litehtml::element::ptr&) {
}
void CursorStyles::Container::on_mouse_event(
const litehtml::element::ptr&,
litehtml::mouse_event) {
}
void CursorStyles::Container::set_cursor(const char*) {
}
void CursorStyles::Container::transform_text(
std::string&,
litehtml::text_transform) {
}
void CursorStyles::Container::import_css(
std::string &text,
const std::string&,
std::string&) {
text.clear();
}
void CursorStyles::Container::set_clip(
const litehtml::position&,
const litehtml::border_radiuses&) {
}
void CursorStyles::Container::del_clip() {
}
void CursorStyles::Container::get_viewport(
litehtml::position &viewport) const {
viewport.x = viewport.y = litehtml::pixel_t(0.f);
viewport.width = litehtml::pixel_t(float(_width));
viewport.height = litehtml::pixel_t(float(_height));
}
litehtml::element::ptr CursorStyles::Container::create_element(
const char*,
const litehtml::string_map&,
const std::shared_ptr<litehtml::document>&) {
return nullptr;
}
void CursorStyles::Container::get_media_features(
litehtml::media_features &media) const {
media.type = litehtml::media_type_screen;
media.width = litehtml::pixel_t(float(_width));
media.height = litehtml::pixel_t(float(_height));
media.device_width = media.width;
media.device_height = media.height;
media.color = kColorBits;
media.color_index = kColorIndex;
media.monochrome = 0;
media.resolution = litehtml::pixel_t(float(kCssDpi * _dpr));
}
void CursorStyles::Container::get_language(
std::string &language,
std::string &culture) const {
language = kLanguage;
culture.clear();
}
CursorStyles::CursorStyles(double dpr)
: _container(std::make_unique<Container>(dpr)) {
}
CursorStyles::~CursorStyles() {
_elements.clear();
_document = nullptr;
}
bool CursorStyles::pointer(
twlite::Renderer &renderer,
int64 hit,
int64 hover,
int64 active) {
sync(renderer, hover, active);
const auto element = Lookup(_elements, hit);
return element && (element->css().get_cursor() == kPointerCursor);
}
std::optional<bool> CursorStyles::hold(
twlite::Renderer &renderer,
int64 hit,
int64 hover) {
sync(renderer, hover, 0);
const auto chain = ShadowChain(_html, hit);
if (chain.empty() || (hit && !_elements.contains(hit))) {
return std::nullopt;
}
auto values = std::vector<std::string>();
for (const auto id : chain) {
if (const auto element = Lookup(_elements, id)) {
values.push_back(twlite::computed_touch_action(element));
}
}
return twidget::gesture::claimOf(values).hold;
}
void CursorStyles::sync(
twlite::Renderer &renderer,
int64 hover,
int64 active) {
const auto reconciled = refresh(renderer);
const auto hoverChanged = Retarget(
_elements,
_hover,
hover,
litehtml::_hover_);
const auto activeChanged = Retarget(
_elements,
_active,
active,
litehtml::_active_);
if (reconciled || hoverChanged || activeChanged) {
const auto ignore = [](const litehtml::position&) {};
_document->root()->find_styles_changes(ignore);
}
}
bool CursorStyles::refresh(twlite::Renderer &renderer) {
const auto builds = renderer.stats().builds;
if (_document && _builds == builds) {
return false;
}
_builds = builds;
const auto &html = renderer.last_html();
const auto &master = renderer.master_css();
const auto width = renderer.width();
const auto height = renderer.viewport_height();
const auto same = (_master == master)
&& (_width == width)
&& (_height == height);
if (_document && same && (_html == html)) {
return false;
}
_html = html;
if (_document && same) {
const auto hover = ChainOf(Lookup(_elements, _hover));
const auto active = ChainOf(Lookup(_elements, _active));
auto changed = false;
if (_document->update_from_string(_html, &changed)) {
if (!changed || _document->last_patch_paint_only()) {
return false;
}
index();
const auto hoverCleared = Reconcile(
_elements,
hover,
_hover,
litehtml::_hover_);
const auto activeCleared = Reconcile(
_elements,
active,
_active,
litehtml::_active_);
return hoverCleared || activeCleared;
}
}
_master = master;
rebuild(width, height);
return false;
}
void CursorStyles::rebuild(double width, int height) {
_hover = _active = 0;
_elements.clear();
_document = nullptr;
_width = width;
_height = height;
_container->resize(width, height);
_document = litehtml::document::createUpdatableFromString(
_html,
_container.get(),
_master);
index();
}
void CursorStyles::index() {
_elements.clear();
const auto root = _document->root();
if (!root) {
return;
}
for (const auto &element : root->select_all(kIdSelector)) {
if (const auto value = element->get_attr(kIdAttribute)) {
_elements[int64(std::strtoll(value, nullptr, 10))] = element;
}
}
}
} // namespace Tgw