791 lines
32 KiB
Python
791 lines
32 KiB
Python
"""
|
||
LowLevelSelectorWidget (PySide2)
|
||
--------------------------------
|
||
Виджет для:
|
||
* Выбора XML файла с описанием переменных (как в примере пользователя)
|
||
* Парсинга всех <variable> и их вложенных <member>
|
||
* Построения плоского списка путей (имя/подпуть) с расчётом абсолютного адреса (base_address + offset)
|
||
* Определения структур с полями даты (year, month, day, hour, minute)
|
||
* Выбора переменной и (опционально) переменной даты / ручного ввода даты
|
||
* Выбора типов: ptr_type , iq_type, return_type
|
||
* Форматирования адреса в виде 0x000000 (6 HEX)
|
||
* Генерации словаря/кадра для последующей LowLevel-команды (не отправляет сам)
|
||
|
||
Интеграция:
|
||
* Подключите сигнал variablePrepared(dict) к функции, формирующей и отправляющей пакет.
|
||
* Содержимое dict:
|
||
{
|
||
'address': int,
|
||
'address_hex': str, # '0x....'
|
||
'ptr_type': int, # значение enum *
|
||
'iq_type': int,
|
||
'return_type': int,
|
||
'datetime': {
|
||
'year': int,
|
||
'month': int,
|
||
'day': int,
|
||
'hour': int,
|
||
'minute': int,
|
||
},
|
||
'path': str, # полный путь переменной
|
||
'type_string': str, # строка типа из XML
|
||
}
|
||
|
||
Зависимости: только PySide2 и стандартная библиотека.
|
||
"""
|
||
from __future__ import annotations
|
||
import sys
|
||
import xml.etree.ElementTree as ET
|
||
from dataclasses import dataclass, field
|
||
from typing import List, Dict, Optional, Tuple
|
||
from PySide2 import QtCore, QtGui, QtWidgets
|
||
from path_hints import PathHints
|
||
from generate_debug_vars import choose_type_map, type_map
|
||
|
||
# ------------------------------------------------------------ Enumerations --
|
||
# Сопоставление строк из XML типу ptr_type (адаптируйте под реальный проект)
|
||
PTR_TYPE_MAP = type_map
|
||
|
||
PT_ENUM_ORDER = [
|
||
'unknown','int8','int16','int32','int64',
|
||
'uint8','uint16','uint32','uint64','float',
|
||
'struct','union'
|
||
]
|
||
|
||
IQ_ENUM_ORDER = [
|
||
'iq_none','iq','iq1','iq2','iq3','iq4','iq5','iq6',
|
||
'iq7','iq8','iq9','iq10','iq11','iq12','iq13','iq14',
|
||
'iq15','iq16','iq17','iq18','iq19','iq20','iq21','iq22',
|
||
'iq23','iq24','iq25','iq26','iq27','iq28','iq29','iq30'
|
||
]
|
||
|
||
# Для примера: маппинг имени enum -> числовое значение (индекс по порядку)
|
||
PT_ENUM_VALUE = {name: idx for idx, name in enumerate(PT_ENUM_ORDER)}
|
||
IQ_ENUM_VALUE = {name: idx for idx, name in enumerate(IQ_ENUM_ORDER)}
|
||
|
||
# -------------------------------------------------------------- Data types --
|
||
DATE_FIELD_SET = {'year','month','day','hour','minute'}
|
||
|
||
@dataclass
|
||
class MemberNode:
|
||
name: str
|
||
offset: int = 0
|
||
type_str: str = ''
|
||
size: Optional[int] = None
|
||
children: List['MemberNode'] = field(default_factory=list)
|
||
# --- новые, но необязательные (совместимость) ---
|
||
kind: Optional[str] = None # 'array', 'union', ...
|
||
count: Optional[int] = None # size1 (число элементов в массиве)
|
||
|
||
def is_date_struct(self) -> bool:
|
||
if not self.children:
|
||
return False
|
||
child_names = {c.name for c in self.children}
|
||
return DATE_FIELD_SET.issubset(child_names)
|
||
|
||
|
||
@dataclass
|
||
class VariableNode:
|
||
name: str
|
||
address: int
|
||
type_str: str
|
||
size: Optional[int]
|
||
members: List[MemberNode] = field(default_factory=list)
|
||
# --- новые, но необязательные ---
|
||
kind: Optional[str] = None # 'array'
|
||
count: Optional[int] = None # size1
|
||
|
||
def base_address_hex(self) -> str:
|
||
return f"0x{self.address:06X}"
|
||
|
||
|
||
# --------------------------- XML Parser ----------------------------
|
||
|
||
class VariablesXML:
|
||
"""
|
||
Читает твой XML и выдаёт плоский список путей:
|
||
- Массивы -> name[i], многоуровневые -> name[i][j]
|
||
- Указатель на структуру -> дети через '->'
|
||
- Обычная структура -> дети через '.'
|
||
"""
|
||
# предположительные размеры примитивов (под STM/MCU: int=2)
|
||
_PRIM_SIZE = {
|
||
'char':1, 'signed char':1, 'unsigned char':1, 'uint8_t':1, 'int8_t':1,
|
||
'short':2, 'short int':2, 'signed short':2, 'unsigned short':2,
|
||
'uint16_t':2, 'int16_t':2,
|
||
'int':2, 'signed int':2, 'unsigned int':2,
|
||
'long':4, 'unsigned long':4, 'int32_t':4, 'uint32_t':4,
|
||
'float':4,
|
||
'long long':8, 'unsigned long long':8, 'int64_t':8, 'uint64_t':8, 'double':8,
|
||
}
|
||
|
||
def __init__(self, path: str):
|
||
self.path = path
|
||
self.timestamp: str = ''
|
||
self.variables: List[VariableNode] = []
|
||
choose_type_map(0)
|
||
self._parse()
|
||
|
||
# ------------------ low helpers ------------------
|
||
|
||
@staticmethod
|
||
def _parse_int_guess(txt: Optional[str]) -> Optional[int]:
|
||
if not txt:
|
||
return None
|
||
txt = txt.strip()
|
||
if txt.startswith(('0x','0X')):
|
||
return int(txt, 16)
|
||
# если в строке есть буквы A-F → возможно hex
|
||
if any(c in 'abcdefABCDEF' for c in txt):
|
||
try:
|
||
return int(txt, 16)
|
||
except ValueError:
|
||
pass
|
||
try:
|
||
return int(txt, 10)
|
||
except ValueError:
|
||
return None
|
||
|
||
@staticmethod
|
||
def _is_pointer_to_struct(t: str) -> bool:
|
||
if not t:
|
||
return False
|
||
low = t.replace('\t',' ').replace('\n',' ')
|
||
return 'struct ' in low and '*' in low
|
||
|
||
@staticmethod
|
||
def _is_struct_or_union(t: str) -> bool:
|
||
if not t:
|
||
return False
|
||
low = t.strip()
|
||
return low.startswith('struct ') or low.startswith('union ')
|
||
|
||
@staticmethod
|
||
def _strip_array_suffix(t: str) -> str:
|
||
return t[:-2].strip() if t.endswith('[]') else t
|
||
|
||
def _guess_primitive_size(self, type_str: str) -> Optional[int]:
|
||
if not type_str:
|
||
return None
|
||
base = type_str
|
||
for tok in ('volatile','const'):
|
||
base = base.replace(tok, '')
|
||
base = base.replace('*',' ')
|
||
base = base.replace('[',' ').replace(']',' ')
|
||
base = ' '.join(base.split()).strip()
|
||
return self._PRIM_SIZE.get(base)
|
||
|
||
# ------------------ XML read ------------------
|
||
|
||
def _parse(self):
|
||
tree = ET.parse(self.path)
|
||
root = tree.getroot()
|
||
|
||
ts = root.find('timestamp')
|
||
self.timestamp = ts.text.strip() if ts is not None and ts.text else ''
|
||
|
||
def parse_member(elem) -> MemberNode:
|
||
name = elem.get('name','')
|
||
offset = int(elem.get('offset','0'),16) if elem.get('offset') else 0
|
||
t = elem.get('type','') or ''
|
||
size_attr = elem.get('size')
|
||
size = int(size_attr,16) if size_attr else None
|
||
kind = elem.get('kind')
|
||
size1_attr = elem.get('size1')
|
||
count = None
|
||
if size1_attr:
|
||
count = self._parse_int_guess(size1_attr)
|
||
node = MemberNode(name=name, offset=offset, type_str=t, size=size,
|
||
kind=kind, count=count)
|
||
for ch in elem.findall('member'):
|
||
node.children.append(parse_member(ch))
|
||
return node
|
||
|
||
for var in root.findall('variable'):
|
||
addr = int(var.get('address','0'),16)
|
||
name = var.get('name','')
|
||
t = var.get('type','') or ''
|
||
size_attr = var.get('size')
|
||
size = int(size_attr,16) if size_attr else None
|
||
kind = var.get('kind')
|
||
size1_attr = var.get('size1')
|
||
count = None
|
||
if size1_attr:
|
||
count = self._parse_int_guess(size1_attr)
|
||
members = [parse_member(m) for m in var.findall('member')]
|
||
self.variables.append(
|
||
VariableNode(name=name, address=addr, type_str=t, size=size,
|
||
members=members, kind=kind, count=count)
|
||
)
|
||
|
||
# ------------------ flatten (expanded) ------------------
|
||
|
||
def flattened(self,
|
||
max_array_elems: Optional[int] = None
|
||
) -> List[Tuple[str,int,str]]:
|
||
"""
|
||
Вернёт [(path, addr, type_str), ...].
|
||
max_array_elems: ограничить разворачивание больших массивов (None = все).
|
||
"""
|
||
out: List[Tuple[str,int,str]] = []
|
||
|
||
def add(path: str, addr: int, t: str):
|
||
out.append((path, addr, t))
|
||
|
||
def compute_stride(size_bytes: Optional[int],
|
||
count: Optional[int],
|
||
base_type: Optional[str],
|
||
node_children: Optional[List[MemberNode]]) -> int:
|
||
# 1) size_bytes/count
|
||
if size_bytes and count and count > 0:
|
||
if size_bytes % count == 0:
|
||
stride = size_bytes // count
|
||
if stride <= 0:
|
||
stride = 1
|
||
return stride
|
||
else:
|
||
# size не кратен count → скорее всего size = размер одного элемента
|
||
return max(size_bytes, 1)
|
||
|
||
# 2) попытка по типу (примитив)
|
||
if base_type:
|
||
gs = self._guess_primitive_size(base_type)
|
||
if gs:
|
||
return gs
|
||
|
||
# 3) попытка по детям (структура)
|
||
if node_children:
|
||
min_off = min(ch.offset for ch in node_children)
|
||
max_end = min_off
|
||
for ch in node_children:
|
||
sz = ch.size
|
||
if not sz:
|
||
sz = self._guess_primitive_size(ch.type_str) or 1
|
||
end = ch.offset + sz
|
||
if end > max_end:
|
||
max_end = end
|
||
stride = max_end - min_off
|
||
if stride > 0:
|
||
return stride
|
||
|
||
return 1
|
||
|
||
|
||
def expand_members(prefix_name: str,
|
||
base_addr: int,
|
||
members: List[MemberNode],
|
||
parent_is_ptr_struct: bool):
|
||
"""
|
||
Разворачиваем список members относительно базового адреса.
|
||
parent_is_ptr_struct: если True, то соединение '->' иначе '.'
|
||
"""
|
||
join = '->' if parent_is_ptr_struct else '.'
|
||
for m in members:
|
||
path_m = f"{prefix_name}{join}{m.name}" if prefix_name else m.name
|
||
addr_m = base_addr + m.offset
|
||
add(path_m, addr_m, m.type_str)
|
||
|
||
# массив?
|
||
if (m.kind == 'array') or m.type_str.endswith('[]'):
|
||
count = m.count
|
||
if count is None:
|
||
count = 0 # неизвестно → не разворачиваем
|
||
if count <= 0:
|
||
continue
|
||
base_t = self._strip_array_suffix(m.type_str)
|
||
stride = compute_stride(m.size, count, base_t, m.children if m.children else None)
|
||
limit = count if max_array_elems is None else min(count, max_array_elems)
|
||
for i in range(limit):
|
||
path_i = f"{path_m}[{i}]"
|
||
addr_i = addr_m + i*stride
|
||
add(path_i, addr_i, base_t)
|
||
# элемент массива: если структура / union → раскроем поля
|
||
if m.children and self._is_struct_or_union(base_t):
|
||
expand_members(path_i, addr_i, m.children, parent_is_ptr_struct=False)
|
||
# элемент массива: если указатель на структуру
|
||
elif self._is_pointer_to_struct(base_t):
|
||
# у таких обычно нет children в XML, но если есть — используем
|
||
expand_members(path_i, addr_i, m.children, parent_is_ptr_struct=True)
|
||
continue
|
||
|
||
# не массив
|
||
if m.children:
|
||
is_ptr_struct = self._is_pointer_to_struct(m.type_str)
|
||
expand_members(path_m, addr_m, m.children, parent_is_ptr_struct=is_ptr_struct)
|
||
|
||
# --- top-level ---
|
||
for v in self.variables:
|
||
add(v.name, v.address, v.type_str)
|
||
|
||
# top-level массив?
|
||
if (v.kind == 'array') or v.type_str.endswith('[]'):
|
||
count = v.count
|
||
if count is None:
|
||
count = 0
|
||
if count > 0:
|
||
base_t = self._strip_array_suffix(v.type_str)
|
||
stride = compute_stride(v.size, count, base_t, v.members if v.members else None)
|
||
limit = count if max_array_elems is None else min(count, max_array_elems)
|
||
for i in range(limit):
|
||
p = f"{v.name}[{i}]"
|
||
a = v.address + i*stride
|
||
add(p, a, base_t)
|
||
# массив структур?
|
||
if v.members and self._is_struct_or_union(base_t):
|
||
expand_members(p, a, v.members, parent_is_ptr_struct=False)
|
||
# массив указателей на структуры?
|
||
elif self._is_pointer_to_struct(base_t):
|
||
expand_members(p, a, v.members, parent_is_ptr_struct=True)
|
||
continue # к след. переменной
|
||
|
||
# top-level не массив
|
||
if v.members:
|
||
is_ptr_struct = self._is_pointer_to_struct(v.type_str)
|
||
expand_members(v.name, v.address, v.members, parent_is_ptr_struct=is_ptr_struct)
|
||
|
||
return out
|
||
|
||
# -------------------- date candidates (как было) --------------------
|
||
|
||
def date_struct_candidates(self) -> List[Tuple[str,int]]:
|
||
cands = []
|
||
for v in self.variables:
|
||
# верхний уровень (если есть все поля даты)
|
||
direct_names = {mm.name for mm in v.members}
|
||
if DATE_FIELD_SET.issubset(direct_names):
|
||
cands.append((v.name, v.address))
|
||
# проверка членов первого уровня
|
||
for m in v.members:
|
||
if m.is_date_struct():
|
||
cands.append((f"{v.name}.{m.name}", v.address + m.offset))
|
||
return cands
|
||
|
||
|
||
# ------------------------------------------- Address / validation helpers --
|
||
HEX_ADDR_MASK = QtCore.QRegExp(r"0x[0-9A-Fa-f]{0,6}")
|
||
class HexAddrValidator(QtGui.QRegExpValidator):
|
||
def __init__(self, parent=None):
|
||
super().__init__(HEX_ADDR_MASK, parent)
|
||
|
||
@staticmethod
|
||
def normalize(text: str) -> str:
|
||
if not text:
|
||
return '0x000000'
|
||
try:
|
||
val = int(text,16)
|
||
except ValueError:
|
||
return '0x000000'
|
||
return f"0x{val & 0xFFFFFF:06X}"
|
||
|
||
# --------------------------------------------------------- Main Widget ----
|
||
class LowLevelSelectorWidget(QtWidgets.QWidget):
|
||
variablePrepared = QtCore.Signal(dict)
|
||
xmlLoaded = QtCore.Signal(str)
|
||
|
||
def __init__(self, parent=None):
|
||
super().__init__(parent)
|
||
self.setWindowTitle('LowLevel Variable Selector')
|
||
self._xml: Optional[VariablesXML] = None
|
||
self._paths = []
|
||
self._path_info = {}
|
||
self._addr_index = {}
|
||
self._backspace_pressed = False
|
||
self._hints = PathHints()
|
||
self._build_ui()
|
||
self._connect()
|
||
|
||
|
||
def _build_ui(self):
|
||
lay = QtWidgets.QVBoxLayout(self)
|
||
|
||
# --- File chooser ---
|
||
file_box = QtWidgets.QHBoxLayout()
|
||
self.btn_load = QtWidgets.QPushButton('Load XML...')
|
||
self.lbl_file = QtWidgets.QLabel('<no file>')
|
||
self.lbl_file.setTextInteractionFlags(QtCore.Qt.TextSelectableByMouse)
|
||
file_box.addWidget(self.btn_load)
|
||
file_box.addWidget(self.lbl_file, 1)
|
||
lay.addLayout(file_box)
|
||
|
||
self.lbl_timestamp = QtWidgets.QLabel('Timestamp: -')
|
||
lay.addWidget(self.lbl_timestamp)
|
||
|
||
form = QtWidgets.QFormLayout()
|
||
|
||
# --- Search field for variable ---
|
||
self.edit_var_search = QtWidgets.QLineEdit()
|
||
self.edit_var_search.setPlaceholderText("Введите имя переменной или адрес 0x......")
|
||
form.addRow('Variable:', self.edit_var_search)
|
||
|
||
# Popup list
|
||
self._popup = QtWidgets.QListView()
|
||
self._popup.setWindowFlags(QtCore.Qt.ToolTip)
|
||
self._popup.setEditTriggers(QtWidgets.QAbstractItemView.NoEditTriggers)
|
||
self._popup.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
|
||
self._popup.clicked.connect(self._on_popup_clicked)
|
||
self._model_all = QtGui.QStandardItemModel(self)
|
||
self._model_filtered = QtGui.QStandardItemModel(self)
|
||
|
||
# Address
|
||
self.edit_address = QtWidgets.QLineEdit('0x000000')
|
||
self.edit_address.setValidator(HexAddrValidator(self))
|
||
self.edit_address.setMaximumWidth(120)
|
||
form.addRow('Address:', self.edit_address)
|
||
|
||
# Manual date spins
|
||
dt_row = QtWidgets.QHBoxLayout()
|
||
self.spin_year = QtWidgets.QSpinBox(); self.spin_year.setRange(2000, 2100); self.spin_year.setValue(2025)
|
||
self.spin_month = QtWidgets.QSpinBox(); self.spin_month.setRange(1,12)
|
||
self.spin_day = QtWidgets.QSpinBox(); self.spin_day.setRange(1,31)
|
||
self.spin_hour = QtWidgets.QSpinBox(); self.spin_hour.setRange(0,23)
|
||
self.spin_minute = QtWidgets.QSpinBox(); self.spin_minute.setRange(0,59)
|
||
for w,label in [(self.spin_year,'Y'),(self.spin_month,'M'),(self.spin_day,'D'),(self.spin_hour,'h'),(self.spin_minute,'m')]:
|
||
box = QtWidgets.QVBoxLayout()
|
||
box.addWidget(QtWidgets.QLabel(label, alignment=QtCore.Qt.AlignHCenter))
|
||
box.addWidget(w)
|
||
dt_row.addLayout(box)
|
||
form.addRow('Compile Date:', dt_row)
|
||
|
||
# Types
|
||
self.cmb_ptr_type = QtWidgets.QComboBox(); self.cmb_ptr_type.addItems(PT_ENUM_ORDER)
|
||
self.cmb_iq_type = QtWidgets.QComboBox(); self.cmb_iq_type.addItems(IQ_ENUM_ORDER)
|
||
self.cmb_return_type = QtWidgets.QComboBox(); self.cmb_return_type.addItems(IQ_ENUM_ORDER)
|
||
form.addRow('Type:', self.cmb_ptr_type)
|
||
form.addRow('IQ Type:', self.cmb_iq_type)
|
||
form.addRow('Return IQ Type:', self.cmb_return_type)
|
||
|
||
lay.addLayout(form)
|
||
|
||
self.btn_prepare = QtWidgets.QPushButton('Prepare Variable')
|
||
lay.addWidget(self.btn_prepare)
|
||
lay.addStretch(1)
|
||
|
||
self.txt_info = QtWidgets.QPlainTextEdit()
|
||
self.txt_info.setReadOnly(True)
|
||
self.txt_info.setMaximumHeight(140)
|
||
lay.addWidget(QtWidgets.QLabel('Info:'))
|
||
lay.addWidget(self.txt_info)
|
||
|
||
# Event filter for keyboard on search field
|
||
self.edit_var_search.installEventFilter(self)
|
||
|
||
def _connect(self):
|
||
self.btn_load.clicked.connect(self._on_load_xml)
|
||
self.edit_address.editingFinished.connect(self._normalize_address)
|
||
self.btn_prepare.clicked.connect(self._emit_variable)
|
||
self.edit_var_search.textEdited.connect(self._on_var_search_edited)
|
||
self.edit_var_search.returnPressed.connect(self._activate_current_popup_selection)
|
||
QtWidgets.QApplication.instance().focusChanged.connect(self._on_focus_changed)
|
||
|
||
def focusOutEvent(self, event):
|
||
super().focusOutEvent(event)
|
||
self._hide_popup()
|
||
|
||
def _on_focus_changed(self, old, now):
|
||
# Если фокус ушёл из нашего виджета — скрываем подсказки
|
||
if now is None or not self.isAncestorOf(now):
|
||
self._hide_popup()
|
||
# ---------------- XML Load ----------------
|
||
def _on_load_xml(self):
|
||
path, _ = QtWidgets.QFileDialog.getOpenFileName(
|
||
self, 'Select variables XML', '', 'XML Files (*.xml);;All Files (*)')
|
||
if not path:
|
||
return
|
||
try:
|
||
self._xml = VariablesXML(path)
|
||
except Exception as e:
|
||
QtWidgets.QMessageBox.critical(self, 'Parse error', f'Ошибка парсинга:\n{e}')
|
||
return
|
||
self.lbl_file.setText(path)
|
||
self.lbl_timestamp.setText(f'Timestamp: {self._xml.timestamp or "-"}')
|
||
self._populate_variables()
|
||
self._apply_timestamp_to_date()
|
||
self.xmlLoaded.emit(path)
|
||
self._log(f'Loaded {path}, variables={len(self._xml.variables)}')
|
||
|
||
def _apply_timestamp_to_date(self):
|
||
if not self._xml.timestamp:
|
||
return
|
||
import datetime
|
||
try:
|
||
# Пример: "Sat Jul 19 15:27:59 2025"
|
||
dt = datetime.datetime.strptime(self._xml.timestamp, "%a %b %d %H:%M:%S %Y")
|
||
self.spin_year.setValue(dt.year)
|
||
self.spin_month.setValue(dt.month)
|
||
self.spin_day.setValue(dt.day)
|
||
self.spin_hour.setValue(dt.hour)
|
||
self.spin_minute.setValue(dt.minute)
|
||
except Exception as e:
|
||
print(f"Ошибка разбора timestamp '{self._xml.timestamp}': {e}")
|
||
|
||
def _populate_variables(self):
|
||
if not self._xml:
|
||
return
|
||
flat = self._xml.flattened()
|
||
# flat: [(path, addr, type_str), ...]
|
||
|
||
self._paths = []
|
||
self._path_info = {}
|
||
self._addr_index = {}
|
||
self._model_all.clear() # держим «сырой» полный список (можно не показывать)
|
||
self._model_filtered.clear() # текущие подсказки
|
||
|
||
# индексирование
|
||
for path, addr, t in flat:
|
||
self._paths.append(path)
|
||
self._path_info[path] = (addr, t)
|
||
if addr in self._addr_index:
|
||
self._addr_index[addr] = None
|
||
else:
|
||
self._addr_index[addr] = path
|
||
|
||
# наполняем «all» модель (необязательная, но пусть остаётся — не используем напрямую)
|
||
it = QtGui.QStandardItem(f"{path} [{addr:06X}]")
|
||
it.setData(path, QtCore.Qt.UserRole+1)
|
||
it.setData(addr, QtCore.Qt.UserRole+2)
|
||
it.setData(t, QtCore.Qt.UserRole+3)
|
||
self._model_all.appendRow(it)
|
||
|
||
# построить подсказки
|
||
self._hints.set_paths([(p, self._path_info[p][1]) for p in self._paths])
|
||
|
||
# начальное состояние попапа (пустой ввод → top-level)
|
||
self._update_popup_model(self._hints.suggest(''))
|
||
|
||
self._log(f"Variables loaded: {len(flat)}")
|
||
|
||
# --------------- Search mechanics ---------------
|
||
def _update_popup_model(self, paths: List[str]):
|
||
"""Обновляет модель попапа списком путей (full paths)."""
|
||
self._model_filtered.clear()
|
||
limit = 400
|
||
added = 0
|
||
for p in paths:
|
||
info = self._path_info.get(str(p))
|
||
if not info:
|
||
continue
|
||
addr, t = info
|
||
it = QtGui.QStandardItem(f"{p} [{addr:06X}]")
|
||
it.setData(p, QtCore.Qt.UserRole+1)
|
||
it.setData(addr, QtCore.Qt.UserRole+2)
|
||
it.setData(t, QtCore.Qt.UserRole+3)
|
||
self._model_filtered.appendRow(it)
|
||
added += 1
|
||
if added >= limit:
|
||
break
|
||
if added >= limit:
|
||
extra = QtGui.QStandardItem("... (more results truncated)")
|
||
extra.setEnabled(False)
|
||
self._model_filtered.appendRow(extra)
|
||
|
||
def _show_popup(self):
|
||
if self._model_filtered.rowCount() == 0:
|
||
self._popup.hide()
|
||
return
|
||
self._popup.setModel(self._model_filtered)
|
||
self._popup.setMinimumWidth(self.edit_var_search.width())
|
||
pos = self.edit_var_search.mapToGlobal(QtCore.QPoint(0, self.edit_var_search.height()))
|
||
self._popup.move(pos)
|
||
self._popup.show()
|
||
self._popup.raise_()
|
||
self._popup.setFocus()
|
||
self._popup.setCurrentIndex(self._model_filtered.index(0,0))
|
||
|
||
def _hide_popup(self):
|
||
self._popup.hide()
|
||
|
||
def _on_var_search_edited(self, text: str):
|
||
# Показываем подсказки при вводе текста, если не было Backspace (чтобы не добавлять разделитель)
|
||
t = text.strip()
|
||
if self._backspace_pressed:
|
||
# При стирании не показываем автодополнение с разделителем
|
||
self._backspace_pressed = False
|
||
self._hide_popup()
|
||
return
|
||
|
||
# адрес?
|
||
if t.startswith("0x") and len(t) >= 3:
|
||
try:
|
||
addr = int(t, 16)
|
||
path = self._addr_index.get(addr)
|
||
if path:
|
||
self._set_current_variable(path, from_address=True)
|
||
self._hide_popup()
|
||
return
|
||
except ValueError:
|
||
pass
|
||
|
||
# подсказки по имени
|
||
suggestions = self._hints.suggest(t)
|
||
self._update_popup_model(suggestions)
|
||
self._show_popup()
|
||
|
||
|
||
def _on_popup_clicked(self, idx: QtCore.QModelIndex):
|
||
if not idx.isValid():
|
||
return
|
||
path = idx.data(QtCore.Qt.UserRole + 1)
|
||
if not path:
|
||
return
|
||
|
||
# Реализуем автодополнение по цепочке, пока подсказка имеет детей
|
||
current_path = path
|
||
|
||
children = self._hints.get_children(str(current_path))
|
||
if children:
|
||
current_path = self._hints.add_separator(current_path)
|
||
|
||
self._set_current_variable(str(current_path)) # <-- здесь
|
||
|
||
if not children:
|
||
self._hide_popup()
|
||
|
||
|
||
def _activate_current_popup_selection(self):
|
||
if self._popup.isVisible():
|
||
idx = self._popup.currentIndex()
|
||
if idx.isValid():
|
||
self._on_popup_clicked(idx)
|
||
return
|
||
# Попытка прямого совпадения
|
||
path = self.edit_var_search.text().strip()
|
||
if path in self._path_info:
|
||
self._set_current_variable(path)
|
||
|
||
def eventFilter(self, obj, ev):
|
||
if obj is self.edit_var_search and ev.type() == QtCore.QEvent.KeyPress:
|
||
key = ev.key()
|
||
if key in (QtCore.Qt.Key_Down, QtCore.Qt.Key_Up):
|
||
if not self._popup.isVisible():
|
||
self._show_popup()
|
||
else:
|
||
step = 1 if key == QtCore.Qt.Key_Down else -1
|
||
cur = self._popup.currentIndex()
|
||
row = cur.row() + step
|
||
if row < 0: row = 0
|
||
if row >= self._model_filtered.rowCount():
|
||
row = self._model_filtered.rowCount() - 1
|
||
self._popup.setCurrentIndex(self._model_filtered.index(row, 0))
|
||
return True
|
||
|
||
elif key == QtCore.Qt.Key_Escape:
|
||
self._hide_popup()
|
||
return True
|
||
|
||
elif key == QtCore.Qt.Key_Backspace:
|
||
# Помечаем, что была нажата Backspace
|
||
self._backspace_pressed = True
|
||
return False # дальше обрабатываем обычным образом
|
||
|
||
elif key == QtCore.Qt.Key_Space and (ev.modifiers() & QtCore.Qt.ControlModifier):
|
||
# Ctrl+Space — показать подсказки
|
||
text = self.edit_var_search.text()
|
||
suggestions = self._hints.suggest(text)
|
||
self._update_popup_model(suggestions)
|
||
self._show_popup()
|
||
return True
|
||
|
||
else:
|
||
# Любая другая клавиша — сбрасываем Backspace-флаг
|
||
self._backspace_pressed = False
|
||
|
||
return super().eventFilter(obj, ev)
|
||
|
||
|
||
def _set_current_variable(self, path: str, from_address=False):
|
||
self.edit_var_search.setText(path)
|
||
self._update_popup_model(self._hints.suggest(path))
|
||
self._show_popup()
|
||
if path not in self._path_info:
|
||
return
|
||
addr, type_str = self._path_info[path]
|
||
|
||
# Разделитель добавляем только если не стираем (Backspace), и если уже не добавлен
|
||
# В этой функции не будем добавлять разделитель, добавляем его только при автодополнении выше
|
||
self.edit_address.setText(f"0x{addr:06X}")
|
||
ptr_enum_name = self._map_type_to_ptr_enum(type_str)
|
||
self._select_combo_text(self.cmb_ptr_type, ptr_enum_name)
|
||
source = "ADDR" if from_address else "SEARCH"
|
||
self._log(f"[{source}] Selected {path} @0x{addr:06X} type={type_str} -> ptr={ptr_enum_name}")
|
||
|
||
# --------------- Date struct / address / helpers ---------------
|
||
|
||
def _normalize_address(self):
|
||
self.edit_address.setText(HexAddrValidator.normalize(self.edit_address.text()))
|
||
|
||
def _map_type_to_ptr_enum(self, type_str: str) -> str:
|
||
if not type_str:
|
||
return 'unknown'
|
||
low = type_str.lower()
|
||
token = low.replace('*',' ').replace('[',' ')
|
||
return PTR_TYPE_MAP.get(token, 'unknown')
|
||
|
||
def _select_combo_text(self, combo: QtWidgets.QComboBox, text: str):
|
||
ix = combo.findText(text.replace('pt_', ''))
|
||
if ix >= 0:
|
||
combo.setCurrentIndex(ix)
|
||
|
||
def _collect_datetime(self) -> Dict[str,int]:
|
||
return {
|
||
'year': self.spin_year.value(),
|
||
'month': self.spin_month.value(),
|
||
'day': self.spin_day.value(),
|
||
'hour': self.spin_hour.value(),
|
||
'minute': self.spin_minute.value(),
|
||
}
|
||
|
||
def _emit_variable(self):
|
||
if not self._path_info:
|
||
QtWidgets.QMessageBox.warning(self, 'No XML', 'Сначала загрузите XML файл.')
|
||
return
|
||
path = self.edit_var_search.text().strip()
|
||
if path not in self._path_info:
|
||
QtWidgets.QMessageBox.warning(self, 'Variable', 'Переменная не выбрана / не найдена.')
|
||
return
|
||
addr, type_str = self._path_info[path]
|
||
ptr_type_name = self.cmb_ptr_type.currentText()
|
||
iq_type_name = self.cmb_iq_type.currentText()
|
||
ret_type_name = self.cmb_return_type.currentText()
|
||
out = {
|
||
'address': addr,
|
||
'address_hex': f"0x{addr:06X}",
|
||
'ptr_type': PT_ENUM_VALUE.get(ptr_type_name, 0),
|
||
'iq_type': IQ_ENUM_VALUE.get(iq_type_name, 0),
|
||
'return_type': IQ_ENUM_VALUE.get(ret_type_name, 0),
|
||
'datetime': self._collect_datetime(),
|
||
'path': path,
|
||
'type_string': type_str,
|
||
'ptr_type_name': ptr_type_name,
|
||
'iq_type_name': iq_type_name,
|
||
'return_type_name': ret_type_name,
|
||
}
|
||
self._log(f"Prepared variable: {out}")
|
||
self.variablePrepared.emit(out)
|
||
|
||
def _log(self, msg: str):
|
||
self.txt_info.appendPlainText(msg)
|
||
|
||
# ----------------------------------------------------------- Demo window --
|
||
class _DemoWindow(QtWidgets.QMainWindow):
|
||
def __init__(self):
|
||
super().__init__()
|
||
self.setWindowTitle('LowLevel Selector Demo')
|
||
self.selector = LowLevelSelectorWidget(self)
|
||
self.setCentralWidget(self.selector)
|
||
self.selector.variablePrepared.connect(self.on_var)
|
||
|
||
def on_var(self, data: dict):
|
||
print('Variable prepared ->', data)
|
||
|
||
def closeEvent(self, ev):
|
||
self.setCentralWidget(None)
|
||
super().closeEvent(ev)
|
||
|
||
# ----------------------------------------------------------------- main ---
|
||
if __name__ == '__main__':
|
||
app = QtWidgets.QApplication(sys.argv)
|
||
w = _DemoWindow()
|
||
w.resize(640, 520)
|
||
w.show()
|
||
sys.exit(app.exec_())
|