fl0919/goeingPrintServer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

删除gui

Browse Source
This commit is contained in:
lifangliang 2025-07-25 09:56:07 +08:00
parent 65f06344cb
commit 3cb4527d14
14 changed files with 9 additions and 3386 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

179
src/main/java/com/goeing/printserver/main/gui/AboutDialog.java
View File

@ -1,179 +0,0 @@
package com.goeing.printserver.main.gui;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.util.Locale;
import com.goeing.printserver.main.utils.LocaleChangeListener;
import com.goeing.printserver.main.utils.LocaleManager;
import com.goeing.printserver.main.utils.MessageUtils;
/**
* 关于对话框，显示应用程序信息
*/
public class AboutDialog extends JDialog implements LocaleChangeListener {
private JLabel titleLabel;
private JLabel versionLabel;
private JLabel buildDateLabel;
private JLabel jdkVersionLabel;
private JLabel osVersionLabel;
private JLabel copyrightLabel;
private JButton closeButton;
/**
* 创建关于对话框
*
* @param parent 父窗口
*/
public AboutDialog(Window parent) {
super(parent, MessageUtils.getMessage("about.title"), ModalityType.APPLICATION_MODAL);
initializeUI();
// 注册语言变更监听器
LocaleManager.getInstance().addLocaleChangeListener(this);
}
/**
* 初始化用户界面
*/
private void initializeUI() {
setSize(400, 300);
setLocationRelativeTo(getOwner());
setResizable(false);
setLayout(new BorderLayout());
// 创建图标面板
JPanel iconPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
iconPanel.setBorder(BorderFactory.createEmptyBorder(20, 0, 10, 0));
// 创建应用图标
ImageIcon appIcon = createAppIcon();
JLabel iconLabel = new JLabel(appIcon);
iconPanel.add(iconLabel);
add(iconPanel, BorderLayout.NORTH);
// 创建信息面板
JPanel infoPanel = new JPanel();
infoPanel.setLayout(new BoxLayout(infoPanel, BoxLayout.Y_AXIS));
infoPanel.setBorder(BorderFactory.createEmptyBorder(10, 20, 10, 20));
// 添加应用信息
titleLabel = addInfoLabel(infoPanel, MessageUtils.getMessage("about.app.name"), Font.BOLD, 16);
versionLabel = addInfoLabel(infoPanel, MessageUtils.getMessage("about.version", new Object[]{"1.0.0"}), Font.PLAIN, 12);
buildDateLabel = addInfoLabel(infoPanel, MessageUtils.getMessage("about.build.date", new Object[]{java.time.LocalDate.now().toString()}), Font.PLAIN, 12);
jdkVersionLabel = addInfoLabel(infoPanel, MessageUtils.getMessage("about.jdk.version", new Object[]{System.getProperty("java.version")}), Font.PLAIN, 12);
osVersionLabel = addInfoLabel(infoPanel, MessageUtils.getMessage("about.os.version", new Object[]{System.getProperty("os.name") + " " + System.getProperty("os.version")}), Font.PLAIN, 12);
// 添加空白间隔
infoPanel.add(Box.createVerticalStrut(10));
// 添加版权信息
copyrightLabel = addInfoLabel(infoPanel, MessageUtils.getMessage("about.copyright", new Object[]{java.time.Year.now().getValue()}), Font.ITALIC, 12);
add(infoPanel, BorderLayout.CENTER);
// 创建按钮面板
JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
closeButton = new JButton(MessageUtils.getMessage("button.close"));
closeButton.addActionListener(e -> {
// 移除语言变更监听器
LocaleManager.getInstance().removeLocaleChangeListener(this);
dispose();
});
buttonPanel.add(closeButton);
add(buttonPanel, BorderLayout.SOUTH);
}
/**
* 添加信息标签
*
* @param panel 面板
* @param text 文本
* @param fontStyle 字体样式
* @param fontSize 字体大小
*/
private JLabel addInfoLabel(JPanel panel, String text, int fontStyle, int fontSize) {
JLabel label = new JLabel(text);
label.setFont(new Font(label.getFont().getName(), fontStyle, fontSize));
label.setAlignmentX(0.5f); // CENTER_ALIGNMENT = 0.5f
panel.add(label);
panel.add(Box.createVerticalStrut(5));
return label;
}
/**
* 创建应用图标
*
* @return 图标
*/
private ImageIcon createAppIcon() {
// 创建一个简单的打印机图标
int iconSize = 64;
BufferedImage image = new BufferedImage(iconSize, iconSize, BufferedImage.TYPE_INT_ARGB);
Graphics2D g2d = image.createGraphics();
// 启用抗锯齿
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
// 绘制打印机主体
g2d.setColor(new Color(50, 50, 50));
g2d.fillRect(10, 25, 44, 25);
// 绘制打印机纸盒
g2d.setColor(new Color(200, 200, 200));
g2d.fillRect(15, 50, 34, 5);
// 绘制打印机出纸口
g2d.setColor(new Color(240, 240, 240));
g2d.fillRect(15, 15, 34, 10);
// 绘制打印纸
g2d.setColor(Color.WHITE);
g2d.fillRect(20, 5, 24, 20);
// 绘制打印机按钮
g2d.setColor(new Color(0, 150, 200));
g2d.fillOval(45, 30, 5, 5);
g2d.dispose();
return new ImageIcon(image);
}
/**
* 显示关于对话框
*
* @param parent 父窗口
*/
public static void showDialog(Window parent) {
AboutDialog dialog = new AboutDialog(parent);
dialog.setVisible(true);
}
/**
* 当语言变更时更新UI元素
* @param newLocale 新的语言区域
*/
@Override
public void onLocaleChanged(Locale newLocale) {
// 更新窗口标题
setTitle(MessageUtils.getMessage("about.title"));
// 更新标签文本
titleLabel.setText(MessageUtils.getMessage("about.app.name"));
versionLabel.setText(MessageUtils.getMessage("about.version", new Object[]{"1.0.0"}));
buildDateLabel.setText(MessageUtils.getMessage("about.build.date", new Object[]{java.time.LocalDate.now().toString()}));
jdkVersionLabel.setText(MessageUtils.getMessage("about.jdk.version", new Object[]{System.getProperty("java.version")}));
osVersionLabel.setText(MessageUtils.getMessage("about.os.version", new Object[]{System.getProperty("os.name") + " " + System.getProperty("os.version")}));
copyrightLabel.setText(MessageUtils.getMessage("about.copyright", new Object[]{java.time.Year.now().getValue()}));
// 更新按钮文本
closeButton.setText(MessageUtils.getMessage("button.close"));
}
}

86
src/main/java/com/goeing/printserver/main/gui/GUILauncher.java
View File

@ -1,86 +0,0 @@
package com.goeing.printserver.main.gui;
import com.goeing.printserver.main.utils.MessageUtils;
import jakarta.annotation.PreDestroy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
import java.awt.*;
/**
* GUI启动器，负责在Spring Boot应用程序启动后初始化图形界面
*/
@Component
@Slf4j
public class GUILauncher {
private final PrintQueueGUI printQueueGUI;
private final PrintServerTray printServerTray;
private final PrintSettingsPanel settingsPanel;
@Autowired
public GUILauncher(PrintQueueGUI printQueueGUI, PrintServerTray printServerTray, PrintSettingsPanel settingsPanel) {
this.printQueueGUI = printQueueGUI;
this.printServerTray = printServerTray;
this.settingsPanel = settingsPanel;
}
/**
* 在应用程序准备就绪后启动GUI
*/
@EventListener(ApplicationReadyEvent.class)
public void launchGUI() {
log.info("应用程序已准备就绪，正在启动图形界面...");
// 检查是否支持图形界面
boolean isHeadless = GraphicsEnvironment.isHeadless();
if (isHeadless) {
log.warn("当前环境不支持图形界面，将以无头模式运行");
// 在无头模式下，设置一个系统属性，其他组件可以检查这个属性
System.setProperty("app.headless.mode", "true");
return;
}
try {
// 初始化GUI和系统托盘
printServerTray.initialize();
// 根据设置决定是否显示主窗口
if (!settingsPanel.isStartMinimized()) {
printQueueGUI.show();
} else {
log.info("根据用户设置，应用程序启动时最小化到系统托盘");
}
// 显示欢迎通知
printServerTray.displayMessage(
MessageUtils.getMessage("tray.notification.title"),
MessageUtils.getMessage("tray.notification.message"),
TrayIcon.MessageType.INFO
);
// 更新托盘提示
printServerTray.updateTooltip(MessageUtils.getMessage("app.name") + " - " + MessageUtils.getMessage("app.status.running"));
log.info("图形界面已启动");
} catch (Exception e) {
log.error("初始化图形界面时发生错误: {}", e.getMessage());
log.warn("将以无头模式运行");
System.setProperty("app.headless.mode", "true");
}
}
/**
* 在应用程序关闭时释放资源
*/
@PreDestroy
public void shutdown() {
log.info("正在关闭图形界面...");
printQueueGUI.shutdown();
printServerTray.shutdown();
log.info("图形界面已关闭");
}
}

169
src/main/java/com/goeing/printserver/main/gui/PrintNotificationService.java
View File

@ -1,169 +0,0 @@
package com.goeing.printserver.main.gui;
import com.goeing.printserver.main.domain.request.PrintRequest;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import java.awt.*;
/**
* 打印通知服务，用于在打印任务状态变化时发送系统通知
*/
@Service
@Slf4j
public class PrintNotificationService {
private PrintServerTray printServerTray;
private final PrintSettingsPanel settingsPanel;
private boolean headless = false;
@Autowired
public PrintNotificationService(@Lazy PrintSettingsPanel settingsPanel) {
this.settingsPanel = settingsPanel;
// 检查是否在无头模式下运行
this.headless = GraphicsEnvironment.isHeadless() || Boolean.getBoolean("app.headless.mode");
if (headless) {
log.info("系统运行在无头模式下，通知功能将被禁用");
}
}
@Autowired
@Lazy
public void setPrintServerTray(PrintServerTray printServerTray) {
this.printServerTray = printServerTray;
}
/**
* 通知打印任务已添加到队列
*
* @param printRequest 打印请求
* @param queueSize 当前队列大小
*/
public void notifyTaskQueued(PrintRequest printRequest, int queueSize) {
if (headless || !settingsPanel.isEnableNotifications()) {
return; // 无头模式或通知被禁用时不发送通知
}
String fileName = extractFileName(printRequest.getFileUrl());
String message = String.format(
"文件 '%s' 已添加到打印队列\n打印机: %s\n队列位置: %d",
fileName,
printRequest.getPrinterName(),
queueSize
);
printServerTray.displayMessage("新打印任务", message, TrayIcon.MessageType.INFO);
updateTrayTooltip(queueSize);
}
/**
* 通知打印任务开始处理
*
* @param printRequest 打印请求
* @param queueSize 当前队列大小
*/
public void notifyTaskStarted(PrintRequest printRequest, int queueSize) {
if (headless || !settingsPanel.isEnableNotifications()) {
return; // 无头模式或通知被禁用时不发送通知
}
String fileName = extractFileName(printRequest.getFileUrl());
String message = String.format(
"开始打印文件 '%s'\n打印机: %s",
fileName,
printRequest.getPrinterName()
);
printServerTray.displayMessage("打印开始", message, TrayIcon.MessageType.INFO);
updateTrayTooltip(queueSize);
}
/**
* 通知打印任务完成
*
* @param printRequest 打印请求
* @param queueSize 当前队列大小
*/
public void notifyTaskCompleted(PrintRequest printRequest, int queueSize) {
if (headless || !settingsPanel.isEnableNotifications()) {
return; // 无头模式或通知被禁用时不发送通知
}
String fileName = extractFileName(printRequest.getFileUrl());
String message = String.format(
"文件 '%s' 打印完成\n打印机: %s",
fileName,
printRequest.getPrinterName()
);
printServerTray.displayMessage("打印完成", message, TrayIcon.MessageType.INFO);
updateTrayTooltip(queueSize);
}
/**
* 通知打印任务失败
*
* @param printRequest 打印请求
* @param errorMessage 错误消息
* @param queueSize 当前队列大小
*/
public void notifyTaskFailed(PrintRequest printRequest, String errorMessage, int queueSize) {
if (headless || !settingsPanel.isEnableNotifications()) {
return; // 无头模式或通知被禁用时不发送通知
}
String fileName = extractFileName(printRequest.getFileUrl());
String message = String.format(
"文件 '%s' 打印失败\n打印机: %s\n错误: %s",
fileName,
printRequest.getPrinterName(),
errorMessage
);
printServerTray.displayMessage("打印失败", message, TrayIcon.MessageType.ERROR);
updateTrayTooltip(queueSize);
}
/**
* 从URL中提取文件名
*
* @param fileUrl 文件URL
* @return 文件名
*/
private String extractFileName(String fileUrl) {
if (fileUrl == null || fileUrl.isEmpty()) {
return "未知文件";
}
// 尝试从URL中提取文件名
int lastSlashIndex = fileUrl.lastIndexOf('/');
if (lastSlashIndex >= 0 && lastSlashIndex < fileUrl.length() - 1) {
String fileName = fileUrl.substring(lastSlashIndex + 1);
// 移除查询参数
int queryIndex = fileName.indexOf('?');
if (queryIndex > 0) {
fileName = fileName.substring(0, queryIndex);
}
return fileName;
}
return fileUrl; // 如果无法提取，则返回完整URL
}
/**
* 更新托盘提示
*
* @param queueSize 当前队列大小
*/
private void updateTrayTooltip(int queueSize) {
String tooltip;
if (queueSize > 0) {
tooltip = String.format("打印服务器 - 运行中 (队列中有 %d 个任务)", queueSize);
} else {
tooltip = "打印服务器 - 运行中 (队列为空)";
}
printServerTray.updateTooltip(tooltip);
}
}

