22 |
29 |
30 |
31 |
32 |
--------------------------------------------------------------------------------
/litehtmlt.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env vpython3
2 | import logme
3 |
4 | from litehtmlpy import litehtml, litehtmlpy
5 |
6 | class Button(litehtml.litehtmlpy.html_tag):
7 | def __init__(self, attributes, doc):
8 | super().__init__(doc)
9 | print('i`m the button', attributes, 'tagName=', self.get_tagName())
10 | def draw(self, hdc, x, y, clip, ri):
11 | super().draw(hdc, x, y, clip, ri)
12 | print('Button.draw', hdc, x, y, clip, ri.pos())
13 |
14 | class document_container(litehtml.document_container):
15 | def __init__(self):
16 | super().__init__()
17 | self.handlers = []
18 |
19 | def import_css(self, text, url, base_url):
20 | url = urllib.parse.urljoin(base_url, url)
21 | if os.path.exists(url):
22 | with open(url, 'rt') as fp:
23 | data = fp.read()
24 | elif url.split(':')[0] in ('http', 'https'):
25 | r = requests.get(url)
26 | if r.headers['Content-Type'] == 'text/css':
27 | data = r.text
28 | if data is None:
29 | print('unknown import_css', url)
30 | return
31 | return data
32 |
33 | def create_element(self, tag_name, attributes=None, doc=None):
34 | if tag_name == 'button':
35 | if doc is not None:
36 | tagh = Button(attributes, doc)
37 | self.handlers.append(tagh)
38 | return tagh
39 | return True
40 |
41 | def main():
42 | #litehtml.litehtml.liblitehtmlpy.debuglog(1)
43 | html = open('litehtmlt.html', 'rt').read()
44 | cntr = document_container()
45 |
46 | doc = litehtmlpy.fromString(cntr, html, None, None)
47 | doc.render(cntr.size[0], litehtmlpy.render_all)
48 | clip = litehtmlpy.position(0, 0, doc.width(), doc.height())
49 | doc.draw(0, 0, 0, clip)
50 | del doc, cntr
51 |
52 | main()
53 |
--------------------------------------------------------------------------------
/logme.py:
--------------------------------------------------------------------------------
1 | import logging
2 | logger = logging.getLogger()
3 | handler = logging.StreamHandler()
4 | formatter = logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
5 | handler.setFormatter(formatter)
6 | logger.addHandler(handler)
7 | logger.setLevel(logging.DEBUG)
8 |
9 | if 1:
10 | import sys
11 | sys.path.insert(1, 'src')
12 |
13 | from litehtmlpy import litehtmlpy
14 | #litehtmlpy.debuglog(1)
15 |
--------------------------------------------------------------------------------
/mingw-cross.cmake:
--------------------------------------------------------------------------------
1 | #
2 | # https://cmake.org/cmake/help/book/mastering-cmake/chapter/Cross%20Compiling%20With%20CMake.html
3 | #
4 | # the name of the target operating system
5 | set(CMAKE_SYSTEM_NAME Windows)
6 |
7 | # which compilers to use for C and C++
8 | set(CMAKE_C_COMPILER x86_64-w64-mingw32-gcc)
9 | set(CMAKE_CXX_COMPILER x86_64-w64-mingw32-g++)
10 |
11 | # where is the target environment located
12 | set(CMAKE_FIND_ROOT_PATH /usr/bin
13 | /devel/bin/mingw-install)
14 |
15 | # adjust the default behavior of the FIND_XXX() commands:
16 | # search programs in the host environment
17 | set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
18 |
19 | # search headers and libraries in the target environment
20 | set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
21 | set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
22 |
23 | #set(CMAKE_BUILD_TYPE DEBUG)
24 | #set(CMAKE_C_FLAGS "-O0 -ggdb")
25 | #set(CMAKE_C_FLAGS_DEBUG "-O0 -ggdb")
26 | #set(CMAKE_C_FLAGS_RELEASE "-O0 -ggdb")
27 | #set(CMAKE_CXX_FLAGS "-O0 -ggdb")
28 | #set(CMAKE_CXX_FLAGS_DEBUG "-O0 -ggdb")
29 | #set(CMAKE_CXX_FLAGS_RELEASE "-O0 -ggdb")
30 | set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -static -static-libgcc -march=x86-64 -mtune=generic")
31 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static -static-libgcc -static-libstdc++ -march=x86-64 -mtune=generic")
32 | set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L/usr/local/lib -static -static-libgcc -static-libstdc++ -march=x86-64 -mtune=generic")
33 |
--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
1 | [build-system]
2 | requires = [
3 | "setuptools>=42",
4 | "wheel",
5 | "ninja",
6 | "cmake>=3.12",
7 | "pybind11",
8 | ]
9 | build-backend = "setuptools.build_meta"
10 |
11 | [project]
12 | name = "litehtmlpy"
13 | version = "0.1.0"
14 | authors = [
15 | { name="Grzegorz Makarewicz", email="mak@trisoft.com.pl" },
16 | ]
17 | description = "LiteHtmlPy is a solution that helps python developers to create printouts and previews of html5/css3 pages without using a web browser."
18 | readme = "README.md"
19 | requires-python = ">=3.7"
20 | classifiers=[
21 | 'Development Status :: 4 - Beta',
22 | 'Development Status :: 5 - Production/Stable',
23 | 'Operating System :: OS Independent',
24 | 'Intended Audience :: Developers',
25 | 'License :: OSI Approved :: MIT License',
26 | 'Programming Language :: Python :: 3',
27 | 'Topic :: Software Development :: Libraries :: Python Modules',
28 | 'Topic :: Office/Business',
29 | 'Topic :: Text Processing',
30 | 'Topic :: Multimedia :: Graphics',
31 | ]
32 |
33 | [project.urls]
34 | "Homepage" = "https://github.com/m32/litehtmlpy"
35 | "Bug Tracker" = "https://github.com/m32/litehtmlpy/issues"
36 |
--------------------------------------------------------------------------------
/set_inner_html.cpp:
--------------------------------------------------------------------------------
1 | void litehtml::element::set_inner_html(const litehtml::tchar_t* str, litehtml::css* user_styles)
2 | {
3 | // parse document into GumboOutput
4 | GumboOptions options = kGumboDefaultOptions;
5 |
6 | options.fragment_context = gumbo_tag_enum(get_tagName());
7 |
8 | GumboOutput* output = gumbo_parse_with_options(&options, str, strlen(str));
9 | document::ptr doc = m_doc.lock();
10 |
11 | m_children.clear();
12 |
13 | document::create_node(output->root->v.element.children.data[0], m_children, true, doc);
14 | gumbo_destroy_output(&kGumboDefaultOptions, output);
15 |
16 | for (auto& child : m_children)
17 | {
18 | child->parent(shared_from_this());
19 | }
20 |
21 | if( doc->is_initialised() )
22 | {
23 | for (auto& child : m_children)
24 | {
25 | // Let's process created elements tree
26 | // apply master CSS
27 | child->apply_stylesheet(doc->get_context()->master_css());
28 |
29 | // parse elements attributes
30 | child->parse_attributes();
31 |
32 | // Apply parsed styles.
33 | child->apply_stylesheet(doc->get_styles());
34 |
35 | // Apply user styles if any
36 | if (user_styles)
37 | {
38 | child->apply_stylesheet(*user_styles);
39 | }
40 |
41 | // Parse applied styles in the elements
42 | child->parse_styles();
43 |
44 | // Finally initialize elements
45 | child->init();
46 | }
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 | import os
2 | import re
3 | import subprocess
4 | import sys
5 | from pathlib import Path
6 |
7 | from setuptools import Extension, setup, find_packages
8 | from setuptools.command.build_ext import build_ext
9 |
10 | from pybind11 import get_include
11 |
12 | # Convert distutils Windows platform specifiers to CMake -A arguments
13 | PLAT_TO_CMAKE = {
14 | "win32": "Win32",
15 | "win-amd64": "x64",
16 | "win-arm32": "ARM",
17 | "win-arm64": "ARM64",
18 | }
19 |
20 |
21 | # A CMakeExtension needs a sourcedir instead of a file list.
22 | # The name must be the _single_ output extension from the CMake build.
23 | # If you need multiple extensions, see scikit-build.
24 | class CMakeExtension(Extension):
25 | def __init__(self, name: str, sourcedir: str = "") -> None:
26 | super().__init__(name, sources=[])
27 | self.sourcedir = os.fspath(Path(sourcedir).resolve())
28 |
29 |
30 | class CMakeBuild(build_ext):
31 | def build_extension(self, ext: CMakeExtension) -> None:
32 | # Must be in this form due to bug in .resolve() only fixed in Python 3.10+
33 | ext_fullpath = Path.cwd() / self.get_ext_fullpath(ext.name) # type: ignore[no-untyped-call]
34 | extdir = ext_fullpath.parent.resolve()
35 |
36 | # Using this requires trailing slash for auto-detection & inclusion of
37 | # auxiliary "native" libs
38 |
39 | debug = int(os.environ.get("DEBUG", 0)) if self.debug is None else self.debug
40 | cfg = "Debug" if debug else "Release"
41 |
42 | # CMake lets you override the generator - we need to check this.
43 | # Can be set with Conda-Build, for example.
44 | cmake_generator = os.environ.get("CMAKE_GENERATOR", "")
45 |
46 | # Set Python_EXECUTABLE instead if you use PYBIND11_FINDPYTHON
47 | # EXAMPLE_VERSION_INFO shows you how to pass a value into the C++ code
48 | # from Python.
49 | cname = ext.name
50 | cmake_args = [
51 | f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={extdir}{os.sep}{cname}{os.sep}",
52 | f"-DPYTHON_EXECUTABLE={sys.executable}",
53 | f"-DCMAKE_BUILD_TYPE={cfg}", # not used on MSVC, but no harm
54 | "-DPYBIND11_INCLUDE_DIR={}".format(get_include()),
55 | "-DLITEHTML_BUILD_TESTING=OFF",
56 | "-DLITEHTMLPY_BUILD_TESTING=OFF",
57 | "-Wno-dev",
58 | ]
59 | build_args = []
60 | # Adding CMake arguments set as environment variable
61 | # (needed e.g. to build for ARM OSx on conda-forge)
62 | if "CMAKE_ARGS" in os.environ:
63 | cmake_args += [item for item in os.environ["CMAKE_ARGS"].split(" ") if item]
64 |
65 | if self.compiler.compiler_type != "msvc":
66 | # Using Ninja-build since it a) is available as a wheel and b)
67 | # multithreads automatically. MSVC would require all variables be
68 | # exported for Ninja to pick it up, which is a little tricky to do.
69 | # Users can override the generator with CMAKE_GENERATOR in CMake
70 | # 3.15+.
71 | if not cmake_generator or cmake_generator == "Ninja":
72 | try:
73 | import ninja # noqa: F401
74 |
75 | ninja_executable_path = Path(ninja.BIN_DIR) / "ninja"
76 | cmake_args += [
77 | "-GNinja",
78 | f"-DCMAKE_MAKE_PROGRAM:FILEPATH={ninja_executable_path}",
79 | ]
80 | except ImportError:
81 | pass
82 |
83 | else:
84 |
85 | # Single config generators are handled "normally"
86 | single_config = any(x in cmake_generator for x in {"NMake", "Ninja"})
87 |
88 | # CMake allows an arch-in-generator style for backward compatibility
89 | contains_arch = any(x in cmake_generator for x in {"ARM", "Win64"})
90 |
91 | # Specify the arch if using MSVC generator, but only if it doesn't
92 | # contain a backward-compatibility arch spec already in the
93 | # generator name.
94 | if not single_config and not contains_arch:
95 | cmake_args += ["-A", PLAT_TO_CMAKE[self.plat_name]]
96 |
97 | # Multi-config generators have a different way to specify configs
98 | if not single_config:
99 | cmake_args += [
100 | f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{cfg.upper()}={extdir}"
101 | ]
102 | build_args += ["--config", cfg]
103 |
104 | if sys.platform.startswith("darwin"):
105 | # Cross-compile support for macOS - respect ARCHFLAGS if set
106 | archs = re.findall(r"-arch (\S+)", os.environ.get("ARCHFLAGS", ""))
107 | if archs:
108 | cmake_args += ["-DCMAKE_OSX_ARCHITECTURES={}".format(";".join(archs))]
109 |
110 | # Set CMAKE_BUILD_PARALLEL_LEVEL to control the parallel build level
111 | # across all generators.
112 | if "CMAKE_BUILD_PARALLEL_LEVEL" not in os.environ:
113 | # self.parallel is a Python 3 only way to set parallel jobs by hand
114 | # using -j in the build_ext call, not supported by pip or PyPA-build.
115 | if hasattr(self, "parallel") and self.parallel:
116 | # CMake 3.12+ only.
117 | build_args += [f"-j{self.parallel}"]
118 |
119 | subprocess.run(
120 | ["cmake", ext.sourcedir, *cmake_args], check=True
121 | )
122 | subprocess.run(
123 | ["cmake", "--build", ".", *build_args], check=True
124 | )
125 |
126 |
127 | # The information here can also be placed in setup.cfg - better separation of
128 | # logic and declaration, and simpler if you include description/version in a file.
129 | setup(
130 | name="litehtmlpy",
131 | version="0.1.0",
132 | author="Grzegorz Makarewicz",
133 | author_email="mak@trisoft.com.pl",
134 | description="LiteHtmlPy is a solution that helps python developers to create printouts and previews of html5/css3 pages without using a web browser.",
135 | long_description="",
136 | ext_modules=[
137 | CMakeExtension("litehtmlpy.litehtmlpy")
138 | ],
139 | cmdclass={"build_ext": CMakeBuild},
140 | zip_safe=False,
141 | # extras_require={"test": ["pytest>=6.0"]},
142 | python_requires=">=3.7",
143 | packages=find_packages(where="src"),
144 | package_dir={"": "src"},
145 | )
146 |
--------------------------------------------------------------------------------
/src/background.h:
--------------------------------------------------------------------------------
1 | py::class_