openhmi-nx: decode, encode, render Nextion HMI projects; .tft research

Black-box reverse-engineered .HMI format (container, three checksums,
pages, all 31 component types, pictures, fonts), readable JSON, page
renderer matching Nextion Editor, demo project built from code and a
test suite (66 tests). See docs/COVERAGE.md for status.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
mangavalkandClaude Opus 5.5 committed 2026-11-15 15:11:02 +01:00
commit 69e22cfb06
70 files changed
+25058

No files matched your search

Binary file not shown.
+37
View File
@@ -0,0 +1,37 @@
import os
import sys
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, os.path.join(ROOT, "src"))
FIXTURE = os.path.join(ROOT, "tests", "fixtures", "demo_editor_saved.HMI")
try:
import PIL # noqa: F401
HAVE_PIL = True
except ImportError:
HAVE_PIL = False
def demo_project():
"""The demo project, built from code (needs Pillow)."""
sys.path.insert(0, os.path.join(ROOT, "examples"))
import make_demo
return make_demo.build()
def bitwise_word_crc(data, crc=0xFFFFFFFF):
"""Reference: STM32-style CRC-32, each byte zero-extended to a 32-bit word, bit by bit."""
for b in data:
crc ^= b
for _ in range(32):
crc = ((crc << 1) ^ 0x04C11DB7) & 0xFFFFFFFF if crc & 0x80000000 else (crc << 1) & 0xFFFFFFFF
return crc
def bitwise_dword_crc(data, crc=0xFFFFFFFF):
"""Reference: STM32-style CRC-32 over little-endian 32-bit words, bit by bit."""
for i in range(0, len(data), 4):
crc ^= int.from_bytes(data[i:i + 4], "little")
for _ in range(32):
crc = ((crc << 1) ^ 0x04C11DB7) & 0xFFFFFFFF if crc & 0x80000000 else (crc << 1) & 0xFFFFFFFF
return crc
+52
View File
@@ -0,0 +1,52 @@
import struct
import unittest
from helpers import FIXTURE, bitwise_dword_crc, bitwise_word_crc
from nxhmi import checksum
from nxhmi.container import HMIFile
class ChecksumAlgorithms(unittest.TestCase):
def test_word_per_byte_matches_bitwise_reference(self):
for data in (b"", b"\x00", bytes(range(256)), b"nextion" * 13):
self.assertEqual(checksum.word_per_byte_crc(data), bitwise_word_crc(data))
def test_dword_matches_bitwise_reference(self):
for data in (b"", bytes(range(64)), b"abcd" * 50):
self.assertEqual(checksum.dword_crc(data), bitwise_dword_crc(data))
def test_dword_needs_multiple_of_4(self):
with self.assertRaises(ValueError):
checksum.dword_crc(b"abc")
def test_table_crc_appends_magic(self):
tbl = struct.pack("<I", 0)
expect = bitwise_dword_crc(tbl + struct.pack("<I", checksum.TABLE_MAGIC))
self.assertEqual(checksum.table_crc(tbl), expect)
def test_page_crc_definition(self):
page = bytearray(80)
struct.pack_into("<IIII", page, 4, 80, 56, 2, 0)
page[20], page[21] = 0x00, 0x4F
tail = struct.pack("<II", 80, 2) + bytes(page[20:22])
self.assertEqual(checksum.page_crc(bytes(page)), bitwise_word_crc(bytes(page[4:]) + tail))
class ChecksumsOfEditorOutput(unittest.TestCase):
"""Every checksum in a file written by Nextion Editor 1.68 must verify."""
def test_fixture(self):
h = HMIFile.load(FIXTURE)
self.assertEqual(h.table_ok(), (True, True))
for e in h.live():
blob = h.read(e.name)
stored = struct.unpack_from("<I", blob, 0)[0]
if e.name.endswith(".pa"):
self.assertEqual(checksum.page_crc(blob), stored, e.name)
if e.name == "main.HMI":
self.assertEqual(checksum.main_crc(blob), stored)
if __name__ == "__main__":
unittest.main()
+56
View File
@@ -0,0 +1,56 @@
import unittest
import helpers # noqa: F401
from nxhmi import components as C
from nxhmi.page import Page
class Templates(unittest.TestCase):
def test_all_31_types(self):
self.assertEqual(len(C.TYPES), 31)
self.assertEqual(len(C.INTELLIGENT_ONLY), 11)
for t, tpl in C.TYPES.items():
names = [a[0] for a in tpl["att"]]
self.assertEqual(names[:3], ["type", "id", "objname"], tpl["kind"])
self.assertEqual(dict((a[0], a[2]) for a in tpl["att"])["type"], t)
def test_templates_have_no_project_specific_names(self):
self.assertEqual(dict((a[0], a[2]) for a in C.TYPES[121]["att"])["objname"], "page0")
class Factory(unittest.TestCase):
def test_add_every_kind(self):
p = C.new_page("p0")
for k in C.kinds():
if k == "page":
continue
att = {a[0] for a in C.TYPES[C.KINDS[k]]["att"]}
kw = dict(x=5, y=6, w=50, h=20) if "x" in att else {}
C.add(p, k, **kw)
q = Page.parse(p.pack())
self.assertEqual(len(q.components), len(C.kinds()))
ids = [c.get("id") for c in q.components]
self.assertEqual(sorted(ids), list(range(len(ids))))
self.assertEqual(len({c.name for c in q.components}), len(q.components))
def test_endx_endy_and_events(self):
p = C.new_page("p0")
b = C.add(p, "button", x=10, y=20, w=30, h=40, txt="ok", events={"codesup": ["page 1"]})
self.assertEqual((b.get("endx"), b.get("endy")), (39, 59))
self.assertEqual(b.event("codesup"), ["page 1"])
def test_duplicate_name_rejected(self):
p = C.new_page("p0")
C.add(p, "text", "t0")
with self.assertRaises(ValueError):
C.add(p, "text", "t0")
def test_new_page_defaults(self):
p = C.new_page("x", w=800, h=480)
pc = p.components[0]
self.assertEqual((pc.get("sta"), pc.get("bco"), pc.get("w"), pc.get("h")), (1, 0xFFFF, 800, 480))
if __name__ == "__main__":
unittest.main()
+61
View File
@@ -0,0 +1,61 @@
import struct
import unittest
from helpers import FIXTURE
from nxhmi.container import (BACKUP_TABLE_OFFSET, DATA_OFFSET, MARKER_OFFSET, VERSION_MAGIC, VERSION_OFFSET,
HMIError, HMIFile, build)
class Container(unittest.TestCase):
def test_build_layout(self):
f = build([("a.bin", b"hello"), ("b.bin", b"world!")])
raw = f.to_bytes()
self.assertEqual(raw[VERSION_OFFSET:VERSION_OFFSET + 8], VERSION_MAGIC)
self.assertEqual(struct.unpack_from("<I", raw, MARKER_OFFSET)[0], 0xFFFFFFFF)
self.assertEqual(raw[DATA_OFFSET:DATA_OFFSET + 5], b"hello")
g = HMIFile.from_bytes(raw)
self.assertEqual(g.names(), ["a.bin", "b.bin"])
self.assertEqual(g.read("b.bin"), b"world!")
self.assertEqual(raw[0:200], raw[BACKUP_TABLE_OFFSET:BACKUP_TABLE_OFFSET + 200])
def test_replace_like_the_editor(self):
g = HMIFile.from_bytes(build([("a.bin", b"one")]).to_bytes())
g.write("a.bin", b"two, longer")
raw = g.to_bytes()
h = HMIFile.from_bytes(raw)
self.assertEqual(h.read("a.bin"), b"two, longer")
old = [e for e in h.entries if e.deleted]
self.assertEqual(len(old), 1)
self.assertEqual(old[0].raw_name[:1], b"\0") # deleted entries lose name[0]
self.assertEqual(h.table_ok(), (True, True))
def test_delete(self):
g = HMIFile.from_bytes(build([("a", b"1"), ("b", b"2")]).to_bytes())
g.delete("a")
self.assertEqual(HMIFile.from_bytes(g.to_bytes()).names(), ["b"])
with self.assertRaises(KeyError):
g.read("a")
def test_backup_table_fallback_and_both_corrupt(self):
raw = bytearray(build([("x", b"data")]).to_bytes())
raw[5] ^= 0xFF
self.assertEqual(HMIFile.from_bytes(bytes(raw)).names(), ["x"])
raw[BACKUP_TABLE_OFFSET + 5] ^= 0xFF
with self.assertRaises(HMIError):
HMIFile.from_bytes(bytes(raw))
def test_compacted(self):
g = HMIFile.from_bytes(build([("a", b"1" * 10)]).to_bytes())
g.write("a", b"2" * 10)
c = g.compacted()
self.assertEqual(len(c.entries), 1)
self.assertEqual(c.read("a"), b"2" * 10)
def test_editor_file_roundtrip_byte_identical(self):
data = open(FIXTURE, "rb").read()
self.assertEqual(HMIFile.from_bytes(data).to_bytes(), data)
if __name__ == "__main__":
unittest.main()
+35
View File
@@ -0,0 +1,35 @@
import unittest
import helpers # noqa: F401
from nxhmi import enums
class Enums(unittest.TestCase):
def test_colours_exact_roundtrip(self):
for v in range(0, 0x10000, 37):
self.assertEqual(enums.hex_to_rgb565(enums.rgb565_to_hex(v)), v)
self.assertEqual(enums.rgb565_to_hex(0xF800), "#ff0000")
def test_general_and_per_type(self):
self.assertEqual(enums.to_label(116, "xcen", "u8", 2), "right")
self.assertEqual(enums.to_label(52, "sta", "u8", 1), "string") # variable type
self.assertEqual(enums.to_label(121, "sta", "u8", 0), "no background")
self.assertEqual(enums.to_label(58, "sta", "u8", 1), "has") # QR logo
self.assertEqual(enums.to_label(98, "style", "u8", 4), "3D_Auto")
self.assertEqual(enums.to_label(116, "style", "u8", 4), 4) # not a text style
def test_from_label(self):
self.assertEqual(enums.from_label(116, "xcen", "u8", "Center"), 1)
self.assertEqual(enums.from_label(116, "bco", "u16", "#ffffff"), 0xFFFF)
self.assertEqual(enums.from_label(116, "x", "u16", 7), 7)
self.assertEqual(enums.from_label(116, "x", "u16", "0x10"), 16)
with self.assertRaises(ValueError):
enums.from_label(116, "xcen", "u8", "sideways")
def test_strings_untouched(self):
self.assertEqual(enums.to_label(116, "txt", "str", "#abc"), "#abc")
if __name__ == "__main__":
unittest.main()
+93
View File
@@ -0,0 +1,93 @@
"""Pictures and fonts."""
import io
import random
import struct
import unittest
from helpers import FIXTURE, HAVE_PIL
from nxhmi import fonts, pictures
from nxhmi.container import HMIFile
class Pictures(unittest.TestCase):
def test_layout_rotated_bottom_up(self):
px = {(0, 0): (255, 0, 0), (1, 0): (0, 255, 0), (0, 1): (0, 0, 255), (1, 1): (255, 255, 255)}
raw = pictures.to_rgb565(lambda x, y: px[(x, y)], 2, 2)
self.assertEqual([struct.unpack_from("<H", raw, 2 * i)[0] for i in range(4)], [0x001F, 0xF800, 0xFFFF, 0x07E0])
def test_truncation(self):
raw = pictures.to_rgb565(lambda x, y: (7, 3, 255), 1, 1)
self.assertEqual(struct.unpack("<H", raw)[0], (0 << 11) | (0 << 5) | 31)
def test_headers(self):
i = pictures.make_picture(b"\0" * 8, 2, 2)
self.assertEqual(pictures.info(i), {"format": 0, "width": 2, "height": 2, "length": 8})
s = pictures.make_source(b"PNGDATA", 2, 2)
self.assertEqual(pictures.source_file(s), b"PNGDATA")
self.assertEqual(pictures.source_info(s)["type"], "png")
@unittest.skipUnless(HAVE_PIL, "needs Pillow")
def test_image_roundtrip(self):
from PIL import Image
img = Image.new("RGB", (5, 3))
for x in range(5):
for y in range(3):
img.putpixel((x, y), (x * 50, y * 100, 200))
b = io.BytesIO(); img.save(b, "PNG")
pic, src = pictures.from_image_file(b.getvalue())
self.assertEqual(pictures.source_file(src), b.getvalue())
back = pictures.to_image(pic)
for x in range(5):
for y in range(3):
r, g, bb = img.getpixel((x, y))
self.assertEqual(back.getpixel((x, y))[0] >> 3, r >> 3)
def test_editor_pictures_decode(self):
h = HMIFile.load(FIXTURE)
for n in h.names():
if n.endswith(".i"):
self.assertEqual(pictures.info(h.read(n))["format"], 0)
class Fonts(unittest.TestCase):
def test_rle_roundtrip_random(self):
random.seed(3)
for _ in range(60):
w, h = random.choice([(8, 16), (16, 32), (12, 24), (5, 7)])
rows = [[1 if random.random() < 0.35 else 0 for _ in range(w)] for _ in range(h)]
self.assertEqual(fonts.decode_glyph(b"\x01" + fonts.encode_glyph(rows, w, h), w, h), rows)
def test_codes(self):
# pixels are scanned per column from the bottom row up; rows are returned top -> bottom
col = [r[0] for r in fonts.decode_glyph(b"\x01\x7e", 1, 32)] # 01 1 11110: 30 transparent, 2 ink
self.assertEqual(col, [1, 1] + [0] * 30)
self.assertEqual(fonts.decode_glyph(b"\x01\x22", 1, 2), [[1], [1]]) # 00 1 00010: 2 ink
self.assertEqual(fonts.decode_glyph(b"\x01\x02\x41", 1, 4), [[1], [0], [0], [0]]) # 2 t, then 01 0: 1 t + 1 ink
self.assertEqual(fonts.decode_glyph(b"\x01\xca", 1, 4), [[0], [1], [1], [0]]) # 11 001 010: 1 t + 2 ink
self.assertEqual(fonts.decode_glyph(b"\x01\x84", 1, 7), [[1], [1], [1], [0], [0], [0], [0]]) # 10 0: 4 t + 3 ink
def test_font_pack_parse(self):
f = fonts.Font("T-8", 8, 8, 1, 0x20, 0x21, [fonts.Glyph(0x20, 8, [[0] * 8 for _ in range(8)]),
fonts.Glyph(0x21, 4, [[1, 0, 0, 1] for _ in range(8)])])
g = fonts.Font.parse(f.pack())
self.assertEqual((g.name, g.glyph("!").width, g.glyph("!").pixels), ("T-8", 4, f.glyphs[1].pixels))
def test_editor_fonts_reencode_identical(self):
h = HMIFile.load(FIXTURE)
for n in h.names():
if n.endswith(".zi"):
blob = h.read(n)
self.assertEqual(fonts.Font.parse(blob).pack(), blob, n)
@unittest.skipUnless(HAVE_PIL, "needs Pillow")
def test_from_ttf_default_font(self):
f = fonts.from_ttf(None, 20)
self.assertEqual(len(f.glyphs), 95)
self.assertTrue(any(any(r) for r in f.glyph("A").pixels))
self.assertFalse(any(any(r) for r in f.glyph(" ").pixels))
self.assertEqual(fonts.Font.parse(f.pack()).name, "Aileron-20ascii")
if __name__ == "__main__":
unittest.main()
+64
View File
@@ -0,0 +1,64 @@
import unittest
from helpers import FIXTURE
from nxhmi.container import HMIFile
from nxhmi.page import Attr, Component, Group, Page
def small_page():
pc = Component([Group("att", [Attr.encode("type", "u8", 121), Attr.encode("id", "u8", 0),
Attr.encode("objname", "str", "p0"), Attr.encode("w", "u16", 480)]),
Group("codesload", []), Group("codesdown", [b"page 1"])])
t = Component([Group("att", [Attr.encode("type", "u8", 116), Attr.encode("id", "u8", 1),
Attr.encode("objname", "str", "t0"), Attr.encode("txt", "str", "hi"),
Attr.encode("txt_maxl", "u16", 10), Attr.encode("dir", "u8", 1)])])
return Page("p0", [pc, t])
class PageModel(unittest.TestCase):
def test_roundtrip(self):
blob = small_page().pack()
self.assertEqual(Page.parse(blob).pack(), blob)
def test_checksum_verified_on_parse(self):
blob = bytearray(small_page().pack())
blob[-5] ^= 1
with self.assertRaises(ValueError):
Page.parse(bytes(blob))
Page.parse(bytes(blob), verify=False)
def test_header_fields(self):
p = Page.parse(small_page().pack())
self.assertEqual((p.name, p.b21, p.version), ("p0", 0x4F, 0x21))
self.assertEqual(len(p.components), 2)
def test_string_detection_by_companion(self):
t = Page.parse(small_page().pack()).component("t0")
self.assertEqual(t.attr("txt").decoded()[0], "str") # has txt_maxl
self.assertEqual(t.attr("dir").decoded(), ("u8", 1)) # no dir_m -> number
self.assertEqual(t.attr("objname").decoded()[0], "str")
def test_set_get_and_grow(self):
p = Page.parse(small_page().pack())
t = p.component("t0")
t.set("txt", "a much longer text")
t.set_event("codesdown", ["click t0,1", "page 0"])
q = Page.parse(p.pack())
self.assertEqual(q.component("t0").get("txt"), "a much longer text")
self.assertEqual(q.component("t0").event("codesdown"), ["click t0,1", "page 0"])
def test_signed_values(self):
a = Attr.encode("val", "u32", -1234567)
self.assertEqual(a.value, (-1234567 & 0xFFFFFFFF).to_bytes(4, "little"))
def test_editor_pages_roundtrip(self):
h = HMIFile.load(FIXTURE)
for e in h.live():
if e.name.endswith(".pa"):
blob = h.read(e.name)
self.assertEqual(Page.parse(blob).pack(), blob, e.name)
if __name__ == "__main__":
unittest.main()
+115
View File
@@ -0,0 +1,115 @@
import json
import os
import shutil
import struct
import tempfile
import unittest
from helpers import FIXTURE, HAVE_PIL, demo_project
from nxhmi import checksum, models, project
from nxhmi.container import HMIFile
from nxhmi.page import Page
class NewProject(unittest.TestCase):
def test_new_project(self):
h = project.new_project("NX4832T035_011", "start")
self.assertEqual(h.names(), ["main.HMI", "Program.s", "0.pa"])
main = h.read("main.HMI")
self.assertEqual(checksum.main_crc(main), struct.unpack_from("<I", main, 0)[0])
self.assertEqual(project.parse_main(main)["resources"], [["pa", "0.pa"]])
self.assertEqual(Page.parse(h.read("0.pa")).name, "start")
self.assertEqual(project.project_size(h), (480, 320))
def test_every_model(self):
for name, (mid, series, w, hgt) in models.MODELS.items():
h = project.new_project(name)
main = h.read("main.HMI")
self.assertEqual(struct.unpack_from("<I", main, 16)[0], mid)
self.assertEqual(main[11], series)
self.assertEqual(Page.parse(h.read("0.pa")).components[0].get("w"), w)
def test_unknown_model(self):
with self.assertRaises(KeyError):
project.new_project("NX0000X000_000")
def test_add_page_registers_resource(self):
h = project.new_project()
project.add_page(h, "two")
h2 = HMIFile.from_bytes(h.to_bytes())
self.assertIn(["pa", "1.pa"], project.parse_main(h2.read("main.HMI"))["resources"])
with self.assertRaises(ValueError):
project.add_page(h2, "two")
def test_resource_order(self):
main = project.make_main("NX4832T035_011", [("pa", "0.pa")])
main = project.main_insert_resource(main, "i", "0.i")
main = project.main_insert_resource(main, "zi", "0.zi")
main = project.main_insert_resource(main, "i", "1.i")
self.assertEqual([r[1] for r in project.parse_main(main)["resources"]], ["0.i", "1.i", "0.zi", "0.pa"])
class DecodeEncode(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.mkdtemp()
def tearDown(self):
shutil.rmtree(self.tmp)
def test_editor_file_decode_encode_identical(self):
out = os.path.join(self.tmp, "dec")
project.decode(FIXTURE, out)
re = os.path.join(self.tmp, "re.HMI")
project.encode(out, re)
a, b = HMIFile.load(FIXTURE), HMIFile.load(re)
self.assertEqual(sorted(a.names()), sorted(b.names()))
for n in a.names():
self.assertEqual(a.read(n), b.read(n), n)
def test_readable_json(self):
out = os.path.join(self.tmp, "dec")
project.decode(FIXTURE, out)
pj = json.load(open(os.path.join(out, "pages", "0_home.json"), encoding="utf-8"))
att = {c["att"][2][2]: {a[0]: a[2] for a in c["att"]} for c in pj["components"]}
self.assertEqual(att["home"]["sta"], "image")
self.assertEqual(att["tStatus"]["pco"], "#00ff00")
self.assertEqual(att["tStatus"]["style"], "border")
def test_raw_json(self):
out = os.path.join(self.tmp, "raw")
project.decode(FIXTURE, out, readable=False)
pj = json.load(open(os.path.join(out, "pages", "0_home.json"), encoding="utf-8"))
self.assertEqual({a[0]: a[2] for a in pj["components"][0]["att"]}["sta"], 2)
def test_edit_through_json(self):
out = os.path.join(self.tmp, "dec")
project.decode(FIXTURE, out)
path = os.path.join(out, "pages", "0_home.json")
pj = json.load(open(path, encoding="utf-8"))
for c in pj["components"]:
for a in c["att"]:
if c["att"][2][2] == "title" and a[0] == "txt":
a[2] = "changed"
if c["att"][2][2] == "title" and a[0] == "xcen":
a[2] = "right"
json.dump(pj, open(path, "w", encoding="utf-8"))
re = os.path.join(self.tmp, "re.HMI")
project.encode(out, re)
t = Page.parse(HMIFile.load(re).read("0.pa")).component("title")
self.assertEqual((t.get("txt"), t.get("xcen")), ("changed", 2))
@unittest.skipUnless(HAVE_PIL, "needs Pillow")
class Demo(unittest.TestCase):
def test_demo_matches_editor_resave(self):
"""The demo built by nxhmi is byte-identical to the same project re-saved by Nextion Editor."""
ours = HMIFile.from_bytes(demo_project().to_bytes())
editor = HMIFile.load(FIXTURE)
self.assertEqual(sorted(ours.names()), sorted(editor.names()))
for n in ours.names():
self.assertEqual(ours.read(n), editor.read(n), n)
if __name__ == "__main__":
unittest.main()
+98
View File
@@ -0,0 +1,98 @@
"""Renderer rules, each one measured against Nextion Editor 1.68 (see docs/RENDER.md)."""
import unittest
from helpers import FIXTURE, HAVE_PIL
from nxhmi import components as C
from nxhmi.container import HMIFile, build
@unittest.skipUnless(HAVE_PIL, "needs Pillow")
class Render(unittest.TestCase):
def render(self, page):
from nxhmi.render import Renderer
return Renderer(build([("0.pa", page.pack())])).render(page.name)
def test_page_solid(self):
p = C.new_page("p", w=40, h=20, bco=0x001F)
self.assertEqual(self.render(p).getpixel((5, 5)), (0, 0, 255))
def test_progress_bar(self):
p = C.new_page("p", w=100, h=40)
C.add(p, "progress_bar", x=10, y=10, w=50, h=10, val=50, bco=0, pco=0xF800)
img = self.render(p)
self.assertEqual(img.getpixel((20, 15)), (255, 0, 0))
self.assertEqual(img.getpixel((50, 15)), (0, 0, 0))
def test_slider_auto_cursor_truncates(self):
p = C.new_page("p", w=240, h=40)
C.add(p, "slider", x=0, y=0, w=200, h=25, val=50, minval=0, maxval=100, pco=0x07E0, bco=0)
img = self.render(p)
# cursor is 25 px wide (auto = slider thickness), at int(0.5 * 175) = 87
self.assertEqual(img.getpixel((87, 10)), (0, 255, 0))
self.assertEqual(img.getpixel((86, 10)), (0, 0, 0))
self.assertEqual(img.getpixel((111, 10)), (0, 255, 0))
self.assertEqual(img.getpixel((112, 10)), (0, 0, 0))
def test_3d_border_colours(self):
p = C.new_page("p", w=60, h=40)
C.add(p, "button", x=0, y=0, w=50, h=30, style=4, sta=1, bco=0xBDF7, txt="")
img = self.render(p)
self.assertEqual(img.getpixel((10, 0)), (230, 226, 230))
self.assertEqual(img.getpixel((10, 29)), (65, 68, 65))
def test_picture_button_has_no_frame(self):
p = C.new_page("p", w=60, h=40)
b = C.add(p, "button", x=0, y=0, w=50, h=30, style=4, sta=1, bco=0x0000, txt="")
b.set("sta", 2) # picture skin, picture missing -> nothing drawn
img = self.render(p)
self.assertEqual(img.getpixel((10, 0)), (255, 255, 255))
def test_waveform_grid_from_bottom(self):
p = C.new_page("p", w=100, h=100)
C.add(p, "waveform", x=0, y=0, w=50, h=50, gdw=20, gdh=20, gdc=0x07E0, sta=1, bco=0)
img = self.render(p)
self.assertEqual(img.getpixel((5, 49)), (0, 255, 0)) # bottom row is a grid line
self.assertEqual(img.getpixel((5, 29)), (0, 255, 0))
self.assertEqual(img.getpixel((5, 0)), (0, 0, 0))
def test_checkbox(self):
p = C.new_page("p", w=100, h=100)
C.add(p, "checkbox", x=0, y=0, w=40, h=40, val=1, bco=0xFFFF, pco=0x001F, style=0)
img = self.render(p)
self.assertEqual(img.getpixel((10, 10)), (0, 0, 255))
self.assertEqual(img.getpixel((9, 9)), (255, 255, 255))
self.assertEqual(img.getpixel((29, 29)), (0, 0, 255))
self.assertEqual(img.getpixel((30, 30)), (255, 255, 255))
def test_dual_state_on_is_pressed(self):
p = C.new_page("p", w=60, h=40)
C.add(p, "dual_state_button", x=0, y=0, w=50, h=30, val=1, style=4, sta=1, txt="")
img = self.render(p)
self.assertEqual(img.getpixel((10, 0)), (65, 68, 65)) # dark top edge when on
def test_demo_pages_render(self):
from nxhmi.render import Renderer
r = Renderer(HMIFile.load(FIXTURE))
for name in ("home", "controls", "gallery"):
img = r.render(name)
self.assertEqual(img.size, (480, 320))
self.assertEqual(r.render("home").getpixel((0, 319)), r.pic(0).getpixel((0, 319)))
def test_text_clamped_inside_box(self):
from nxhmi import fonts, project
from nxhmi.render import Renderer
h = project.new_project()
fid = project.add_font(h, fonts.from_ttf(None, 32))
from nxhmi.page import Page
p = Page.parse(h.read("0.pa"))
C.add(p, "text", x=0, y=0, w=200, h=20, txt="Hg", font=fid, ycen=1, sta=1, bco=0xFFFF, pco=0)
h.write("0.pa", p.pack())
img = Renderer(h).render("page0")
ink_rows = [y for y in range(20) if any(img.getpixel((x, y)) == (0, 0, 0) for x in range(200))]
self.assertTrue(ink_rows and ink_rows[0] >= 0)
self.assertEqual(img.getpixel((10, 25)), (255, 255, 255)) # nothing drawn below the box
if __name__ == "__main__":
unittest.main()
+91
View File
@@ -0,0 +1,91 @@
import contextlib
import io
import os
import shutil
import struct
import tempfile
import unittest
from helpers import FIXTURE, HAVE_PIL, bitwise_word_crc
from nxhmi import cli, tft
def fake_tft(payload: bytes) -> bytes:
"""A synthetic .tft-shaped blob: layout table + trailer CRC computed the way the trailer behaves
(word-per-byte CRC whose stream ends at the trailer). Real .tft files cannot be used in tests:
they contain Nextion's firmware."""
head = bytearray(0x200)
struct.pack_into("<HH", head, 0x0C, 480, 320)
for i, o in enumerate(range(tft.LAYOUT_START, tft.LAYOUT_END, 4)):
struct.pack_into("<I", head, o, (i * 1000) ^ tft.LAYOUT_KEY)
body = bytes(head) + payload
return body + struct.pack("<I", bitwise_word_crc(body, 0x12345678))
class Tft(unittest.TestCase):
def test_layout_table(self):
t = fake_tft(b"x" * 10)
self.assertEqual(tft.layout_table(t)[:3], [0, 1000, 2000])
self.assertEqual(tft.header_info(t)["width"], 480)
def test_patch_trailer_same_length(self):
old = fake_tft(b"page data: colour ff ff")
new_body = old[:-4].replace(b"ff ff", b"00 f8")
expect = fake_tft(b"page data: colour 00 f8")
self.assertEqual(tft.patch_trailer(old, new_body + b"\0\0\0\0"), expect)
def test_patch_trailer_rejects_length_change(self):
with self.assertRaises(ValueError):
tft.patch_trailer(b"\0" * 20, b"\0" * 24)
class Cli(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.mkdtemp()
self.hmi = os.path.join(self.tmp, "p.HMI")
shutil.copy(FIXTURE, self.hmi)
def tearDown(self):
shutil.rmtree(self.tmp)
def run_cli(self, *args):
out = io.StringIO()
with contextlib.redirect_stdout(out):
rc = cli.main(list(args))
return rc, out.getvalue()
def test_info_verify_dump(self):
self.assertIn("home", self.run_cli("info", self.hmi)[1])
self.assertEqual(self.run_cli("verify", self.hmi)[0], 0)
self.assertIn('"title"', self.run_cli("dump", self.hmi, "--page", "home")[1])
def test_decode_encode(self):
d = os.path.join(self.tmp, "dec")
self.run_cli("decode", self.hmi, d)
self.run_cli("encode", d, os.path.join(self.tmp, "re.HMI"))
self.assertEqual(self.run_cli("verify", os.path.join(self.tmp, "re.HMI"))[0], 0)
def test_set_add_newpage_kinds(self):
self.run_cli("set", self.hmi, "home", "title", "txt", "hello")
self.run_cli("add", self.hmi, "home", "button", "x=1", "y=2", "w=30", "h=20", "txt=ok", "--name", "bNew")
self.run_cli("new-page", self.hmi, "extra")
out = self.run_cli("info", self.hmi)[1]
self.assertIn("extra", out)
self.assertEqual(self.run_cli("verify", self.hmi)[0], 0)
self.assertIn("button", self.run_cli("kinds")[1])
@unittest.skipUnless(HAVE_PIL, "needs Pillow")
def test_add_picture_font_render(self):
from PIL import Image
png = os.path.join(self.tmp, "i.png")
Image.new("RGB", (8, 8), (1, 2, 3)).save(png)
self.run_cli("add-picture", self.hmi, png)
self.assertEqual(self.run_cli("verify", self.hmi)[0], 0)
out = os.path.join(self.tmp, "png")
self.run_cli("render", self.hmi, out)
self.assertTrue(os.path.exists(os.path.join(out, "home.png")))
if __name__ == "__main__":
unittest.main()