1429 lines
40 KiB
C++
1429 lines
40 KiB
C++
#include "PetWindow.h"
|
||
|
||
#include "../ai/AIProviderFactory.h"
|
||
#include "../ai/ConversationManager.h"
|
||
#include "../ai/ConversationStore.h"
|
||
#include "../character/CharacterPackageLoader.h"
|
||
#include "../character/CharacterPackageRepository.h"
|
||
#include "../config/ConfigManager.h"
|
||
#include "../util/Logger.h"
|
||
#include "ChatBubble.h"
|
||
#include "ChatHistoryPanel.h"
|
||
#include "ChatInputDialog.h"
|
||
#include "PetView.h"
|
||
#include "SettingsDialog.h"
|
||
|
||
#include <QAction>
|
||
#include <QContextMenuEvent>
|
||
#include <QCursor>
|
||
#include <QDialog>
|
||
#include <QGuiApplication>
|
||
#include <QHideEvent>
|
||
#include <QList>
|
||
#include <QMenu>
|
||
#include <QMouseEvent>
|
||
#include <QPixmap>
|
||
#include <QPointF>
|
||
#include <QPointer>
|
||
#include <QRandomGenerator>
|
||
#include <QScreen>
|
||
#include <QSet>
|
||
#include <QShowEvent>
|
||
#include <QStringList>
|
||
#include <QVBoxLayout>
|
||
#include <QtGlobal>
|
||
|
||
#include <algorithm>
|
||
#include <memory>
|
||
|
||
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.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);
|
||
return config;
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
}
|
||
|
||
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_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);
|
||
m_chatInputDialog->setSubmitCallback([window](const QString &message) {
|
||
return !window.isNull() && window->submitChatMessage(message);
|
||
});
|
||
|
||
loadInitialImage();
|
||
}
|
||
|
||
PetWindow::~PetWindow()
|
||
{
|
||
saveConversationHistoryIfNeeded();
|
||
}
|
||
|
||
void PetWindow::applyAppConfig(const AppConfig &config)
|
||
{
|
||
const AppConfig normalizedConfig = normalizedAppConfig(config);
|
||
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 (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;
|
||
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)
|
||
{
|
||
m_chatBubble->showMessage(message, bubbleAnchorPosition());
|
||
}
|
||
|
||
void PetWindow::openSettingsDialog()
|
||
{
|
||
ConfigManager configManager;
|
||
SettingsDialog dialog(configManager.loadAIConfigStore(), currentAppConfig(), [this]() {
|
||
return isManualStateSwitchLocked();
|
||
}, [this]() {
|
||
clearConversation();
|
||
}, this);
|
||
if (dialog.exec() != QDialog::Accepted)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (!configManager.saveAIConfigStore(dialog.aiConfigStore()))
|
||
{
|
||
Logger::warning(QStringLiteral("Failed to save AI config from settings dialog."));
|
||
}
|
||
|
||
applyAppConfig(dialog.appConfig());
|
||
if (!configManager.saveAppConfig(currentAppConfig()))
|
||
{
|
||
Logger::warning(QStringLiteral("Failed to save app config from settings dialog."));
|
||
}
|
||
}
|
||
|
||
void PetWindow::setSettingsFallbackInContextMenuEnabled(bool enabled)
|
||
{
|
||
m_settingsFallbackInContextMenuEnabled = enabled;
|
||
}
|
||
|
||
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("取消 AI 请求"));
|
||
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;
|
||
}
|
||
|
||
m_chatInputDialog->showAt(chatInputAnchorPosition());
|
||
}
|
||
|
||
bool PetWindow::submitChatMessage(const QString &message)
|
||
{
|
||
if (!m_conversationManager || m_conversationManager->isBusy())
|
||
{
|
||
showBubbleMessage(QStringLiteral("AI 回复正在进行。"));
|
||
return false;
|
||
}
|
||
|
||
const QString trimmedMessage = message.trimmed();
|
||
if (trimmedMessage.isEmpty())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (trimmedMessage.size() > MaxUserMessageLength)
|
||
{
|
||
playState(QStringLiteral("error"), false);
|
||
showBubbleMessage(QStringLiteral("消息太长，请控制在 4000 字以内。"));
|
||
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;
|
||
}
|
||
|
||
if (!m_conversationManager->setProvider(std::move(provider)))
|
||
{
|
||
showBubbleMessage(QStringLiteral("AI 回复正在进行。"));
|
||
return false;
|
||
}
|
||
|
||
stopAnimationPrewarm();
|
||
playState(QStringLiteral("think"), false);
|
||
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(
|
||
trimmedMessage,
|
||
[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();
|
||
refreshChatHistoryPanel();
|
||
showBubbleMessage(hadActiveRequest
|
||
? QStringLiteral("已取消 AI 请求，并清空对话。")
|
||
: 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;
|
||
}
|
||
|
||
showBubbleMessage(QStringLiteral("没有正在进行的 AI 请求。"));
|
||
}
|
||
|
||
bool PetWindow::hasActiveAIRequest() const
|
||
{
|
||
return m_conversationManager && m_conversationManager->isBusy();
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
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();
|
||
}
|
||
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);
|
||
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();
|
||
event->accept();
|
||
return;
|
||
}
|
||
|
||
QWidget::mouseReleaseEvent(event);
|
||
}
|
||
|
||
void PetWindow::loadInitialImage()
|
||
{
|
||
QString loadError;
|
||
m_characterPackage = CharacterPackageLoader::load(CharacterPackageRepository::defaultPackagePath(), &loadError);
|
||
if (!loadError.isEmpty())
|
||
{
|
||
Logger::warning(QStringLiteral("Character package load failed: ") + loadError);
|
||
}
|
||
|
||
buildAnimationClips();
|
||
|
||
if (m_clips.contains(QStringLiteral("idle")))
|
||
{
|
||
playResolvedState(m_stateMachine.start(), true);
|
||
return;
|
||
}
|
||
|
||
setDisplayImage(CharacterPackageRepository::defaultPreviewPath(), true);
|
||
}
|
||
|
||
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());
|
||
}
|
||
|
||
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();
|
||
}
|
||
}
|