503
src/main/java/com/goeing/printserver/main/gui/PrintQueueGUI.java
View File

@ -1,503 +0,0 @@
package com.goeing.printserver.main.gui;
import com.goeing.printserver.main.service.PrintQueueService;
import com.goeing.printserver.main.utils.LocaleChangeListener;
import com.goeing.printserver.main.utils.LocaleManager;
import com.goeing.printserver.main.utils.MessageUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import jakarta.annotation.PreDestroy;
import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* 打印队列图形界面
*/
@Component
public class PrintQueueGUI implements LocaleChangeListener {
private final PrintQueueService printQueueService;
private PrinterStatusPanel printerStatusPanel;
private final PrintStatisticsPanel statisticsPanel;
private final PrintTaskSearchPanel searchPanel;
private final PrintSettingsPanel settingsPanel;
private final WebSocketStatusPanel webSocketStatusPanel;
private final SystemLogPanel systemLogPanel;
private JFrame frame;
private JTable currentTaskTable;
private JTable queuedTasksTable;
private DefaultTableModel currentTaskModel;
private DefaultTableModel queuedTasksModel;
private JLabel statusLabel;
private final ScheduledExecutorService refreshExecutor = Executors.newSingleThreadScheduledExecutor();
private final DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
@Autowired
public PrintQueueGUI(PrintQueueService printQueueService,
PrintStatisticsPanel statisticsPanel, PrintTaskSearchPanel searchPanel,
PrintSettingsPanel settingsPanel, WebSocketStatusPanel webSocketStatusPanel,
SystemLogPanel systemLogPanel) {
this.printQueueService = printQueueService;
this.statisticsPanel = statisticsPanel;
this.searchPanel = searchPanel;
this.settingsPanel = settingsPanel;
this.webSocketStatusPanel = webSocketStatusPanel;
this.systemLogPanel = systemLogPanel;
// 注册语言变更监听器
LocaleManager.getInstance().addLocaleChangeListener(this);
// 只有在非无头模式下才初始化GUI
if (!GraphicsEnvironment.isHeadless() && !Boolean.getBoolean("app.headless.mode")) {
SwingUtilities.invokeLater(this::initializeGUI);
}
}
@Autowired
public void setPrinterStatusPanel(PrinterStatusPanel printerStatusPanel) {
this.printerStatusPanel = printerStatusPanel;
}
/**
* 初始化图形界面
*/
private void initializeGUI() {
// 创建主窗口
frame = new JFrame(MessageUtils.getMessage("main.title"));
frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
frame.setSize(800, 600);
frame.setLayout(new BorderLayout());
// 添加窗口关闭监听器
frame.addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
// 只隐藏窗口，不关闭应用程序
frame.setVisible(false);
}
});
// 创建菜单栏
JMenuBar menuBar = createMenuBar();
frame.setJMenuBar(menuBar);
// 创建顶部面板
JPanel topPanel = new JPanel(new BorderLayout());
statusLabel = new JLabel(MessageUtils.getMessage("queue.status.idle"));
statusLabel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
topPanel.add(statusLabel, BorderLayout.WEST);
// 创建刷新按钮
JButton refreshButton = new JButton(MessageUtils.getMessage("button.refresh"));
refreshButton.addActionListener(e -> refreshData());
topPanel.add(refreshButton, BorderLayout.EAST);
frame.add(topPanel, BorderLayout.NORTH);
// 创建选项卡面板
JTabbedPane tabbedPane = new JTabbedPane();
// 创建当前任务面板
JPanel currentTaskPanel = createCurrentTaskPanel();
tabbedPane.addTab(MessageUtils.getMessage("tab.current.task"), currentTaskPanel);
// 创建队列任务面板
JPanel queuedTasksPanel = createQueuedTasksPanel();
tabbedPane.addTab(MessageUtils.getMessage("tab.queued.tasks"), queuedTasksPanel);
// 添加打印机状态面板
tabbedPane.addTab(MessageUtils.getMessage("tab.printer.status"), printerStatusPanel);
// 添加统计面板
tabbedPane.addTab(MessageUtils.getMessage("tab.statistics"), statisticsPanel);
// 添加任务搜索面板
tabbedPane.addTab(MessageUtils.getMessage("tab.task.search"), searchPanel);
// 添加设置面板
tabbedPane.addTab(MessageUtils.getMessage("tab.settings"), settingsPanel);
// 添加WebSocket状态面板
tabbedPane.addTab(MessageUtils.getMessage("tab.websocket.status"), webSocketStatusPanel);
// 添加系统日志面板
tabbedPane.addTab(MessageUtils.getMessage("tab.system.log"), systemLogPanel);
frame.add(tabbedPane, BorderLayout.CENTER);
// 启动定时刷新
startRefreshTimer();
// 显示窗口
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
/**
* 创建当前任务面板
*/
private JPanel createCurrentTaskPanel() {
JPanel panel = new JPanel(new BorderLayout());
panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
// 创建表格模型
String[] columnNames = {
MessageUtils.getMessage("table.header.file.url"),
MessageUtils.getMessage("table.header.printer"),
MessageUtils.getMessage("table.header.status"),
MessageUtils.getMessage("table.header.queued.time"),
MessageUtils.getMessage("table.header.start.time"),
MessageUtils.getMessage("table.header.end.time")
};
currentTaskModel = new DefaultTableModel(columnNames, 0) {
@Override
public boolean isCellEditable(int row, int column) {
return false; // 禁止编辑单元格
}
};
// 创建表格
currentTaskTable = new JTable(currentTaskModel);
currentTaskTable.getTableHeader().setReorderingAllowed(false);
currentTaskTable.setFillsViewportHeight(true);
// 添加双击事件监听器
currentTaskTable.addMouseListener(new java.awt.event.MouseAdapter() {
@Override
public void mouseClicked(java.awt.event.MouseEvent e) {
if (e.getClickCount() == 2) {
showTaskDetails(currentTaskTable);
}
}
});
// 添加滚动面板
JScrollPane scrollPane = new JScrollPane(currentTaskTable);
panel.add(scrollPane, BorderLayout.CENTER);
return panel;
}
/**
* 创建队列任务面板
*/
private JPanel createQueuedTasksPanel() {
JPanel panel = new JPanel(new BorderLayout());
panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
// 创建表格模型
String[] columnNames = {
MessageUtils.getMessage("table.header.file.url"),
MessageUtils.getMessage("table.header.printer"),
MessageUtils.getMessage("table.header.status"),
MessageUtils.getMessage("table.header.queued.time")
};
queuedTasksModel = new DefaultTableModel(columnNames, 0) {
@Override
public boolean isCellEditable(int row, int column) {
return false; // 禁止编辑单元格
}
};
// 创建表格
queuedTasksTable = new JTable(queuedTasksModel);
queuedTasksTable.getTableHeader().setReorderingAllowed(false);
queuedTasksTable.setFillsViewportHeight(true);
// 添加双击事件监听器
queuedTasksTable.addMouseListener(new java.awt.event.MouseAdapter() {
@Override
public void mouseClicked(java.awt.event.MouseEvent e) {
if (e.getClickCount() == 2) {
showTaskDetails(queuedTasksTable);
}
}
});
// 添加滚动面板
JScrollPane scrollPane = new JScrollPane(queuedTasksTable);
panel.add(scrollPane, BorderLayout.CENTER);
return panel;
}
/**
* 启动定时刷新
*/
private void startRefreshTimer() {
refreshExecutor.scheduleAtFixedRate(this::refreshData, 0, 2, TimeUnit.SECONDS);
}
/**
* 刷新数据
*/
private void refreshData() {
SwingUtilities.invokeLater(() -> {
try {
// 更新队列状态
int queueSize = printQueueService.getQueueSize();
Map<String, Object> currentTask = printQueueService.getCurrentTaskInfo();
if (currentTask != null) {
statusLabel.setText(MessageUtils.getMessage("queue.status.processing", new Object[]{queueSize}));
} else if (queueSize > 0) {
statusLabel.setText(MessageUtils.getMessage("queue.status.waiting", new Object[]{queueSize}));
} else {
statusLabel.setText(MessageUtils.getMessage("queue.status.idle"));
}
// 更新当前任务表格
updateCurrentTaskTable(currentTask);
// 更新队列任务表格
List<Map<String, Object>> queuedTasks = printQueueService.getQueuedTasksInfo();
updateQueuedTasksTable(queuedTasks);
} catch (Exception e) {
e.printStackTrace();
statusLabel.setText(MessageUtils.getMessage("error.refresh.data", new Object[]{e.getMessage()}));
}
});
}
/**
* 更新当前任务表格
*/
private void updateCurrentTaskTable(Map<String, Object> currentTask) {
// 清空表格
currentTaskModel.setRowCount(0);
if (currentTask != null) {
Object[] rowData = new Object[6];
rowData[0] = currentTask.get("fileUrl");
rowData[1] = currentTask.get("printerName");
rowData[2] = currentTask.get("status");
rowData[3] = formatDateTime(currentTask.get("queuedTime"));
rowData[4] = formatDateTime(currentTask.get("startTime"));
rowData[5] = formatDateTime(currentTask.get("endTime"));
currentTaskModel.addRow(rowData);
}
}
/**
* 更新队列任务表格
*/
private void updateQueuedTasksTable(List<Map<String, Object>> queuedTasks) {
// 清空表格
queuedTasksModel.setRowCount(0);
if (queuedTasks != null && !queuedTasks.isEmpty()) {
for (Map<String, Object> task : queuedTasks) {
Object[] rowData = new Object[4];
rowData[0] = task.get("fileUrl");
rowData[1] = task.get("printerName");
rowData[2] = task.get("status");
rowData[3] = formatDateTime(task.get("queuedTime"));
queuedTasksModel.addRow(rowData);
}
}
}
/**
* 格式化日期时间
*/
private String formatDateTime(Object dateTimeObj) {
if (dateTimeObj == null) {
return "";
}
if (dateTimeObj instanceof LocalDateTime) {
return ((LocalDateTime) dateTimeObj).format(dateFormatter);
}
return dateTimeObj.toString();
}
/**
* 显示窗口
*/
public void show() {
if (frame != null) {
frame.setVisible(true);
frame.toFront();
}
}
/**
* 创建菜单栏
*/
private JMenuBar createMenuBar() {
JMenuBar menuBar = new JMenuBar();
// 文件菜单
JMenu fileMenu = new JMenu(MessageUtils.getMessage("menu.file"));
JMenuItem refreshItem = new JMenuItem(MessageUtils.getMessage("menu.file.refresh"));
JMenuItem exitItem = new JMenuItem(MessageUtils.getMessage("menu.file.exit"));
refreshItem.addActionListener(e -> refreshData());
exitItem.addActionListener(e -> System.exit(0));
fileMenu.add(refreshItem);
fileMenu.addSeparator();
fileMenu.add(exitItem);
// 视图菜单
JMenu viewMenu = new JMenu(MessageUtils.getMessage("menu.view"));
JMenuItem alwaysOnTopItem = new JCheckBoxMenuItem(MessageUtils.getMessage("menu.view.always.on.top"));
alwaysOnTopItem.addActionListener(e -> {
boolean selected = ((JCheckBoxMenuItem) e.getSource()).isSelected();
frame.setAlwaysOnTop(selected);
});
viewMenu.add(alwaysOnTopItem);
// 语言菜单
JMenu languageMenu = new JMenu(MessageUtils.getMessage("menu.language"));
// 添加语言选项
ButtonGroup languageGroup = new ButtonGroup();
for (Locale locale : LocaleManager.getInstance().getSupportedLocales()) {
JRadioButtonMenuItem languageItem = new JRadioButtonMenuItem(locale.getDisplayName());
languageItem.setSelected(locale.equals(LocaleManager.getInstance().getCurrentLocale()));
languageItem.addActionListener(e -> LocaleManager.getInstance().setCurrentLocale(locale));
languageGroup.add(languageItem);
languageMenu.add(languageItem);
}
// 帮助菜单
JMenu helpMenu = new JMenu(MessageUtils.getMessage("menu.help"));
JMenuItem aboutItem = new JMenuItem(MessageUtils.getMessage("menu.help.about"));
aboutItem.addActionListener(e -> AboutDialog.showDialog(frame));
helpMenu.add(aboutItem);
// 添加菜单到菜单栏
menuBar.add(fileMenu);
menuBar.add(viewMenu);
menuBar.add(languageMenu);
menuBar.add(helpMenu);
return menuBar;
}
/**
* 显示任务详情
*
* @param table 表格
*/
private void showTaskDetails(JTable table) {
int selectedRow = table.getSelectedRow();
if (selectedRow >= 0) {
Map<String, Object> taskInfo = null;
if (table == currentTaskTable) {
// 当前任务表格
taskInfo = printQueueService.getCurrentTaskInfo();
} else if (table == queuedTasksTable) {
// 队列任务表格
List<Map<String, Object>> queuedTasks = printQueueService.getQueuedTasksInfo();
if (selectedRow < queuedTasks.size()) {
taskInfo = queuedTasks.get(selectedRow);
}
}
if (taskInfo != null) {
PrintTaskDetailDialog dialog = new PrintTaskDetailDialog(frame, taskInfo);
dialog.setVisible(true);
}
}
}
/**
* 关闭窗口和资源
*/
@PreDestroy
public void shutdown() {
refreshExecutor.shutdownNow();
printerStatusPanel.shutdown();
statisticsPanel.shutdown();
searchPanel.shutdown();
settingsPanel.shutdown();
LocaleManager.getInstance().removeLocaleChangeListener(this);
if (frame != null) {
frame.dispose();
}
}
/**
* 当语言变更时更新界面
*/
@Override
public void onLocaleChanged(Locale newLocale) {
if (frame != null) {
SwingUtilities.invokeLater(() -> {
// 更新窗口标题
frame.setTitle(MessageUtils.getMessage("main.title"));
// 更新状态标签
refreshData();
// 更新菜单栏
frame.setJMenuBar(createMenuBar());
// 更新选项卡标题
JTabbedPane tabbedPane = (JTabbedPane) frame.getContentPane().getComponent(1);
tabbedPane.setTitleAt(0, MessageUtils.getMessage("tab.current.task"));
tabbedPane.setTitleAt(1, MessageUtils.getMessage("tab.queued.tasks"));
tabbedPane.setTitleAt(2, MessageUtils.getMessage("tab.printer.status"));
tabbedPane.setTitleAt(3, MessageUtils.getMessage("tab.statistics"));
tabbedPane.setTitleAt(4, MessageUtils.getMessage("tab.task.search"));
tabbedPane.setTitleAt(5, MessageUtils.getMessage("tab.settings"));
// 更新表格列名
updateTableHeaders();
});
}
}
/**
* 更新表格列名
*/
private void updateTableHeaders() {
// 更新当前任务表格列名
String[] currentTaskColumnNames = {
MessageUtils.getMessage("table.header.file.url"),
MessageUtils.getMessage("table.header.printer"),
MessageUtils.getMessage("table.header.status"),
MessageUtils.getMessage("table.header.queued.time"),
MessageUtils.getMessage("table.header.start.time"),
MessageUtils.getMessage("table.header.end.time")
};
for (int i = 0; i < currentTaskColumnNames.length; i++) {
currentTaskTable.getColumnModel().getColumn(i).setHeaderValue(currentTaskColumnNames[i]);
}
// 更新队列任务表格列名
String[] queuedTasksColumnNames = {
MessageUtils.getMessage("table.header.file.url"),
MessageUtils.getMessage("table.header.printer"),
MessageUtils.getMessage("table.header.status"),
MessageUtils.getMessage("table.header.queued.time")
};
for (int i = 0; i < queuedTasksColumnNames.length; i++) {
queuedTasksTable.getColumnModel().getColumn(i).setHeaderValue(queuedTasksColumnNames[i]);
}
// 刷新表格头
currentTaskTable.getTableHeader().repaint();
queuedTasksTable.getTableHeader().repaint();
}
}

