python-msilib 0.7.0__cp315-cp315-win_amd64.whl

msilib/__init__.py

@@ -0,0 +1,937 @@
+"""Read and write Microsoft Installer files."""
+
+# Copyright (C) 2005 Martin v. Löwis
+# Licensed to PSF under a Contributor Agreement.
+from __future__ import annotations
+
+import contextlib
+import fnmatch
+import os
+import platform
+import re
+import string
+from importlib import metadata
+from tempfile import mkstemp
+from typing import TYPE_CHECKING, Any, Final
+
+from msilib._msi import (
+    MSICOLINFO_NAMES,
+    MSICOLINFO_TYPES,
+    MSIDBOPEN_CREATE,
+    MSIDBOPEN_CREATEDIRECT,
+    MSIDBOPEN_DIRECT,
+    MSIDBOPEN_PATCHFILE,
+    MSIDBOPEN_READONLY,
+    MSIDBOPEN_TRANSACT,
+    MSIMODIFY_ASSIGN,
+    MSIMODIFY_DELETE,
+    MSIMODIFY_INSERT,
+    MSIMODIFY_INSERT_TEMPORARY,
+    MSIMODIFY_MERGE,
+    MSIMODIFY_REFRESH,
+    MSIMODIFY_REPLACE,
+    MSIMODIFY_SEEK,
+    MSIMODIFY_UPDATE,
+    MSIMODIFY_VALIDATE,
+    MSIMODIFY_VALIDATE_DELETE,
+    MSIMODIFY_VALIDATE_FIELD,
+    MSIMODIFY_VALIDATE_NEW,
+    PID_APPNAME,
+    PID_AUTHOR,
+    PID_CHARCOUNT,
+    PID_CODEPAGE,
+    PID_COMMENTS,
+    PID_CREATE_DTM,
+    PID_KEYWORDS,
+    PID_LASTAUTHOR,
+    PID_LASTPRINTED,
+    PID_LASTSAVE_DTM,
+    PID_PAGECOUNT,
+    PID_REVNUMBER,
+    PID_SECURITY,
+    PID_SUBJECT,
+    PID_TEMPLATE,
+    PID_TITLE,
+    PID_WORDCOUNT,
+    CreateRecord,
+    FCICreate,
+    MSIError,
+    OpenDatabase,
+    UuidCreate,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Container, Iterable
+    from types import ModuleType
+
+    from ._msi import _Database
+    from .sequence import _SequenceType
+
+__version__ = metadata.version("python-msilib")
+
+__all__ = [
+    "CAB",
+    "MSICOLINFO_NAMES",
+    "MSICOLINFO_TYPES",
+    "MSIDBOPEN_CREATE",
+    "MSIDBOPEN_CREATEDIRECT",
+    "MSIDBOPEN_DIRECT",
+    "MSIDBOPEN_PATCHFILE",
+    "MSIDBOPEN_READONLY",
+    "MSIDBOPEN_TRANSACT",
+    "MSIMODIFY_ASSIGN",
+    "MSIMODIFY_DELETE",
+    "MSIMODIFY_INSERT",
+    "MSIMODIFY_INSERT_TEMPORARY",
+    "MSIMODIFY_MERGE",
+    "MSIMODIFY_REFRESH",
+    "MSIMODIFY_REPLACE",
+    "MSIMODIFY_SEEK",
+    "MSIMODIFY_UPDATE",
+    "MSIMODIFY_VALIDATE",
+    "MSIMODIFY_VALIDATE_DELETE",
+    "MSIMODIFY_VALIDATE_FIELD",
+    "MSIMODIFY_VALIDATE_NEW",
+    "PID_APPNAME",
+    "PID_AUTHOR",
+    "PID_CHARCOUNT",
+    "PID_CODEPAGE",
+    "PID_COMMENTS",
+    "PID_CREATE_DTM",
+    "PID_KEYWORDS",
+    "PID_LASTAUTHOR",
+    "PID_LASTPRINTED",
+    "PID_LASTSAVE_DTM",
+    "PID_PAGECOUNT",
+    "PID_REVNUMBER",
+    "PID_SECURITY",
+    "PID_SUBJECT",
+    "PID_TEMPLATE",
+    "PID_TITLE",
+    "PID_WORDCOUNT",
+    "Binary",
+    "Control",
+    "CreateRecord",
+    "Dialog",
+    "Directory",
+    "FCICreate",
+    "Feature",
+    "MSIError",
+    "OpenDatabase",
+    "RadioButtonGroup",
+    "Table",
+    "UuidCreate",
+    "add_data",
+    "add_stream",
+    "add_tables",
+    "change_sequence",
+    "datasizemask",
+    "gen_uuid",
+    "init_database",
+    "knownbits",
+    "make_id",
+    "type_binary",
+    "type_key",
+    "type_localizable",
+    "type_long",
+    "type_nullable",
+    "type_short",
+    "type_string",
+    "type_valid",
+    "typemask",
+]
+
+
+# Should work in windows, but also in mingw, cygwin, ...
+AMD64: Final[bool] = platform.machine() in ("x64", "x86_64", "AMD64")
+ARM64: Final[bool] = platform.machine() in ("aarch64", "arm64", "ARM64")
+
+# Keep msilib.Win64 around to preserve backwards compatibility.
+Win64: Final[bool] = AMD64
+
+# Partially taken from Wine
+datasizemask: Final = 0x00FF
+type_valid: Final = 0x0100
+type_localizable: Final = 0x0200
+
+typemask: Final = 0x0C00
+type_long: Final = 0x0000
+type_short: Final = 0x0400
+type_string: Final = 0x0C00
+type_binary: Final = 0x0800
+
+type_nullable: Final = 0x1000
+type_key: Final = 0x2000
+# XXX temporary, localizable?
+knownbits: Final = (
+    datasizemask
+    | type_valid
+    | type_localizable
+    | typemask
+    | type_nullable
+    | type_key
+)
+
+
+class Table:
+    name: str
+    fields: list[tuple[int, str, int]]
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.fields = []
+
+    def add_field(self, index: int, name: str, type: int) -> None:
+        self.fields.append((index, name, type))
+
+    def sql(self) -> str:
+        fields = []
+        keys = []
+        self.fields.sort()
+        # fields: list[str] = [""] * len(self.fields)
+        for index, name, ftype in self.fields:
+            index - 1
+            unk = ftype & ~knownbits
+            if unk:
+                print(f"{self.name}.{name} unknown bits {unk:x}")
+            size = ftype & datasizemask
+            dtype = ftype & typemask
+            if dtype == type_string:
+                tname = f"CHAR({size})" if size else "CHAR"
+            elif dtype == type_short:
+                assert size == 2
+                tname = "SHORT"
+            elif dtype == type_long:
+                assert size == 4
+                tname = "LONG"
+            elif dtype == type_binary:
+                assert size == 0
+                tname = "OBJECT"
+            else:
+                tname = "unknown"
+                print(f"{self.name}.{name} unknown integer type {size}")
+            flags = "" if ftype & type_nullable else " NOT NULL"
+            if ftype & type_localizable:
+                flags += " LOCALIZABLE"
+            # fields[idx] = f"`{name}` {tname}{flags}"
+            fields.append(f"`{name}` {tname}{flags}")
+            if ftype & type_key:
+                keys.append(f"`{name}`")
+        fields = ", ".join(fields)
+        keys = ", ".join(keys)
+        return f"CREATE TABLE {self.name} ({fields} PRIMARY KEY {keys})"
+
+    def create(self, db: _Database) -> None:
+        v = db.OpenView(self.sql())
+        v.Execute(None)
+        v.Close()
+
+
+def change_sequence(
+    seq: _SequenceType,
+    action: str,
+    seqno: int | None = None,
+    cond: str | None = None,
+) -> None:
+    """Change the sequence number of an action in a sequence list."""
+    for i in range(len(seq)):
+        if seq[i][0] == action:
+            if cond is None:
+                cond = seq[i][1]
+            if seqno is None:
+                seqno = seq[i][2]
+            seq[i] = (action, cond, seqno)
+            return
+    msg = "Action not found in sequence"
+    raise ValueError(msg)
+
+
+def add_data(
+    db: _Database, table: str, values: Iterable[tuple[Any, ...]]
+) -> None:
+    sql = "SELECT * FROM `{table}`"
+    v = db.OpenView(sql.format(table=table))
+    count = v.GetColumnInfo(MSICOLINFO_NAMES).GetFieldCount()
+    r = CreateRecord(count)
+    for value in values:
+        assert len(value) == count, value
+        for i in range(count):
+            field = value[i]
+            if isinstance(field, int):
+                r.SetInteger(i + 1, field)
+            elif isinstance(field, str):
+                r.SetString(i + 1, field)
+            elif field is None:
+                pass
+            elif isinstance(field, Binary):
+                r.SetStream(i + 1, field.name)
+            else:
+                msg = f"Unsupported type {field.__class__.__name__}"
+                raise TypeError(msg)
+        try:
+            v.Modify(MSIMODIFY_INSERT, r)
+        except Exception:  # noqa: BLE001
+            msg = f"Could not insert {values!r} into {table}"
+            raise MSIError(msg) from None
+
+        r.ClearData()
+    v.Close()
+
+
+def add_stream(db: _Database, name: str, path: str) -> None:
+    sql = "INSERT INTO _Streams (Name, Data) VALUES ('{name}', ?)"
+    v = db.OpenView(sql.format(name=name))
+    r = CreateRecord(1)
+    r.SetStream(1, path)
+    v.Execute(r)
+    v.Close()
+
+
+def init_database(
+    name: str,
+    schema: ModuleType,
+    ProductName: str,
+    ProductCode: str,
+    ProductVersion: str,
+    Manufacturer: str,
+) -> _Database:
+    with contextlib.suppress(OSError):
+        os.unlink(name)
+    ProductCode = ProductCode.upper()
+    # Create the database
+    db = OpenDatabase(name, MSIDBOPEN_CREATE)
+    # Create the tables
+    for t in schema.tables:
+        t.create(db)
+    # Fill the validation table
+    add_data(db, "_Validation", schema._Validation_records)  # noqa: SLF001
+    # Initialize the summary information, allowing at most 20 properties
+    si = db.GetSummaryInformation(20)
+    si.SetProperty(PID_TITLE, "Installation Database")
+    si.SetProperty(PID_SUBJECT, ProductName)
+    si.SetProperty(PID_AUTHOR, Manufacturer)
+    # https://learn.microsoft.com/en-us/windows/win32/msi/template-summary
+    if AMD64:
+        si.SetProperty(PID_TEMPLATE, "x64;1033")
+    elif ARM64:
+        si.SetProperty(PID_TEMPLATE, "Arm64;1033")
+    else:
+        si.SetProperty(PID_TEMPLATE, "Intel;1033")
+    si.SetProperty(PID_REVNUMBER, gen_uuid())
+    # https://learn.microsoft.com/en-us/windows/win32/msi/word-count-summary
+    # 2 = long file names, compressed, original media
+    si.SetProperty(PID_WORDCOUNT, 2)
+    # https://learn.microsoft.com/en-us/windows/win32/msi/page-count-summary
+    # https://learn.microsoft.com/en-us/windows/win32/msi/using-64-bit-windows-installer-packages
+    if ARM64:
+        si.SetProperty(PID_PAGECOUNT, 500)  # minimum of Windows Installer 5.0
+    else:
+        si.SetProperty(PID_PAGECOUNT, 200)  # minimum of Windows Installer 2.0
+    si.SetProperty(PID_APPNAME, "Python MSI Library")
+    # XXX more properties
+    si.Persist()
+    add_data(
+        db,
+        "Property",
+        [
+            ("ProductName", ProductName),
+            ("ProductCode", ProductCode),
+            ("ProductVersion", ProductVersion),
+            ("Manufacturer", Manufacturer),
+            ("ProductLanguage", "1033"),
+        ],
+    )
+    db.Commit()
+    return db
+
+
+def add_tables(db: _Database, module: ModuleType) -> None:
+    for table in module.tables:
+        add_data(db, table, getattr(module, table))
+
+
+def make_id(value: str) -> str:
+    identifier_chars = string.ascii_letters + string.digits + "._"
+    value = "".join([c if c in identifier_chars else "_" for c in value])
+    if value[0] in (string.digits + "."):
+        value = "_" + value
+    assert re.match("^[A-Za-z_][A-Za-z0-9_.]*$", value), "FILE" + value
+    return value
+
+
+def gen_uuid() -> str:
+    return "{" + UuidCreate().upper() + "}"
+
+
+class CAB:
+    name: str
+    files: list[tuple[str, str]]
+    filenames: set[str]
+    index: int
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.files = []
+        self.filenames = set()
+        self.index = 0
+
+    def gen_id(self, file: str) -> str:
+        logical = _logical = make_id(file)
+        pos = 1
+        while logical in self.filenames:
+            logical = f"{_logical}.{pos}"
+            pos += 1
+        self.filenames.add(logical)
+        return logical
+
+    def append(
+        self, full: str, file: str, logical: str | None
+    ) -> tuple[int, str] | None:
+        if os.path.isdir(full):
+            return None
+        if not logical:
+            logical = self.gen_id(file)
+        self.index += 1
+        self.files.append((full, logical))
+        return self.index, logical
+
+    def commit(self, db: _Database) -> None:
+        fd, filename = mkstemp()
+        os.close(fd)
+        FCICreate(filename, self.files)
+        add_data(
+            db, "Media", [(1, self.index, None, "#" + self.name, None, None)]
+        )
+        add_stream(db, self.name, filename)
+        os.unlink(filename)
+        db.Commit()
+
+
+_directories: set[str] = set()
+
+
+class Directory:
+    db: _Database
+    cab: CAB
+    basedir: Directory | None
+    physical: str
+    logical: str
+    component: str | None
+    short_names: set[str]
+    ids: set[str]
+    keyfiles: dict[str, str]
+    componentflags: int | None
+    absolute: str
+
+    def __init__(
+        self,
+        db: _Database,
+        cab: CAB,
+        basedir: Directory | None,
+        physical: str,
+        _logical: str,
+        default: str,
+        componentflags: int | None = None,
+    ) -> None:
+        """Create a new directory in the Directory table.
+
+        There is a current component at each point in time for the directory,
+        which is either explicitly created through start_component, or
+        implicitly when files are added for the first time. Files are added
+        into the current component, and into the cab file. To create a
+        directory, a base directory object needs to be specified (can be None),
+        the path to the physical directory, and a logical directory name.
+        Default specifies the DefaultDir slot in the directory table.
+        componentflags specifies the default flags that new components get.
+        """
+        index = 1
+        _logical = make_id(_logical)
+        logical = _logical
+        while logical in _directories:
+            logical = f"{_logical}{index}"
+            index += 1
+        _directories.add(logical)
+        self.db = db
+        self.cab = cab
+        self.basedir = basedir
+        self.physical = physical
+        self.logical = logical
+        self.component = None
+        self.short_names = set()
+        self.ids = set()
+        self.keyfiles = {}
+        self.componentflags = componentflags
+        if basedir:
+            self.absolute = os.path.join(basedir.absolute, physical)
+            blogical = basedir.logical
+        else:
+            self.absolute = physical
+            blogical = None
+        add_data(db, "Directory", [(logical, blogical, default)])
+
+    def start_component(
+        self,
+        component: str | None = None,
+        feature: Feature | None = None,
+        flags: int | None = None,
+        keyfile: str | None = None,
+        uuid: str | None = None,
+    ) -> None:
+        """Add an entry to the Component table.
+
+        And make this component the current for this directory. If no component
+        name is given, the directory name is used. If no feature is given, the
+        current feature is used. If no flags are given, the directory's default
+        flags are used. If no keyfile is given, the KeyPath is left null in the
+        Component table.
+        """
+        if flags is None:
+            flags = self.componentflags or 0
+        uuid = gen_uuid() if uuid is None else uuid.upper()
+        if component is None:
+            component = self.logical
+        self.component = component
+        # https://learn.microsoft.com/en-us/windows/win32/msi/component-table
+        if AMD64 or ARM64:
+            flags |= 256  # msidbComponentAttributes64bit
+        if keyfile:
+            keyid = self.cab.gen_id(keyfile)
+            self.keyfiles[keyfile] = keyid
+        else:
+            keyid = None
+        add_data(
+            self.db,
+            "Component",
+            [(component, uuid, self.logical, flags, None, keyid)],
+        )
+        if feature is None:
+            feature = current_feature
+        add_data(self.db, "FeatureComponents", [(feature.id, component)])
+
+    def make_short(self, file: str) -> str:
+        oldfile = file
+        file = file.replace("+", "_")
+        file = "".join(c for c in file if c not in r' "/\[]:;=,')
+        parts = file.split(".")
+        if len(parts) > 1:
+            prefix = "".join(parts[:-1]).upper()
+            suffix = parts[-1].upper()
+            if not prefix:
+                prefix = suffix
+                suffix = None
+        else:
+            prefix = file.upper()
+            suffix = None
+        if (
+            len(parts) < 3
+            and len(prefix) <= 8
+            and file == oldfile
+            and (not suffix or len(suffix) <= 3)
+        ):
+            newfile = f"{prefix}.{suffix}" if suffix else prefix
+        else:
+            newfile = None
+        if newfile is None or newfile in self.short_names:
+            prefix = prefix[:6]
+            if suffix:
+                suffix = suffix[:3]
+            pos = 1
+            while 1:
+                if suffix:
+                    newfile = f"{prefix}~{pos}.{suffix}"
+                else:
+                    newfile = f"{prefix}~{pos}"
+                if newfile not in self.short_names:
+                    break
+                pos += 1
+                assert pos < 10000
+                if pos in (10, 100, 1000):
+                    prefix = prefix[:-1]
+        self.short_names.add(newfile)
+        # restrictions on short names
+        assert not re.search(r'[\?|><:/*"+,;=\[\]]', newfile)
+        return newfile
+
+    def add_file(
+        self,
+        file: str,
+        src: str | None = None,
+        version: str | None = None,
+        language: str | None = None,
+    ) -> str | None:
+        """Add a file to the current component of the directory.
+
+        Starting a new one if there is no current component. By default, the
+        file name in the source and the file table will be identical. If the
+        src file is specified, it is interpreted relative to the current
+        directory. Optionally, a version and a language can be specified for
+        the entry in the File table.
+        """
+        if not self.component:
+            self.start_component(self.logical, current_feature, 0)
+        if not src:
+            # Allow relative paths for file if src is not specified
+            src = file
+            file = os.path.basename(file)
+        absolute = os.path.join(self.absolute, src)
+        # restrictions on long names
+        assert not re.search(r'[\?|><:/*]"', file)
+        logical = self.keyfiles.get(file, None)
+        ok = self.cab.append(absolute, file, logical)
+        if ok is None:
+            return None
+        sequence, logical = ok
+        assert logical not in self.ids
+        self.ids.add(logical)
+        short = self.make_short(file)
+        full = f"{short}|{file}"
+        filesize = os.stat(absolute).st_size
+        # constants.msidbFileAttributesVital
+        # Compressed omitted, since it is the database default
+        # could add r/o, system, hidden
+        attributes = 512
+        add_data(
+            self.db,
+            "File",
+            [
+                (
+                    logical,
+                    self.component,
+                    full,
+                    filesize,
+                    version,
+                    language,
+                    attributes,
+                    sequence,
+                )
+            ],
+        )
+        # if not version:
+        #    # Add hash if the file is not versioned
+        #    filehash = FileHash(absolute, 0)
+        #    add_data(self.db, "MsiFileHash",
+        #             [(logical, 0, filehash.IntegerData(1),
+        #               filehash.IntegerData(2), filehash.IntegerData(3),
+        #               filehash.IntegerData(4))])
+        # Automatically remove .pyc files on uninstall (2)
+        # XXX: adding so many RemoveFile entries makes installer unbelievably
+        # slow. So instead, we have to use wildcard remove entries
+        if file.endswith(".py"):
+            add_data(
+                self.db,
+                "RemoveFile",
+                [
+                    (
+                        logical + "c",
+                        self.component,
+                        f"{short}C|{file}c",
+                        self.logical,
+                        2,
+                    ),
+                    (
+                        logical + "o",
+                        self.component,
+                        f"{short}O|{file}o",
+                        self.logical,
+                        2,
+                    ),
+                ],
+            )
+        return logical
+
+    def glob(
+        self, pattern: str, exclude: Container[str] | None = None
+    ) -> list[str]:
+        """Add a list of files to the current component.
+
+        Add a list of files to the current component as specified in the
+        glob pattern. Individual files can be excluded in the exclude list.
+        """
+        try:
+            files = os.listdir(self.absolute)
+        except OSError:
+            return []
+        if pattern[:1] != ".":
+            files = (f for f in files if f[0] != ".")
+        files = fnmatch.filter(files, pattern)
+        for f in files:
+            if exclude and f in exclude:
+                continue
+            self.add_file(f)
+        return files
+
+    def remove_pyc(self) -> None:
+        """Remove .pyc files on uninstall."""
+        if not self.component:
+            self.component = self.logical
+        add_data(
+            self.db,
+            "RemoveFile",
+            [(self.component + "c", self.component, "*.pyc", self.logical, 2)],
+        )
+
+
+class Binary:
+    name: str
+
+    def __init__(self, fname: str) -> None:
+        self.name = fname
+
+    def __repr__(self) -> str:
+        return f'msilib.Binary(os.path.join(dirname,"{self.name}"))'
+
+
+current_feature: Feature
+
+
+class Feature:
+    id: str
+
+    def __init__(
+        self,
+        db: _Database,
+        id: str,
+        title: str,
+        desc: str,
+        display: int,
+        level: int = 1,
+        parent: Feature | None = None,
+        directory: str | None = None,
+        attributes: int = 0,
+    ) -> None:
+        self.id = id
+        pid = parent.id if parent else None
+        add_data(
+            db,
+            "Feature",
+            [(id, pid, title, desc, display, level, directory, attributes)],
+        )
+
+    def set_current(self) -> None:
+        global current_feature  # noqa: PLW0603
+        current_feature = self
+
+
+class Control:
+    dlg: Dialog
+    name: str
+
+    def __init__(self, dlg: Dialog, name: str) -> None:
+        self.dlg = dlg
+        self.name = name
+
+    def event(
+        self,
+        event: str,
+        argument: str,
+        condition: str = "1",
+        ordering: int | None = None,
+    ) -> None:
+        add_data(
+            self.dlg.db,
+            "ControlEvent",
+            [(self.dlg.name, self.name, event, argument, condition, ordering)],
+        )
+
+    def mapping(self, event: str, attribute: str) -> None:
+        add_data(
+            self.dlg.db,
+            "EventMapping",
+            [(self.dlg.name, self.name, event, attribute)],
+        )
+
+    def condition(self, action: str, condition: str) -> None:
+        add_data(
+            self.dlg.db,
+            "ControlCondition",
+            [(self.dlg.name, self.name, action, condition)],
+        )
+
+
+class RadioButtonGroup(Control):
+    property: str
+    index: int
+
+    def __init__(self, dlg: Dialog, name: str, property: str) -> None:
+        self.dlg = dlg
+        self.name = name
+        self.property = property
+        self.index = 1
+
+    def add(
+        self,
+        name: str,
+        x: int,
+        y: int,
+        w: int,
+        h: int,
+        text: str,
+        value: str | None = None,
+    ) -> None:
+        if value is None:
+            value = name
+        add_data(
+            self.dlg.db,
+            "RadioButton",
+            [(self.property, self.index, value, x, y, w, h, text, None)],
+        )
+        self.index += 1
+
+
+class Dialog:
+    db: _Database
+    name: str
+    x: int
+    y: int
+    w: int
+    h: int
+
+    def __init__(
+        self,
+        db: _Database,
+        name: str,
+        x: int,
+        y: int,
+        w: int,
+        h: int,
+        attr: int,
+        title: str,
+        first: str,
+        default: str | None,
+        cancel: str | None,
+    ) -> None:
+        self.db = db
+        self.name = name
+        self.x, self.y, self.w, self.h = x, y, w, h
+        add_data(
+            db,
+            "Dialog",
+            [(name, x, y, w, h, attr, title, first, default, cancel)],
+        )
+
+    def control(
+        self,
+        name: str,
+        type: str,
+        x: int,
+        y: int,
+        w: int,
+        h: int,
+        attr: int,
+        prop: str | None,
+        text: str | None,
+        next: str | None,
+        help: str | None,
+    ) -> Control:
+        add_data(
+            self.db,
+            "Control",
+            [
+                (
+                    self.name,
+                    name,
+                    type,
+                    x,
+                    y,
+                    w,
+                    h,
+                    attr,
+                    prop,
+                    text,
+                    next,
+                    help,
+                )
+            ],
+        )
+        return Control(self, name)
+
+    def text(
+        self,
+        name: str,
+        x: int,
+        y: int,
+        w: int,
+        h: int,
+        attr: int,
+        text: str | None,
+    ) -> Control:
+        return self.control(
+            name, "Text", x, y, w, h, attr, None, text, None, None
+        )
+
+    def bitmap(
+        self, name: str, x: int, y: int, w: int, h: int, text: str | None
+    ) -> Control:
+        return self.control(
+            name, "Bitmap", x, y, w, h, 1, None, text, None, None
+        )
+
+    def line(self, name: str, x: int, y: int, w: int, h: int) -> Control:
+        return self.control(
+            name, "Line", x, y, w, h, 1, None, None, None, None
+        )
+
+    def pushbutton(
+        self,
+        name: str,
+        x: int,
+        y: int,
+        w: int,
+        h: int,
+        attr: int,
+        text: str | None,
+        next: str | None,
+    ) -> Control:
+        return self.control(
+            name, "PushButton", x, y, w, h, attr, None, text, next, None
+        )
+
+    def radiogroup(
+        self,
+        name: str,
+        x: int,
+        y: int,
+        w: int,
+        h: int,
+        attr: int,
+        prop: str,
+        text: str | None,
+        next: str | None,
+    ) -> Control:
+        add_data(
+            self.db,
+            "Control",
+            [
+                (
+                    self.name,
+                    name,
+                    "RadioButtonGroup",
+                    x,
+                    y,
+                    w,
+                    h,
+                    attr,
+                    prop,
+                    text,
+                    next,
+                    None,
+                )
+            ],
+        )
+        return RadioButtonGroup(self, name, prop)
+
+    def checkbox(
+        self,
+        name: str,
+        x: int,
+        y: int,
+        w: int,
+        h: int,
+        attr: int,
+        prop: str | None,
+        text: str | None,
+        next: str | None,
+    ) -> Control:
+        return self.control(
+            name, "CheckBox", x, y, w, h, attr, prop, text, next, None
+        )