2596 lines
78 KiB
C++
2596 lines
78 KiB
C++
#include "PetWindow.h"
|
||
|
||
#include "../ai/AIProviderFactory.h"
|
||
#include "../ai/ConversationManager.h"
|
||
#include "../ai/ConversationStore.h"
|
||
#include "../assistant/CommandDispatcher.h"
|
||
#include "../character/CharacterPackageLoader.h"
|
||
#include "../character/CharacterPackageRepository.h"
|
||
#include "../config/ConfigManager.h"
|
||
#include "../fileops/FileOperationManager.h"
|
||
#include "../launcher/AppLaunchManager.h"
|
||
#include "../launcher/AppLaunchStore.h"
|
||
#include "../notification/NotificationDispatcher.h"
|
||
#include "../reminder/ReminderCommandHandler.h"
|
||
#include "../reminder/ReminderManager.h"
|
||
#include "../reminder/ReminderSoundPlayer.h"
|
||
#include "../reminder/ReminderSoundRepository.h"
|
||
#include "../system/StartupManager.h"
|
||
#include "../util/Logger.h"
|
||
#include "../web/WebCapabilityDetector.h"
|
||
#include "../web/WebChatManager.h"
|
||
#include "../web/WebStore.h"
|
||
#include "../weather/WeatherManager.h"
|
||
#include "../weather/WeatherStore.h"
|
||
#include "ChatBubble.h"
|
||
#include "ChatHistoryPanel.h"
|
||
#include "ChatInputDialog.h"
|
||
#include "PetView.h"
|
||
#include "SettingsDialog.h"
|
||
|
||
#include <QAction>
|
||
#include <QApplication>
|
||
#include <QContextMenuEvent>
|
||
#include <QCursor>
|
||
#include <QDialog>
|
||
#include <QDialogButtonBox>
|
||
#include <QFileDialog>
|
||
#include <QFileInfo>
|
||
#include <QFont>
|
||
#include <QFrame>
|
||
#include <QGuiApplication>
|
||
#include <QHideEvent>
|
||
#include <QInputDialog>
|
||
#include <QLabel>
|
||
#include <QList>
|
||
#include <QLineEdit>
|
||
#include <QMenu>
|
||
#include <QMessageBox>
|
||
#include <QMouseEvent>
|
||
#include <QPixmap>
|
||
#include <QPointF>
|
||
#include <QPointer>
|
||
#include <QPushButton>
|
||
#include <QCheckBox>
|
||
#include <QRandomGenerator>
|
||
#include <QScreen>
|
||
#include <QSet>
|
||
#include <QShowEvent>
|
||
#include <QStringList>
|
||
#include <QVBoxLayout>
|
||
#include <QtGlobal>
|
||
|
||
#include <algorithm>
|
||
#include <memory>
|
||
#include <utility>
|
||
|
||
namespace
|
||
{
|
||
constexpr int MaxUserMessageLength = 4000;
|
||
constexpr int ChatInputLowerOffsetY = 48;
|
||
constexpr int StreamBubbleUpdateIntervalMs = 80;
|
||
constexpr int MinAnimationTargetSide = 32;
|
||
constexpr int MaxAnimationTargetSide = 2048;
|
||
constexpr int LowPowerFpsCap = 6;
|
||
constexpr int ChatFinishedReturnDelayMs = 1500;
|
||
constexpr int StandardPrewarmIntervalMs = 800;
|
||
constexpr int LowPowerPrewarmIntervalMs = 1500;
|
||
constexpr qint64 BytesPerMegabyte = 1024 * 1024;
|
||
|
||
int boundedAnimationTargetSide(double sideLength)
|
||
{
|
||
const double boundedSideLength = qBound(
|
||
static_cast<double>(MinAnimationTargetSide),
|
||
sideLength,
|
||
static_cast<double>(MaxAnimationTargetSide));
|
||
return qRound(boundedSideLength);
|
||
}
|
||
|
||
int evenBoundedHistoryLimit(int value, int minimum, int maximum)
|
||
{
|
||
const int boundedValue = qBound(minimum, value, maximum);
|
||
return boundedValue - (boundedValue % 2);
|
||
}
|
||
|
||
QString megabytesText(qint64 bytes)
|
||
{
|
||
return QString::number(static_cast<double>(bytes) / static_cast<double>(BytesPerMegabyte), 'f', 1);
|
||
}
|
||
|
||
AppConfig normalizedAppConfig(AppConfig config)
|
||
{
|
||
config.launchAtStartup = StartupManager::isLaunchAtStartupEnabled();
|
||
config.scale = qBound(0.5, config.scale, 2.0);
|
||
if (config.performanceMode != QStringLiteral("standard")
|
||
&& config.performanceMode != QStringLiteral("low-power"))
|
||
{
|
||
config.performanceMode = QStringLiteral("standard");
|
||
}
|
||
config.animationCacheLimitMb = qBound(64, config.animationCacheLimitMb, 1024);
|
||
config.requestContextMessageLimit = qBound(0, config.requestContextMessageLimit, 200);
|
||
config.memoryHistoryMessageLimit = evenBoundedHistoryLimit(config.memoryHistoryMessageLimit, 2, 5000);
|
||
config.savedHistoryMessageLimit = evenBoundedHistoryLimit(config.savedHistoryMessageLimit, 2, 10000);
|
||
config.characterId = config.characterId.trimmed();
|
||
if (!CharacterPackageRepository::hasPackage(config.characterId))
|
||
{
|
||
config.characterId = CharacterPackageRepository::defaultCharacterId();
|
||
}
|
||
config.reminderSoundId = ReminderSoundRepository::soundInfo(config.reminderSoundId).id;
|
||
config.reminderSoundVolume = qBound(0.0, config.reminderSoundVolume, 1.0);
|
||
return config;
|
||
}
|
||
|
||
QScreen *screenForPopup(const QWidget *reference)
|
||
{
|
||
if (reference != nullptr)
|
||
{
|
||
if (QScreen *screen = QGuiApplication::screenAt(reference->frameGeometry().center()))
|
||
{
|
||
return screen;
|
||
}
|
||
}
|
||
|
||
if (QScreen *screen = QGuiApplication::screenAt(QCursor::pos()))
|
||
{
|
||
return screen;
|
||
}
|
||
|
||
return QGuiApplication::primaryScreen();
|
||
}
|
||
|
||
void centerDialogOnScreen(QDialog *dialog, const QWidget *reference)
|
||
{
|
||
if (dialog == nullptr)
|
||
{
|
||
return;
|
||
}
|
||
|
||
QScreen *screen = screenForPopup(reference);
|
||
if (screen == nullptr)
|
||
{
|
||
return;
|
||
}
|
||
|
||
const QRect availableGeometry = screen->availableGeometry();
|
||
const QSize dialogSize = dialog->size().isValid()
|
||
? dialog->size()
|
||
: dialog->sizeHint();
|
||
const int x = availableGeometry.left() + qMax(0, (availableGeometry.width() - dialogSize.width()) / 2);
|
||
const int y = availableGeometry.top() + qMax(0, (availableGeometry.height() - dialogSize.height()) / 2);
|
||
dialog->move(QPoint(x, y));
|
||
}
|
||
|
||
QString userVisibleErrorMessage(const ChatResponse &response)
|
||
{
|
||
QString message = response.errorMessage.trimmed();
|
||
if (message.isEmpty())
|
||
{
|
||
message = QStringLiteral("未知错误。");
|
||
}
|
||
|
||
if (response.httpStatus > 0)
|
||
{
|
||
message = QStringLiteral("HTTP ") + QString::number(response.httpStatus) + QStringLiteral("：") + message;
|
||
}
|
||
|
||
return message;
|
||
}
|
||
|
||
|
||
QString webCitationListText(const QVector<WebCitation> &citations)
|
||
{
|
||
QStringList lines;
|
||
const int count = qMin(citations.size(), 10);
|
||
for (int index = 0; index < count; ++index)
|
||
{
|
||
const WebCitation &citation = citations.at(index);
|
||
lines.append(QStringLiteral("[%1] %2\n%3")
|
||
.arg(index + 1)
|
||
.arg(citation.title.trimmed().isEmpty() ? QStringLiteral("来源") : citation.title.trimmed())
|
||
.arg(citation.url));
|
||
}
|
||
return lines.join(QStringLiteral("\n"));
|
||
}
|
||
|
||
}
|
||
|
||
PetWindow::PetWindow(QWidget *parent)
|
||
: QWidget(parent)
|
||
, m_chatBubble(std::make_unique<ChatBubble>())
|
||
, m_chatHistoryPanel(std::make_unique<ChatHistoryPanel>(this))
|
||
, m_chatInputDialog(std::make_unique<ChatInputDialog>(MaxUserMessageLength, this))
|
||
, m_conversationManager(std::make_unique<ConversationManager>())
|
||
, m_conversationStore(std::make_unique<ConversationStore>(ConfigManager().conversationHistoryPath()))
|
||
, m_fileOperationManager(std::make_unique<FileOperationManager>())
|
||
, m_appLaunchManager(std::make_unique<AppLaunchManager>())
|
||
, m_notificationDispatcher(std::make_unique<NotificationDispatcher>())
|
||
, m_reminderManager(std::make_unique<ReminderManager>())
|
||
, m_reminderSoundPlayer(std::make_unique<ReminderSoundPlayer>())
|
||
, m_webChatManager(std::make_unique<WebChatManager>())
|
||
, m_weatherManager(std::make_unique<WeatherManager>())
|
||
, m_petView(new PetView(this))
|
||
, m_dragging(false)
|
||
, m_alwaysOnTop(true)
|
||
, m_centerNextFrame(false)
|
||
{
|
||
setAttribute(Qt::WA_TranslucentBackground);
|
||
setWindowFlags(Qt::FramelessWindowHint | Qt::Tool | Qt::WindowStaysOnTopHint);
|
||
setMouseTracking(true);
|
||
|
||
auto *layout = new QVBoxLayout(this);
|
||
layout->setContentsMargins(0, 0, 0, 0);
|
||
layout->addWidget(m_petView);
|
||
|
||
m_frameAnimator.setFrameChangedCallback([this](const QPixmap &pixmap) {
|
||
setDisplayPixmap(pixmap, m_centerNextFrame);
|
||
m_centerNextFrame = false;
|
||
});
|
||
|
||
m_frameAnimator.setClipFinishedCallback([this](const QString &nextState) {
|
||
playResolvedState(m_stateMachine.finishState(nextState), false);
|
||
});
|
||
|
||
m_idleBehaviorTimer.setSingleShot(true);
|
||
connect(&m_idleBehaviorTimer, &QTimer::timeout, this, [this]() {
|
||
playIdleBehavior();
|
||
});
|
||
|
||
m_behaviorReturnTimer.setSingleShot(true);
|
||
connect(&m_behaviorReturnTimer, &QTimer::timeout, this, [this]() {
|
||
returnToIdleFromBehavior();
|
||
});
|
||
|
||
m_streamBubbleUpdateTimer.setSingleShot(true);
|
||
connect(&m_streamBubbleUpdateTimer, &QTimer::timeout, this, [this]() {
|
||
flushStreamingBubble(false);
|
||
});
|
||
|
||
m_animationPrewarmTimer.setSingleShot(true);
|
||
connect(&m_animationPrewarmTimer, &QTimer::timeout, this, [this]() {
|
||
processAnimationPrewarm();
|
||
});
|
||
|
||
QPointer<PetWindow> window(this);
|
||
refreshChatInputWebToggle();
|
||
m_chatInputDialog->setSubmitCallback([window](const QString &message, bool webEnabled) {
|
||
return !window.isNull() && window->submitChatMessage(message, webEnabled);
|
||
});
|
||
|
||
m_reminderManager->setTriggeredCallback([window](const ReminderItem &item) {
|
||
if (!window.isNull())
|
||
{
|
||
window->handleTriggeredReminder(item);
|
||
}
|
||
});
|
||
|
||
loadInitialImage();
|
||
}
|
||
|
||
PetWindow::~PetWindow()
|
||
{
|
||
saveConversationHistoryIfNeeded();
|
||
}
|
||
|
||
void PetWindow::applyAppConfig(const AppConfig &config)
|
||
{
|
||
const AppConfig normalizedConfig = normalizedAppConfig(config);
|
||
const bool characterChanged = m_appConfig.characterId != normalizedConfig.characterId;
|
||
const bool rebuildClips = !qFuzzyCompare(m_appConfig.scale, normalizedConfig.scale)
|
||
|| m_appConfig.performanceMode != normalizedConfig.performanceMode
|
||
|| m_appConfig.enableLazyLoad != normalizedConfig.enableLazyLoad;
|
||
const bool animationCachePolicyChanged =
|
||
m_appConfig.enableAnimationPrewarm != normalizedConfig.enableAnimationPrewarm
|
||
|| m_appConfig.animationCacheLimitMb != normalizedConfig.animationCacheLimitMb
|
||
|| m_appConfig.unloadAnimationsWhenHidden != normalizedConfig.unloadAnimationsWhenHidden;
|
||
const bool loadPersistedHistory = !m_appConfig.saveConversationHistory
|
||
&& normalizedConfig.saveConversationHistory;
|
||
|
||
m_appConfig = normalizedConfig;
|
||
setAlwaysOnTop(m_appConfig.alwaysOnTop);
|
||
configureConversation(loadPersistedHistory);
|
||
|
||
if (m_appConfig.hasWindowPosition && isPointVisibleOnScreen(m_appConfig.windowPosition))
|
||
{
|
||
move(m_appConfig.windowPosition);
|
||
}
|
||
|
||
if (characterChanged)
|
||
{
|
||
m_frameAnimator.stop();
|
||
loadCharacterPackage(m_appConfig.characterId, false);
|
||
}
|
||
else if (rebuildClips && !m_characterPackage.states.isEmpty())
|
||
{
|
||
const QString previousState = m_stateMachine.currentState().isEmpty()
|
||
? QStringLiteral("idle")
|
||
: m_stateMachine.currentState();
|
||
|
||
m_frameAnimator.stop();
|
||
buildAnimationClips();
|
||
|
||
const QString nextState = m_clips.contains(previousState)
|
||
? previousState
|
||
: QStringLiteral("idle");
|
||
if (m_clips.contains(nextState))
|
||
{
|
||
playResolvedState(m_stateMachine.requestState(nextState), false);
|
||
}
|
||
}
|
||
|
||
if (isAnimationCacheManagementEnabled())
|
||
{
|
||
if (animationCachePolicyChanged && !rebuildClips)
|
||
{
|
||
m_animationPrewarmAttemptedStates.clear();
|
||
m_animationPrewarmQueue.clear();
|
||
trimAnimationCache(QStringLiteral("config updated"));
|
||
}
|
||
scheduleAnimationPrewarm();
|
||
}
|
||
else
|
||
{
|
||
stopAnimationPrewarm();
|
||
}
|
||
}
|
||
|
||
AppConfig PetWindow::currentAppConfig() const
|
||
{
|
||
AppConfig config = m_appConfig;
|
||
config.windowPosition = pos();
|
||
config.hasWindowPosition = true;
|
||
config.alwaysOnTop = m_alwaysOnTop;
|
||
config.launchAtStartup = StartupManager::isLaunchAtStartupEnabled();
|
||
return config;
|
||
}
|
||
|
||
void PetWindow::pauseAnimation()
|
||
{
|
||
if (!m_appConfig.pauseWhenHidden)
|
||
{
|
||
return;
|
||
}
|
||
|
||
m_returnToIdleAfterResume = m_behaviorReturnTimer.isActive();
|
||
m_idleBehaviorTimer.stop();
|
||
m_behaviorReturnTimer.stop();
|
||
stopAnimationPrewarm();
|
||
m_frameAnimator.pause();
|
||
}
|
||
|
||
void PetWindow::resumeAnimation()
|
||
{
|
||
m_frameAnimator.resume();
|
||
|
||
if (m_stateMachine.currentState() == QStringLiteral("idle"))
|
||
{
|
||
scheduleIdleBehavior();
|
||
}
|
||
else if (m_returnToIdleAfterResume)
|
||
{
|
||
m_behaviorReturnTimer.start(4000);
|
||
}
|
||
|
||
m_returnToIdleAfterResume = false;
|
||
scheduleAnimationPrewarm();
|
||
}
|
||
|
||
void PetWindow::showBubbleMessage(const QString &message)
|
||
{
|
||
hideReminderActions();
|
||
m_chatBubble->showMessage(message, bubbleAnchorPosition());
|
||
}
|
||
|
||
void PetWindow::openSettingsDialog()
|
||
{
|
||
ConfigManager configManager;
|
||
WeatherStore weatherStore;
|
||
WebStore webStore;
|
||
AppLaunchStore appLaunchStore;
|
||
QString weatherConfigError;
|
||
const WeatherConfig weatherConfig = weatherStore.load(&weatherConfigError);
|
||
if (!weatherConfigError.isEmpty())
|
||
{
|
||
Logger::warning(QStringLiteral("Weather config load warning: ") + weatherConfigError);
|
||
}
|
||
QString webConfigError;
|
||
const WebConfig webConfig = webStore.load(&webConfigError);
|
||
if (!webConfigError.isEmpty())
|
||
{
|
||
Logger::warning(QStringLiteral("Web config load warning: ") + webConfigError);
|
||
}
|
||
QString appLaunchConfigError;
|
||
const AppLaunchConfig appLaunchConfig = appLaunchStore.load(&appLaunchConfigError);
|
||
if (!appLaunchConfigError.isEmpty())
|
||
{
|
||
Logger::warning(QStringLiteral("Launcher config load warning: ") + appLaunchConfigError);
|
||
}
|
||
|
||
SettingsDialog dialog(
|
||
configManager.loadAIConfigStore(),
|
||
currentAppConfig(),
|
||
weatherConfig,
|
||
webConfig,
|
||
appLaunchConfig,
|
||
m_conversationManager ? m_conversationManager->history() : QVector<ChatMessage>(),
|
||
m_reminderManager ? m_reminderManager->allReminders() : QVector<ReminderItem>(),
|
||
[this]() {
|
||
return isManualStateSwitchLocked();
|
||
},
|
||
[this]() {
|
||
clearConversation();
|
||
},
|
||
[this](const QString &reminderId, QString *errorMessage) {
|
||
return m_reminderManager && m_reminderManager->cancelReminder(reminderId, errorMessage);
|
||
},
|
||
[this](const QString &reminderId, const QString &title, const QDateTime &remindAt, const ReminderRecurrence &recurrence, ReminderItem *updatedItem, QString *errorMessage) {
|
||
if (!m_reminderManager)
|
||
{
|
||
if (errorMessage != nullptr)
|
||
{
|
||
*errorMessage = QStringLiteral("提醒功能初始化失败。");
|
||
}
|
||
return false;
|
||
}
|
||
|
||
if (!m_reminderManager->updateReminder(reminderId, title, remindAt, recurrence, errorMessage))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (updatedItem != nullptr)
|
||
{
|
||
const QVector<ReminderItem> reminders = m_reminderManager->allReminders();
|
||
bool found = false;
|
||
for (const ReminderItem &item : reminders)
|
||
{
|
||
if (item.id == reminderId)
|
||
{
|
||
*updatedItem = item;
|
||
found = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!found)
|
||
{
|
||
if (errorMessage != nullptr)
|
||
{
|
||
*errorMessage = QStringLiteral("提醒已更新，但没有找到更新后的记录。");
|
||
}
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
},
|
||
[this](QString *errorMessage) {
|
||
return m_reminderManager && m_reminderManager->pruneFinishedReminders(20, errorMessage);
|
||
},
|
||
[this](const QString &soundId, double volume) {
|
||
if (m_reminderSoundPlayer)
|
||
{
|
||
m_reminderSoundPlayer->play(soundId, volume);
|
||
}
|
||
},
|
||
this);
|
||
centerDialogOnScreen(&dialog, this);
|
||
if (dialog.exec() != QDialog::Accepted)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (!configManager.saveAIConfigStore(dialog.aiConfigStore()))
|
||
{
|
||
Logger::warning(QStringLiteral("Failed to save AI config from settings dialog."));
|
||
}
|
||
|
||
AppConfig acceptedAppConfig = dialog.appConfig();
|
||
QString startupError;
|
||
if (!StartupManager::setLaunchAtStartupEnabled(acceptedAppConfig.launchAtStartup, &startupError))
|
||
{
|
||
Logger::warning(QStringLiteral("Failed to update startup setting: ") + startupError);
|
||
acceptedAppConfig.launchAtStartup = StartupManager::isLaunchAtStartupEnabled();
|
||
QMessageBox::warning(
|
||
this,
|
||
QStringLiteral("开机自启动"),
|
||
startupError.isEmpty() ? QStringLiteral("开机自启动设置保存失败。") : startupError);
|
||
}
|
||
|
||
applyAppConfig(acceptedAppConfig);
|
||
if (!configManager.saveAppConfig(currentAppConfig()))
|
||
{
|
||
Logger::warning(QStringLiteral("Failed to save app config from settings dialog."));
|
||
}
|
||
|
||
QString saveWeatherConfigError;
|
||
if (!weatherStore.save(dialog.weatherConfig(), &saveWeatherConfigError))
|
||
{
|
||
Logger::warning(QStringLiteral("Failed to save weather config from settings dialog: ") + saveWeatherConfigError);
|
||
}
|
||
|
||
QString saveWebConfigError;
|
||
if (!webStore.save(dialog.webConfig(), &saveWebConfigError))
|
||
{
|
||
Logger::warning(QStringLiteral("Failed to save web config from settings dialog: ") + saveWebConfigError);
|
||
}
|
||
refreshChatInputWebToggle();
|
||
|
||
QString saveLauncherConfigError;
|
||
if (!appLaunchStore.save(dialog.appLaunchConfig(), &saveLauncherConfigError))
|
||
{
|
||
Logger::warning(QStringLiteral("Failed to save launcher config from settings dialog: ") + saveLauncherConfigError);
|
||
}
|
||
}
|
||
|
||
void PetWindow::activateFromExternalInstance()
|
||
{
|
||
if (!isVisible())
|
||
{
|
||
show();
|
||
resumeAnimation();
|
||
}
|
||
|
||
if (isMinimized())
|
||
{
|
||
setWindowState(windowState() & ~Qt::WindowMinimized);
|
||
}
|
||
|
||
if (QWidget *modalWidget = QApplication::activeModalWidget())
|
||
{
|
||
modalWidget->raise();
|
||
modalWidget->activateWindow();
|
||
return;
|
||
}
|
||
|
||
raise();
|
||
activateWindow();
|
||
if (m_reminderManager)
|
||
{
|
||
m_reminderManager->checkDueRemindersNow();
|
||
}
|
||
updateBubblePosition();
|
||
}
|
||
|
||
void PetWindow::setSettingsFallbackInContextMenuEnabled(bool enabled)
|
||
{
|
||
m_settingsFallbackInContextMenuEnabled = enabled;
|
||
}
|
||
|
||
void PetWindow::setTrayNotificationCallback(std::function<bool(const QString &, const QString &)> callback)
|
||
{
|
||
if (m_notificationDispatcher)
|
||
{
|
||
m_notificationDispatcher->setShowCallback(std::move(callback));
|
||
}
|
||
}
|
||
|
||
void PetWindow::contextMenuEvent(QContextMenuEvent *event)
|
||
{
|
||
resetBubbleAutoHideTimer();
|
||
|
||
QMenu menu(this);
|
||
|
||
QAction *topAction = menu.addAction(QStringLiteral("取消置顶"));
|
||
topAction->setCheckable(true);
|
||
topAction->setChecked(m_alwaysOnTop);
|
||
|
||
const bool aiRequestRunning = hasActiveAIRequest();
|
||
QAction *chatAction = menu.addAction(QStringLiteral("聊天"));
|
||
chatAction->setEnabled(!aiRequestRunning);
|
||
QAction *showConversationAction = menu.addAction(QStringLiteral("显示对话"));
|
||
QAction *cancelAIAction = menu.addAction(QStringLiteral("取消当前请求"));
|
||
cancelAIAction->setEnabled(aiRequestRunning);
|
||
QAction *clearConversationAction = menu.addAction(QStringLiteral("清空对话"));
|
||
clearConversationAction->setEnabled(m_conversationManager && m_conversationManager->hasHistory());
|
||
QAction *settingsAction = nullptr;
|
||
if (m_settingsFallbackInContextMenuEnabled)
|
||
{
|
||
settingsAction = menu.addAction(QStringLiteral("设置"));
|
||
}
|
||
|
||
addStateTestActions(&menu);
|
||
|
||
menu.addSeparator();
|
||
QAction *exitAction = menu.addAction(QStringLiteral("退出"));
|
||
|
||
QAction *selectedAction = menu.exec(event->globalPos());
|
||
if (selectedAction == topAction)
|
||
{
|
||
setAlwaysOnTop(!m_alwaysOnTop);
|
||
}
|
||
else if (selectedAction == chatAction)
|
||
{
|
||
startChat();
|
||
}
|
||
else if (selectedAction == showConversationAction)
|
||
{
|
||
showConversationHistory();
|
||
}
|
||
else if (selectedAction == cancelAIAction)
|
||
{
|
||
cancelActiveAIRequest();
|
||
}
|
||
else if (selectedAction == clearConversationAction)
|
||
{
|
||
clearConversation();
|
||
}
|
||
else if (settingsAction != nullptr && selectedAction == settingsAction)
|
||
{
|
||
openSettingsDialog();
|
||
}
|
||
else if (selectedAction == exitAction)
|
||
{
|
||
close();
|
||
}
|
||
else if (selectedAction != nullptr && selectedAction->data().isValid())
|
||
{
|
||
if (isManualStateSwitchLocked())
|
||
{
|
||
return;
|
||
}
|
||
|
||
playState(selectedAction->data().toString(), false);
|
||
}
|
||
}
|
||
|
||
void PetWindow::startChat()
|
||
{
|
||
if (!m_chatInputDialog)
|
||
{
|
||
return;
|
||
}
|
||
|
||
refreshChatInputWebToggle();
|
||
m_chatInputDialog->showAt(chatInputAnchorPosition());
|
||
}
|
||
|
||
bool PetWindow::submitChatMessage(const QString &message, bool webEnabled)
|
||
{
|
||
const QString normalizedMessage = message.trimmed();
|
||
if (normalizedMessage.isEmpty())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (normalizedMessage.size() > MaxUserMessageLength)
|
||
{
|
||
playState(QStringLiteral("error"), false);
|
||
showBubbleMessage(QStringLiteral("消息太长，请控制在 4000 字以内。"));
|
||
return false;
|
||
}
|
||
|
||
CommandDispatcher dispatcher;
|
||
const CommandDispatchResult result = dispatcher.dispatch(normalizedMessage);
|
||
if (result.action == CommandDispatchAction::Reminder)
|
||
{
|
||
return handleReminderChatMessage(result.message);
|
||
}
|
||
|
||
if (result.action == CommandDispatchAction::Weather)
|
||
{
|
||
return handleWeatherChatMessage(result.message);
|
||
}
|
||
|
||
if (result.action == CommandDispatchAction::FileOperation)
|
||
{
|
||
return handleFileOperationChatMessage(result.message);
|
||
}
|
||
|
||
if (result.action == CommandDispatchAction::LaunchApp)
|
||
{
|
||
return handleLaunchAppChatMessage(result.message);
|
||
}
|
||
|
||
if (result.action == CommandDispatchAction::UnsupportedTool)
|
||
{
|
||
playState(QStringLiteral("talk"), false);
|
||
showBubbleMessage(result.message);
|
||
return true;
|
||
}
|
||
|
||
saveWebTogglePreference(webEnabled);
|
||
return webEnabled ? submitWebChatMessage(result.message) : submitAiChatMessage(result.message);
|
||
}
|
||
|
||
bool PetWindow::handleReminderChatMessage(const QString &message)
|
||
{
|
||
if (!m_reminderManager)
|
||
{
|
||
playState(QStringLiteral("error"), false);
|
||
showBubbleMessage(QStringLiteral("提醒功能初始化失败。"));
|
||
return false;
|
||
}
|
||
|
||
const ReminderCommandResult result = ReminderCommandHandler::handle(
|
||
message,
|
||
*m_reminderManager);
|
||
playState(result.success ? QStringLiteral("talk") : QStringLiteral("error"), false);
|
||
showBubbleMessage(result.message);
|
||
return result.success;
|
||
}
|
||
|
||
bool PetWindow::handleWeatherChatMessage(const QString &message)
|
||
{
|
||
if (!m_weatherManager)
|
||
{
|
||
playState(QStringLiteral("error"), false);
|
||
showBubbleMessage(QStringLiteral("天气功能初始化失败。"));
|
||
return false;
|
||
}
|
||
|
||
if (hasActiveAIRequest() || m_streamingChatActive)
|
||
{
|
||
playState(QStringLiteral("talk"), false);
|
||
showBubbleMessage(QStringLiteral("当前请求正在进行，请稍后再查天气。"));
|
||
return false;
|
||
}
|
||
|
||
if (m_weatherManager->isBusy())
|
||
{
|
||
playState(QStringLiteral("talk"), false);
|
||
showBubbleMessage(QStringLiteral("天气查询正在进行，请稍后。"));
|
||
return false;
|
||
}
|
||
|
||
WeatherStore weatherStore;
|
||
QString weatherConfigError;
|
||
const WeatherConfig weatherConfig = weatherStore.load(&weatherConfigError);
|
||
if (!weatherConfigError.isEmpty())
|
||
{
|
||
Logger::warning(QStringLiteral("Weather config load warning: ") + weatherConfigError);
|
||
}
|
||
|
||
stopAnimationPrewarm();
|
||
playState(QStringLiteral("think"), false);
|
||
hideReminderActions();
|
||
showBubbleMessage(QStringLiteral("正在查询天气..."));
|
||
|
||
QPointer<PetWindow> window(this);
|
||
m_weatherManager->queryWeather(message, weatherConfig, [window](const WeatherQueryResult &result) {
|
||
if (window.isNull())
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (result.success)
|
||
{
|
||
window->playState(QStringLiteral("talk"), false);
|
||
window->showBubbleMessage(result.message);
|
||
window->m_behaviorReturnTimer.start(ChatFinishedReturnDelayMs);
|
||
return;
|
||
}
|
||
|
||
window->playState(QStringLiteral("error"), false);
|
||
window->showBubbleMessage(result.errorMessage.isEmpty() ? QStringLiteral("天气查询失败。") : result.errorMessage);
|
||
window->m_behaviorReturnTimer.start(ChatFinishedReturnDelayMs);
|
||
});
|
||
return true;
|
||
}
|
||
|
||
bool PetWindow::handleFileOperationChatMessage(const QString &message)
|
||
{
|
||
if (!m_fileOperationManager)
|
||
{
|
||
playState(QStringLiteral("error"), false);
|
||
showBubbleMessage(QStringLiteral("文件操作功能初始化失败。"));
|
||
return false;
|
||
}
|
||
|
||
const QString text = message.trimmed();
|
||
const auto contains = [&text](const QString &keyword) {
|
||
return text.contains(keyword, Qt::CaseInsensitive);
|
||
};
|
||
if (contains(QStringLiteral("删除")) || contains(QStringLiteral("移动")) || contains(QStringLiteral("覆盖"))
|
||
|| contains(QStringLiteral("执行")) || contains(QStringLiteral("运行")) || contains(QStringLiteral("脚本")) || contains(QStringLiteral("命令")))
|
||
{
|
||
playState(QStringLiteral("error"), false);
|
||
showBubbleMessage(QStringLiteral("文件操作 v1 不支持删除、覆盖、移动、执行脚本或运行命令。"));
|
||
return false;
|
||
}
|
||
|
||
if (contains(QStringLiteral("截图")) || contains(QStringLiteral("保存到")))
|
||
{
|
||
playState(QStringLiteral("talk"), false);
|
||
showBubbleMessage(QStringLiteral("文件操作 v1 暂不支持截图或把当前内容保存到指定位置。"));
|
||
return false;
|
||
}
|
||
|
||
if (contains(QStringLiteral("打包")) || contains(QStringLiteral("压缩")) || contains(QStringLiteral("zip")))
|
||
{
|
||
playState(QStringLiteral("talk"), false);
|
||
showBubbleMessage(QStringLiteral("zip 打包需要额外稳定的压缩实现，本版暂不启用；可以先使用复制或备份。"));
|
||
return false;
|
||
}
|
||
|
||
const auto confirmPlan = [this](const FileOperationPlan &plan) {
|
||
QString messageText = plan.description;
|
||
if (!plan.warnings.isEmpty())
|
||
{
|
||
messageText += QStringLiteral("\n\n注意：\n") + plan.warnings.join(QLatin1Char('\n'));
|
||
}
|
||
messageText += QStringLiteral("\n\n请确认是否执行。");
|
||
return QMessageBox::warning(
|
||
this,
|
||
plan.title,
|
||
messageText,
|
||
QMessageBox::Yes | QMessageBox::Cancel,
|
||
QMessageBox::Cancel) == QMessageBox::Yes;
|
||
};
|
||
|
||
FileOperationResult operationResult;
|
||
if (contains(QStringLiteral("列出")) || contains(QStringLiteral("目录")) || contains(QStringLiteral("文件夹")))
|
||
{
|
||
const QString directoryPath = QFileDialog::getExistingDirectory(
|
||
this,
|
||
QStringLiteral("选择要列出的文件夹"),
|
||
QString(),
|
||
QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
|
||
if (directoryPath.isEmpty())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
operationResult = m_fileOperationManager->executeListDirectory(m_fileOperationManager->listDirectoryPlan(directoryPath));
|
||
}
|
||
else if (contains(QStringLiteral("复制")))
|
||
{
|
||
const QString sourceFilePath = QFileDialog::getOpenFileName(this, QStringLiteral("选择要复制的文件"));
|
||
if (sourceFilePath.isEmpty())
|
||
{
|
||
return false;
|
||
}
|
||
const QString targetDirectoryPath = QFileDialog::getExistingDirectory(
|
||
this,
|
||
QStringLiteral("选择复制到的文件夹"),
|
||
QString(),
|
||
QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
|
||
if (targetDirectoryPath.isEmpty())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
const FileOperationPlan plan = m_fileOperationManager->copyFilePlan(sourceFilePath, targetDirectoryPath);
|
||
if (!confirmPlan(plan))
|
||
{
|
||
return false;
|
||
}
|
||
operationResult = m_fileOperationManager->executeCopyFile(plan);
|
||
}
|
||
else if (contains(QStringLiteral("备份")))
|
||
{
|
||
const QString sourceFilePath = QFileDialog::getOpenFileName(this, QStringLiteral("选择要备份的文件"));
|
||
if (sourceFilePath.isEmpty())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
const FileOperationPlan plan = m_fileOperationManager->backupFilePlan(sourceFilePath);
|
||
if (!confirmPlan(plan))
|
||
{
|
||
return false;
|
||
}
|
||
operationResult = m_fileOperationManager->executeBackupFile(plan);
|
||
}
|
||
else if (contains(QStringLiteral("重命名")))
|
||
{
|
||
const QString sourceFilePath = QFileDialog::getOpenFileName(this, QStringLiteral("选择要重命名的文件"));
|
||
if (sourceFilePath.isEmpty())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
bool ok = false;
|
||
const QString newFileName = QInputDialog::getText(
|
||
this,
|
||
QStringLiteral("重命名文件"),
|
||
QStringLiteral("新文件名"),
|
||
QLineEdit::Normal,
|
||
QFileInfo(sourceFilePath).fileName(),
|
||
&ok).trimmed();
|
||
if (!ok || newFileName.isEmpty())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
const FileOperationPlan plan = m_fileOperationManager->renameFilePlan(sourceFilePath, newFileName);
|
||
if (!confirmPlan(plan))
|
||
{
|
||
return false;
|
||
}
|
||
operationResult = m_fileOperationManager->executeRenameFile(plan);
|
||
}
|
||
else
|
||
{
|
||
const QString sourceFilePath = QFileDialog::getOpenFileName(
|
||
this,
|
||
QStringLiteral("选择要读取的文本文件"),
|
||
QString(),
|
||
QStringLiteral("Text Files (*.txt *.md *.markdown *.log *.json *.csv *.ini *.xml *.yaml *.yml);;All Files (*)"));
|
||
if (sourceFilePath.isEmpty())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
operationResult = m_fileOperationManager->executeReadTextFile(m_fileOperationManager->readTextFilePlan(sourceFilePath));
|
||
}
|
||
|
||
if (!operationResult.success)
|
||
{
|
||
playState(QStringLiteral("error"), false);
|
||
showBubbleMessage(operationResult.errorMessage.isEmpty() ? QStringLiteral("文件操作失败。") : operationResult.errorMessage);
|
||
return false;
|
||
}
|
||
|
||
playState(QStringLiteral("talk"), false);
|
||
const QString output = operationResult.outputText.trimmed();
|
||
showBubbleMessage(output.isEmpty() ? operationResult.message : output);
|
||
return true;
|
||
}
|
||
|
||
bool PetWindow::handleLaunchAppChatMessage(const QString &message)
|
||
{
|
||
if (!m_appLaunchManager)
|
||
{
|
||
playState(QStringLiteral("error"), false);
|
||
showBubbleMessage(QStringLiteral("应用启动功能初始化失败。"));
|
||
return false;
|
||
}
|
||
|
||
AppLaunchStore store;
|
||
QString loadError;
|
||
AppLaunchConfig config = store.load(&loadError);
|
||
if (!loadError.isEmpty())
|
||
{
|
||
Logger::warning(QStringLiteral("Launcher config load warning: ") + loadError);
|
||
}
|
||
|
||
AppLaunchPlan plan = m_appLaunchManager->resolveLaunchPlan(message, config);
|
||
if (plan.needsManualSelection)
|
||
{
|
||
const QString executablePath = QFileDialog::getOpenFileName(
|
||
this,
|
||
QStringLiteral("选择要启动的应用"),
|
||
QString(),
|
||
QStringLiteral("Applications (*.exe)"));
|
||
if (executablePath.isEmpty())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
plan = m_appLaunchManager->manualSelectionPlan(message, executablePath);
|
||
}
|
||
|
||
if (!plan.success)
|
||
{
|
||
playState(QStringLiteral("error"), false);
|
||
showBubbleMessage(plan.errorMessage.isEmpty() ? QStringLiteral("没有找到可启动的应用。") : plan.errorMessage);
|
||
return false;
|
||
}
|
||
|
||
QString confirmText = QStringLiteral("应用：%1\n来源：%2")
|
||
.arg(plan.displayName.isEmpty() ? plan.requestedName : plan.displayName,
|
||
plan.matchSource.isEmpty() ? QStringLiteral("未知") : plan.matchSource);
|
||
if (!plan.executablePath.trimmed().isEmpty())
|
||
{
|
||
confirmText += QStringLiteral("\n路径：") + plan.executablePath;
|
||
}
|
||
if (!plan.shortcutPath.trimmed().isEmpty())
|
||
{
|
||
confirmText += QStringLiteral("\n快捷方式：") + plan.shortcutPath;
|
||
}
|
||
if (!plan.workingDirectory.trimmed().isEmpty())
|
||
{
|
||
confirmText += QStringLiteral("\n工作目录：") + plan.workingDirectory;
|
||
}
|
||
QDialog confirmDialog(this);
|
||
confirmDialog.setWindowTitle(QStringLiteral("启动应用"));
|
||
confirmDialog.setModal(true);
|
||
|
||
auto *confirmLayout = new QVBoxLayout(&confirmDialog);
|
||
confirmLayout->setContentsMargins(18, 18, 18, 14);
|
||
confirmLayout->setSpacing(12);
|
||
|
||
auto *questionLabel = new QLabel(QStringLiteral("确认启动该应用？"), &confirmDialog);
|
||
QFont questionFont = questionLabel->font();
|
||
questionFont.setBold(true);
|
||
questionLabel->setFont(questionFont);
|
||
confirmLayout->addWidget(questionLabel);
|
||
|
||
auto *detailLabel = new QLabel(confirmText, &confirmDialog);
|
||
detailLabel->setWordWrap(true);
|
||
detailLabel->setTextInteractionFlags(Qt::TextSelectableByMouse);
|
||
detailLabel->setMinimumWidth(520);
|
||
confirmLayout->addWidget(detailLabel);
|
||
|
||
auto *rememberCheckBox = new QCheckBox(QStringLiteral("记住为此名称，下次直接匹配"), &confirmDialog);
|
||
rememberCheckBox->setVisible(plan.canRemember);
|
||
confirmLayout->addWidget(rememberCheckBox);
|
||
|
||
auto *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, &confirmDialog);
|
||
if (QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok))
|
||
{
|
||
okButton->setText(QStringLiteral("启动"));
|
||
}
|
||
if (QPushButton *cancelButton = buttonBox->button(QDialogButtonBox::Cancel))
|
||
{
|
||
cancelButton->setText(QStringLiteral("取消"));
|
||
}
|
||
QObject::connect(buttonBox, &QDialogButtonBox::accepted, &confirmDialog, &QDialog::accept);
|
||
QObject::connect(buttonBox, &QDialogButtonBox::rejected, &confirmDialog, &QDialog::reject);
|
||
confirmLayout->addWidget(buttonBox);
|
||
|
||
if (confirmDialog.exec() != QDialog::Accepted)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
const AppLaunchResult result = m_appLaunchManager->executeLaunchPlan(plan);
|
||
if (!result.success)
|
||
{
|
||
playState(QStringLiteral("error"), false);
|
||
showBubbleMessage(result.errorMessage.isEmpty() ? QStringLiteral("启动应用失败。") : result.errorMessage);
|
||
return false;
|
||
}
|
||
|
||
QString bubbleText = result.message;
|
||
if (plan.canRemember && rememberCheckBox->isChecked())
|
||
{
|
||
RegisteredApp app = m_appLaunchManager->registeredAppFromPlan(
|
||
plan,
|
||
{plan.requestedName, plan.displayName});
|
||
|
||
bool replaced = false;
|
||
for (RegisteredApp &existingApp : config.apps)
|
||
{
|
||
if (existingApp.id == app.id)
|
||
{
|
||
existingApp = app;
|
||
replaced = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!replaced)
|
||
{
|
||
config.apps.append(app);
|
||
}
|
||
|
||
QString saveError;
|
||
if (!store.save(config, &saveError))
|
||
{
|
||
Logger::warning(QStringLiteral("Failed to save launcher config after manual app selection: ") + saveError);
|
||
bubbleText += QStringLiteral("\n但保存应用别名失败。");
|
||
}
|
||
}
|
||
|
||
playState(QStringLiteral("talk"), false);
|
||
showBubbleMessage(bubbleText.isEmpty() ? QStringLiteral("应用已启动。") : bubbleText);
|
||
return true;
|
||
}
|
||
|
||
|
||
bool PetWindow::submitWebChatMessage(const QString &message)
|
||
{
|
||
if (!m_webChatManager)
|
||
{
|
||
playState(QStringLiteral("error"), false);
|
||
showBubbleMessage(QStringLiteral("联网模式初始化失败。"));
|
||
return false;
|
||
}
|
||
|
||
if (hasActiveWebRequest())
|
||
{
|
||
playState(QStringLiteral("talk"), false);
|
||
showBubbleMessage(QStringLiteral("联网请求正在进行，请稍后。"));
|
||
return false;
|
||
}
|
||
|
||
if ((m_conversationManager && m_conversationManager->isBusy()) || m_streamingChatActive)
|
||
{
|
||
playState(QStringLiteral("talk"), false);
|
||
showBubbleMessage(QStringLiteral("AI 回复正在进行，请稍后再使用联网模式。"));
|
||
return false;
|
||
}
|
||
|
||
ConfigManager configManager;
|
||
AIConfig aiConfig = configManager.loadAIConfig();
|
||
|
||
WebStore webStore;
|
||
QString webConfigError;
|
||
WebConfig webConfig = webStore.load(&webConfigError);
|
||
if (!webConfigError.isEmpty())
|
||
{
|
||
Logger::warning(QStringLiteral("Web config load warning: ") + webConfigError);
|
||
}
|
||
|
||
const WebCapability capability = WebCapabilityDetector::detect(aiConfig, webConfig);
|
||
if (!capability.supported)
|
||
{
|
||
playState(QStringLiteral("talk"), false);
|
||
showBubbleMessage(capability.userMessage);
|
||
refreshChatInputWebToggle();
|
||
return false;
|
||
}
|
||
|
||
QString runtimeError;
|
||
AIConfig runtimeConfig = aiConfig;
|
||
if (!AIProviderFactory::prepareRuntimeConfig(runtimeConfig, &runtimeError))
|
||
{
|
||
playState(QStringLiteral("error"), false);
|
||
showBubbleMessage(runtimeError);
|
||
return false;
|
||
}
|
||
|
||
const QString chatMessage = message.trimmed();
|
||
if (chatMessage.isEmpty())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (!m_conversationManager)
|
||
{
|
||
playState(QStringLiteral("error"), false);
|
||
showBubbleMessage(QStringLiteral("AI 对话功能初始化失败。"));
|
||
return false;
|
||
}
|
||
|
||
m_conversationManager->setConversationMetadata(runtimeConfig.provider, runtimeConfig.model);
|
||
ChatRequest request = m_conversationManager->buildRequestForUserMessage(chatMessage);
|
||
if (request.messages.isEmpty())
|
||
{
|
||
playState(QStringLiteral("error"), false);
|
||
showBubbleMessage(QStringLiteral("联网请求内容为空。"));
|
||
return false;
|
||
}
|
||
|
||
stopAnimationPrewarm();
|
||
playState(QStringLiteral("think"), false);
|
||
hideReminderActions();
|
||
showBubbleMessage(QStringLiteral("正在联网思考..."));
|
||
|
||
QPointer<PetWindow> window(this);
|
||
WebChatRequest webRequest;
|
||
webRequest.chatRequest = request;
|
||
webRequest.aiConfig = runtimeConfig;
|
||
webRequest.webConfig = webConfig;
|
||
m_webChatManager->sendWebChat(webRequest, [window, chatMessage](const WebChatResponse &response) {
|
||
if (window.isNull())
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (!response.success)
|
||
{
|
||
window->playState(QStringLiteral("error"), false);
|
||
window->showBubbleMessage(response.errorMessage.isEmpty()
|
||
? QStringLiteral("联网请求失败。")
|
||
: response.errorMessage);
|
||
window->m_behaviorReturnTimer.start(ChatFinishedReturnDelayMs);
|
||
return;
|
||
}
|
||
|
||
window->playState(QStringLiteral("talk"), false);
|
||
const QString displayText = window->formatWebChatResponseForDisplay(response);
|
||
if (window->m_conversationManager)
|
||
{
|
||
window->m_conversationManager->appendExternalExchange(chatMessage, displayText);
|
||
}
|
||
window->saveConversationHistoryIfNeeded();
|
||
window->refreshChatHistoryPanel();
|
||
window->showBubbleMessage(displayText);
|
||
window->m_behaviorReturnTimer.start(ChatFinishedReturnDelayMs);
|
||
});
|
||
return true;
|
||
}
|
||
|
||
bool PetWindow::hasActiveWebRequest() const
|
||
{
|
||
return m_webChatManager && m_webChatManager->isBusy();
|
||
}
|
||
|
||
QString PetWindow::formatWebChatResponseForDisplay(const WebChatResponse &response) const
|
||
{
|
||
QString message = response.content.trimmed();
|
||
if (message.isEmpty())
|
||
{
|
||
message = QStringLiteral("联网请求已完成，但没有返回内容。");
|
||
}
|
||
|
||
WebStore webStore;
|
||
const WebConfig webConfig = webStore.load();
|
||
if (!webConfig.showCitations)
|
||
{
|
||
return message;
|
||
}
|
||
|
||
if (!response.citations.isEmpty())
|
||
{
|
||
message += QStringLiteral("\n\n来源：\n") + webCitationListText(response.citations);
|
||
}
|
||
else if (!response.usedWeb)
|
||
{
|
||
message += QStringLiteral("\n\n（模型未使用联网来源）");
|
||
}
|
||
else
|
||
{
|
||
message += QStringLiteral("\n\n（模型使用了联网能力，但未返回可展示来源）");
|
||
}
|
||
|
||
return message;
|
||
}
|
||
|
||
void PetWindow::refreshChatInputWebToggle()
|
||
{
|
||
if (!m_chatInputDialog)
|
||
{
|
||
return;
|
||
}
|
||
|
||
WebStore webStore;
|
||
QString errorMessage;
|
||
const WebConfig webConfig = webStore.load(&errorMessage);
|
||
if (!errorMessage.isEmpty())
|
||
{
|
||
Logger::warning(QStringLiteral("Web config load warning: ") + errorMessage);
|
||
}
|
||
|
||
ConfigManager configManager;
|
||
const AIConfig aiConfig = configManager.loadAIConfig();
|
||
const WebCapability capability = WebCapabilityDetector::detect(aiConfig, webConfig);
|
||
const bool available = webConfig.enabled;
|
||
m_chatInputDialog->setWebToggleAvailable(available, capability.userMessage);
|
||
const bool checked = webConfig.rememberLastToggle ? webConfig.lastToggleOn : webConfig.defaultToggleOn;
|
||
m_chatInputDialog->setWebEnabled(available && checked);
|
||
}
|
||
|
||
void PetWindow::saveWebTogglePreference(bool webEnabled)
|
||
{
|
||
WebStore webStore;
|
||
QString loadError;
|
||
WebConfig webConfig = webStore.load(&loadError);
|
||
if (!loadError.isEmpty())
|
||
{
|
||
Logger::warning(QStringLiteral("Web config load warning: ") + loadError);
|
||
}
|
||
|
||
if (!webConfig.rememberLastToggle)
|
||
{
|
||
return;
|
||
}
|
||
|
||
webConfig.lastToggleOn = webEnabled;
|
||
QString saveError;
|
||
if (!webStore.save(webConfig, &saveError))
|
||
{
|
||
Logger::warning(QStringLiteral("Failed to save web toggle preference: ") + saveError);
|
||
}
|
||
}
|
||
|
||
void PetWindow::handleTriggeredReminder(const ReminderItem &item)
|
||
{
|
||
playReminderSound();
|
||
|
||
if (shouldNotifyOnlyForReminder())
|
||
{
|
||
showReminderNotification(item);
|
||
return;
|
||
}
|
||
|
||
enqueueVisibleTriggeredReminder(item);
|
||
}
|
||
|
||
void PetWindow::playReminderSound()
|
||
{
|
||
if (m_appConfig.reminderSoundEnabled && m_reminderSoundPlayer)
|
||
{
|
||
m_reminderSoundPlayer->play(m_appConfig.reminderSoundId, m_appConfig.reminderSoundVolume);
|
||
}
|
||
}
|
||
|
||
void PetWindow::showReminderNotification(const ReminderItem &item)
|
||
{
|
||
if (m_notificationDispatcher)
|
||
{
|
||
const bool shown = m_notificationDispatcher->showReminder(QStringLiteral("定时提醒"), QStringLiteral("到时间啦：%1").arg(item.title));
|
||
if (!shown)
|
||
{
|
||
Logger::warning(QStringLiteral("Reminder notification backend unavailable: id=%1").arg(item.id));
|
||
}
|
||
return;
|
||
}
|
||
|
||
Logger::warning(QStringLiteral("Reminder notification dispatcher is unavailable: id=%1").arg(item.id));
|
||
}
|
||
|
||
bool PetWindow::shouldNotifyOnlyForReminder() const
|
||
{
|
||
return !isVisible() || hasActiveAIRequest() || m_streamingChatActive;
|
||
}
|
||
|
||
void PetWindow::enqueueVisibleTriggeredReminder(const ReminderItem &item)
|
||
{
|
||
m_pendingVisibleTriggeredReminders.append(item);
|
||
showNextTriggeredReminder();
|
||
}
|
||
|
||
void PetWindow::showNextTriggeredReminder()
|
||
{
|
||
if (m_hasActiveTriggeredReminder || m_dragging || m_pendingVisibleTriggeredReminders.isEmpty())
|
||
{
|
||
return;
|
||
}
|
||
|
||
const ReminderItem item = m_pendingVisibleTriggeredReminders.takeFirst();
|
||
showTriggeredReminder(item);
|
||
}
|
||
|
||
void PetWindow::finishActiveTriggeredReminder(bool hideBubble)
|
||
{
|
||
hideReminderActions();
|
||
m_hasActiveTriggeredReminder = false;
|
||
if (hideBubble && m_chatBubble)
|
||
{
|
||
m_chatBubble->hideBubble();
|
||
}
|
||
|
||
showNextTriggeredReminder();
|
||
}
|
||
|
||
void PetWindow::showTriggeredReminder(const ReminderItem &item)
|
||
{
|
||
const QString reminderState = m_clips.contains(QStringLiteral("happy"))
|
||
? QStringLiteral("happy")
|
||
: QStringLiteral("talk");
|
||
playState(reminderState, false);
|
||
hideReminderActions();
|
||
m_chatBubble->showMessage(QStringLiteral("到时间啦：%1").arg(item.title), bubbleAnchorPosition(), 0);
|
||
showReminderActions(item);
|
||
}
|
||
|
||
void PetWindow::ensureReminderActionPanel()
|
||
{
|
||
if (m_reminderActionPanel)
|
||
{
|
||
return;
|
||
}
|
||
|
||
auto *panel = new QFrame();
|
||
panel->setObjectName(QStringLiteral("ReminderActionPanel"));
|
||
panel->setWindowFlags(Qt::Tool | Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint);
|
||
panel->setAttribute(Qt::WA_TranslucentBackground);
|
||
panel->setAttribute(Qt::WA_ShowWithoutActivating);
|
||
panel->setStyleSheet(QStringLiteral(
|
||
"QFrame#ReminderActionPanel {"
|
||
"background: #ffffff;"
|
||
"border: 1px solid #c7cdd4;"
|
||
"border-radius: 8px;"
|
||
"}"
|
||
"QPushButton {"
|
||
"background: #f1f4f7;"
|
||
"border: 1px solid #aeb6bf;"
|
||
"border-radius: 6px;"
|
||
"padding: 7px 12px;"
|
||
"color: #202124;"
|
||
"}"
|
||
"QPushButton:hover {"
|
||
"background: #e4e9ee;"
|
||
"}"
|
||
"QPushButton:pressed {"
|
||
"background: #d5dce3;"
|
||
"}"));
|
||
|
||
auto *layout = new QVBoxLayout(panel);
|
||
layout->setContentsMargins(8, 8, 8, 8);
|
||
layout->setSpacing(8);
|
||
|
||
auto *dismissButton = new QPushButton(QStringLiteral("知道了"), panel);
|
||
auto *snoozeButton = new QPushButton(QStringLiteral("5分钟后再提醒"), panel);
|
||
layout->addWidget(dismissButton);
|
||
layout->addWidget(snoozeButton);
|
||
|
||
connect(dismissButton, &QPushButton::clicked, this, [this]() {
|
||
finishActiveTriggeredReminder(true);
|
||
});
|
||
|
||
connect(snoozeButton, &QPushButton::clicked, this, [this]() {
|
||
if (!m_hasActiveTriggeredReminder)
|
||
{
|
||
finishActiveTriggeredReminder(true);
|
||
return;
|
||
}
|
||
|
||
const ReminderItem item = m_activeTriggeredReminder;
|
||
hideReminderActions();
|
||
snoozeTriggeredReminder(item);
|
||
});
|
||
|
||
m_reminderActionPanel.reset(panel);
|
||
}
|
||
|
||
void PetWindow::showReminderActions(const ReminderItem &item)
|
||
{
|
||
m_activeTriggeredReminder = item;
|
||
m_hasActiveTriggeredReminder = true;
|
||
ensureReminderActionPanel();
|
||
if (!m_reminderActionPanel)
|
||
{
|
||
return;
|
||
}
|
||
|
||
m_reminderActionPanel->adjustSize();
|
||
updateReminderActionPosition();
|
||
m_reminderActionPanel->show();
|
||
m_reminderActionPanel->raise();
|
||
}
|
||
|
||
void PetWindow::hideReminderActions()
|
||
{
|
||
m_hasActiveTriggeredReminder = false;
|
||
if (m_reminderActionPanel)
|
||
{
|
||
m_reminderActionPanel->hide();
|
||
}
|
||
}
|
||
|
||
void PetWindow::updateReminderActionPosition()
|
||
{
|
||
if (!m_reminderActionPanel)
|
||
{
|
||
return;
|
||
}
|
||
|
||
m_reminderActionPanel->adjustSize();
|
||
const QSize panelSize = m_reminderActionPanel->sizeHint();
|
||
const QRect petGeometry = frameGeometry();
|
||
constexpr int PanelSideSpacing = 8;
|
||
|
||
QPoint position(
|
||
petGeometry.right() + PanelSideSpacing,
|
||
petGeometry.center().y() - panelSize.height() / 2);
|
||
|
||
if (QScreen *screen = screenForPopup(this))
|
||
{
|
||
const QRect availableGeometry = screen->availableGeometry();
|
||
const int maxX = qMax(availableGeometry.left(), availableGeometry.right() - panelSize.width());
|
||
const int maxY = qMax(availableGeometry.top(), availableGeometry.bottom() - panelSize.height());
|
||
if (position.x() > maxX)
|
||
{
|
||
position.setX(petGeometry.left() - panelSize.width() - PanelSideSpacing);
|
||
}
|
||
|
||
position.setX(qBound(
|
||
availableGeometry.left(),
|
||
position.x(),
|
||
maxX));
|
||
position.setY(qBound(
|
||
availableGeometry.top(),
|
||
position.y(),
|
||
maxY));
|
||
}
|
||
|
||
m_reminderActionPanel->move(position);
|
||
}
|
||
|
||
void PetWindow::snoozeTriggeredReminder(const ReminderItem &item)
|
||
{
|
||
m_hasActiveTriggeredReminder = false;
|
||
if (!m_reminderManager)
|
||
{
|
||
playState(QStringLiteral("error"), false);
|
||
showBubbleMessage(QStringLiteral("提醒功能初始化失败。"));
|
||
QTimer::singleShot(1200, this, [this]() {
|
||
showNextTriggeredReminder();
|
||
});
|
||
return;
|
||
}
|
||
|
||
ReminderItem snoozedItem;
|
||
QString errorMessage;
|
||
if (!m_reminderManager->snoozeReminder(item, 5, &snoozedItem, &errorMessage))
|
||
{
|
||
playState(QStringLiteral("error"), false);
|
||
showBubbleMessage(errorMessage.isEmpty() ? QStringLiteral("创建稍后提醒失败。") : errorMessage);
|
||
QTimer::singleShot(1200, this, [this]() {
|
||
showNextTriggeredReminder();
|
||
});
|
||
return;
|
||
}
|
||
|
||
playState(QStringLiteral("talk"), false);
|
||
showBubbleMessage(QStringLiteral("已延后提醒：%1，时间：%2").arg(snoozedItem.title, reminderDisplayTime(snoozedItem.remindAt)));
|
||
QTimer::singleShot(1200, this, [this]() {
|
||
showNextTriggeredReminder();
|
||
});
|
||
}
|
||
|
||
bool PetWindow::submitAiChatMessage(const QString &message)
|
||
{
|
||
if (hasActiveWebRequest())
|
||
{
|
||
showBubbleMessage(QStringLiteral("当前联网请求正在进行，请稍后。"));
|
||
return false;
|
||
}
|
||
|
||
if (!m_conversationManager || m_conversationManager->isBusy())
|
||
{
|
||
showBubbleMessage(QStringLiteral("AI 回复正在进行。"));
|
||
return false;
|
||
}
|
||
|
||
const QString chatMessage = message.trimmed();
|
||
if (chatMessage.isEmpty())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
ConfigManager configManager;
|
||
AIConfig config = configManager.loadAIConfig();
|
||
QString errorMessage;
|
||
if (!AIProviderFactory::prepareRuntimeConfig(config, &errorMessage))
|
||
{
|
||
playState(QStringLiteral("error"), false);
|
||
showBubbleMessage(errorMessage);
|
||
return false;
|
||
}
|
||
|
||
std::unique_ptr<LLMProvider> provider = AIProviderFactory::createProvider(config);
|
||
if (!provider)
|
||
{
|
||
playState(QStringLiteral("error"), false);
|
||
showBubbleMessage(QStringLiteral("当前 Provider 协议暂未接入。"));
|
||
return false;
|
||
}
|
||
|
||
m_conversationManager->setConversationMetadata(config.provider, config.model);
|
||
if (!m_conversationManager->setProvider(std::move(provider)))
|
||
{
|
||
showBubbleMessage(QStringLiteral("AI 回复正在进行。"));
|
||
return false;
|
||
}
|
||
|
||
stopAnimationPrewarm();
|
||
playState(QStringLiteral("think"), false);
|
||
hideReminderActions();
|
||
m_streamingAssistantText.clear();
|
||
m_streamBubbleUpdateTimer.stop();
|
||
m_streamingChatActive = true;
|
||
m_streamingTalkStarted = false;
|
||
m_chatBubble->showMessage(QStringLiteral("正在思考..."), bubbleAnchorPosition(), 0);
|
||
|
||
QPointer<PetWindow> window(this);
|
||
m_conversationManager->sendUserMessageStreaming(
|
||
chatMessage,
|
||
[window](const QString &delta) {
|
||
if (!window.isNull())
|
||
{
|
||
window->handleChatStreamDelta(delta);
|
||
}
|
||
},
|
||
[window](const ChatResponse &response) {
|
||
if (window.isNull())
|
||
{
|
||
return;
|
||
}
|
||
|
||
window->m_streamBubbleUpdateTimer.stop();
|
||
if (response.success)
|
||
{
|
||
const bool shouldReturnToIdleAfterChat =
|
||
window->m_streamingTalkStarted
|
||
|| window->m_stateMachine.currentState() == QStringLiteral("think")
|
||
|| window->m_stateMachine.currentState() == QStringLiteral("talk")
|
||
|| window->m_frameAnimator.currentStateName() == QStringLiteral("think")
|
||
|| window->m_frameAnimator.currentStateName() == QStringLiteral("talk");
|
||
window->finishStreamingChat();
|
||
window->m_streamingAssistantText = response.content;
|
||
window->flushStreamingBubble(true);
|
||
window->saveConversationHistoryIfNeeded();
|
||
window->refreshChatHistoryPanel();
|
||
if (shouldReturnToIdleAfterChat)
|
||
{
|
||
window->m_behaviorReturnTimer.start(ChatFinishedReturnDelayMs);
|
||
}
|
||
return;
|
||
}
|
||
|
||
window->cancelStreamingChat();
|
||
window->m_streamingAssistantText.clear();
|
||
window->playState(QStringLiteral("error"), false);
|
||
window->showBubbleMessage(QStringLiteral("AI 回复失败：") + userVisibleErrorMessage(response));
|
||
});
|
||
|
||
return true;
|
||
}
|
||
|
||
void PetWindow::clearConversation()
|
||
{
|
||
if (!m_conversationManager)
|
||
{
|
||
return;
|
||
}
|
||
|
||
const bool hadActiveRequest = hasActiveAIRequest();
|
||
m_conversationManager->clear();
|
||
if (m_conversationStore && !m_conversationStore->clear())
|
||
{
|
||
Logger::warning(QStringLiteral("Failed to clear persisted conversation history."));
|
||
}
|
||
cancelStreamingChat();
|
||
if (m_webChatManager && m_webChatManager->isBusy())
|
||
{
|
||
m_webChatManager->cancel();
|
||
}
|
||
refreshChatHistoryPanel();
|
||
showBubbleMessage(hadActiveRequest
|
||
? QStringLiteral("已取消当前请求，并清空对话。")
|
||
: QStringLiteral("对话已清空。"));
|
||
playState(QStringLiteral("idle"), false);
|
||
}
|
||
|
||
void PetWindow::cancelActiveAIRequest()
|
||
{
|
||
if (m_conversationManager && m_conversationManager->isBusy())
|
||
{
|
||
m_conversationManager->cancel();
|
||
cancelStreamingChat();
|
||
showBubbleMessage(QStringLiteral("AI 请求已取消。"));
|
||
playState(QStringLiteral("idle"), false);
|
||
return;
|
||
}
|
||
|
||
if (m_webChatManager && m_webChatManager->isBusy())
|
||
{
|
||
m_webChatManager->cancel();
|
||
showBubbleMessage(QStringLiteral("联网请求已取消。"));
|
||
playState(QStringLiteral("idle"), false);
|
||
return;
|
||
}
|
||
|
||
showBubbleMessage(QStringLiteral("没有正在进行的 AI 或联网请求。"));
|
||
}
|
||
|
||
bool PetWindow::hasActiveAIRequest() const
|
||
{
|
||
return (m_conversationManager && m_conversationManager->isBusy()) || hasActiveWebRequest();
|
||
}
|
||
|
||
bool PetWindow::isManualStateSwitchLocked() const
|
||
{
|
||
if (m_streamingChatActive || hasActiveAIRequest())
|
||
{
|
||
return true;
|
||
}
|
||
|
||
const QString currentState = m_stateMachine.currentState();
|
||
return currentState == QStringLiteral("think") || currentState == QStringLiteral("talk");
|
||
}
|
||
|
||
void PetWindow::showConversationHistory()
|
||
{
|
||
const QVector<ChatMessage> history = m_conversationManager ? m_conversationManager->history() : QVector<ChatMessage>();
|
||
const int prunedCount = m_conversationManager ? m_conversationManager->prunedHistoryMessageCount() : 0;
|
||
m_chatHistoryPanel->setMessages(history, prunedCount);
|
||
m_chatHistoryPanel->showNear(frameGeometry());
|
||
}
|
||
|
||
void PetWindow::refreshChatHistoryPanel()
|
||
{
|
||
if (!m_chatHistoryPanel || !m_chatHistoryPanel->isVisible())
|
||
{
|
||
return;
|
||
}
|
||
|
||
const QVector<ChatMessage> history = m_conversationManager ? m_conversationManager->history() : QVector<ChatMessage>();
|
||
const int prunedCount = m_conversationManager ? m_conversationManager->prunedHistoryMessageCount() : 0;
|
||
m_chatHistoryPanel->setMessages(history, prunedCount);
|
||
}
|
||
|
||
void PetWindow::configureConversation(bool loadPersistedHistory)
|
||
{
|
||
if (!m_conversationManager)
|
||
{
|
||
return;
|
||
}
|
||
|
||
m_conversationManager->setRequestContextMessageLimit(m_appConfig.requestContextMessageLimit);
|
||
m_conversationManager->setMemoryHistoryMessageLimit(m_appConfig.memoryHistoryMessageLimit);
|
||
|
||
if (loadPersistedHistory)
|
||
{
|
||
loadConversationHistoryIfNeeded();
|
||
}
|
||
|
||
saveConversationHistoryIfNeeded();
|
||
refreshChatHistoryPanel();
|
||
}
|
||
|
||
void PetWindow::loadConversationHistoryIfNeeded()
|
||
{
|
||
if (!m_appConfig.saveConversationHistory || !m_conversationManager || !m_conversationStore)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (m_conversationManager->hasHistory())
|
||
{
|
||
return;
|
||
}
|
||
|
||
QString loadError;
|
||
const QVector<ChatMessage> history = m_conversationStore->load(m_appConfig.savedHistoryMessageLimit, &loadError);
|
||
if (!loadError.isEmpty())
|
||
{
|
||
Logger::warning(QStringLiteral("Failed to load conversation history: ") + loadError);
|
||
}
|
||
|
||
if (!history.isEmpty())
|
||
{
|
||
m_conversationManager->setHistory(history);
|
||
}
|
||
}
|
||
|
||
void PetWindow::saveConversationHistoryIfNeeded()
|
||
{
|
||
if (!m_appConfig.saveConversationHistory || !m_conversationManager || !m_conversationStore)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (!m_conversationManager->hasHistory())
|
||
{
|
||
if (!m_conversationStore->clear())
|
||
{
|
||
Logger::warning(QStringLiteral("Failed to clear empty conversation history."));
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (!m_conversationStore->save(m_conversationManager->history(), m_appConfig.savedHistoryMessageLimit))
|
||
{
|
||
Logger::warning(QStringLiteral("Failed to save conversation history."));
|
||
}
|
||
}
|
||
|
||
void PetWindow::handleChatStreamDelta(const QString &delta)
|
||
{
|
||
if (delta.isEmpty())
|
||
{
|
||
return;
|
||
}
|
||
|
||
m_streamingAssistantText += delta;
|
||
if (m_streamingChatActive && !m_streamingTalkStarted)
|
||
{
|
||
m_streamingTalkStarted = true;
|
||
playState(QStringLiteral("talk"), false);
|
||
if (m_stateMachine.currentState() == QStringLiteral("talk"))
|
||
{
|
||
m_returnToIdleAfterResume = false;
|
||
}
|
||
}
|
||
|
||
if (!isVisible())
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (!m_streamBubbleUpdateTimer.isActive())
|
||
{
|
||
m_streamBubbleUpdateTimer.start(StreamBubbleUpdateIntervalMs);
|
||
}
|
||
}
|
||
|
||
void PetWindow::flushStreamingBubble(bool finalUpdate)
|
||
{
|
||
if (!isVisible() || m_streamingAssistantText.trimmed().isEmpty())
|
||
{
|
||
return;
|
||
}
|
||
|
||
hideReminderActions();
|
||
m_chatBubble->showMessage(
|
||
m_streamingAssistantText,
|
||
bubbleAnchorPosition(),
|
||
finalUpdate ? 10000 : 0,
|
||
true);
|
||
}
|
||
|
||
void PetWindow::finishStreamingChat()
|
||
{
|
||
m_streamingChatActive = false;
|
||
m_streamingTalkStarted = false;
|
||
scheduleAnimationPrewarm();
|
||
}
|
||
|
||
void PetWindow::cancelStreamingChat()
|
||
{
|
||
m_streamBubbleUpdateTimer.stop();
|
||
m_streamingAssistantText.clear();
|
||
m_streamingChatActive = false;
|
||
m_streamingTalkStarted = false;
|
||
scheduleAnimationPrewarm();
|
||
}
|
||
|
||
void PetWindow::resetBubbleAutoHideTimer()
|
||
{
|
||
if (m_chatBubble)
|
||
{
|
||
m_chatBubble->resetAutoHideTimer();
|
||
}
|
||
}
|
||
|
||
QPoint PetWindow::chatInputAnchorPosition() const
|
||
{
|
||
return frameGeometry().topLeft() + QPoint(width() / 2, height() / 2 + ChatInputLowerOffsetY);
|
||
}
|
||
|
||
void PetWindow::hideEvent(QHideEvent *event)
|
||
{
|
||
m_streamBubbleUpdateTimer.stop();
|
||
stopAnimationPrewarm();
|
||
if (m_chatBubble)
|
||
{
|
||
m_chatBubble->hideBubble();
|
||
}
|
||
hideReminderActions();
|
||
if (m_chatInputDialog)
|
||
{
|
||
m_chatInputDialog->hide();
|
||
}
|
||
if (m_chatHistoryPanel)
|
||
{
|
||
m_chatHistoryPanel->hide();
|
||
}
|
||
|
||
if (isAnimationCacheManagementEnabled() && m_appConfig.unloadAnimationsWhenHidden)
|
||
{
|
||
unloadNonProtectedAnimationCache(QStringLiteral("window hidden"));
|
||
}
|
||
|
||
QWidget::hideEvent(event);
|
||
}
|
||
|
||
void PetWindow::showEvent(QShowEvent *event)
|
||
{
|
||
QWidget::showEvent(event);
|
||
if (m_reminderManager)
|
||
{
|
||
m_reminderManager->start();
|
||
m_reminderManager->checkDueRemindersNow();
|
||
}
|
||
scheduleAnimationPrewarm();
|
||
}
|
||
|
||
void PetWindow::mouseDoubleClickEvent(QMouseEvent *event)
|
||
{
|
||
resetBubbleAutoHideTimer();
|
||
if (event->button() == Qt::LeftButton)
|
||
{
|
||
m_dragging = false;
|
||
playResolvedState(m_stateMachine.endDrag(), false);
|
||
startChat();
|
||
event->accept();
|
||
return;
|
||
}
|
||
|
||
QWidget::mouseDoubleClickEvent(event);
|
||
}
|
||
|
||
void PetWindow::mouseMoveEvent(QMouseEvent *event)
|
||
{
|
||
if (m_dragging && (event->buttons() & Qt::LeftButton))
|
||
{
|
||
resetBubbleAutoHideTimer();
|
||
move(event->globalPosition().toPoint() - m_dragOffset);
|
||
updateBubblePosition();
|
||
event->accept();
|
||
return;
|
||
}
|
||
|
||
QWidget::mouseMoveEvent(event);
|
||
}
|
||
|
||
void PetWindow::moveEvent(QMoveEvent *event)
|
||
{
|
||
QWidget::moveEvent(event);
|
||
updateBubblePosition();
|
||
}
|
||
|
||
void PetWindow::mousePressEvent(QMouseEvent *event)
|
||
{
|
||
resetBubbleAutoHideTimer();
|
||
|
||
if (event->button() == Qt::LeftButton)
|
||
{
|
||
m_dragging = true;
|
||
m_dragOffset = event->globalPosition().toPoint() - frameGeometry().topLeft();
|
||
stopAnimationPrewarm();
|
||
playResolvedState(m_stateMachine.beginDrag(), false);
|
||
event->accept();
|
||
return;
|
||
}
|
||
|
||
QWidget::mousePressEvent(event);
|
||
}
|
||
|
||
void PetWindow::mouseReleaseEvent(QMouseEvent *event)
|
||
{
|
||
resetBubbleAutoHideTimer();
|
||
|
||
if (event->button() == Qt::LeftButton)
|
||
{
|
||
m_dragging = false;
|
||
playResolvedState(m_stateMachine.endDrag(), false);
|
||
scheduleAnimationPrewarm();
|
||
showNextTriggeredReminder();
|
||
event->accept();
|
||
return;
|
||
}
|
||
|
||
QWidget::mouseReleaseEvent(event);
|
||
}
|
||
|
||
void PetWindow::loadInitialImage()
|
||
{
|
||
loadCharacterPackage(m_appConfig.characterId, true);
|
||
}
|
||
|
||
bool PetWindow::loadCharacterPackage(const QString &characterId, bool centerWindow)
|
||
{
|
||
const QString requestedCharacterId = CharacterPackageRepository::hasPackage(characterId)
|
||
? characterId
|
||
: CharacterPackageRepository::defaultCharacterId();
|
||
QString loadError;
|
||
CharacterPackage package = CharacterPackageLoader::load(CharacterPackageRepository::packagePath(requestedCharacterId), &loadError);
|
||
if (!loadError.isEmpty() && requestedCharacterId != CharacterPackageRepository::defaultCharacterId())
|
||
{
|
||
Logger::warning(QStringLiteral("Character package load failed: id=%1 error=%2")
|
||
.arg(requestedCharacterId, loadError));
|
||
loadError.clear();
|
||
package = CharacterPackageLoader::load(CharacterPackageRepository::defaultPackagePath(), &loadError);
|
||
m_appConfig.characterId = CharacterPackageRepository::defaultCharacterId();
|
||
}
|
||
|
||
if (!loadError.isEmpty())
|
||
{
|
||
Logger::warning(QStringLiteral("Character package load failed: ") + loadError);
|
||
}
|
||
|
||
m_characterPackage = package;
|
||
buildAnimationClips();
|
||
|
||
if (m_clips.contains(QStringLiteral("idle")))
|
||
{
|
||
playResolvedState(m_stateMachine.start(), centerWindow);
|
||
return true;
|
||
}
|
||
|
||
setDisplayImage(CharacterPackageRepository::previewPath(m_appConfig.characterId), centerWindow);
|
||
return !m_characterPackage.states.isEmpty();
|
||
}
|
||
|
||
void PetWindow::buildAnimationClips()
|
||
{
|
||
stopAnimationPrewarm();
|
||
m_animationPrewarmQueue.clear();
|
||
m_animationPrewarmAttemptedStates.clear();
|
||
m_clipLastAccessSerial.clear();
|
||
m_clipAccessSerial = 0;
|
||
m_clips.clear();
|
||
|
||
QSet<QString> availableStates;
|
||
const QSize targetSize = animationTargetSize();
|
||
const bool loadFramesImmediately = !m_appConfig.enableLazyLoad;
|
||
for (auto iterator = m_characterPackage.states.constBegin(); iterator != m_characterPackage.states.constEnd(); ++iterator)
|
||
{
|
||
AnimationClip clip = AnimationClip::fromState(iterator.value(), targetSize, loadFramesImmediately);
|
||
clip.fps = effectiveAnimationFps(clip.fps);
|
||
if (!clip.isValid())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
availableStates.insert(iterator.key());
|
||
m_clips.insert(iterator.key(), clip);
|
||
}
|
||
|
||
m_stateMachine.setAvailableStates(availableStates);
|
||
}
|
||
|
||
void PetWindow::addStateTestActions(QMenu *menu)
|
||
{
|
||
QMenu *stateMenu = menu->addMenu(QStringLiteral("State Test"));
|
||
const bool stateSwitchLocked = isManualStateSwitchLocked();
|
||
const QStringList stateNames = {
|
||
QStringLiteral("idle"),
|
||
QStringLiteral("talk"),
|
||
QStringLiteral("think"),
|
||
QStringLiteral("sleep"),
|
||
QStringLiteral("happy"),
|
||
QStringLiteral("error"),
|
||
QStringLiteral("drag"),
|
||
};
|
||
|
||
for (const QString &stateName : stateNames)
|
||
{
|
||
if (!m_clips.contains(stateName))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
QAction *stateAction = stateMenu->addAction(stateName);
|
||
stateAction->setData(stateName);
|
||
}
|
||
|
||
stateMenu->setEnabled(!stateSwitchLocked && !stateMenu->actions().isEmpty());
|
||
}
|
||
|
||
void PetWindow::updateBubblePosition()
|
||
{
|
||
m_chatBubble->updateAnchorPosition(bubbleAnchorPosition());
|
||
updateReminderActionPosition();
|
||
}
|
||
|
||
QPoint PetWindow::bubbleAnchorPosition() const
|
||
{
|
||
const CharacterBase &base = m_characterPackage.base;
|
||
const CharacterBubble &bubble = m_characterPackage.bubble;
|
||
const double baseWidth = base.width > 0 ? static_cast<double>(base.width) : static_cast<double>(width());
|
||
const double baseHeight = base.height > 0 ? static_cast<double>(base.height) : static_cast<double>(height());
|
||
const double scaleX = baseWidth > 0.0 ? static_cast<double>(width()) / baseWidth : 1.0;
|
||
const double scaleY = baseHeight > 0.0 ? static_cast<double>(height()) / baseHeight : 1.0;
|
||
const QPointF localAnchor(
|
||
static_cast<double>(width()) * base.anchorX + bubble.offsetX * scaleX,
|
||
static_cast<double>(height()) * base.anchorY + bubble.offsetY * scaleY);
|
||
|
||
return frameGeometry().topLeft() + QPoint(qRound(localAnchor.x()), qRound(localAnchor.y()));
|
||
}
|
||
|
||
void PetWindow::playState(const QString &stateName, bool centerWindow)
|
||
{
|
||
playResolvedState(m_stateMachine.requestState(stateName), centerWindow);
|
||
}
|
||
|
||
void PetWindow::playResolvedState(const QString &stateName, bool centerWindow)
|
||
{
|
||
if (stateName.isEmpty())
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (m_streamingChatActive
|
||
&& stateName != QStringLiteral("error")
|
||
&& stateName != QStringLiteral("drag"))
|
||
{
|
||
const QString preferredHeldState = m_streamingTalkStarted
|
||
? QStringLiteral("talk")
|
||
: QStringLiteral("think");
|
||
const QString heldState = m_stateMachine.requestState(preferredHeldState, StateRequestSource::System);
|
||
|
||
if (stateName != heldState)
|
||
{
|
||
if (!heldState.isEmpty() && m_clips.contains(heldState))
|
||
{
|
||
playResolvedState(heldState, centerWindow);
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (m_frameAnimator.currentStateName() == stateName && m_frameAnimator.isPlaying())
|
||
{
|
||
noteAnimationClipAccess(stateName);
|
||
return;
|
||
}
|
||
|
||
auto clipIterator = m_clips.find(stateName);
|
||
if (clipIterator == m_clips.end())
|
||
{
|
||
return;
|
||
}
|
||
|
||
AnimationClip *clip = &clipIterator.value();
|
||
const bool wasLoaded = clip->isLoaded();
|
||
if (!clip->ensureLoaded())
|
||
{
|
||
Logger::warning(QStringLiteral("Animation state failed to load: state=%1").arg(stateName));
|
||
return;
|
||
}
|
||
|
||
noteAnimationClipAccess(stateName);
|
||
if (!wasLoaded)
|
||
{
|
||
Logger::info(QStringLiteral("Animation state loaded: state=%1 frames=%2 cacheMb=%3")
|
||
.arg(stateName)
|
||
.arg(QString::number(clip->loadedFrameCount()))
|
||
.arg(megabytesText(clip->estimatedMemoryBytes())));
|
||
}
|
||
|
||
m_idleBehaviorTimer.stop();
|
||
m_behaviorReturnTimer.stop();
|
||
m_centerNextFrame = centerWindow;
|
||
m_frameAnimator.play(clip);
|
||
|
||
if (stateName == QStringLiteral("idle"))
|
||
{
|
||
scheduleIdleBehavior();
|
||
}
|
||
else if (clip->loop)
|
||
{
|
||
m_behaviorReturnTimer.start(4000);
|
||
}
|
||
|
||
trimAnimationCache(QStringLiteral("state played"));
|
||
scheduleAnimationPrewarm();
|
||
}
|
||
|
||
QSize PetWindow::animationTargetSize() const
|
||
{
|
||
const CharacterBase &base = m_characterPackage.base;
|
||
const double totalScale = base.scale * m_appConfig.scale;
|
||
return QSize(
|
||
boundedAnimationTargetSide(static_cast<double>(base.width) * totalScale),
|
||
boundedAnimationTargetSide(static_cast<double>(base.height) * totalScale));
|
||
}
|
||
|
||
int PetWindow::effectiveAnimationFps(int fps) const
|
||
{
|
||
if (isLowPowerMode())
|
||
{
|
||
return qMax(1, qMin(fps, LowPowerFpsCap));
|
||
}
|
||
|
||
return qMax(1, fps);
|
||
}
|
||
|
||
bool PetWindow::isLowPowerMode() const
|
||
{
|
||
return m_appConfig.performanceMode == QStringLiteral("low-power");
|
||
}
|
||
|
||
bool PetWindow::isAnimationCacheManagementEnabled() const
|
||
{
|
||
return m_appConfig.enableLazyLoad;
|
||
}
|
||
|
||
void PetWindow::rebuildAnimationPrewarmQueue()
|
||
{
|
||
m_animationPrewarmQueue.clear();
|
||
if (!isAnimationCacheManagementEnabled() || !m_appConfig.enableAnimationPrewarm)
|
||
{
|
||
return;
|
||
}
|
||
|
||
const auto appendStateIfNeeded = [this](const QString &stateName) {
|
||
if (stateName == QStringLiteral("idle")
|
||
|| m_animationPrewarmQueue.contains(stateName)
|
||
|| m_animationPrewarmAttemptedStates.contains(stateName))
|
||
{
|
||
return;
|
||
}
|
||
|
||
const auto iterator = m_clips.constFind(stateName);
|
||
if (iterator != m_clips.constEnd() && !iterator.value().isLoaded())
|
||
{
|
||
m_animationPrewarmQueue.append(stateName);
|
||
}
|
||
};
|
||
|
||
appendStateIfNeeded(QStringLiteral("drag"));
|
||
appendStateIfNeeded(QStringLiteral("think"));
|
||
appendStateIfNeeded(QStringLiteral("talk"));
|
||
|
||
QStringList stateNames = m_clips.keys();
|
||
stateNames.sort();
|
||
for (const QString &stateName : stateNames)
|
||
{
|
||
appendStateIfNeeded(stateName);
|
||
}
|
||
}
|
||
|
||
void PetWindow::scheduleAnimationPrewarm()
|
||
{
|
||
if (!isAnimationCacheManagementEnabled() || !m_appConfig.enableAnimationPrewarm)
|
||
{
|
||
stopAnimationPrewarm();
|
||
return;
|
||
}
|
||
|
||
if (!isVisible() || m_dragging || m_streamingChatActive || hasActiveAIRequest())
|
||
{
|
||
stopAnimationPrewarm();
|
||
return;
|
||
}
|
||
|
||
if (m_animationPrewarmQueue.isEmpty())
|
||
{
|
||
rebuildAnimationPrewarmQueue();
|
||
}
|
||
|
||
if (m_animationPrewarmQueue.isEmpty() || m_animationPrewarmTimer.isActive())
|
||
{
|
||
return;
|
||
}
|
||
|
||
m_animationPrewarmTimer.start(isLowPowerMode() ? LowPowerPrewarmIntervalMs : StandardPrewarmIntervalMs);
|
||
}
|
||
|
||
void PetWindow::stopAnimationPrewarm()
|
||
{
|
||
m_animationPrewarmTimer.stop();
|
||
}
|
||
|
||
void PetWindow::processAnimationPrewarm()
|
||
{
|
||
m_animationPrewarmTimer.stop();
|
||
if (!isAnimationCacheManagementEnabled() || !m_appConfig.enableAnimationPrewarm)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (!isVisible() || m_dragging || m_streamingChatActive || hasActiveAIRequest())
|
||
{
|
||
return;
|
||
}
|
||
|
||
while (!m_animationPrewarmQueue.isEmpty())
|
||
{
|
||
const QString stateName = m_animationPrewarmQueue.takeFirst();
|
||
m_animationPrewarmAttemptedStates.insert(stateName);
|
||
auto clipIterator = m_clips.find(stateName);
|
||
if (clipIterator == m_clips.end() || clipIterator.value().isLoaded())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
AnimationClip &clip = clipIterator.value();
|
||
if (!clip.ensureLoaded())
|
||
{
|
||
Logger::warning(QStringLiteral("Animation state prewarm failed: state=%1").arg(stateName));
|
||
continue;
|
||
}
|
||
|
||
noteAnimationClipAccess(stateName);
|
||
Logger::info(QStringLiteral("Animation state prewarmed: state=%1 frames=%2 cacheMb=%3")
|
||
.arg(stateName)
|
||
.arg(QString::number(clip.loadedFrameCount()))
|
||
.arg(megabytesText(clip.estimatedMemoryBytes())));
|
||
trimAnimationCache(QStringLiteral("prewarm"));
|
||
break;
|
||
}
|
||
|
||
scheduleAnimationPrewarm();
|
||
}
|
||
|
||
void PetWindow::noteAnimationClipAccess(const QString &stateName)
|
||
{
|
||
if (!m_clips.contains(stateName))
|
||
{
|
||
return;
|
||
}
|
||
|
||
++m_clipAccessSerial;
|
||
m_clipLastAccessSerial.insert(stateName, m_clipAccessSerial);
|
||
}
|
||
|
||
qint64 PetWindow::animationCacheLimitBytes() const
|
||
{
|
||
return static_cast<qint64>(m_appConfig.animationCacheLimitMb) * BytesPerMegabyte;
|
||
}
|
||
|
||
qint64 PetWindow::loadedAnimationCacheBytes() const
|
||
{
|
||
qint64 totalBytes = 0;
|
||
for (auto iterator = m_clips.constBegin(); iterator != m_clips.constEnd(); ++iterator)
|
||
{
|
||
totalBytes += iterator.value().estimatedMemoryBytes();
|
||
}
|
||
|
||
return totalBytes;
|
||
}
|
||
|
||
int PetWindow::loadedAnimationClipCount() const
|
||
{
|
||
int count = 0;
|
||
for (auto iterator = m_clips.constBegin(); iterator != m_clips.constEnd(); ++iterator)
|
||
{
|
||
if (iterator.value().isLoaded())
|
||
{
|
||
++count;
|
||
}
|
||
}
|
||
|
||
return count;
|
||
}
|
||
|
||
QSet<QString> PetWindow::protectedAnimationStates() const
|
||
{
|
||
QSet<QString> states;
|
||
states.insert(QStringLiteral("idle"));
|
||
|
||
const QString animatorState = m_frameAnimator.currentStateName();
|
||
if (!animatorState.isEmpty())
|
||
{
|
||
states.insert(animatorState);
|
||
}
|
||
|
||
const QString stateMachineState = m_stateMachine.currentState();
|
||
if (!stateMachineState.isEmpty())
|
||
{
|
||
states.insert(stateMachineState);
|
||
}
|
||
|
||
if (m_streamingChatActive || hasActiveAIRequest())
|
||
{
|
||
states.insert(QStringLiteral("think"));
|
||
states.insert(QStringLiteral("talk"));
|
||
}
|
||
|
||
if (m_dragging)
|
||
{
|
||
states.insert(QStringLiteral("drag"));
|
||
}
|
||
|
||
return states;
|
||
}
|
||
|
||
void PetWindow::trimAnimationCache(const QString &reason)
|
||
{
|
||
if (!isAnimationCacheManagementEnabled())
|
||
{
|
||
return;
|
||
}
|
||
|
||
qint64 totalBytes = loadedAnimationCacheBytes();
|
||
const qint64 limitBytes = animationCacheLimitBytes();
|
||
if (totalBytes <= limitBytes)
|
||
{
|
||
return;
|
||
}
|
||
|
||
struct UnloadCandidate
|
||
{
|
||
QString stateName;
|
||
qint64 lastAccessSerial = 0;
|
||
};
|
||
|
||
const QSet<QString> protectedStates = protectedAnimationStates();
|
||
QList<UnloadCandidate> candidates;
|
||
QStringList protectedLoadedStates;
|
||
for (auto iterator = m_clips.constBegin(); iterator != m_clips.constEnd(); ++iterator)
|
||
{
|
||
if (!iterator.value().isLoaded())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (protectedStates.contains(iterator.key()))
|
||
{
|
||
protectedLoadedStates.append(iterator.key());
|
||
continue;
|
||
}
|
||
|
||
candidates.append({iterator.key(), m_clipLastAccessSerial.value(iterator.key(), 0)});
|
||
}
|
||
|
||
std::sort(candidates.begin(), candidates.end(), [](const UnloadCandidate &left, const UnloadCandidate &right) {
|
||
if (left.lastAccessSerial == right.lastAccessSerial)
|
||
{
|
||
return left.stateName < right.stateName;
|
||
}
|
||
|
||
return left.lastAccessSerial < right.lastAccessSerial;
|
||
});
|
||
|
||
for (const UnloadCandidate &candidate : candidates)
|
||
{
|
||
if (totalBytes <= limitBytes)
|
||
{
|
||
break;
|
||
}
|
||
|
||
auto clipIterator = m_clips.find(candidate.stateName);
|
||
if (clipIterator == m_clips.end() || !clipIterator.value().isLoaded())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
const qint64 freedBytes = clipIterator.value().estimatedMemoryBytes();
|
||
clipIterator.value().unloadFrames();
|
||
m_clipLastAccessSerial.remove(candidate.stateName);
|
||
totalBytes -= freedBytes;
|
||
Logger::info(QStringLiteral("Animation state unloaded: state=%1 reason=%2 freedMb=%3 cacheMb=%4 loadedStates=%5")
|
||
.arg(candidate.stateName)
|
||
.arg(reason)
|
||
.arg(megabytesText(freedBytes))
|
||
.arg(megabytesText(totalBytes))
|
||
.arg(QString::number(loadedAnimationClipCount())));
|
||
}
|
||
|
||
if (totalBytes > limitBytes)
|
||
{
|
||
protectedLoadedStates.sort();
|
||
Logger::warning(QStringLiteral("Animation cache remains over limit: reason=%1 cacheMb=%2 limitMb=%3 protectedStates=%4")
|
||
.arg(reason)
|
||
.arg(megabytesText(totalBytes))
|
||
.arg(QString::number(m_appConfig.animationCacheLimitMb))
|
||
.arg(protectedLoadedStates.join(QStringLiteral(","))));
|
||
}
|
||
}
|
||
|
||
void PetWindow::unloadNonProtectedAnimationCache(const QString &reason)
|
||
{
|
||
if (!isAnimationCacheManagementEnabled())
|
||
{
|
||
return;
|
||
}
|
||
|
||
const QSet<QString> protectedStates = protectedAnimationStates();
|
||
for (auto iterator = m_clips.begin(); iterator != m_clips.end(); ++iterator)
|
||
{
|
||
if (!iterator.value().isLoaded())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (protectedStates.contains(iterator.key()))
|
||
{
|
||
Logger::info(QStringLiteral("Animation state kept loaded: state=%1 reason=%2")
|
||
.arg(iterator.key())
|
||
.arg(reason));
|
||
continue;
|
||
}
|
||
|
||
const qint64 freedBytes = iterator.value().estimatedMemoryBytes();
|
||
iterator.value().unloadFrames();
|
||
m_clipLastAccessSerial.remove(iterator.key());
|
||
Logger::info(QStringLiteral("Animation state unloaded: state=%1 reason=%2 freedMb=%3 cacheMb=%4 loadedStates=%5")
|
||
.arg(iterator.key())
|
||
.arg(reason)
|
||
.arg(megabytesText(freedBytes))
|
||
.arg(megabytesText(loadedAnimationCacheBytes()))
|
||
.arg(QString::number(loadedAnimationClipCount())));
|
||
}
|
||
}
|
||
|
||
void PetWindow::scheduleIdleBehavior()
|
||
{
|
||
if (!m_clips.contains(QStringLiteral("idle")))
|
||
{
|
||
return;
|
||
}
|
||
|
||
const int idleDelayMs = isLowPowerMode()
|
||
? QRandomGenerator::global()->bounded(16000, 30001)
|
||
: QRandomGenerator::global()->bounded(8000, 16001);
|
||
m_idleBehaviorTimer.start(idleDelayMs);
|
||
}
|
||
|
||
void PetWindow::playIdleBehavior()
|
||
{
|
||
if (m_dragging || m_stateMachine.currentState() != QStringLiteral("idle"))
|
||
{
|
||
scheduleIdleBehavior();
|
||
return;
|
||
}
|
||
|
||
QStringList candidateStates;
|
||
const QStringList preferredStates = {
|
||
QStringLiteral("think"),
|
||
QStringLiteral("sleep"),
|
||
QStringLiteral("happy"),
|
||
};
|
||
|
||
for (const QString &stateName : preferredStates)
|
||
{
|
||
if (m_clips.contains(stateName))
|
||
{
|
||
candidateStates.append(stateName);
|
||
}
|
||
}
|
||
|
||
if (candidateStates.isEmpty())
|
||
{
|
||
scheduleIdleBehavior();
|
||
return;
|
||
}
|
||
|
||
const int stateIndex = QRandomGenerator::global()->bounded(candidateStates.size());
|
||
playResolvedState(m_stateMachine.requestState(candidateStates.at(stateIndex), StateRequestSource::Automatic), false);
|
||
}
|
||
|
||
void PetWindow::returnToIdleFromBehavior()
|
||
{
|
||
if (m_streamingChatActive)
|
||
{
|
||
const QString heldState = m_streamingTalkStarted
|
||
? QStringLiteral("talk")
|
||
: QStringLiteral("think");
|
||
|
||
if (m_clips.contains(heldState))
|
||
{
|
||
playResolvedState(heldState, false);
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (!m_dragging)
|
||
{
|
||
playResolvedState(m_stateMachine.finishState(QStringLiteral("idle")), false);
|
||
}
|
||
}
|
||
|
||
void PetWindow::setDisplayImage(const QString &imagePath, bool centerWindow)
|
||
{
|
||
QPixmap pixmap(imagePath);
|
||
if (pixmap.isNull())
|
||
{
|
||
m_petView->showFallbackText(QStringLiteral("QtDesktopPet"));
|
||
resize(240, 160);
|
||
return;
|
||
}
|
||
|
||
const QSize targetSize = animationTargetSize();
|
||
const QPixmap scaled = pixmap.scaled(targetSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);
|
||
setDisplayPixmap(scaled, centerWindow);
|
||
}
|
||
|
||
void PetWindow::setDisplayPixmap(const QPixmap &pixmap, bool centerWindow)
|
||
{
|
||
const QSize previousSize = size();
|
||
m_petView->setFrame(pixmap);
|
||
resize(pixmap.size());
|
||
if (size() != previousSize)
|
||
{
|
||
updateBubblePosition();
|
||
}
|
||
|
||
if (centerWindow)
|
||
{
|
||
if (const QScreen *screen = QGuiApplication::primaryScreen())
|
||
{
|
||
const QRect available = screen->availableGeometry();
|
||
move(available.center() - rect().center());
|
||
}
|
||
}
|
||
}
|
||
|
||
bool PetWindow::isPointVisibleOnScreen(const QPoint &point) const
|
||
{
|
||
const QList<QScreen *> screens = QGuiApplication::screens();
|
||
for (const QScreen *screen : screens)
|
||
{
|
||
if (screen != nullptr && screen->availableGeometry().contains(point))
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
void PetWindow::setAlwaysOnTop(bool enabled)
|
||
{
|
||
const bool currentlyOnTop = windowFlags().testFlag(Qt::WindowStaysOnTopHint);
|
||
if (m_alwaysOnTop == enabled && currentlyOnTop == enabled)
|
||
{
|
||
return;
|
||
}
|
||
|
||
m_alwaysOnTop = enabled;
|
||
const bool wasVisible = isVisible();
|
||
|
||
Qt::WindowFlags flags = windowFlags();
|
||
if (enabled)
|
||
{
|
||
flags |= Qt::WindowStaysOnTopHint;
|
||
}
|
||
else
|
||
{
|
||
flags &= ~Qt::WindowStaysOnTopHint;
|
||
}
|
||
|
||
setWindowFlags(flags);
|
||
if (wasVisible)
|
||
{
|
||
show();
|
||
}
|
||
}
|