189
src/main/java/com/goeing/printserver/main/gui/PrintServerTray.java
View File

@ -1,189 +0,0 @@
package com.goeing.printserver.main.gui;
import com.goeing.printserver.main.utils.LocaleChangeListener;
import com.goeing.printserver.main.utils.LocaleManager;
import com.goeing.printserver.main.utils.MessageUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;
import java.util.Locale;
/**
* 打印服务器系统托盘
*/
@Component
@Slf4j
public class PrintServerTray implements LocaleChangeListener {
private PrintQueueGUI printQueueGUI;
private TrayIcon trayIcon;
private SystemTray systemTray;
private boolean traySupported;
@Autowired
public PrintServerTray() {
// 移除构造函数中的PrintQueueGUI依赖，改为在initialize方法中注入
// 注册语言变更监听器
LocaleManager.getInstance().addLocaleChangeListener(this);
}
@Autowired
public void setPrintQueueGUI(PrintQueueGUI printQueueGUI) {
this.printQueueGUI = printQueueGUI;
}
/**
* 初始化系统托盘
*/
public void initialize() {
// 在无头模式下不初始化系统托盘
if (GraphicsEnvironment.isHeadless() || Boolean.getBoolean("app.headless.mode")) {
log.info("在无头模式下运行，跳过系统托盘初始化");
traySupported = false;
return;
}
initializeTray();
}
/**
* 初始化系统托盘
*/
private void initializeTray() {
// 检查系统是否支持系统托盘
if (!SystemTray.isSupported()) {
log.warn("系统不支持系统托盘功能");
traySupported = false;
return;
}
traySupported = true;
systemTray = SystemTray.getSystemTray();
// 创建托盘图标
Image trayImage = createTrayImage();
trayIcon = new TrayIcon(trayImage, MessageUtils.getMessage("app.name"));
trayIcon.setImageAutoSize(true);
// 创建弹出菜单
PopupMenu popupMenu = createPopupMenu();
trayIcon.setPopupMenu(popupMenu);
// 添加鼠标点击事件
trayIcon.addMouseListener(new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent e) {
if (e.getButton() == MouseEvent.BUTTON1) {
// 左键点击显示主窗口
printQueueGUI.show();
}
}
});
// 添加托盘图标
try {
systemTray.add(trayIcon);
log.info("系统托盘图标已添加");
} catch (AWTException e) {
log.error("添加系统托盘图标失败", e);
traySupported = false;
}
}
/**
* 创建托盘图标图像
*/
private Image createTrayImage() {
// 创建一个简单的打印机图标
BufferedImage image = new BufferedImage(16, 16, BufferedImage.TYPE_INT_ARGB);
Graphics2D g2d = image.createGraphics();
// 设置抗锯齿
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
// 绘制打印机图标
g2d.setColor(Color.BLACK);
g2d.fillRect(2, 10, 12, 5); // 打印机底座
g2d.fillRect(3, 3, 10, 7); // 打印机主体
g2d.setColor(Color.WHITE);
g2d.fillRect(4, 4, 8, 5); // 打印机内部
g2d.setColor(Color.BLACK);
g2d.fillRect(5, 6, 6, 1); // 打印纸
g2d.dispose();
return image;
}
/**
* 创建弹出菜单
*/
private PopupMenu createPopupMenu() {
PopupMenu popupMenu = new PopupMenu();
// 添加菜单项
MenuItem openItem = new MenuItem(MessageUtils.getMessage("tray.open"));
MenuItem exitItem = new MenuItem(MessageUtils.getMessage("tray.exit"));
// 设置事件监听器
openItem.addActionListener(e -> printQueueGUI.show());
exitItem.addActionListener(e -> System.exit(0));
// 添加菜单项到弹出菜单
popupMenu.add(openItem);
popupMenu.addSeparator();
popupMenu.add(exitItem);
return popupMenu;
}
/**
* 显示通知消息
*/
public void displayMessage(String caption, String text, TrayIcon.MessageType messageType) {
if (traySupported && trayIcon != null) {
trayIcon.displayMessage(caption, text, messageType);
}
}
/**
* 更新托盘图标提示文本
*/
public void updateTooltip(String tooltip) {
if (traySupported && trayIcon != null) {
trayIcon.setToolTip(tooltip);
}
}
/**
* 关闭系统托盘
*/
public void shutdown() {
if (traySupported && systemTray != null && trayIcon != null) {
systemTray.remove(trayIcon);
log.info("系统托盘图标已移除");
}
// 移除语言变更监听器
LocaleManager.getInstance().removeLocaleChangeListener(this);
}
/**
* 当语言变更时更新系统托盘
*/
@Override
public void onLocaleChanged(Locale newLocale) {
if (traySupported && trayIcon != null) {
// 更新托盘图标提示文本
trayIcon.setToolTip(MessageUtils.getMessage("app.name"));
// 更新弹出菜单
PopupMenu popupMenu = createPopupMenu();
trayIcon.setPopupMenu(popupMenu);
}
}
}

440
src/main/java/com/goeing/printserver/main/gui/PrintSettingsPanel.java
View File

