kushidou/ktouchV2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

重构项目源代码存储结构

Browse Source
This commit is contained in:
tang1219
2026-06-16 14:59:58 +08:00
parent 2dcac48623
commit 29b4d47355
21 changed files with 413 additions and 406 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/display_set
+535
View File
@@ -0,0 +1,535 @@
#!/usr/bin/env python3
"""
显示器配置检查与设置脚本
环境变量: DISPLAY=:0
参数: 配置文件路径
配置文件格式: 分辨率@刷新率|坐标|旋转方向|是否是主屏
示例: 1920x1080@60.0Hz|0,0|1|P
功能: 检查当前分辨率是否与配置文件一致，否则进行设置
"""
import os
import sys
import re
import subprocess
import argparse
from pathlib import Path
class DisplayChecker:
def __init__(self, display_env=":0"):
"""初始化显示器检查器"""
self.display_env = display_env
self.display_name = None
self.config_data = None
self.current_settings = None
def parse_config_file(self, config_path):
"""
解析配置文件
格式: 分辨率@刷新率|坐标|旋转方向|是否是主屏
示例: 1920x1080@60.0Hz|0,0|1|P
"""
try:
with open(config_path, 'r') as f:
content = f.read().strip()
# 从文件名获取显示器名称（去掉后缀）
self.display_name = Path(config_path).stem
# 解析配置内容
parts = content.split('|')
if len(parts) != 4:
raise ValueError("配置文件格式错误，应该有4个部分")
# 解析分辨率和刷新率
res_refresh_match = re.match(r'(\d+)x(\d+)@([\d.]+)Hz', parts[0])
if not res_refresh_match:
raise ValueError("分辨率刷新率格式错误")
width, height, refresh_rate = res_refresh_match.groups()
# 解析坐标
pos_match = re.match(r'(-?\d+),(-?\d+)', parts[1])
if not pos_match:
raise ValueError("坐标格式错误")
pos_x, pos_y = pos_match.groups()
# 解析旋转方向
rotation_map = {'1': 'normal', '2': 'left', '4': 'inverted', '8': 'right'}
rotation = rotation_map.get(parts[2])
if not rotation:
raise ValueError(f"旋转方向错误: {parts[2]}")
# 解析主屏设置
primary = parts[3] == 'P'
self.config_data = {
'width': int(width),
'height': int(height),
'refresh_rate': float(refresh_rate),
'pos_x': int(pos_x),
'pos_y': int(pos_y),
'rotation': rotation,
'primary': primary
}
return True
except Exception as e:
print(f"解析配置文件错误: {e}")
return False
def run_xrandr_command(self, cmd, ignore_errors=False):
"""运行xrandr命令"""
env = os.environ.copy()
env['DISPLAY'] = self.display_env
try:
result = subprocess.run(cmd, shell=True, env=env, capture_output=True, text=True)
if result.returncode != 0:
if ignore_errors:
# 检查是否是"已经存在"之类的错误
error_lower = result.stderr.lower()
if any(keyword in error_lower for keyword in ['already exists', 'already set', 'exist']):
print(f"忽略预期中的错误: {result.stderr.strip()}")
return True
else:
print(f"命令执行失败但忽略错误: {cmd}")
print(f"错误信息: {result.stderr}")
return True
else:
print(f"命令执行失败: {cmd}")
print(f"错误信息: {result.stderr}")
return False
return True
except Exception as e:
print(f"执行命令错误: {e}")
return False
def get_current_display_settings(self):
"""获取当前显示器的设置"""
env = os.environ.copy()
env['DISPLAY'] = self.display_env
try:
result = subprocess.run(
['xrandr'],
env=env,
capture_output=True,
text=True
)
if result.returncode != 0:
print("获取显示器信息失败")
return None
# 解析xrandr输出，找到指定显示器的当前设置
lines = result.stdout.split('\n')
current_settings = {}
for line in lines:
# 查找目标显示器的连接状态行
if line.startswith(f'{self.display_name} '):
# 示例: "HDMI-1 connected primary 1920x1080+0+0 (normal left inverted right x axis y axis) 527mm x 296mm"
# 或者: "HDMI-1 connected 1920x1080+0+0"
# 检查是否是主屏
current_settings['primary'] = 'primary' in line
# 提取当前分辨率
res_match = re.search(r'(\d+x\d+)\+(-?\d+)\+(-?\d+)', line)
if res_match:
current_settings['resolution'] = res_match.group(1)
current_settings['pos_x'] = int(res_match.group(2))
current_settings['pos_y'] = int(res_match.group(3))
# 提取旋转信息
if 'inverted' in line and 'x axis y axis' not in line:
current_settings['rotation'] = 'inverted'
elif 'left' in line and 'x axis y axis' not in line:
current_settings['rotation'] = 'left'
elif 'right' in line and 'x axis y axis' not in line:
current_settings['rotation'] = 'right'
else:
current_settings['rotation'] = 'normal'
# 继续查找当前模式行以获取刷新率
for next_line in lines[lines.index(line)+1:]:
if next_line.strip() and not next_line.startswith(' '):
break
# 查找当前模式（带*的）
if '*'+'+' in next_line or '* ' in next_line:
rate_match = re.search(r'(\d+\.\d+)\*', next_line)
if rate_match:
current_settings['refresh_rate'] = float(rate_match.group(1))
break
self.current_settings = current_settings
return current_settings
except Exception as e:
print(f"获取当前显示器设置错误: {e}")
return None
def get_display_modes(self):
"""
获取显示器支持的模式列表
返回: 字典，键为分辨率，值为该分辨率下支持的刷新率列表
"""
env = os.environ.copy()
env['DISPLAY'] = self.display_env
try:
result = subprocess.run(
['xrandr'],
env=env,
capture_output=True,
text=True
)
if result.returncode != 0:
print("获取显示器信息失败")
return {}
# 解析xrandr输出，找到指定显示器的模式
lines = result.stdout.split('\n')
modes = {}
in_target_display = False
current_resolution = None
for line in lines:
# 检查是否进入目标显示器的部分
if line.startswith(f'{self.display_name} '):
in_target_display = True
continue
elif in_target_display and line.strip() and not line.startswith(' '):
# 新的显示器部分开始，退出
break
if in_target_display:
# 解析分辨率行，例如: "1920x1080" 或 "1280x720i" (隔行扫描)
res_match = re.search(r'^\s*(\d+x\d+i?)\s+', line)
if res_match:
current_resolution = res_match.group(1)
modes[current_resolution] = []
# 解析刷新率，例如: "60.00*+", "59.94", "50.00"
if current_resolution:
rate_matches = re.findall(r'(\d+\.\d+)\*?\+?', line)
for rate in rate_matches:
modes[current_resolution].append(float(rate))
return modes
except Exception as e:
print(f"获取显示器模式错误: {e}")
return {}
def get_existing_modelines(self):
"""获取已经存在的自定义模式"""
env = os.environ.copy()
env['DISPLAY'] = self.display_env
try:
result = subprocess.run(
['xrandr'],
env=env,
capture_output=True,
text=True
)
if result.returncode != 0:
return []
# 查找自定义模式（通常在输出顶部）
lines = result.stdout.split('\n')
modelines = []
capturing_modelines = True
for line in lines:
# 当遇到第一个显示器输出时停止捕获
if re.match(r'^\S+ connected', line):
capturing_modelines = False
continue
if capturing_modelines and line.strip():
# 模式行通常包含分辨率
mode_match = re.match(r'^\s*(\S+)\s+.*?(\d+\.\d+)\s+.*?(\d+)\s+.*?(\d+)\s+.*?(\d+)\s+.*?(\d+)\s+.*?(\d+)\s+.*?(\d+)\s+.*?(\d+)', line)
if mode_match:
modelines.append(mode_match.group(1))
return modelines
except Exception as e:
print(f"获取已存在模式错误: {e}")
return []
def find_matching_mode(self, modes):
"""在支持的模式中查找匹配的模式（允许刷新率误差）"""
target_res = f"{self.config_data['width']}x{self.config_data['height']}"
target_refresh = self.config_data['refresh_rate']
# 检查精确匹配的分辨率
if target_res in modes:
for refresh_rate in modes[target_res]:
# 允许±2fps的误差
if abs(refresh_rate - target_refresh) <= 2.0:
return f"{target_res} {refresh_rate}"
# 检查隔行扫描变体（如果有）
interlaced_res = f"{target_res}i"
if interlaced_res in modes:
for refresh_rate in modes[interlaced_res]:
# 允许±2fps的误差
if abs(refresh_rate - target_refresh) <= 2.0:
return f"{interlaced_res} {refresh_rate}"
return None
def create_and_add_mode(self):
"""使用cvt创建并添加新的显示模式"""
width = self.config_data['width']
height = self.config_data['height']
refresh_rate = self.config_data['refresh_rate']
# 生成模式名称
mode_name = f"{width}x{height}_{refresh_rate}"
# 检查模式是否已经存在
existing_modelines = self.get_existing_modelines()
if mode_name in existing_modelines:
print(f"模式 {mode_name} 已经存在，跳过创建")
else:
# 使用cvt生成模式行
try:
# 运行cvt命令
result = subprocess.run(
['cvt', str(width), str(height), str(refresh_rate)],
capture_output=True,
text=True
)
if result.returncode != 0:
print("cvt命令执行失败")
return None
# 从cvt输出中提取模式行
lines = result.stdout.split('\n')
modeline = None
for line in lines:
if line.startswith('Modeline '):
modeline = line.replace('Modeline ', '').strip()
break
if not modeline:
print("无法从cvt输出中提取模式行")
return None
# 添加新模式（忽略已存在的错误）
add_mode_cmd = f"xrandr --newmode {mode_name} {modeline.split(' ', 1)[1]}"
if not self.run_xrandr_command(add_mode_cmd, ignore_errors=True):
return None
print(f"成功创建新模式: {mode_name}")
except Exception as e:
print(f"创建模式错误: {e}")
return None
# 将新模式添加到显示器（忽略已添加的错误）
add_to_output_cmd = f"xrandr --addmode {self.display_name} {mode_name}"
if not self.run_xrandr_command(add_to_output_cmd, ignore_errors=True):
return None
return mode_name
def parse_resolution(self, resolution_str):
"""解析分辨率字符串，返回宽高元组"""
try:
if 'x' in resolution_str:
width, height = resolution_str.split('x')
# 处理隔行扫描（如1080i）
height = height.replace('i', '')
return int(width), int(height)
return 0, 0
except:
return 0, 0
def compare_settings(self):
"""比较当前设置与配置设置"""
if not self.current_settings or not self.config_data:
return False, "无法获取当前设置或配置数据"
# 检查分辨率（允许±10像素误差）
current_res = self.current_settings.get('resolution', '')
current_width, current_height = self.parse_resolution(current_res)
target_width = self.config_data['width']
target_height = self.config_data['height']
width_diff = abs(current_width - target_width)
height_diff = abs(current_height - target_height)
if width_diff > 10 or height_diff > 10:
return False, f"分辨率不匹配: 当前 {current_res} ({width_diff}, {height_diff} 像素差异), 配置 {target_width}x{target_height}"
# 检查刷新率（允许±2fps误差）
current_refresh = self.current_settings.get('refresh_rate', 0)
target_refresh = self.config_data['refresh_rate']
refresh_diff = abs(current_refresh - target_refresh)
if refresh_diff > 2.0:
return False, f"刷新率不匹配: 当前 {current_refresh:.1f}Hz ({refresh_diff:.1f}Hz 差异), 配置 {target_refresh:.1f}Hz"
# 检查旋转（必须精确匹配）
current_rotation = self.current_settings.get('rotation', 'normal')
if current_rotation != self.config_data['rotation']:
return False, f"旋转不匹配: 当前 {current_rotation}, 配置 {self.config_data['rotation']}"
# 检查主屏设置（必须精确匹配）
current_primary = self.current_settings.get('primary', False)
if current_primary != self.config_data['primary']:
primary_status_current = "是" if current_primary else "否"
primary_status_target = "是" if self.config_data['primary'] else "否"
return False, f"主屏设置不匹配: 当前 {primary_status_current}, 配置 {primary_status_target}"
# 位置不进行校验（根据要求）
# 生成详细的匹配信息
match_details = []
if width_diff > 0 or height_diff > 0:
match_details.append(f"分辨率: {current_res} (差异: {width_diff}x{height_diff} 像素)")
else:
match_details.append(f"分辨率: {current_res} (精确匹配)")
if refresh_diff > 0:
match_details.append(f"刷新率: {current_refresh:.1f}Hz (差异: {refresh_diff:.1f}Hz)")
else:
match_details.append(f"刷新率: {current_refresh:.1f}Hz (精确匹配)")
match_details.append(f"旋转: {current_rotation}")
match_details.append(f"主屏: {'是' if current_primary else '否'}")
match_details.append("位置: 跳过校验")
return True, " | ".join(match_details)
def configure_display(self):
"""配置显示器"""
if not self.config_data:
print("没有可用的配置数据")
return False
# 获取当前支持的模式
modes = self.get_display_modes()
if not modes:
print(f"无法获取显示器 {self.display_name} 的模式信息")
return False
print(f"显示器 {self.display_name} 支持的模式:")
for res, rates in modes.items():
print(f" {res}: {rates}")
# 查找匹配的模式
mode_name = self.find_matching_mode(modes)
# 如果不支持，创建新模式
if not mode_name:
print("显示器不支持该模式，尝试创建新模式...")
mode_name = self.create_and_add_mode()
if not mode_name:
print("创建新模式失败")
return False
else:
print(f"找到匹配模式: {mode_name}")
# 构建xrandr命令
cmd_parts = ["xrandr", f"--output {self.display_name}"]
# 添加模式
if ' ' in mode_name:
resolution, rate = mode_name.split(' ', 1)
cmd_parts.append(f"--mode {resolution}")
cmd_parts.append(f"--rate {rate}")
else:
# 自定义模式
cmd_parts.append(f"--mode {mode_name}")
# 添加位置（即使不校验也设置）
cmd_parts.append(f"--pos {self.config_data['pos_x']}x{self.config_data['pos_y']}")
# 添加旋转
cmd_parts.append(f"--rotate {self.config_data['rotation']}")
# 如果是主屏
if self.config_data['primary']:
cmd_parts.append("--primary")
# 启用显示器
cmd_parts.append("--auto")
# 执行最终配置命令
final_cmd = " ".join(cmd_parts)
print(f"执行命令: {final_cmd}")
if self.run_xrandr_command(final_cmd):
print("显示器配置成功!")
return True
else:
print("显示器配置失败!")
return False
def check_and_configure(self):
"""检查并配置显示器"""
# 获取当前设置
current_settings = self.get_current_display_settings()
if not current_settings:
print("无法获取当前显示器设置，尝试直接配置...")
return self.configure_display()
print("当前显示器设置:")
for key, value in current_settings.items():
print(f" {key}: {value}")
# 比较设置
match, message = self.compare_settings()
if match:
print(f"✓ 设置匹配: {message}")
return True
else:
print(f"✗ 设置不匹配: {message}")
print("开始配置显示器...")
return self.configure_display()
def main():
"""主函数"""
# 检查DISPLAY环境变量
if 'DISPLAY' not in os.environ:
os.environ['DISPLAY'] = ':0'
print("设置DISPLAY环境变量为:0")
# 解析命令行参数
parser = argparse.ArgumentParser(description='显示器配置检查与设置脚本')
parser.add_argument('config_file', help='配置文件路径')
args = parser.parse_args()
# 检查配置文件是否存在
if not os.path.exists(args.config_file):
print(f"配置文件不存在: {args.config_file}")
sys.exit(1)
# 创建检查器并执行检查与配置
checker = DisplayChecker()
if checker.parse_config_file(args.config_file):
if checker.check_and_configure():
print("显示器检查与配置完成")
sys.exit(0)
else:
print("显示器检查与配置失败")
sys.exit(1)
else:
sys.exit(1)
if __name__ == "__main__":
main()