Igor20264
860 lines
29 KiB
Python
860 lines
29 KiB
Python
import docx.text.font as Font
|
|
|
|
from typing import Optional, Union, Dict, Any
|
|
from enum import Enum
|
|
|
|
|
|
class ThemeFont(Enum):
|
|
MAJOR_ASCII = "majorAscii"
|
|
MAJOR_H_ANSI = "majorHAnsi"
|
|
MAJOR_EAST_ASIAN = "majorEastAsia"
|
|
MAJOR_BIDI = "majorBidi"
|
|
MINOR_ASCII = "minorAscii"
|
|
MINOR_H_ANSI = "minorHAnsi"
|
|
MINOR_EAST_ASIAN = "minorEastAsia"
|
|
MINOR_BIDI = "minorBidi"
|
|
|
|
|
|
class Font:
|
|
"""
|
|
Класс, представляющий форматирование шрифта для пробега текста (run) в Word.
|
|
Поддерживает три-state значения (True/False/None) и множественные шрифты.
|
|
"""
|
|
|
|
def __init__(self):
|
|
# Основные шрифты
|
|
self._ascii: Optional[str] = None
|
|
self._h_ansi: Optional[str] = None
|
|
self._east_asia: Optional[str] = None
|
|
self._cs: Optional[str] = None
|
|
|
|
# Тематические шрифты (меньший приоритет)
|
|
self._ascii_theme: Optional[ThemeFont] = None
|
|
self._h_ansi_theme: Optional[ThemeFont] = None
|
|
self._east_asia_theme: Optional[ThemeFont] = None
|
|
self._cs_theme: Optional[ThemeFont] = None
|
|
|
|
# Три-state булевы свойства (None = унаследовано)
|
|
self._bold: Optional[bool] = None
|
|
self._italic: Optional[bool] = None
|
|
self._small_caps: Optional[bool] = None
|
|
self._strike: Optional[bool] = None
|
|
self._double_strike: Optional[bool] = None
|
|
self._outline: Optional[bool] = None
|
|
self._shadow: Optional[bool] = None
|
|
self._emboss: Optional[bool] = None
|
|
self._imprint: Optional[bool] = None
|
|
self._hidden: Optional[bool] = None
|
|
self._all_caps: Optional[bool] = None
|
|
self._complex_script: Optional[bool] = None
|
|
self._rtl: Optional[bool] = None
|
|
self._no_proof: Optional[bool] = None
|
|
|
|
# --- Свойство: name (основное имя шрифта) ---
|
|
@property
|
|
def name(self) -> Optional[str]:
|
|
"""Возвращает имя основного шрифта (w:ascii)."""
|
|
return self._ascii
|
|
|
|
@name.setter
|
|
def name(self, value: Optional[str]) -> None:
|
|
"""
|
|
Устанавливает w:ascii и w:hAnsi одновременно.
|
|
Если значение None — оба атрибута удаляются.
|
|
"""
|
|
if value is None:
|
|
self._ascii = None
|
|
self._h_ansi = None
|
|
else:
|
|
self._ascii = str(value)
|
|
self._h_ansi = str(value)
|
|
|
|
# --- Другие шрифты ---
|
|
@property
|
|
def east_asia(self) -> Optional[str]:
|
|
return self._east_asia
|
|
|
|
@east_asia.setter
|
|
def east_asia(self, value: Optional[str]) -> None:
|
|
self._east_asia = value
|
|
|
|
@property
|
|
def complex_script(self) -> Optional[str]:
|
|
return self._cs
|
|
|
|
@complex_script.setter
|
|
def complex_script(self, value: Optional[str]) -> None:
|
|
self._cs = value
|
|
|
|
@property
|
|
def ascii_theme(self) -> Optional[ThemeFont]:
|
|
return self._ascii_theme
|
|
|
|
@ascii_theme.setter
|
|
def ascii_theme(self, theme_font: Optional[ThemeFont]) -> None:
|
|
if isinstance(theme_font, ThemeFont) or theme_font is None:
|
|
self._ascii_theme = theme_font
|
|
else:
|
|
raise ValueError("ascii_theme must be a ThemeFont or None")
|
|
|
|
@property
|
|
def h_ansi_theme(self) -> Optional[ThemeFont]:
|
|
return self._h_ansi_theme
|
|
|
|
@h_ansi_theme.setter
|
|
def h_ansi_theme(self, theme_font: Optional[ThemeFont]) -> None:
|
|
self._h_ansi_theme = theme_font
|
|
|
|
# --- Три-state Boolean Properties (Toggle properties marked) ---
|
|
|
|
@property
|
|
def bold(self) -> Optional[bool]:
|
|
return self._bold
|
|
|
|
@bold.setter
|
|
def bold(self, value: Optional[bool]) -> None:
|
|
if value in (True, False, None):
|
|
self._bold = value
|
|
else:
|
|
raise ValueError("bold must be True, False, or None")
|
|
|
|
@property
|
|
def italic(self) -> Optional[bool]:
|
|
return self._italic
|
|
|
|
@italic.setter
|
|
def italic(self, value: Optional[bool]) -> None:
|
|
if value in (True, False, None):
|
|
self._italic = value
|
|
else:
|
|
raise ValueError("italic must be True, False, or None")
|
|
|
|
@property
|
|
def small_caps(self) -> Optional[bool]:
|
|
return self._small_caps
|
|
|
|
@small_caps.setter
|
|
def small_caps(self, value: Optional[bool]) -> None:
|
|
if value in (True, False, None):
|
|
self._small_caps = value
|
|
else:
|
|
raise ValueError("small_caps must be True, False, or None")
|
|
|
|
@property
|
|
def strike(self) -> Optional[bool]:
|
|
return self._strike
|
|
|
|
@strike.setter
|
|
def strike(self, value: Optional[bool]) -> None:
|
|
if value in (True, False, None):
|
|
self._strike = value
|
|
else:
|
|
raise ValueError("strike must be True, False, or None")
|
|
|
|
@property
|
|
def double_strike(self) -> Optional[bool]:
|
|
return self._double_strike
|
|
|
|
@double_strike.setter
|
|
def double_strike(self, value: Optional[bool]) -> None:
|
|
if value in (True, False, None):
|
|
self._double_strike = value
|
|
else:
|
|
raise ValueError("double_strike must be True, False, or None")
|
|
|
|
@property
|
|
def outline(self) -> Optional[bool]:
|
|
return self._outline
|
|
|
|
@outline.setter
|
|
def outline(self, value: Optional[bool]) -> None:
|
|
if value in (True, False, None):
|
|
self._outline = value
|
|
else:
|
|
raise ValueError("outline must be True, False, or None")
|
|
|
|
@property
|
|
def shadow(self) -> Optional[bool]:
|
|
return self._shadow
|
|
|
|
@shadow.setter
|
|
def shadow(self, value: Optional[bool]) -> None:
|
|
if value in (True, False, None):
|
|
self._shadow = value
|
|
else:
|
|
raise ValueError("shadow must be True, False, or None")
|
|
|
|
@property
|
|
def emboss(self) -> Optional[bool]:
|
|
return self._emboss
|
|
|
|
@emboss.setter
|
|
def emboss(self, value: Optional[bool]) -> None:
|
|
if value in (True, False, None):
|
|
self._emboss = value
|
|
else:
|
|
raise ValueError("emboss must be True, False, or None")
|
|
|
|
@property
|
|
def imprint(self) -> Optional[bool]:
|
|
return self._imprint
|
|
|
|
@imprint.setter
|
|
def imprint(self, value: Optional[bool]) -> None:
|
|
if value in (True, False, None):
|
|
self._imprint = value
|
|
else:
|
|
raise ValueError("imprint must be True, False, or None")
|
|
|
|
@property
|
|
def hidden(self) -> Optional[bool]:
|
|
return self._hidden
|
|
|
|
@hidden.setter
|
|
def hidden(self, value: Optional[bool]) -> None:
|
|
if value in (True, False, None):
|
|
self._hidden = value
|
|
else:
|
|
raise ValueError("hidden must be True, False, or None")
|
|
|
|
@property
|
|
def all_caps(self) -> Optional[bool]:
|
|
return self._all_caps
|
|
|
|
@all_caps.setter
|
|
def all_caps(self, value: Optional[bool]) -> None:
|
|
if value in (True, False, None):
|
|
self._all_caps = value
|
|
else:
|
|
raise ValueError("all_caps must be True, False, or None")
|
|
|
|
@property
|
|
def cs(self) -> Optional[bool]:
|
|
return self._complex_script
|
|
|
|
@cs.setter
|
|
def cs(self, value: Optional[bool]) -> None:
|
|
if value in (True, False, None):
|
|
self._complex_script = value
|
|
else:
|
|
raise ValueError("cs must be True, False, or None")
|
|
|
|
@property
|
|
def rtl(self) -> Optional[bool]:
|
|
return self._rtl
|
|
|
|
@rtl.setter
|
|
def rtl(self, value: Optional[bool]) -> None:
|
|
if value in (True, False, None):
|
|
self._rtl = value
|
|
else:
|
|
raise ValueError("rtl must be True, False, or None")
|
|
|
|
@property
|
|
def no_proof(self) -> Optional[bool]:
|
|
return self._no_proof
|
|
|
|
@no_proof.setter
|
|
def no_proof(self, value: Optional[bool]) -> None:
|
|
if value in (True, False, None):
|
|
self._no_proof = value
|
|
else:
|
|
raise ValueError("no_proof must be True, False, or None")
|
|
|
|
# --- Методы сериализации в XML / словарь ---
|
|
def to_xml_dict(self) -> Dict[str, Any]:
|
|
"""Преобразует текущее состояние шрифта в словарь, имитирующий XML."""
|
|
r_pr = {}
|
|
|
|
fonts = {}
|
|
if self._ascii:
|
|
fonts['ascii'] = self._ascii
|
|
if self._h_ansi:
|
|
fonts['hAnsi'] = self._h_ansi
|
|
if self._east_asia:
|
|
fonts['eastAsia'] = self._east_asia
|
|
if self._cs:
|
|
fonts['cs'] = self._cs
|
|
if self._ascii_theme:
|
|
fonts['asciiTheme'] = self._ascii_theme.value
|
|
if self._h_ansi_theme:
|
|
fonts['hAnsiTheme'] = self._h_ansi_theme.value
|
|
if self._east_asia_theme:
|
|
fonts['eastAsiaTheme'] = self._east_asia_theme.value
|
|
if self._cs_theme:
|
|
fonts['csTheme'] = self._cs_theme.value
|
|
|
|
if fonts:
|
|
r_pr['rFonts'] = fonts
|
|
|
|
# Boolean properties (если не None)
|
|
bool_map = {
|
|
'b': self._bold,
|
|
'i': self._italic,
|
|
'caps': self._all_caps,
|
|
'smallCaps': self._small_caps,
|
|
'strike': self._strike,
|
|
'dstrike': self._double_strike,
|
|
'outline': self._outline,
|
|
'shadow': self._shadow,
|
|
'emboss': self._emboss,
|
|
'imprint': self._imprint,
|
|
'vanish': self._hidden,
|
|
'cs': self._complex_script,
|
|
'rtl': self._rtl,
|
|
'noProof': self._no_proof
|
|
}
|
|
|
|
for tag, val in bool_map.items():
|
|
if val is not None:
|
|
r_pr[tag] = 'on' if val else 'off'
|
|
|
|
return r_pr
|
|
|
|
def __repr__(self) -> str:
|
|
return f"<Font name={self.name!r} bold={self.bold} italic={self.italic}>"
|
|
|
|
|
|
class FontManager:
|
|
"""
|
|
Централизованный менеджер шрифтов, использующий темы.
|
|
Может устанавливать глобальные шрифты (major/minor) для разных языковых групп.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self._theme_fonts: Dict[ThemeFont, str] = {}
|
|
|
|
def set_theme_font(self, theme_type: ThemeFont, font_name: str) -> None:
|
|
"""Устанавливает шрифт для определённой темы."""
|
|
self._theme_fonts[theme_type] = font_name
|
|
|
|
def get_theme_font(self, theme_type: ThemeFont) -> Optional[str]:
|
|
"""Получает шрифт по типу темы."""
|
|
return self._theme_fonts.get(theme_type)
|
|
|
|
def apply_theme_to_font(self, font: Font) -> None:
|
|
"""Применяет тему к объекту Font, если явно не задан основной шрифт."""
|
|
# Только если w:ascii не задан, используем w:asciiTheme
|
|
if font._ascii is None and font._ascii_theme:
|
|
font._ascii = self.get_theme_font(font._ascii_theme)
|
|
if font._h_ansi is None and font._h_ansi_theme:
|
|
font._h_ansi = self.get_theme_font(font._h_ansi_theme)
|
|
if font._east_asia is None and font._east_asia_theme:
|
|
font._east_asia = self.get_theme_font(font._east_asia_theme)
|
|
if font._cs is None and font._cs_theme:
|
|
font._cs = self.get_theme_font(font._cs_theme)
|
|
|
|
def __repr__(self) -> str:
|
|
return f"<FontManager themes={len(self._theme_fonts)}>"
|
|
|
|
|
|
from enum import Enum
|
|
from typing import Optional, Dict, Any, List
|
|
|
|
|
|
class StyleType(Enum):
|
|
PARAGRAPH = "paragraph"
|
|
CHARACTER = "character"
|
|
TABLE = "table"
|
|
NUMBERING = "numbering"
|
|
|
|
|
|
class Style:
|
|
"""
|
|
Представление одного стиля Word (<w:style>).
|
|
Поддерживает атрибуты: имя, ID, тип, базовый стиль, приоритет, поведение и форматирование.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
style_id: str,
|
|
type_: StyleType,
|
|
name: Optional[str] = None,
|
|
default: bool = False,
|
|
custom_style: bool = False,
|
|
):
|
|
self.style_id = style_id
|
|
self.type = type_
|
|
self.default = default
|
|
self.custom_style = custom_style
|
|
|
|
# Основные свойства
|
|
self._name: Optional[str] = name or style_id # fallback на styleId
|
|
self._based_on: Optional[str] = None # ссылка на другой styleId
|
|
self._next: Optional[str] = None
|
|
self._link: Optional[str] = None
|
|
|
|
# Поведенческие флаги
|
|
self._ui_priority: Optional[int] = None
|
|
self._semi_hidden: bool = False
|
|
self._unhide_when_used: bool = False
|
|
self._q_format: bool = False
|
|
self._locked: bool = False
|
|
|
|
# Форматирование
|
|
self._paragraph_format: Optional[Dict[str, Any]] = None
|
|
self._font: Optional[Dict[str, Any]] = None
|
|
self._table_properties: Optional[Dict[str, Any]] = None
|
|
self._row_properties: Optional[Dict[str, Any]] = None
|
|
self._cell_properties: Optional[Dict[str, Any]] = None
|
|
self._table_style_properties: List[Dict[str, Any]] = []
|
|
|
|
# Служебное
|
|
self._rsid: Optional[str] = None
|
|
|
|
# --- Свойства ---
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
return self._name or self.style_id
|
|
|
|
@name.setter
|
|
def name(self, value: str) -> None:
|
|
self._name = value
|
|
|
|
@property
|
|
def based_on(self) -> Optional[str]:
|
|
return self._based_on
|
|
|
|
@based_on.setter
|
|
def based_on(self, style_id: Optional[str]) -> None:
|
|
self._based_on = style_id
|
|
|
|
@property
|
|
def next_style(self) -> Optional[str]:
|
|
return self._next
|
|
|
|
@next_style.setter
|
|
def next_style(self, style_id: Optional[str]) -> None:
|
|
self._next = style_id
|
|
|
|
@property
|
|
def linked_style(self) -> Optional[str]:
|
|
return self._link
|
|
|
|
@linked_style.setter
|
|
def linked_style(self, style_id: Optional[str]) -> None:
|
|
self._link = style_id
|
|
|
|
@property
|
|
def priority(self) -> Optional[int]:
|
|
return self._ui_priority
|
|
|
|
@priority.setter
|
|
def priority(self, value: Optional[int]) -> None:
|
|
if value is not None and not isinstance(value, int):
|
|
raise ValueError("priority must be an integer or None")
|
|
self._ui_priority = value
|
|
|
|
@property
|
|
def semi_hidden(self) -> bool:
|
|
return self._semi_hidden
|
|
|
|
@semi_hidden.setter
|
|
def semi_hidden(self, value: bool) -> None:
|
|
self._semi_hidden = bool(value)
|
|
|
|
@property
|
|
def unhide_when_used(self) -> bool:
|
|
return self._unhide_when_used
|
|
|
|
@unhide_when_used.setter
|
|
def unhide_when_used(self, value: bool) -> None:
|
|
self._unhide_when_used = bool(value)
|
|
|
|
@property
|
|
def quick_style(self) -> bool:
|
|
return self._q_format
|
|
|
|
@quick_style.setter
|
|
def quick_style(self, value: bool) -> None:
|
|
self._q_format = bool(value)
|
|
|
|
@property
|
|
def locked(self) -> bool:
|
|
return self._locked
|
|
|
|
@locked.setter
|
|
def locked(self, value: bool) -> None:
|
|
self._locked = bool(value)
|
|
|
|
# --- Форматирование ---
|
|
|
|
def set_paragraph_format(self, ppr: Dict[str, Any]) -> None:
|
|
self._paragraph_format = ppr
|
|
|
|
def set_font(self, rpr: Dict[str, Any]) -> None:
|
|
self._font = rpr
|
|
|
|
def set_table_properties(self, tbl_pr: Dict[str, Any]) -> None:
|
|
self._table_properties = tbl_pr
|
|
|
|
def set_row_properties(self, tr_pr: Dict[str, Any]) -> None:
|
|
self._row_properties = tr_pr
|
|
|
|
def set_cell_properties(self, tc_pr: Dict[str, Any]) -> None:
|
|
self._cell_properties = tc_pr
|
|
|
|
def add_table_style_property(self, prop: Dict[str, Any]) -> None:
|
|
self._table_style_properties.append(prop)
|
|
|
|
# --- Вспомогательные методы ---
|
|
|
|
def is_builtin(self) -> bool:
|
|
"""Возвращает True, если стиль встроенный (не пользовательский)."""
|
|
return not self.custom_style
|
|
|
|
def is_visible_in_gallery(self) -> bool:
|
|
"""Появляется ли стиль в галерее стилей?"""
|
|
return not self.semi_hidden and self.quick_style
|
|
|
|
def to_xml_dict(self) -> Dict[str, Any]:
|
|
"""Сериализация в словарь, близкий к XML."""
|
|
result = {
|
|
"w:type": self.type.value,
|
|
"w:styleId": self.style_id,
|
|
}
|
|
if self.default:
|
|
result["w:default"] = "1"
|
|
if self.custom_style:
|
|
result["w:customStyle"] = "1"
|
|
|
|
children = []
|
|
|
|
if self._name:
|
|
children.append({"w:name": {"w:val": self._name}})
|
|
if self._based_on:
|
|
children.append({"w:basedOn": {"w:val": self._based_on}})
|
|
if self._next:
|
|
children.append({"w:next": {"w:val": self._next}})
|
|
if self._link:
|
|
children.append({"w:link": {"w:val": self._link}})
|
|
if self._ui_priority is not None:
|
|
children.append({"w:uiPriority": {"w:val": str(self._ui_priority)}})
|
|
if self._semi_hidden:
|
|
children.append({"w:semiHidden": {}})
|
|
if self._unhide_when_used:
|
|
children.append({"w:unhideWhenUsed": {}})
|
|
if self._q_format:
|
|
children.append({"w:qFormat": {}})
|
|
if self._locked:
|
|
children.append({"w:locked": {}})
|
|
if self._rsid:
|
|
children.append({"w:rsid": {"w:val": self._rsid}})
|
|
|
|
if self._paragraph_format:
|
|
children.append({"w:pPr": self._paragraph_format})
|
|
if self._font:
|
|
children.append({"w:rPr": self._font})
|
|
if self._table_properties:
|
|
children.append({"w:tblPr": self._table_properties})
|
|
if self._row_properties:
|
|
children.append({"w:trPr": self._row_properties})
|
|
if self._cell_properties:
|
|
children.append({"w:tcPr": self._cell_properties})
|
|
for tsp in self._table_style_properties:
|
|
children.append({"w:tblStylePr": tsp})
|
|
|
|
if children:
|
|
result["_children"] = children
|
|
|
|
return result
|
|
|
|
def __repr__(self) -> str:
|
|
return f"<Style id='{self.style_id}' type={self.type.name} name='{self.name}'>"
|
|
|
|
from typing import Iterator, Optional, Dict, List
|
|
import re
|
|
|
|
|
|
class Styles:
|
|
"""
|
|
Коллекция всех стилей документа: определённых, встроенных и latent.
|
|
Имитирует поведение Word по сортировке, отображению и разрешению стилей.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self._styles: Dict[str, Style] = {} # styleId -> Style
|
|
self._latent_styles: Dict[str, Dict[str, Any]] = {}
|
|
self._doc_defaults = {
|
|
"rPr": {},
|
|
"pPr": {}
|
|
}
|
|
self._latent_count = 0
|
|
self._def_semi_hidden = True
|
|
self._def_unhide_when_used = True
|
|
self._def_q_format = False
|
|
self._def_locked_state = False
|
|
self._def_ui_priority = 99
|
|
|
|
# --- Управление latent styles ---
|
|
|
|
def define_latent_style(
|
|
self,
|
|
name: str,
|
|
ui_priority: Optional[int] = None,
|
|
semi_hidden: Optional[bool] = None,
|
|
unhide_when_used: Optional[bool] = None,
|
|
q_format: Optional[bool] = None,
|
|
locked: Optional[bool] = None,
|
|
) -> None:
|
|
"""Добавляет исключение для latent style."""
|
|
self._latent_styles[name] = {
|
|
"uiPriority": ui_priority,
|
|
"semiHidden": semi_hidden,
|
|
"unhideWhenUsed": unhide_when_used,
|
|
"qFormat": q_format,
|
|
"locked": locked,
|
|
}
|
|
|
|
def set_latent_defaults(
|
|
self,
|
|
count: int = 276,
|
|
def_semi_hidden: bool = True,
|
|
def_unhide_when_used: bool = True,
|
|
def_q_format: bool = False,
|
|
def_locked_state: bool = False,
|
|
def_ui_priority: int = 99,
|
|
) -> None:
|
|
"""Устанавливает параметры по умолчанию для latent styles."""
|
|
self._latent_count = count
|
|
self._def_semi_hidden = def_semi_hidden
|
|
self._def_unhide_when_used = def_unhide_when_used
|
|
self._def_q_format = def_q_format
|
|
self._def_locked_state = def_locked_state
|
|
self._def_ui_priority = def_ui_priority
|
|
|
|
def get_latent_behavior(self, name: str) -> Dict[str, Any]:
|
|
"""Возвращает поведенческие атрибуты для встроенного стиля."""
|
|
base = {
|
|
"semiHidden": self._def_semi_hidden,
|
|
"unhideWhenUsed": self._def_unhide_when_used,
|
|
"qFormat": self._def_q_format,
|
|
"locked": self._def_locked_state,
|
|
"uiPriority": self._def_ui_priority,
|
|
}
|
|
override = self._latent_styles.get(name, {})
|
|
base.update({k: v for k, v in override.items() if v is not None})
|
|
return base
|
|
|
|
# --- Добавление/получение стилей ---
|
|
|
|
def add_style(
|
|
self,
|
|
style_id: str,
|
|
type_: StyleType,
|
|
name: Optional[str] = None,
|
|
default: bool = False,
|
|
custom_style: bool = False,
|
|
) -> Style:
|
|
"""Создаёт и добавляет новый стиль."""
|
|
style = Style(style_id, type_, name=name, default=default, custom_style=custom_style)
|
|
self._styles[style_id] = style
|
|
return style
|
|
|
|
def get_by_id(self, style_id: str) -> Optional[Style]:
|
|
"""Получить стиль по ID."""
|
|
return self._styles.get(style_id)
|
|
|
|
def get_by_name(self, name: str) -> Optional[Style]:
|
|
"""Найти стиль по имени (регистронезависимо)."""
|
|
for style in self._styles.values():
|
|
if style.name.lower() == name.lower():
|
|
return style
|
|
return None
|
|
|
|
def __getitem__(self, key: str) -> Style:
|
|
"""Доступ как по ID, так и по имени."""
|
|
style = self.get_by_id(key)
|
|
if style is None:
|
|
style = self.get_by_name(key)
|
|
if style is None:
|
|
raise KeyError(f"Style '{key}' not found.")
|
|
return style
|
|
|
|
def __setitem__(self, key: str, style: Style) -> None:
|
|
if not isinstance(style, Style):
|
|
raise TypeError("Only Style objects can be added.")
|
|
self._styles[style.style_id] = style
|
|
|
|
def __delitem__(self, key: str) -> None:
|
|
style = self.get_by_id(key) or self.get_by_name(key)
|
|
if style is None:
|
|
raise KeyError(f"Style '{key}' not found.")
|
|
del self._styles[style.style_id]
|
|
|
|
def __contains__(self, key: str) -> bool:
|
|
return (key in self._styles) or (self.get_by_name(key) is not None)
|
|
|
|
def __len__(self) -> int:
|
|
return len(self._styles)
|
|
|
|
def __iter__(self) -> Iterator[Style]:
|
|
"""Итерация по всем определённым стилям."""
|
|
return iter(self._styles.values())
|
|
|
|
# --- Document defaults ---
|
|
|
|
def set_default_run_properties(self, rpr: Dict[str, Any]) -> None:
|
|
self._doc_defaults["rPr"] = rpr
|
|
|
|
def set_default_paragraph_properties(self, ppr: Dict[str, Any]) -> None:
|
|
self._doc_defaults["pPr"] = ppr
|
|
|
|
def get_default_font(self) -> Dict[str, Any]:
|
|
return self._doc_defaults["rPr"]
|
|
|
|
def get_default_paragraph_format(self) -> Dict[str, Any]:
|
|
return self._doc_defaults["pPr"]
|
|
|
|
# --- Списки стилей (как в интерфейсе Word) ---
|
|
|
|
def recommended_list(self) -> List[Style]:
|
|
"""Стили, отображаемые в категории 'Recommended'."""
|
|
return [
|
|
s for s in self._styles.values()
|
|
if not s.semi_hidden
|
|
]
|
|
|
|
def styles_in_use(self, used_style_ids: List[str]) -> List[Style]:
|
|
"""Стили, применённые в документе и не semiHidden."""
|
|
return [
|
|
s for s in self._styles.values()
|
|
if s.style_id in used_style_ids and not s.semi_hidden
|
|
]
|
|
|
|
def in_current_document(self) -> List[Style]:
|
|
"""Все определённые стили, кроме semiHidden."""
|
|
return [s for s in self._styles.values() if not s.semi_hidden]
|
|
|
|
def all_styles(self) -> List[Style]:
|
|
"""Все определённые стили (включая semiHidden)."""
|
|
return list(self._styles.values())
|
|
|
|
# --- Сортировка ---
|
|
|
|
def sorted_by_appearance(self) -> List[Style]:
|
|
"""
|
|
Сортировка стилей так, как они отображаются в панели стилей Word:
|
|
- По uiPriority (возрастание)
|
|
- При равном приоритете — по имени (алфавитно)
|
|
- Custom-стили без uiPriority попадают в начало (uiPriority=0)
|
|
"""
|
|
def sort_key(style: Style) -> tuple:
|
|
prio = style.priority if style.priority is not None else 0
|
|
return (prio, style.name.lower())
|
|
|
|
return sorted(self._styles.values(), key=sort_key)
|
|
|
|
# --- Генерация XML ---
|
|
|
|
def to_xml_dict(self) -> Dict[str, Any]:
|
|
result = {
|
|
"w:styles": {
|
|
"_children": []
|
|
}
|
|
}
|
|
|
|
# docDefaults
|
|
if any(self._doc_defaults["rPr"]) or any(self._doc_defaults["pPr"]):
|
|
defaults = {"_children": []}
|
|
if self._doc_defaults["rPr"]:
|
|
defaults["_children"].append({
|
|
"w:rPrDefault": {
|
|
"_children": [{"w:rPr": self._doc_defaults["rPr"]}]
|
|
}
|
|
})
|
|
if self._doc_defaults["pPr"]:
|
|
defaults["_children"].append({
|
|
"w:pPrDefault": {
|
|
"_children": [{"w:pPr": self._doc_defaults["pPr"]}]
|
|
}
|
|
})
|
|
result["w:styles"]["_children"].append(defaults)
|
|
|
|
# latentStyles
|
|
latent_children = []
|
|
for name, props in self._latent_styles.items():
|
|
exc = {"w:name": name}
|
|
if props["uiPriority"] is not None:
|
|
exc["w:uiPriority"] = str(props["uiPriority"])
|
|
if props["semiHidden"] is not None:
|
|
exc["w:semiHidden"] = "1" if props["semiHidden"] else "0"
|
|
if props["unhideWhenUsed"] is not None:
|
|
exc["w:unhideWhenUsed"] = "1" if props["unhideWhenUsed"] else "0"
|
|
if props["qFormat"] is not None:
|
|
exc["w:qFormat"] = "1" if props["qFormat"] else "0"
|
|
if props["locked"] is not None:
|
|
exc["w:locked"] = "1" if props["locked"] else "0"
|
|
latent_children.append({"w:lsdException": exc})
|
|
|
|
latent_attrs = {
|
|
"w:count": str(self._latent_count),
|
|
"w:defSemiHidden": "1" if self._def_semi_hidden else "0",
|
|
"w:defUnhideWhenUsed": "1" if self._def_unhide_when_used else "0",
|
|
"w:defQFormat": "1" if self._def_q_format else "0",
|
|
"w:defLockedState": "1" if self._def_locked_state else "0",
|
|
"w:defUIPriority": str(self._def_ui_priority),
|
|
}
|
|
result["w:styles"]["_children"].append({
|
|
"w:latentStyles": {
|
|
"_children": latent_children,
|
|
**latent_attrs
|
|
}
|
|
})
|
|
|
|
# Все стили
|
|
for style in self._styles.values():
|
|
result["w:styles"]["_children"].append({"w:style": style.to_xml_dict()})
|
|
|
|
return result
|
|
|
|
def __repr__(self) -> str:
|
|
return f"<Styles count={len(self)} latent={len(self._latent_styles)}>"
|
|
|
|
# Создаём коллекцию стилей
|
|
styles = Styles()
|
|
|
|
# Настройка latent-стилей (встроенные по умолчанию)
|
|
styles.set_latent_defaults(count=276, def_semi_hidden=True, def_unhide_when_used=True)
|
|
styles.define_latent_style("Normal", ui_priority=0, semi_hidden=False, unhide_when_used=False, q_format=True)
|
|
styles.define_latent_style("Heading 1", ui_priority=9, q_format=True)
|
|
|
|
# Добавляем стили
|
|
normal = styles.add_style("Normal", StyleType.PARAGRAPH, name="Normal", default=True)
|
|
normal.quick_style = True
|
|
normal.semi_hidden = False
|
|
|
|
heading1 = styles.add_style("Heading1", StyleType.PARAGRAPH, name="Heading 1")
|
|
heading1.based_on = "Normal"
|
|
heading1.priority = 9
|
|
heading1.quick_style = True
|
|
heading1.semi_hidden = False
|
|
heading1.set_font({"b": {}, "sz": {"w:val": "28"}})
|
|
|
|
foobar = styles.add_style("Foobar", StyleType.PARAGRAPH, name="Foobar", custom_style=True)
|
|
foobar.priority = 50
|
|
foobar.semi_hidden = False
|
|
foobar.quick_style = True
|
|
|
|
# Установка умолчаний документа
|
|
styles.set_default_run_properties({
|
|
"rFonts": {"w:asciiTheme": "minorHAnsi"},
|
|
"sz": {"w:val": "24"}
|
|
})
|
|
styles.set_default_paragraph_properties({"spacing": {"w:after": "120"}})
|
|
|
|
# Получение стилей
|
|
print(styles["Normal"]) # <Style id='Normal' ...>
|
|
print(styles["Heading 1"]) # найдёт по имени
|
|
|
|
# Список рекомендованных
|
|
for s in styles.recommended_list():
|
|
print(s.name)
|
|
|
|
# Сортировка
|
|
for s in styles.sorted_by_appearance():
|
|
print(f"{s.name} (priority={s.priority})")
|
|
|
|
# Экспорт
|
|
xml_data = styles.to_xml_dict() |