@ -1,440 +0,0 @@
package com.goeing.printserver.main.gui;
import com.goeing.printserver.main.PrintController;
import com.goeing.printserver.main.config.PrintServerConfig;
import com.goeing.printserver.main.sse.PrinterClient;
import com.goeing.printserver.main.utils.LocaleChangeListener;
import com.goeing.printserver.main.utils.LocaleManager;
import com.goeing.printserver.main.utils.MessageUtils;
import com.goeing.printserver.main.service.PrintQueueService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Locale;
import com.goeing.printserver.main.gui.PrinterStatusPanel.PrinterListUpdatedEvent;
import javax.swing.*;
import java.awt.*;
/**
* 打印设置面板
*/
@Component
@Slf4j
public class PrintSettingsPanel extends JPanel implements LocaleChangeListener {
private final PrintQueueService printQueueService;
private final PrintServerConfig config;
private final PrintController printController;
private final PrinterClient printerClient;
// UI组件
private JComboBox<String> defaultPrinterComboBox;
private JSpinner maxQueueSizeSpinner;
private JCheckBox enableNotificationsCheckBox;
private JCheckBox startMinimizedCheckBox;
private JCheckBox autoStartCheckBox;
private JTextField websocketUrlField;
private JTextField printerIdField;
private JTextField apiKeyField;
// 标签和按钮
private JLabel titleLabel;
private JLabel defaultPrinterLabel;
private JLabel maxQueueSizeLabel;
private JLabel websocketUrlLabel;
private JLabel printerIdLabel;
private JLabel apiKeyLabel;
private JButton saveButton;
private JButton resetButton;
@Autowired
public PrintSettingsPanel(@Lazy PrintQueueService printQueueService, PrintServerConfig config, @Lazy PrintController printController, @Lazy PrinterClient printerClient) {
this.printQueueService = printQueueService;
this.config = config;
this.printController = printController;
this.printerClient = printerClient;
initializeUI();
loadSettings();
// 注册语言变更监听器
LocaleManager.getInstance().addLocaleChangeListener(this);
}
/**
* 初始化用户界面
*/
private void initializeUI() {
setLayout(new BorderLayout());
setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
// 创建标题
String message = MessageUtils.getMessage("settings.title");
titleLabel = new JLabel(message);
titleLabel.setFont(new Font(titleLabel.getFont().getName(), Font.BOLD, 16));
titleLabel.setBorder(BorderFactory.createEmptyBorder(0, 0, 10, 0));
add(titleLabel, BorderLayout.NORTH);
// 创建设置面板
JPanel settingsPanel = new JPanel(new GridBagLayout());
GridBagConstraints gbc = new GridBagConstraints();
gbc.insets = new Insets(5, 5, 5, 5);
gbc.anchor = GridBagConstraints.WEST;
gbc.fill = GridBagConstraints.HORIZONTAL;
// 默认打印机设置
gbc.gridx = 0;
gbc.gridy = 0;
gbc.gridwidth = 1;
defaultPrinterLabel = new JLabel(MessageUtils.getMessage("settings.defaultPrinter"));
settingsPanel.add(defaultPrinterLabel, gbc);
gbc.gridx = 1;
gbc.weightx = 1.0;
defaultPrinterComboBox = new JComboBox<>();
updatePrinterList(); // 初始化打印机列表
settingsPanel.add(defaultPrinterComboBox, gbc);
// 最大队列大小设置
gbc.gridx = 0;
gbc.gridy = 1;
gbc.weightx = 0.0;
maxQueueSizeLabel = new JLabel(MessageUtils.getMessage("settings.maxQueueSize"));
settingsPanel.add(maxQueueSizeLabel, gbc);
gbc.gridx = 1;
gbc.weightx = 1.0;
SpinnerNumberModel spinnerModel = new SpinnerNumberModel(10, 1, 100, 1);
maxQueueSizeSpinner = new JSpinner(spinnerModel);
settingsPanel.add(maxQueueSizeSpinner, gbc);
// 启用通知设置
gbc.gridx = 0;
gbc.gridy = 2;
gbc.gridwidth = 2;
enableNotificationsCheckBox = new JCheckBox(MessageUtils.getMessage("settings.notifications"));
settingsPanel.add(enableNotificationsCheckBox, gbc);
// 启动时最小化设置
gbc.gridx = 0;
gbc.gridy = 3;
startMinimizedCheckBox = new JCheckBox(MessageUtils.getMessage("settings.startMinimized"));
settingsPanel.add(startMinimizedCheckBox, gbc);
// 开机自启动设置
gbc.gridx = 0;
gbc.gridy = 4;
autoStartCheckBox = new JCheckBox(MessageUtils.getMessage("settings.autoStart"));
settingsPanel.add(autoStartCheckBox, gbc);
// WebSocket URL设置
gbc.gridx = 0;
gbc.gridy = 5;
gbc.gridwidth = 1;
gbc.weightx = 0.0;
websocketUrlLabel = new JLabel(MessageUtils.getMessage("settings.websocketUrl"));
settingsPanel.add(websocketUrlLabel, gbc);
gbc.gridx = 1;
gbc.weightx = 1.0;
websocketUrlField = new JTextField();
settingsPanel.add(websocketUrlField, gbc);
// 打印机ID设置
gbc.gridx = 0;
gbc.gridy = 6;
gbc.weightx = 0.0;
printerIdLabel = new JLabel(MessageUtils.getMessage("settings.printerId"));
settingsPanel.add(printerIdLabel, gbc);
gbc.gridx = 1;
gbc.weightx = 1.0;
printerIdField = new JTextField();
settingsPanel.add(printerIdField, gbc);
// API Key设置
gbc.gridx = 0;
gbc.gridy = 7;
gbc.weightx = 0.0;
apiKeyLabel = new JLabel(MessageUtils.getMessage("settings.apiKey"));
settingsPanel.add(apiKeyLabel, gbc);
gbc.gridx = 1;
gbc.weightx = 1.0;
apiKeyField = new JTextField();
settingsPanel.add(apiKeyField, gbc);
// 添加一个弹性空间
gbc.gridx = 0;
gbc.gridy = 8;
gbc.gridwidth = 2;
gbc.weighty = 1.0;
settingsPanel.add(Box.createVerticalGlue(), gbc);
// 添加设置面板到滚动面板
JScrollPane scrollPane = new JScrollPane(settingsPanel);
scrollPane.setBorder(null);
add(scrollPane, BorderLayout.CENTER);
// 创建按钮面板
JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
saveButton = new JButton(MessageUtils.getMessage("settings.save"));
saveButton.addActionListener(e -> saveSettings());
buttonPanel.add(saveButton);
resetButton = new JButton(MessageUtils.getMessage("settings.reset"));
resetButton.addActionListener(e -> resetSettings());
buttonPanel.add(resetButton);
add(buttonPanel, BorderLayout.SOUTH);
}
/**
* 加载设置
*/
private void loadSettings() {
// 从配置对象加载设置
config.loadConfig();
// 更新UI组件
defaultPrinterComboBox.setSelectedItem(config.getDefaultPrinter());
maxQueueSizeSpinner.setValue(config.getMaxQueueSize());
enableNotificationsCheckBox.setSelected(config.isEnableNotifications());
startMinimizedCheckBox.setSelected(config.isStartMinimized());
autoStartCheckBox.setSelected(config.isAutoStart());
websocketUrlField.setText(config.getWebsocketUrl());
printerIdField.setText(config.getPrinterId());
apiKeyField.setText(config.getApiKey());
}
/**
* 保存设置
*/
private void saveSettings() {
try {
// 从UI组件获取设置值
String defaultPrinter = defaultPrinterComboBox.getSelectedItem().toString();
int maxQueueSize = (Integer) maxQueueSizeSpinner.getValue();
boolean enableNotifications = enableNotificationsCheckBox.isSelected();
boolean startMinimized = startMinimizedCheckBox.isSelected();
boolean autoStart = autoStartCheckBox.isSelected();
String websocketUrl = websocketUrlField.getText().trim();
String printerId = printerIdField.getText().trim();
String apiKey = apiKeyField.getText().trim();
// 检查WebSocket相关配置是否发生变化
boolean websocketConfigChanged = !websocketUrl.equals(config.getWebsocketUrl()) ||
!printerId.equals(config.getPrinterId()) ||
!apiKey.equals(config.getApiKey());
// 更新配置对象
config.setDefaultPrinter(defaultPrinter);
config.setMaxQueueSize(maxQueueSize);
config.setEnableNotifications(enableNotifications);
config.setStartMinimized(startMinimized);
config.setAutoStart(autoStart);
config.setWebsocketUrl(websocketUrl);
config.setPrinterId(printerId);
config.setApiKey(apiKey);
// 保存配置
config.saveConfig();
// 应用设置到服务
applySettings();
// 如果WebSocket配置发生变化，重新连接WebSocket
if (websocketConfigChanged) {
printerClient.reconnect();
String message = MessageUtils.getMessage("settings.saved") + "\n\n" +
MessageUtils.getMessage("settings.websocket.reconnected");
JOptionPane.showMessageDialog(this, message, MessageUtils.getMessage("dialog.success"), JOptionPane.INFORMATION_MESSAGE);
} else {
JOptionPane.showMessageDialog(this, MessageUtils.getMessage("settings.saved"), MessageUtils.getMessage("dialog.success"), JOptionPane.INFORMATION_MESSAGE);
}
} catch (Exception e) {
log.error(MessageUtils.getMessage("log.settings.save.error"), e);
JOptionPane.showMessageDialog(this, MessageUtils.getMessage("settings.save.error", new Object[]{e.getMessage()}), MessageUtils.getMessage("dialog.error"), JOptionPane.ERROR_MESSAGE);
}
}
/**
* 重置设置为默认值
*/
private void resetSettings() {
int option = JOptionPane.showConfirmDialog(this, MessageUtils.getMessage("settings.reset.confirm"), MessageUtils.getMessage("dialog.confirm"), JOptionPane.YES_NO_OPTION);
if (option == JOptionPane.YES_OPTION) {
try {
// 重置配置对象到默认值
config.resetToDefaults();
// 保存默认配置
config.saveConfig();
// 更新UI
loadSettings();
// 应用默认设置
applySettings();
JOptionPane.showMessageDialog(this, MessageUtils.getMessage("settings.reset.success"), MessageUtils.getMessage("dialog.success"), JOptionPane.INFORMATION_MESSAGE);
} catch (Exception e) {
log.error(MessageUtils.getMessage("log.settings.reset.error"), e);
JOptionPane.showMessageDialog(this, MessageUtils.getMessage("settings.reset.error", new Object[]{e.getMessage()}), MessageUtils.getMessage("dialog.error"), JOptionPane.ERROR_MESSAGE);
}
}
}
/**
* 应用设置到服务
*/
private void applySettings() {
// 在这里应用设置到相关服务
// 例如，可以设置打印队列服务的最大队列大小等
printQueueService.setMaxQueueSize(config.getMaxQueueSize());
// 通知设置变更
log.info(MessageUtils.getMessage("log.settings.applied"),
config.getDefaultPrinter(),
config.getMaxQueueSize(),
config.isEnableNotifications(),
config.isStartMinimized(),
config.isAutoStart());
}
/**
* 获取是否启动时最小化设置
*
* @return 是否启动时最小化
*/
public boolean isStartMinimized() {
return config.isStartMinimized();
}
/**
* 获取是否启用通知设置
*
* @return 是否启用通知
*/
public boolean isEnableNotifications() {
return config.isEnableNotifications();
}
/**
* 获取默认打印机设置
*
* @return 默认打印机名称
*/
public String getDefaultPrinter() {
return config.getDefaultPrinter();
}
/**
* 获取最大队列大小设置
*
* @return 最大队列大小
*/
public int getMaxQueueSize() {
return config.getMaxQueueSize();
}
/**
* 更新打印机列表
*/
public void updatePrinterList() {
try {
// 保存当前选中的打印机
String selectedPrinter = defaultPrinterComboBox.getSelectedItem() != null ?
defaultPrinterComboBox.getSelectedItem().toString() : null;
// 清空打印机列表
defaultPrinterComboBox.removeAllItems();
List<String> printers = printController.printerList();
updatePrinterComboBox(printers, selectedPrinter);
} catch (Exception e) {
log.error(MessageUtils.getMessage("log.printer.list.update.error"), e);
}
}
/**
* 使用提供的打印机列表更新下拉框
*
* @param printers 打印机列表
* @param selectedPrinter 当前选中的打印机
*/
private void updatePrinterComboBox(List<String> printers, String selectedPrinter) {
if (printers != null && !printers.isEmpty()) {
for (String printer : printers) {
defaultPrinterComboBox.addItem(printer);
}
// 尝试恢复之前选中的打印机
if (selectedPrinter != null && printers.contains(selectedPrinter)) {
defaultPrinterComboBox.setSelectedItem(selectedPrinter);
} else {
// 如果之前选中的打印机不存在，则使用配置中的默认打印机
String defaultPrinter = config.getDefaultPrinter();
if (defaultPrinter != null && printers.contains(defaultPrinter)) {
defaultPrinterComboBox.setSelectedItem(defaultPrinter);
}
}
// 使用debug级别记录日志，减少info日志输出
log.debug(MessageUtils.getMessage("log.printer.list.updated"), printers.size());
}
}
/**
* 监听打印机列表更新事件
*
* @param event 打印机列表更新事件
*/
@EventListener
public void onPrinterListUpdated(PrinterListUpdatedEvent event) {
SwingUtilities.invokeLater(() -> {
// 保存当前选中的打印机
String selectedPrinter = defaultPrinterComboBox.getSelectedItem() != null ?
defaultPrinterComboBox.getSelectedItem().toString() : null;
// 清空并重新填充打印机列表
defaultPrinterComboBox.removeAllItems();
updatePrinterComboBox(event.getPrinters(), selectedPrinter);
// 使用debug级别记录日志，减少info日志输出
log.debug(MessageUtils.getMessage("log.printer.list.event.received"));
});
}
/**
* 当语言变更时更新UI元素
*/
@Override
public void onLocaleChanged(Locale newLocale) {
// 更新标题和标签
titleLabel.setText(MessageUtils.getMessage("settings.title"));
defaultPrinterLabel.setText(MessageUtils.getMessage("settings.defaultPrinter"));
maxQueueSizeLabel.setText(MessageUtils.getMessage("settings.maxQueueSize"));
websocketUrlLabel.setText(MessageUtils.getMessage("settings.websocketUrl"));
printerIdLabel.setText(MessageUtils.getMessage("settings.printerId"));
apiKeyLabel.setText(MessageUtils.getMessage("settings.apiKey"));
// 更新复选框
enableNotificationsCheckBox.setText(MessageUtils.getMessage("settings.notifications"));
startMinimizedCheckBox.setText(MessageUtils.getMessage("settings.startMinimized"));
autoStartCheckBox.setText(MessageUtils.getMessage("settings.autoStart"));
// 更新按钮
saveButton.setText(MessageUtils.getMessage("settings.save"));
resetButton.setText(MessageUtils.getMessage("settings.reset"));
}
/**
* 关闭资源
*/
public void shutdown() {
// 移除语言变更监听器
LocaleManager.getInstance().removeLocaleChangeListener(this);
}
}

251
src/main/java/com/goeing/printserver/main/gui/PrintStatisticsPanel.java
View File

@ -1,251 +0,0 @@
package com.goeing.printserver.main.gui;
import com.goeing.printserver.main.service.PrintQueueService;
import com.goeing.printserver.main.utils.LocaleChangeListener;
import com.goeing.printserver.main.utils.LocaleManager;
import com.goeing.printserver.main.utils.MessageUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.swing.*;
import java.awt.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Locale;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 打印统计面板
*/
@Component
@Slf4j
public class PrintStatisticsPanel extends JPanel implements LocaleChangeListener {
private final PrintQueueService printQueueService;
private final ScheduledExecutorService refreshExecutor = Executors.newSingleThreadScheduledExecutor();
private final DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// 统计数据
private final AtomicInteger totalTasksCount = new AtomicInteger(0);
private final AtomicInteger completedTasksCount = new AtomicInteger(0);
private final AtomicInteger failedTasksCount = new AtomicInteger(0);
private LocalDateTime startTime = LocalDateTime.now();
// UI组件
private JLabel totalTasksLabel;
private JLabel completedTasksLabel;
private JLabel failedTasksLabel;
private JLabel queueSizeLabel;
private JLabel upTimeLabel;
private JLabel currentTimeLabel;
@Autowired
public PrintStatisticsPanel(PrintQueueService printQueueService) {
this.printQueueService = printQueueService;
initializeUI();
startRefreshTimer();
// 注册语言变更监听器
LocaleManager.getInstance().addLocaleChangeListener(this);
}
/**
* 初始化用户界面
*/
private void initializeUI() {
setLayout(new BorderLayout());
setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
// 创建顶部面板
JPanel topPanel = new JPanel(new BorderLayout());
JLabel titleLabel = new JLabel(MessageUtils.getMessage("stats.title"));
titleLabel.setFont(new Font(titleLabel.getFont().getName(), Font.BOLD, 14));
topPanel.add(titleLabel, BorderLayout.WEST);
// 创建刷新按钮
JButton refreshButton = new JButton(MessageUtils.getMessage("button.refresh"));
refreshButton.addActionListener(e -> refreshStatistics());
topPanel.add(refreshButton, BorderLayout.EAST);
add(topPanel, BorderLayout.NORTH);
// 创建统计信息面板
JPanel statsPanel = new JPanel();
statsPanel.setLayout(new BoxLayout(statsPanel, BoxLayout.Y_AXIS));
statsPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
// 添加统计信息
totalTasksLabel = createStatLabel(MessageUtils.getMessage("stats.totalTasks", new Object[]{0}));
completedTasksLabel = createStatLabel(MessageUtils.getMessage("stats.completedTasks", new Object[]{0}));
failedTasksLabel = createStatLabel(MessageUtils.getMessage("stats.failedTasks", new Object[]{0}));
queueSizeLabel = createStatLabel(MessageUtils.getMessage("stats.queueSize", new Object[]{0}));
upTimeLabel = createStatLabel(MessageUtils.getMessage("stats.uptime", new Object[]{0, 0}));
currentTimeLabel = createStatLabel(MessageUtils.getMessage("stats.currentTime", new Object[]{LocalDateTime.now().format(dateFormatter)}));
statsPanel.add(totalTasksLabel);
statsPanel.add(Box.createVerticalStrut(10));
statsPanel.add(completedTasksLabel);
statsPanel.add(Box.createVerticalStrut(10));
statsPanel.add(failedTasksLabel);
statsPanel.add(Box.createVerticalStrut(10));
statsPanel.add(queueSizeLabel);
statsPanel.add(Box.createVerticalStrut(10));
statsPanel.add(upTimeLabel);
statsPanel.add(Box.createVerticalStrut(10));
statsPanel.add(currentTimeLabel);
// 添加一个弹性空间，使内容居上
statsPanel.add(Box.createVerticalGlue());
// 添加重置按钮
JButton resetButton = new JButton(MessageUtils.getMessage("stats.reset"));
resetButton.addActionListener(e -> resetStatistics());
resetButton.setAlignmentX(0.0f); // LEFT_ALIGNMENT = 0.0f
JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
buttonPanel.add(resetButton);
buttonPanel.setAlignmentX(0.0f); // LEFT_ALIGNMENT = 0.0f
statsPanel.add(buttonPanel);
add(new JScrollPane(statsPanel), BorderLayout.CENTER);
}
/**
* 创建统计标签
*
* @param text 标签文本
* @return 标签组件
*/
private JLabel createStatLabel(String text) {
JLabel label = new JLabel(text);
label.setFont(new Font(label.getFont().getName(), Font.PLAIN, 14));
label.setAlignmentX(0.0f); // LEFT_ALIGNMENT = 0.0f
return label;
}
/**
* 启动定时刷新
*/
private void startRefreshTimer() {
refreshExecutor.scheduleAtFixedRate(this::refreshStatistics, 0, 1, TimeUnit.SECONDS);
}
/**
* 刷新统计信息
*/
private void refreshStatistics() {
SwingUtilities.invokeLater(() -> {
try {
// 更新队列大小
int queueSize = printQueueService.getQueueSize();
queueSizeLabel.setText(MessageUtils.getMessage("stats.queueSize", new Object[]{queueSize}));
// 更新运行时间
LocalDateTime now = LocalDateTime.now();
long hours = java.time.Duration.between(startTime, now).toHours();
long minutes = java.time.Duration.between(startTime, now).toMinutes() % 60;
upTimeLabel.setText(MessageUtils.getMessage("stats.uptime", new Object[]{hours, minutes}));
// 更新当前时间
currentTimeLabel.setText(MessageUtils.getMessage("stats.currentTime", new Object[]{now.format(dateFormatter)}));
} catch (Exception e) {
log.error(MessageUtils.getMessage("log.error.refresh.statistics"), e);
}
});
}
/**
* 重置统计信息
*/
private void resetStatistics() {
totalTasksCount.set(0);
completedTasksCount.set(0);
failedTasksCount.set(0);
startTime = LocalDateTime.now();
totalTasksLabel.setText(MessageUtils.getMessage("stats.totalTasks", new Object[]{0}));
completedTasksLabel.setText(MessageUtils.getMessage("stats.completedTasks", new Object[]{0}));
failedTasksLabel.setText(MessageUtils.getMessage("stats.failedTasks", new Object[]{0}));
upTimeLabel.setText(MessageUtils.getMessage("stats.uptime", new Object[]{0, 0}));
}
/**
* 增加总任务数
*/
public void incrementTotalTasks() {
int total = totalTasksCount.incrementAndGet();
SwingUtilities.invokeLater(() -> totalTasksLabel.setText(MessageUtils.getMessage("stats.totalTasks", new Object[]{total})));
}
/**
* 增加已完成任务数
*/
public void incrementCompletedTasks() {
int completed = completedTasksCount.incrementAndGet();
SwingUtilities.invokeLater(() -> completedTasksLabel.setText(MessageUtils.getMessage("stats.completedTasks", new Object[]{completed})));
}
/**
* 增加失败任务数
*/
public void incrementFailedTasks() {
int failed = failedTasksCount.incrementAndGet();
SwingUtilities.invokeLater(() -> failedTasksLabel.setText(MessageUtils.getMessage("stats.failedTasks", new Object[]{failed})));
}
/**
* 关闭资源
*/
public void shutdown() {
refreshExecutor.shutdownNow();
LocaleManager.getInstance().removeLocaleChangeListener(this);
}
/**
* 当语言变更时更新界面
*/
@Override
public void onLocaleChanged(Locale newLocale) {
SwingUtilities.invokeLater(() -> {
// 更新标题标签
java.awt.Component[] components = ((JPanel)getComponent(0)).getComponents();
for (java.awt.Component component : components) {
if (component instanceof JLabel) {
((JLabel) component).setText(MessageUtils.getMessage("stats.title"));
break;
}
}
// 更新刷新按钮
for (java.awt.Component component : components) {
if (component instanceof JButton) {
((JButton) component).setText(MessageUtils.getMessage("button.refresh"));
break;
}
}
// 更新重置按钮
JPanel statsPanel = (JPanel) ((JScrollPane) getComponent(1)).getViewport().getView();
JPanel buttonPanel = (JPanel) statsPanel.getComponent(statsPanel.getComponentCount() - 1);
JButton resetButton = (JButton) buttonPanel.getComponent(0);
resetButton.setText(MessageUtils.getMessage("stats.reset"));
// 刷新统计信息
refreshStatistics();
// 更新其他标签
int total = totalTasksCount.get();
int completed = completedTasksCount.get();
int failed = failedTasksCount.get();
totalTasksLabel.setText(MessageUtils.getMessage("stats.totalTasks", new Object[]{total}));
completedTasksLabel.setText(MessageUtils.getMessage("stats.completedTasks", new Object[]{completed}));
failedTasksLabel.setText(MessageUtils.getMessage("stats.failedTasks", new Object[]{failed}));
});
}
}

253
src/main/java/com/goeing/printserver/main/gui/PrintTaskDetailDialog.java
View File

@ -1,253 +0,0 @@
package com.goeing.printserver.main.gui;
import com.goeing.printserver.main.domain.PrintTask;
import com.goeing.printserver.main.utils.LocaleChangeListener;
import com.goeing.printserver.main.utils.LocaleManager;
import com.goeing.printserver.main.utils.MessageUtils;
import javax.swing.*;
import javax.swing.border.EmptyBorder;
import java.awt.*;
import java.awt.Dialog.ModalityType;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Locale;
import java.util.Map;
/**
* 打印任务详情对话框
*/
public class PrintTaskDetailDialog extends JDialog implements LocaleChangeListener {
private final DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
/**
* 创建打印任务详情对话框
*
* @param parent 父窗口
* @param task 任务信息
*/
public PrintTaskDetailDialog(Frame parent, Map<String, Object> task) {
super(parent, MessageUtils.getMessage("dialog.task.detail.title"), true);
initializeUI(task);
LocaleManager.getInstance().addLocaleChangeListener(this);
}
/**
* 创建打印任务详情对话框
*
* @param parent 父窗口
* @param task 打印任务对象
*/
public PrintTaskDetailDialog(Frame parent, PrintTask task) {
super(parent, MessageUtils.getMessage("dialog.task.detail.title"), true);
initializeUI(task.toMap());
LocaleManager.getInstance().addLocaleChangeListener(this);
}
/**
* 创建打印任务详情对话框（接受Window类型参数）
*
* @param parent 父窗口
* @param task 打印任务对象
*/
public PrintTaskDetailDialog(Window parent, PrintTask task) {
super(parent, MessageUtils.getMessage("dialog.task.detail.title"), ModalityType.APPLICATION_MODAL);
initializeUI(task.toMap());
LocaleManager.getInstance().addLocaleChangeListener(this);
}
/**
* 创建打印任务详情对话框（接受Window类型参数和Map类型任务信息）
*
* @param parent 父窗口
* @param task 任务信息
*/
public PrintTaskDetailDialog(Window parent, Map<String, Object> task) {
super(parent, MessageUtils.getMessage("dialog.task.detail.title"), ModalityType.APPLICATION_MODAL);
initializeUI(task);
LocaleManager.getInstance().addLocaleChangeListener(this);
}
/**
* 初始化用户界面
*
* @param task 任务信息
*/
private void initializeUI(Map<String, Object> task) {
setSize(500, 400);
setLocationRelativeTo(getParent());
setLayout(new BorderLayout());
// 创建内容面板
JPanel contentPanel = new JPanel();
contentPanel.setLayout(new BoxLayout(contentPanel, BoxLayout.Y_AXIS));
contentPanel.setBorder(new EmptyBorder(10, 10, 10, 10));
// 添加任务信息
addTaskInfo(contentPanel, task);
// 添加滚动面板
JScrollPane scrollPane = new JScrollPane(contentPanel);
scrollPane.setBorder(null);
add(scrollPane, BorderLayout.CENTER);
// 添加关闭按钮
JButton closeButton = new JButton(MessageUtils.getMessage("common.close"));
closeButton.addActionListener(e -> {
LocaleManager.getInstance().removeLocaleChangeListener(this);
dispose();
});
JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
buttonPanel.add(closeButton);
add(buttonPanel, BorderLayout.SOUTH);
}
/**
* 添加任务信息
*
* @param panel 面板
* @param task 任务信息
*/
private void addTaskInfo(JPanel panel, Map<String, Object> task) {
// 添加标题
JLabel titleLabel = new JLabel(MessageUtils.getMessage("dialog.task.detail.title"));
titleLabel.setFont(new Font(titleLabel.getFont().getName(), Font.BOLD, 16));
titleLabel.setAlignmentX(0.0f); // LEFT_ALIGNMENT = 0.0f
panel.add(titleLabel);
panel.add(Box.createVerticalStrut(10));
// 添加基本信息
addInfoField(panel, MessageUtils.getMessage("dialog.task.detail.file.url"), getStringValue(task.get("fileUrl")));
addInfoField(panel, MessageUtils.getMessage("dialog.task.detail.printer"), getStringValue(task.get("printerName")));
addInfoField(panel, MessageUtils.getMessage("dialog.task.detail.status"), getStringValue(task.get("status")));
addInfoField(panel, MessageUtils.getMessage("dialog.task.detail.queued.time"), formatDateTime(task.get("queuedTime")));
// 添加开始和结束时间（如果有）
if (task.containsKey("startTime") && task.get("startTime") != null) {
addInfoField(panel, MessageUtils.getMessage("dialog.task.detail.start.time"), formatDateTime(task.get("startTime")));
}
if (task.containsKey("endTime") && task.get("endTime") != null) {
addInfoField(panel, MessageUtils.getMessage("dialog.task.detail.end.time"), formatDateTime(task.get("endTime")));
}
// 添加打印选项（如果有）
if (task.containsKey("printOption") && task.get("printOption") != null) {
panel.add(Box.createVerticalStrut(10));
JLabel optionsLabel = new JLabel(MessageUtils.getMessage("dialog.task.detail.print.options"));
optionsLabel.setFont(new Font(optionsLabel.getFont().getName(), Font.BOLD, 14));
optionsLabel.setAlignmentX(0.0f); // LEFT_ALIGNMENT = 0.0f
panel.add(optionsLabel);
panel.add(Box.createVerticalStrut(5));
Map<String, Object> printOption = (Map<String, Object>) task.get("printOption");
for (Map.Entry<String, Object> entry : printOption.entrySet()) {
addInfoField(panel, entry.getKey() + ":", getStringValue(entry.getValue()));
}
}
}
/**
* 添加信息字段
*
* @param panel 面板
* @param label 标签
* @param value 值
*/
private void addInfoField(JPanel panel, String label, String value) {
JPanel fieldPanel = new JPanel(new BorderLayout());
fieldPanel.setAlignmentX(0.0f); // LEFT_ALIGNMENT = 0.0f
fieldPanel.setMaximumSize(new Dimension(Integer.MAX_VALUE, 25));
JLabel labelComponent = new JLabel(label);
labelComponent.setPreferredSize(new Dimension(100, 20));
fieldPanel.add(labelComponent, BorderLayout.WEST);
JTextField valueField = new JTextField(value);
valueField.setEditable(false);
valueField.setBorder(null);
valueField.setBackground(null);
fieldPanel.add(valueField, BorderLayout.CENTER);
panel.add(fieldPanel);
panel.add(Box.createVerticalStrut(5));
}
/**
* 获取字符串值
*
* @param value 值
* @return 字符串值
*/
private String getStringValue(Object value) {
return value != null ? value.toString() : "";
}
/**
* 格式化日期时间
*
* @param dateTimeObj 日期时间对象
* @return 格式化后的日期时间字符串
*/
private String formatDateTime(Object dateTimeObj) {
if (dateTimeObj == null) {
return "";
}
if (dateTimeObj instanceof LocalDateTime) {
return ((LocalDateTime) dateTimeObj).format(dateFormatter);
}
return dateTimeObj.toString();
}
/**
* 当语言变更时更新界面
*/
@Override
public void onLocaleChanged(Locale newLocale) {
SwingUtilities.invokeLater(() -> {
// 更新对话框标题
setTitle(MessageUtils.getMessage("dialog.task.detail.title"));
// 更新标题标签
Container contentPane = getContentPane();
JScrollPane scrollPane = (JScrollPane) contentPane.getComponent(0);
JPanel contentPanel = (JPanel) scrollPane.getViewport().getView();
JLabel titleLabel = (JLabel) contentPanel.getComponent(0);
titleLabel.setText(MessageUtils.getMessage("dialog.task.detail.title"));
// 更新字段标签
for (int i = 2; i < contentPanel.getComponentCount(); i++) {
Component comp = contentPanel.getComponent(i);
if (comp instanceof JPanel) {
JPanel fieldPanel = (JPanel) comp;
JLabel label = (JLabel) fieldPanel.getComponent(0);
String labelText = label.getText();
if (labelText.contains("文件URL") || labelText.contains("File URL")) {
label.setText(MessageUtils.getMessage("dialog.task.detail.file.url"));
} else if (labelText.contains("打印机") || labelText.contains("Printer")) {
label.setText(MessageUtils.getMessage("dialog.task.detail.printer"));
} else if (labelText.contains("状态") || labelText.contains("Status")) {
label.setText(MessageUtils.getMessage("dialog.task.detail.status"));
} else if (labelText.contains("队列时间") || labelText.contains("Queued Time")) {
label.setText(MessageUtils.getMessage("dialog.task.detail.queued.time"));
} else if (labelText.contains("开始时间") || labelText.contains("Start Time")) {
label.setText(MessageUtils.getMessage("dialog.task.detail.start.time"));
} else if (labelText.contains("结束时间") || labelText.contains("End Time")) {
label.setText(MessageUtils.getMessage("dialog.task.detail.end.time"));
} else if (labelText.contains("打印选项") || labelText.contains("Print Options")) {
label.setText(MessageUtils.getMessage("dialog.task.detail.print.options"));
}
}
}
// 更新关闭按钮
JPanel buttonPanel = (JPanel) contentPane.getComponent(1);
JButton closeButton = (JButton) buttonPanel.getComponent(0);
closeButton.setText(MessageUtils.getMessage("common.close"));
});
}
}

404
src/main/java/com/goeing/printserver/main/gui/PrintTaskSearchPanel.java
View File

@ -1,404 +0,0 @@
package com.goeing.printserver.main.gui;
import com.goeing.printserver.main.domain.PrintTask;
import com.goeing.printserver.main.service.PrintQueueService;
import com.goeing.printserver.main.service.PrintHistoryService;
import com.goeing.printserver.main.utils.LocaleChangeListener;
import com.goeing.printserver.main.utils.LocaleManager;
import com.goeing.printserver.main.utils.MessageUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Locale;
/**
* 打印任务搜索面板
*/
@Component
@Slf4j
public class PrintTaskSearchPanel extends JPanel implements LocaleChangeListener {
private final PrintQueueService printQueueService;
private final PrintHistoryService historyService;
private final DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
private String allText;
// UI组件
private JComboBox<String> printerComboBox;
private JComboBox<String> statusComboBox;
private JTextField fileUrlField;
private JCheckBox includeHistoryCheckBox;
private JTable resultsTable;
private DefaultTableModel tableModel;
@Autowired
public PrintTaskSearchPanel(PrintQueueService printQueueService, PrintHistoryService historyService) {
this.printQueueService = printQueueService;
this.historyService = historyService;
this.allText = MessageUtils.getMessage("common.all");
initializeUI();
// 注册语言变更监听器
LocaleManager.getInstance().addLocaleChangeListener(this);
}
/**
* 初始化用户界面
*/
private void initializeUI() {
setLayout(new BorderLayout());
setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
// 创建搜索条件面板
JPanel searchPanel = new JPanel(new GridBagLayout());
GridBagConstraints gbc = new GridBagConstraints();
gbc.insets = new Insets(5, 5, 5, 5);
gbc.fill = GridBagConstraints.HORIZONTAL;
// 打印机选择
gbc.gridx = 0;
gbc.gridy = 0;
searchPanel.add(new JLabel(MessageUtils.getMessage("search.printer")), gbc);
gbc.gridx = 1;
gbc.weightx = 1.0;
printerComboBox = new JComboBox<>(new String[]{MessageUtils.getMessage("common.all")});
searchPanel.add(printerComboBox, gbc);
// 状态选择
gbc.gridx = 0;
gbc.gridy = 1;
gbc.weightx = 0.0;
searchPanel.add(new JLabel(MessageUtils.getMessage("search.status")), gbc);
gbc.gridx = 1;
gbc.weightx = 1.0;
statusComboBox = new JComboBox<>(new String[]{MessageUtils.getMessage("common.all"), "queued", "processing", "completed", "failed"});
searchPanel.add(statusComboBox, gbc);
// 文件URL
gbc.gridx = 0;
gbc.gridy = 2;
gbc.weightx = 0.0;
searchPanel.add(new JLabel(MessageUtils.getMessage("search.fileUrl")), gbc);
gbc.gridx = 1;
gbc.weightx = 1.0;
fileUrlField = new JTextField();
searchPanel.add(fileUrlField, gbc);
// 包含历史记录选项
gbc.gridx = 0;
gbc.gridy = 3;
gbc.gridwidth = 2;
includeHistoryCheckBox = new JCheckBox(MessageUtils.getMessage("search.includeHistory"));
includeHistoryCheckBox.setSelected(true);
searchPanel.add(includeHistoryCheckBox, gbc);
// 搜索按钮
gbc.gridx = 0;
gbc.gridy = 4;
gbc.gridwidth = 2;
gbc.weightx = 1.0;
gbc.anchor = GridBagConstraints.CENTER;
JButton searchButton = new JButton(MessageUtils.getMessage("common.search"));
searchButton.addActionListener(e -> performSearch());
searchPanel.add(searchButton, gbc);
add(searchPanel, BorderLayout.NORTH);
// 创建结果表格
String[] columnNames = {
MessageUtils.getMessage("table.header.file.url"),
MessageUtils.getMessage("table.header.printer"),
MessageUtils.getMessage("table.header.status"),
MessageUtils.getMessage("table.header.queued.time"),
MessageUtils.getMessage("table.header.start.time"),
MessageUtils.getMessage("table.header.end.time")
};
tableModel = new DefaultTableModel(columnNames, 0) {
@Override
public boolean isCellEditable(int row, int column) {
return false;
}
};
resultsTable = new JTable(tableModel);
resultsTable.getTableHeader().setReorderingAllowed(false);
resultsTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
// 添加双击事件
resultsTable.addMouseListener(new java.awt.event.MouseAdapter() {
@Override
public void mouseClicked(java.awt.event.MouseEvent evt) {
if (evt.getClickCount() == 2) {
showTaskDetails();
}
}
});
JScrollPane scrollPane = new JScrollPane(resultsTable);
add(scrollPane, BorderLayout.CENTER);
// 创建按钮面板
JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
JButton detailsButton = new JButton(MessageUtils.getMessage("search.viewDetails"));
detailsButton.addActionListener(e -> showTaskDetails());
buttonPanel.add(detailsButton);
JButton clearButton = new JButton(MessageUtils.getMessage("search.clearResults"));
clearButton.addActionListener(e -> clearResults());
buttonPanel.add(clearButton);
add(buttonPanel, BorderLayout.SOUTH);
}
/**
* 执行搜索
*/
private void performSearch() {
// 清空当前结果
clearResults();
// 获取搜索条件
String printer = printerComboBox.getSelectedItem().toString();
String status = statusComboBox.getSelectedItem().toString();
String fileUrl = fileUrlField.getText().trim();
// 获取当前任务和队列任务
List<PrintTask> currentTasks = printQueueService.getCurrentTask() != null ?
List.of(printQueueService.getCurrentTask()) : List.of();
List<PrintTask> queuedTasks = printQueueService.getQueuedTasks();
// 添加当前任务和队列任务到结果中
addTasksToResults(currentTasks, printer, status, fileUrl);
addTasksToResults(queuedTasks, printer, status, fileUrl);
// 如果选择包含历史记录，则添加历史任务到结果中
if (includeHistoryCheckBox.isSelected()) {
List<PrintTask> historyTasks = historyService.getAllHistory();
addTasksToResults(historyTasks, printer, status, fileUrl);
}
// 更新状态
updateStatus();
}
/**
* 将符合条件的任务添加到结果表格中
*
* @param tasks 任务列表
* @param printer 打印机筛选条件
* @param status 状态筛选条件
* @param fileUrl 文件URL筛选条件
*/
private void addTasksToResults(List<PrintTask> tasks, String printer, String status, String fileUrl) {
for (PrintTask task : tasks) {
// 应用筛选条件
if (!allText.equals(printer) && !printer.equals(task.getPrinter())) {
continue;
}
if (!allText.equals(status) && !status.equals(task.getStatus())) {
continue;
}
if (!fileUrl.isEmpty() && !task.getFileUrl().contains(fileUrl)) {
continue;
}
// 添加到表格
Object[] row = {
task.getFileUrl(),
task.getPrinter(),
task.getStatus(),
formatDateTime(task.getQueuedTime()),
formatDateTime(task.getStartTime()),
formatDateTime(task.getEndTime())
};
tableModel.addRow(row);
}
}
/**
* 格式化日期时间
*
* @param dateTime 日期时间
* @return 格式化后的字符串
*/
private String formatDateTime(LocalDateTime dateTime) {
return dateTime != null ? dateTime.format(dateFormatter) : "--";
}
/**
* 更新状态信息
*/
private void updateStatus() {
int resultCount = tableModel.getRowCount();
if (resultCount == 0) {
JOptionPane.showMessageDialog(this, MessageUtils.getMessage("search.noResults"), MessageUtils.getMessage("dialog.title.search.results"), JOptionPane.INFORMATION_MESSAGE);
}
}
/**
* 清空搜索结果
*/
private void clearResults() {
while (tableModel.getRowCount() > 0) {
tableModel.removeRow(0);
}
}
/**
* 显示任务详情
*/
private void showTaskDetails() {
int selectedRow = resultsTable.getSelectedRow();
if (selectedRow >= 0) {
String fileUrl = (String) tableModel.getValueAt(selectedRow, 0);
String printer = (String) tableModel.getValueAt(selectedRow, 1);
String status = (String) tableModel.getValueAt(selectedRow, 2);
String queuedTime = (String) tableModel.getValueAt(selectedRow, 3);
String startTime = (String) tableModel.getValueAt(selectedRow, 4);
String endTime = (String) tableModel.getValueAt(selectedRow, 5);
// 查找对应的任务对象
PrintTask task = findTaskByFileUrl(fileUrl);
if (task != null) {
// 显示详情对话框
PrintTaskDetailDialog dialog = new PrintTaskDetailDialog(SwingUtilities.getWindowAncestor(this), task);
dialog.setVisible(true);
} else {
// 使用表格中的数据创建一个简化的任务对象
PrintTask simpleTask = new PrintTask();
simpleTask.setFileUrl(fileUrl);
simpleTask.setPrinter(printer);
simpleTask.setStatus(status);
// 显示详情对话框
PrintTaskDetailDialog dialog = new PrintTaskDetailDialog(SwingUtilities.getWindowAncestor(this), simpleTask);
dialog.setVisible(true);
}
} else {
JOptionPane.showMessageDialog(this, MessageUtils.getMessage("search.selectTask"), MessageUtils.getMessage("dialog.title.prompt"), JOptionPane.INFORMATION_MESSAGE);
}
}
/**
* 根据文件URL查找任务
*
* @param fileUrl 文件URL
* @return 任务对象，如果未找到则返回null
*/
private PrintTask findTaskByFileUrl(String fileUrl) {
return findTaskByFileUrl(fileUrl, true);
}
/**
* 根据文件URL查找任务，可选是否包含历史记录
*
* @param fileUrl 文件URL
* @param includeHistory 是否包含历史记录
* @return 任务对象，如果未找到则返回null
*/
private PrintTask findTaskByFileUrl(String fileUrl, boolean includeHistory) {
// 检查当前任务
PrintTask currentTask = printQueueService.getCurrentTask();
if (currentTask != null && currentTask.getFileUrl().equals(fileUrl)) {
return currentTask;
}
// 检查队列中的任务
for (PrintTask task : printQueueService.getQueuedTasks()) {
if (task.getFileUrl().equals(fileUrl)) {
return task;
}
}
// 检查历史记录中的任务
if (includeHistory && includeHistoryCheckBox.isSelected()) {
List<PrintTask> historyTasks = historyService.getHistoryByFileUrl(fileUrl);
if (!historyTasks.isEmpty()) {
return historyTasks.get(0);
}
}
return null;
}
/**
* 当语言变更时更新界面
*/
@Override
public void onLocaleChanged(Locale newLocale) {
SwingUtilities.invokeLater(() -> {
// 更新 allText 变量
allText = MessageUtils.getMessage("common.all");
// 更新标签文本
java.awt.Component[] searchPanelComponents = ((JPanel)getComponent(0)).getComponents();
for (java.awt.Component component : searchPanelComponents) {
if (component instanceof JLabel) {
JLabel label = (JLabel) component;
if (label.getText().contains("打印机") || label.getText().contains("Printer")) {
label.setText(MessageUtils.getMessage("search.printer"));
} else if (label.getText().contains("状态") || label.getText().contains("Status")) {
label.setText(MessageUtils.getMessage("search.status"));
} else if (label.getText().contains("URL")) {
label.setText(MessageUtils.getMessage("search.fileUrl"));
}
} else if (component instanceof JCheckBox) {
((JCheckBox) component).setText(MessageUtils.getMessage("search.includeHistory"));
} else if (component instanceof JButton) {
((JButton) component).setText(MessageUtils.getMessage("common.search"));
} else if (component instanceof JComboBox) {
JComboBox<String> comboBox = (JComboBox<String>) component;
if (comboBox.getItemAt(0).toString().equals("全部") ||
comboBox.getItemAt(0).toString().equals("All")) {
comboBox.removeItemAt(0);
comboBox.insertItemAt(MessageUtils.getMessage("common.all"), 0);
comboBox.setSelectedIndex(0);
}
}
}
// 更新按钮文本
JPanel buttonPanel = (JPanel) getComponent(2);
java.awt.Component[] buttonComponents = buttonPanel.getComponents();
for (java.awt.Component component : buttonComponents) {
if (component instanceof JButton) {
JButton button = (JButton) component;
if (button.getText().contains("详情") || button.getText().contains("Details")) {
button.setText(MessageUtils.getMessage("search.viewDetails"));
} else if (button.getText().contains("清空") || button.getText().contains("Clear")) {
button.setText(MessageUtils.getMessage("search.clearResults"));
}
}
}
// 更新表格列名
String[] columnNames = {
MessageUtils.getMessage("table.header.file.url"),
MessageUtils.getMessage("table.header.printer"),
MessageUtils.getMessage("table.header.status"),
MessageUtils.getMessage("table.header.queued.time"),
MessageUtils.getMessage("table.header.start.time"),
MessageUtils.getMessage("table.header.end.time")
};
for (int i = 0; i < columnNames.length; i++) {
resultsTable.getColumnModel().getColumn(i).setHeaderValue(columnNames[i]);
}
resultsTable.getTableHeader().repaint();
});
}
/**
* 关闭资源
*/
public void shutdown() {
LocaleManager.getInstance().removeLocaleChangeListener(this);
}
}

222
src/main/java/com/goeing/printserver/main/gui/PrinterStatusPanel.java
View File

@ -1,222 +0,0 @@
package com.goeing.printserver.main.gui;
import com.goeing.printserver.main.PrintController;
import com.goeing.printserver.main.config.PrintServerConfig;
import com.goeing.printserver.main.utils.LocaleChangeListener;
import com.goeing.printserver.main.utils.LocaleManager;
import com.goeing.printserver.main.utils.MessageUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* 打印机状态面板
*/
@Component
@Slf4j
public class PrinterStatusPanel extends JPanel implements LocaleChangeListener {
private PrintController printController;
private final PrintServerConfig config;
private JTable printerTable;
private DefaultTableModel printerModel;
private final ScheduledExecutorService refreshExecutor = Executors.newSingleThreadScheduledExecutor();
// 使用ApplicationEventPublisher来发布事件，避免循环依赖
@Autowired
private org.springframework.context.ApplicationEventPublisher eventPublisher;
@Autowired
public PrinterStatusPanel(PrintServerConfig config) {
this.config = config;
// 注册语言变更监听器
LocaleManager.getInstance().addLocaleChangeListener(this);
}
@Autowired
public void setPrintController(PrintController printController) {
this.printController = printController;
// 在设置完依赖后初始化UI和定时器
initializeUI();
startRefreshTimer();
}
/**
* 初始化用户界面
*/
private void initializeUI() {
setLayout(new BorderLayout());
setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
// 创建顶部面板
JPanel topPanel = new JPanel(new BorderLayout());
JLabel titleLabel = new JLabel(MessageUtils.getMessage("printer.status.title"));
titleLabel.setFont(new Font(titleLabel.getFont().getName(), Font.BOLD, 14));
topPanel.add(titleLabel, BorderLayout.WEST);
// 创建刷新按钮
JButton refreshButton = new JButton(MessageUtils.getMessage("button.refresh"));
refreshButton.addActionListener(e -> refreshPrinterList());
topPanel.add(refreshButton, BorderLayout.EAST);
add(topPanel, BorderLayout.NORTH);
// 创建表格模型
String[] columnNames = {
MessageUtils.getMessage("table.header.printer.name"),
MessageUtils.getMessage("table.header.status"),
MessageUtils.getMessage("table.header.default")
};
printerModel = new DefaultTableModel(columnNames, 0) {
@Override
public boolean isCellEditable(int row, int column) {
return false; // 禁止编辑单元格
}
@Override
public Class<?> getColumnClass(int columnIndex) {
return columnIndex == 2 ? Boolean.class : String.class;
}
};
// 创建表格
printerTable = new JTable(printerModel);
printerTable.getTableHeader().setReorderingAllowed(false);
printerTable.setFillsViewportHeight(true);
// 添加滚动面板
JScrollPane scrollPane = new JScrollPane(printerTable);
add(scrollPane, BorderLayout.CENTER);
}
/**
* 启动定时刷新
*/
private void startRefreshTimer() {
// 增加刷新间隔到60秒，减少刷新频率
refreshExecutor.scheduleAtFixedRate(this::refreshPrinterList, 0, 60, TimeUnit.SECONDS);
}
/**
* 刷新打印机列表
*/
private void refreshPrinterList() {
SwingUtilities.invokeLater(() -> {
try {
List<String> printers = printController.printerList();
updatePrinterTable(printers);
} catch (Exception e) {
log.error("刷新打印机列表时发生错误", e);
}
});
}
/**
* 更新打印机表格
*
* @param printers 打印机列表
*/
private void updatePrinterTable(List<String> printers) {
// 清空表格
printerModel.setRowCount(0);
if (printers != null && !printers.isEmpty()) {
String defaultPrinter = config.getDefaultPrinter();
for (String printer : printers) {
Object[] rowData = new Object[3];
rowData[0] = printer;
rowData[1] = MessageUtils.getMessage("printer.status.available"); // 默认状态为可用
rowData[2] = printer.equals(defaultPrinter); // 是否为默认打印机
printerModel.addRow(rowData);
}
// 更新PrintSettingsPanel中的打印机下拉列表
updatePrinterComboBoxes(printers);
}
}
/**
* 更新所有打印机下拉列表
*
* @param printers 打印机列表
*/
private void updatePrinterComboBoxes(List<String> printers) {
// 发布打印机列表更新事件
eventPublisher.publishEvent(new PrinterListUpdatedEvent(printers));
// 使用debug级别记录日志，减少info日志输出
log.debug(MessageUtils.getMessage("log.printer.list.updated"), printers.size());
}
/**
* 打印机列表更新事件
*/
public static class PrinterListUpdatedEvent {
private final List<String> printers;
public PrinterListUpdatedEvent(List<String> printers) {
this.printers = printers;
}
public List<String> getPrinters() {
return printers;
}
}
/**
* 关闭资源
*/
public void shutdown() {
refreshExecutor.shutdownNow();
LocaleManager.getInstance().removeLocaleChangeListener(this);
}
/**
* 当语言变更时更新界面
*/
@Override
public void onLocaleChanged(Locale newLocale) {
SwingUtilities.invokeLater(() -> {
// 更新标题标签
java.awt.Component[] components = ((JPanel)getComponent(0)).getComponents();
for (java.awt.Component component : components) {
if (component instanceof JLabel) {
((JLabel) component).setText(MessageUtils.getMessage("printer.status.title"));
break;
}
}
// 更新刷新按钮
for (java.awt.Component component : components) {
if (component instanceof JButton) {
((JButton) component).setText(MessageUtils.getMessage("button.refresh"));
break;
}
}
// 更新表格列名
String[] columnNames = {
MessageUtils.getMessage("table.header.printer.name"),
MessageUtils.getMessage("table.header.status"),
MessageUtils.getMessage("table.header.default")
};
for (int i = 0; i < columnNames.length; i++) {
printerTable.getColumnModel().getColumn(i).setHeaderValue(columnNames[i]);
}
printerTable.getTableHeader().repaint();
// 刷新打印机列表以更新状态文本
refreshPrinterList();
});
}
}

82
src/main/java/com/goeing/printserver/main/gui/SwingLogAppender.java
View File

@ -1,82 +0,0 @@
package com.goeing.printserver.main.gui;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.AppenderBase;
import lombok.extern.slf4j.Slf4j;
/**
* 自定义日志Appender，将日志输出到Swing界面
*/
public class SwingLogAppender extends AppenderBase<ILoggingEvent> {
private static SystemLogPanel logPanel;
/**
* 设置日志面板
*/
public static void setLogPanel(SystemLogPanel panel) {
logPanel = panel;
}
@Override
protected void append(ILoggingEvent event) {
if (logPanel != null && isStarted()) {
try {
// 转换日志级别
SystemLogPanel.LogLevel level = convertLogLevel(event.getLevel());
// 格式化日志消息，包含时间戳
String timestamp = java.time.LocalDateTime.ofInstant(
java.time.Instant.ofEpochMilli(event.getTimeStamp()),
java.time.ZoneId.systemDefault()
).format(java.time.format.DateTimeFormatter.ofPattern("HH:mm:ss.SSS"));
String loggerName = event.getLoggerName();
// 简化logger名称，只显示最后两个包名
String[] parts = loggerName.split("\\.");
if (parts.length > 2) {
loggerName = parts[parts.length - 2] + "." + parts[parts.length - 1];
}
String message = String.format("%s [%s] %s",
timestamp,
loggerName,
event.getFormattedMessage());
// 如果有异常信息，添加到消息中
if (event.getThrowableProxy() != null) {
message += "\n 异常: " + event.getThrowableProxy().getMessage();
// 添加异常堆栈的前几行
if (event.getThrowableProxy().getStackTraceElementProxyArray() != null &&
event.getThrowableProxy().getStackTraceElementProxyArray().length > 0) {
message += "\n 位置: " + event.getThrowableProxy().getStackTraceElementProxyArray()[0].toString();
}
}
// 添加到日志面板
logPanel.addLogEntry(level, message);
} catch (Exception e) {
// 避免日志记录本身出错导致的循环问题
System.err.println("SwingLogAppender error: " + e.getMessage());
}
}
}
/**
* 转换日志级别
*/
private SystemLogPanel.LogLevel convertLogLevel(ch.qos.logback.classic.Level level) {
switch (level.toInt()) {
case ch.qos.logback.classic.Level.ERROR_INT:
return SystemLogPanel.LogLevel.ERROR;
case ch.qos.logback.classic.Level.WARN_INT:
return SystemLogPanel.LogLevel.WARN;
case ch.qos.logback.classic.Level.INFO_INT:
return SystemLogPanel.LogLevel.INFO;
case ch.qos.logback.classic.Level.DEBUG_INT:
case ch.qos.logback.classic.Level.TRACE_INT:
default:
return SystemLogPanel.LogLevel.DEBUG;
}
}
}

331
src/main/java/com/goeing/printserver/main/gui/SystemLogPanel.java
View File

@ -1,331 +0,0 @@
package com.goeing.printserver.main.gui;
import com.goeing.printserver.main.utils.LocaleChangeListener;
import com.goeing.printserver.main.utils.LocaleManager;
import com.goeing.printserver.main.utils.MessageUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import javax.swing.*;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.SimpleAttributeSet;
import javax.swing.text.StyleConstants;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Locale;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
/**
* 系统日志面板
*/
@Component
@Slf4j
public class SystemLogPanel extends JPanel implements LocaleChangeListener {
private static final int MAX_LOG_LINES = 1000; // 最大日志行数
private final DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
private final BlockingQueue<LogEntry> logQueue = new LinkedBlockingQueue<>();
// UI组件
private JLabel titleLabel;
private JTextPane logTextPane;
private JScrollPane scrollPane;
private JButton clearButton;
private JButton saveButton;
private JComboBox<LogLevel> logLevelComboBox;
private JCheckBox autoScrollCheckBox;
// 样式
private SimpleAttributeSet infoStyle;
private SimpleAttributeSet warnStyle;
private SimpleAttributeSet errorStyle;
private SimpleAttributeSet debugStyle;
// 当前日志级别过滤
private LogLevel currentLogLevel = LogLevel.INFO;
public SystemLogPanel() {
initializeStyles();
initializeUI();
startLogProcessor();
initializeLogPanel();
// 注册语言变更监听器
LocaleManager.getInstance().addLocaleChangeListener(this);
}
/**
* 初始化文本样式
*/
private void initializeStyles() {
infoStyle = new SimpleAttributeSet();
StyleConstants.setForeground(infoStyle, Color.BLACK);
warnStyle = new SimpleAttributeSet();
StyleConstants.setForeground(warnStyle, Color.ORANGE);
StyleConstants.setBold(warnStyle, true);
errorStyle = new SimpleAttributeSet();
StyleConstants.setForeground(errorStyle, Color.RED);
StyleConstants.setBold(errorStyle, true);
debugStyle = new SimpleAttributeSet();
StyleConstants.setForeground(debugStyle, Color.GRAY);
StyleConstants.setItalic(debugStyle, true);
}
/**
* 初始化用户界面
*/
private void initializeUI() {
setLayout(new BorderLayout());
setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
// 创建顶部面板
JPanel topPanel = new JPanel(new BorderLayout());
// 标题
titleLabel = new JLabel(MessageUtils.getMessage("log.panel.title"));
titleLabel.setFont(new Font(titleLabel.getFont().getName(), Font.BOLD, 16));
titleLabel.setBorder(BorderFactory.createEmptyBorder(0, 0, 10, 0));
topPanel.add(titleLabel, BorderLayout.WEST);
// 控制面板
JPanel controlPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
// 日志级别过滤
JLabel levelLabel = new JLabel(MessageUtils.getMessage("log.level.filter"));
controlPanel.add(levelLabel);
logLevelComboBox = new JComboBox<>(LogLevel.values());
logLevelComboBox.setSelectedItem(currentLogLevel);
logLevelComboBox.addActionListener(e -> {
currentLogLevel = (LogLevel) logLevelComboBox.getSelectedItem();
refreshLogDisplay();
});
controlPanel.add(logLevelComboBox);
// 自动滚动
autoScrollCheckBox = new JCheckBox(MessageUtils.getMessage("log.auto.scroll"), true);
controlPanel.add(autoScrollCheckBox);
// 清空按钮
clearButton = new JButton(MessageUtils.getMessage("log.button.clear"));
clearButton.addActionListener(e -> clearLogs());
controlPanel.add(clearButton);
// 保存按钮
saveButton = new JButton(MessageUtils.getMessage("log.button.save"));
saveButton.addActionListener(e -> saveLogs());
controlPanel.add(saveButton);
topPanel.add(controlPanel, BorderLayout.EAST);
add(topPanel, BorderLayout.NORTH);
// 创建日志显示区域
logTextPane = new JTextPane();
logTextPane.setEditable(false);
logTextPane.setFont(new Font(Font.MONOSPACED, Font.PLAIN, 12));
logTextPane.setBackground(Color.WHITE);
scrollPane = new JScrollPane(logTextPane);
scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
scrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
add(scrollPane, BorderLayout.CENTER);
}
/**
* 启动日志处理器
*/
private void startLogProcessor() {
Thread logProcessor = new Thread(() -> {
while (!Thread.currentThread().isInterrupted()) {
try {
LogEntry entry = logQueue.take();
SwingUtilities.invokeLater(() -> appendLogEntry(entry));
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
});
logProcessor.setDaemon(true);
logProcessor.setName("LogProcessor");
logProcessor.start();
}
/**
* 初始化日志面板
*/
private void initializeLogPanel() {
// 注册到SwingLogAppender
SwingLogAppender.setLogPanel(this);
// 添加初始化日志
addLogEntry(LogLevel.INFO, "日志面板已初始化");
}
/**
* 添加日志条目（公开方法，供SwingLogAppender调用）
*/
public void addLogEntry(LogLevel level, String message) {
LogEntry entry = new LogEntry(level, message, LocalDateTime.now());
logQueue.offer(entry);
}
/**
* 添加日志条目到显示区域
*/
private void appendLogEntry(LogEntry entry) {
if (entry.level.ordinal() < currentLogLevel.ordinal()) {
return; // 过滤掉低级别的日志
}
Document doc = logTextPane.getDocument();
try {
// 检查是否超过最大行数
if (doc.getLength() > 0) {
String text = doc.getText(0, doc.getLength());
int lineCount = text.split("\n").length;
if (lineCount > MAX_LOG_LINES) {
// 删除前面的行
int firstLineEnd = text.indexOf('\n');
if (firstLineEnd > 0) {
doc.remove(0, firstLineEnd + 1);
}
}
}
// 格式化日志消息（SwingLogAppender已经包含时间戳，这里只添加级别）
String formattedMessage = String.format("[%s] %s\n",
entry.level.name(),
entry.message);
// 选择样式
SimpleAttributeSet style = getStyleForLevel(entry.level);
// 添加到文档
doc.insertString(doc.getLength(), formattedMessage, style);
// 自动滚动到底部
if (autoScrollCheckBox.isSelected()) {
logTextPane.setCaretPosition(doc.getLength());
}
} catch (BadLocationException e) {
log.error("添加日志条目失败", e);
}
}
/**
* 获取日志级别对应的样式
*/
private SimpleAttributeSet getStyleForLevel(LogLevel level) {
switch (level) {
case ERROR:
return errorStyle;
case WARN:
return warnStyle;
case DEBUG:
return debugStyle;
case INFO:
default:
return infoStyle;
}
}
/**
* 刷新日志显示
*/
private void refreshLogDisplay() {
// 这里可以重新过滤和显示日志
// 为简化实现，暂时不做复杂的过滤重显示
}
/**
* 清空日志
*/
private void clearLogs() {
int option = JOptionPane.showConfirmDialog(this,
MessageUtils.getMessage("log.clear.confirm"),
MessageUtils.getMessage("dialog.confirm"),
JOptionPane.YES_NO_OPTION);
if (option == JOptionPane.YES_OPTION) {
logTextPane.setText("");
log.info("日志已清空");
}
}
/**
* 保存日志到文件
*/
private void saveLogs() {
JFileChooser fileChooser = new JFileChooser();
fileChooser.setDialogTitle(MessageUtils.getMessage("log.save.dialog.title"));
fileChooser.setSelectedFile(new java.io.File("printserver_logs_" +
LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss")) + ".txt"));
int result = fileChooser.showSaveDialog(this);
if (result == JFileChooser.APPROVE_OPTION) {
try {
java.io.File file = fileChooser.getSelectedFile();
java.nio.file.Files.write(file.toPath(), logTextPane.getText().getBytes());
JOptionPane.showMessageDialog(this,
MessageUtils.getMessage("log.save.success", new Object[]{file.getAbsolutePath()}),
MessageUtils.getMessage("dialog.success"),
JOptionPane.INFORMATION_MESSAGE);
} catch (Exception e) {
log.error("保存日志文件失败", e);
JOptionPane.showMessageDialog(this,
MessageUtils.getMessage("log.save.error", new Object[]{e.getMessage()}),
MessageUtils.getMessage("dialog.error"),
JOptionPane.ERROR_MESSAGE);
}
}
}
@Override
public void onLocaleChanged(Locale newLocale) {
SwingUtilities.invokeLater(() -> {
titleLabel.setText(MessageUtils.getMessage("log.panel.title"));
clearButton.setText(MessageUtils.getMessage("log.button.clear"));
saveButton.setText(MessageUtils.getMessage("log.button.save"));
autoScrollCheckBox.setText(MessageUtils.getMessage("log.auto.scroll"));
});
}
/**
* 日志级别枚举
*/
public enum LogLevel {
DEBUG, INFO, WARN, ERROR
}
/**
* 日志条目类
*/
private static class LogEntry {
final LogLevel level;
final String message;
final LocalDateTime timestamp;
LogEntry(LogLevel level, String message, LocalDateTime timestamp) {
this.level = level;
this.message = message;
this.timestamp = timestamp;
}
}
/**
* 清理资源
*/
public void shutdown() {
LocaleManager.getInstance().removeLocaleChangeListener(this);
}
}

258
src/main/java/com/goeing/printserver/main/gui/WebSocketStatusPanel.java
View File

@ -1,258 +0,0 @@
package com.goeing.printserver.main.gui;
import com.goeing.printserver.main.sse.PrinterClient;
import com.goeing.printserver.main.utils.LocaleChangeListener;
import com.goeing.printserver.main.utils.LocaleManager;
import com.goeing.printserver.main.utils.MessageUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.swing.*;
import java.awt.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Locale;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* WebSocket连接状态面板
*/
@Component
@Slf4j
public class WebSocketStatusPanel extends JPanel implements LocaleChangeListener {
private final PrinterClient printerClient;
private final ScheduledExecutorService refreshExecutor = Executors.newSingleThreadScheduledExecutor();
private final DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// UI组件
private JLabel titleLabel;
private JLabel connectionStatusLabel;
private JLabel connectionUrlLabel;
private JLabel lastConnectTimeLabel;
private JLabel reconnectCountLabel;
private JButton reconnectButton;
private JButton disconnectButton;
// 状态数据
private boolean isConnected = false;
private String connectionUrl = "";
private LocalDateTime lastConnectTime;
private int reconnectCount = 0;
@Autowired
public WebSocketStatusPanel(PrinterClient printerClient) {
this.printerClient = printerClient;
initializeUI();
startStatusRefresh();
// 注册语言变更监听器
LocaleManager.getInstance().addLocaleChangeListener(this);
}
/**
* 初始化用户界面
*/
private void initializeUI() {
setLayout(new BorderLayout());
setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
// 创建标题
titleLabel = new JLabel(MessageUtils.getMessage("websocket.status.title"));
titleLabel.setFont(new Font(titleLabel.getFont().getName(), Font.BOLD, 16));
titleLabel.setBorder(BorderFactory.createEmptyBorder(0, 0, 10, 0));
add(titleLabel, BorderLayout.NORTH);
// 创建状态信息面板
JPanel statusPanel = new JPanel(new GridBagLayout());
GridBagConstraints gbc = new GridBagConstraints();
gbc.insets = new Insets(5, 5, 5, 5);
gbc.anchor = GridBagConstraints.WEST;
gbc.fill = GridBagConstraints.HORIZONTAL;
// 连接状态
gbc.gridx = 0;
gbc.gridy = 0;
gbc.weightx = 0.0;
JLabel statusTitleLabel = new JLabel(MessageUtils.getMessage("websocket.status.connection"));
statusPanel.add(statusTitleLabel, gbc);
gbc.gridx = 1;
gbc.weightx = 1.0;
connectionStatusLabel = new JLabel(MessageUtils.getMessage("websocket.status.disconnected"));
connectionStatusLabel.setForeground(Color.RED);
statusPanel.add(connectionStatusLabel, gbc);
// 连接URL
gbc.gridx = 0;
gbc.gridy = 1;
gbc.weightx = 0.0;
JLabel urlTitleLabel = new JLabel(MessageUtils.getMessage("websocket.status.url"));
statusPanel.add(urlTitleLabel, gbc);
gbc.gridx = 1;
gbc.weightx = 1.0;
connectionUrlLabel = new JLabel("-");
statusPanel.add(connectionUrlLabel, gbc);
// 最后连接时间
gbc.gridx = 0;
gbc.gridy = 2;
gbc.weightx = 0.0;
JLabel timeTitleLabel = new JLabel(MessageUtils.getMessage("websocket.status.last.connect"));
statusPanel.add(timeTitleLabel, gbc);
gbc.gridx = 1;
gbc.weightx = 1.0;
lastConnectTimeLabel = new JLabel("-");
statusPanel.add(lastConnectTimeLabel, gbc);
// 重连次数
gbc.gridx = 0;
gbc.gridy = 3;
gbc.weightx = 0.0;
JLabel reconnectTitleLabel = new JLabel(MessageUtils.getMessage("websocket.status.reconnect.count"));
statusPanel.add(reconnectTitleLabel, gbc);
gbc.gridx = 1;
gbc.weightx = 1.0;
reconnectCountLabel = new JLabel("0");
statusPanel.add(reconnectCountLabel, gbc);
// 添加弹性空间
gbc.gridx = 0;
gbc.gridy = 4;
gbc.gridwidth = 2;
gbc.weighty = 1.0;
statusPanel.add(Box.createVerticalGlue(), gbc);
add(statusPanel, BorderLayout.CENTER);
// 创建按钮面板
JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
reconnectButton = new JButton(MessageUtils.getMessage("websocket.button.reconnect"));
reconnectButton.addActionListener(e -> reconnectWebSocket());
buttonPanel.add(reconnectButton);
disconnectButton = new JButton(MessageUtils.getMessage("websocket.button.disconnect"));
disconnectButton.addActionListener(e -> disconnectWebSocket());
buttonPanel.add(disconnectButton);
add(buttonPanel, BorderLayout.SOUTH);
}
/**
* 启动状态刷新
*/
private void startStatusRefresh() {
refreshExecutor.scheduleAtFixedRate(this::updateStatus, 0, 1, TimeUnit.SECONDS);
}
/**
* 更新状态信息
*/
private void updateStatus() {
SwingUtilities.invokeLater(() -> {
try {
// 这里需要从PrinterClient获取实际状态
// 由于PrinterClient没有公开状态方法，我们使用反射或添加公开方法
updateConnectionStatus();
} catch (Exception e) {
log.error("更新WebSocket状态失败", e);
}
});
}
/**
* 更新连接状态显示
*/
private void updateConnectionStatus() {
// 获取实际的连接状态
boolean actuallyConnected = printerClient.isConnected();
String currentUrl = printerClient.getCurrentConnectionUrl();
if (actuallyConnected) {
connectionStatusLabel.setText(MessageUtils.getMessage("websocket.status.connected"));
connectionStatusLabel.setForeground(Color.GREEN);
reconnectButton.setEnabled(false);
disconnectButton.setEnabled(true);
// 如果之前是断开状态，现在连接了，更新连接时间
if (!isConnected) {
lastConnectTime = LocalDateTime.now();
}
} else {
connectionStatusLabel.setText(MessageUtils.getMessage("websocket.status.disconnected"));
connectionStatusLabel.setForeground(Color.RED);
reconnectButton.setEnabled(true);
disconnectButton.setEnabled(false);
}
isConnected = actuallyConnected;
connectionUrl = currentUrl != null ? currentUrl : "";
connectionUrlLabel.setText(connectionUrl.isEmpty() ? "-" : connectionUrl);
lastConnectTimeLabel.setText(lastConnectTime != null ? lastConnectTime.format(dateFormatter) : "-");
reconnectCountLabel.setText(String.valueOf(reconnectCount));
}
/**
* 重新连接WebSocket
*/
private void reconnectWebSocket() {
try {
printerClient.reconnect();
reconnectCount++;
lastConnectTime = LocalDateTime.now();
isConnected = true; // 假设连接成功
log.info("手动重新连接WebSocket");
} catch (Exception e) {
log.error("重新连接WebSocket失败", e);
JOptionPane.showMessageDialog(this,
MessageUtils.getMessage("websocket.error.reconnect", new Object[]{e.getMessage()}),
MessageUtils.getMessage("dialog.error"),
JOptionPane.ERROR_MESSAGE);
}
}
/**
* 断开WebSocket连接
*/
private void disconnectWebSocket() {
try {
printerClient.disconnect();
isConnected = false;
log.info("手动断开WebSocket连接");
} catch (Exception e) {
log.error("断开WebSocket连接失败", e);
JOptionPane.showMessageDialog(this,
MessageUtils.getMessage("websocket.error.disconnect", new Object[]{e.getMessage()}),
MessageUtils.getMessage("dialog.error"),
JOptionPane.ERROR_MESSAGE);
}
}
@Override
public void onLocaleChanged(Locale newLocale) {
SwingUtilities.invokeLater(() -> {
titleLabel.setText(MessageUtils.getMessage("websocket.status.title"));
reconnectButton.setText(MessageUtils.getMessage("websocket.button.reconnect"));
disconnectButton.setText(MessageUtils.getMessage("websocket.button.disconnect"));
updateConnectionStatus();
});
}
/**
* 清理资源
*/
public void shutdown() {
if (refreshExecutor != null && !refreshExecutor.isShutdown()) {
refreshExecutor.shutdownNow();
}
LocaleManager.getInstance().removeLocaleChangeListener(this);
}
}

28
src/main/java/com/goeing/printserver/main/service/PrintQueueService.java
View File

@ -2,8 +2,7 @@ package com.goeing.printserver.main.service;
import com.goeing.printserver.main.domain.dto.WebSocketMessageDTO;
import com.goeing.printserver.main.domain.request.PrintRequest;
import com.goeing.printserver.main.gui.PrintNotificationService;
import com.goeing.printserver.main.gui.PrintStatisticsPanel;
import cn.hutool.json.JSONUtil;
import jakarta.websocket.Session;
import lombok.extern.slf4j.Slf4j;
@ -34,13 +33,7 @@ public class PrintQueueService {
@Lazy
private PrintService printService;
@Autowired
@Lazy
private PrintNotificationService notificationService;
@Autowired
@Lazy
private PrintStatisticsPanel statisticsPanel;
@Autowired
private PrintHistoryService historyService;
@ -172,9 +165,8 @@ public class PrintQueueService {
log.info("打印任务已添加到队列: {}, 当前队列长度: {}, 最大队列大小: {}",
printRequest.getFileUrl(), queueSize, maxQueueSize);
// 发送任务已加入队列的通知
notificationService.notifyTaskQueued(printRequest, queueSize);
statisticsPanel.incrementTotalTasks();
// 任务已加入队列
log.info("任务已加入队列: {}", printRequest.getFileUrl());
return true;
}
@ -215,8 +207,8 @@ public class PrintQueueService {
task.setStatus("processing");
log.info("开始处理打印任务: {}", printRequest.getFileUrl());
// 发送任务开始处理的通知
notificationService.notifyTaskStarted(printRequest, printQueue.size());
// 任务开始处理
log.info("开始处理打印任务: {}", printRequest.getFileUrl());
try {
// 执行打印
@ -227,9 +219,8 @@ public class PrintQueueService {
task.setEndTime(LocalDateTime.now());
task.setStatus("completed");
// 发送任务完成的通知
notificationService.notifyTaskCompleted(printRequest, printQueue.size());
statisticsPanel.incrementCompletedTasks();
// 任务完成
log.info("打印任务完成: {}", printRequest.getFileUrl());
historyService.addTaskToHistory(convertToHistoryTask(task));
// 发送成功响应
@ -256,9 +247,8 @@ public class PrintQueueService {
errorMsg = errorMsg.replace("\\", "\\\\").replace("\"", "\\\"").replace("\n", "\\n");
}
// 发送任务失败的通知
notificationService.notifyTaskFailed(printRequest, errorMsg, printQueue.size());
statisticsPanel.incrementFailedTasks();
// 任务失败
log.error("打印任务失败: {}, 错误: {}", printRequest.getFileUrl(), errorMsg);
historyService.addTaskToHistory(convertToHistoryTask(task));
Map<String, String> map = new HashMap<>();