648 lines
23 KiB
C++
648 lines
23 KiB
C++
#include "main_window.h"
|
||
|
||
#include <QApplication>
|
||
#include <QDateTime>
|
||
#include <QEvent>
|
||
#include <QFile>
|
||
#include <QKeyEvent>
|
||
#include <QKeySequence>
|
||
#include <QLabel>
|
||
#include <QMenu>
|
||
#include <QMessageBox>
|
||
#include <QMouseEvent>
|
||
#include <QPoint>
|
||
#include <QScreen>
|
||
#include <QShortcut>
|
||
#include <QStackedWidget>
|
||
#include <QStatusBar>
|
||
#include <QTimer>
|
||
#include <QVBoxLayout>
|
||
|
||
#include <cstring>
|
||
#include <freerdp/codec/color.h>
|
||
#include <freerdp/locale/keyboard.h>
|
||
#include <freerdp/scancode.h>
|
||
|
||
#include "desktop_list_page.h"
|
||
#include "login_page.h"
|
||
|
||
namespace vdi {
|
||
namespace {
|
||
|
||
// FreeRDP 像素格式 -> QImage::Format
|
||
// 注意：FreeRDP 的像素格式值是计算宏（FREERDP_PIXEL_FORMAT），
|
||
// 不能硬编码数值，必须用宏直接比较。
|
||
// FreeRDP 主缓冲是 4 字节/像素（BGRX / BGRA / RGBA），
|
||
// QImage 没有对应的 4 字节 BGRA 格式，因此统一转成 RGB888 输出。
|
||
QImage::Format toQImageFormat(uint32_t freerdpFormat) {
|
||
(void)freerdpFormat;
|
||
return QImage::Format_RGB888;
|
||
}
|
||
|
||
// FreeRDP BGRX32 在当前 ARM64 小端目标上与 QImage::Format_RGB32 的内存布局一致。
|
||
QImage convertFrame(const uint8_t* data, uint32_t width, uint32_t height, uint32_t bytesPerLine,
|
||
uint32_t freerdpFormat) {
|
||
if (!data || width == 0 || height == 0) {
|
||
return QImage();
|
||
}
|
||
if (freerdpFormat == PIXEL_FORMAT_BGRX32 || freerdpFormat == PIXEL_FORMAT_BGRA32) {
|
||
QImage out(static_cast<int>(width), static_cast<int>(height), QImage::Format_RGB32);
|
||
const size_t rowBytes = static_cast<size_t>(width) * 4;
|
||
for (uint32_t y = 0; y < height; ++y) {
|
||
std::memcpy(out.scanLine(static_cast<int>(y)),
|
||
data + static_cast<size_t>(y) * bytesPerLine, rowBytes);
|
||
}
|
||
return out;
|
||
}
|
||
|
||
QImage out(static_cast<int>(width), static_cast<int>(height), QImage::Format_RGB888);
|
||
for (uint32_t y = 0; y < height; ++y) {
|
||
const uint8_t* src = data + static_cast<size_t>(y) * bytesPerLine;
|
||
uint8_t* dst = out.scanLine(static_cast<int>(y));
|
||
for (uint32_t x = 0; x < width; ++x) {
|
||
const uint8_t* p = src + static_cast<size_t>(x) * 4;
|
||
dst[0] = p[0];
|
||
dst[1] = p[1];
|
||
dst[2] = p[2];
|
||
dst += 3;
|
||
}
|
||
}
|
||
return out;
|
||
}
|
||
|
||
constexpr int kReconnectDelayMs = 3000;
|
||
constexpr int kMaxReconnectAttempts = 5;
|
||
|
||
} // namespace
|
||
|
||
MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent) {
|
||
fsm_ = StateMachine([this](State from, State to, const QString& detail) {
|
||
onStateChanged(from, to, detail);
|
||
});
|
||
setupUi();
|
||
setupHotkey();
|
||
setupHeartbeat();
|
||
keyboardLayout_ = freerdp_keyboard_init(0);
|
||
|
||
config_ = loadConfig();
|
||
|
||
// 开机永远进入登录页；不再根据本地配置自动连接 RDP，
|
||
// 会话只能由用户在桌面列表选择后启动。
|
||
fsm_.transitionTo(State::kConfig, QStringLiteral("等待登录"));
|
||
showLogin();
|
||
}
|
||
|
||
MainWindow::~MainWindow() {
|
||
stopSessions();
|
||
}
|
||
|
||
void MainWindow::setupUi() {
|
||
setWindowTitle(QStringLiteral("VDI 云终端"));
|
||
setWindowState(Qt::WindowFullScreen);
|
||
setStyleSheet(QStringLiteral("QMainWindow { background: #0f1420; }"));
|
||
|
||
stack_ = new QStackedWidget(this);
|
||
stack_->setStyleSheet(QStringLiteral("background: #0f1420;"));
|
||
setCentralWidget(stack_);
|
||
|
||
// 登录页
|
||
auto* login = new LoginPage(config_, this);
|
||
loginPage_ = login;
|
||
login->setStyleSheet(
|
||
QStringLiteral("QWidget { background: #0f1420; color: #e6e9ef; }"
|
||
"QLineEdit { background: #1a2233; border: 1px solid #2b3654; "
|
||
"border-radius: 4px; padding: 8px; color: #e6e9ef; }"
|
||
"QLineEdit:focus { border: 1px solid #2f6feb; }"
|
||
"QPushButton { background: #232d44; border: 1px solid #2b3654; "
|
||
"border-radius: 6px; color: #e6e9ef; }"
|
||
"QPushButton:hover { background: #2b3654; }"));
|
||
stack_->addWidget(login);
|
||
|
||
connect(login, &LoginPage::loginRequested, this, &MainWindow::onLoginRequested);
|
||
connect(login, &LoginPage::quitRequested, this, &MainWindow::onQuitRequested);
|
||
|
||
// 桌面列表页
|
||
auto* list = new DesktopListPage(this);
|
||
desktopListPage_ = list;
|
||
list->setStyleSheet(
|
||
QStringLiteral("QWidget { background: #0f1420; color: #e6e9ef; }"
|
||
"QPushButton { background: #232d44; border: 1px solid #2b3654; "
|
||
"border-radius: 6px; color: #e6e9ef; }"
|
||
"QPushButton:hover { background: #2b3654; }"));
|
||
stack_->addWidget(list);
|
||
|
||
connect(list, &DesktopListPage::desktopSelected, this, &MainWindow::onDesktopSelected);
|
||
connect(list, &DesktopListPage::logoutRequested, this, &MainWindow::onLogoutRequested);
|
||
|
||
// 会话视图
|
||
auto* sessionWidget = new QWidget(this);
|
||
auto* sessionLayout = new QVBoxLayout(sessionWidget);
|
||
sessionLayout->setContentsMargins(0, 0, 0, 0);
|
||
|
||
sessionView_ = new QLabel(sessionWidget);
|
||
sessionView_->setFocusPolicy(Qt::StrongFocus);
|
||
sessionView_->setMouseTracking(true);
|
||
sessionView_->installEventFilter(this);
|
||
sessionView_->setAlignment(Qt::AlignCenter);
|
||
sessionView_->setStyleSheet(QStringLiteral("background: #000000; color: #e6e9ef;"));
|
||
sessionView_->setText(QStringLiteral("正在建立远程会话…"));
|
||
|
||
sessionOverlay_ = new QLabel(sessionWidget);
|
||
sessionOverlay_->setAlignment(Qt::AlignCenter);
|
||
sessionOverlay_->setStyleSheet(
|
||
QStringLiteral("background: rgba(15,20,32,0.82); color: #e6e9ef; "
|
||
"font-size: 20px; padding: 40px;"));
|
||
sessionOverlay_->setText(QStringLiteral("正在连接…"));
|
||
sessionOverlay_->hide();
|
||
|
||
sessionLayout->addWidget(sessionView_);
|
||
sessionLayout->addWidget(sessionOverlay_);
|
||
stack_->addWidget(sessionWidget);
|
||
|
||
// 状态条
|
||
statusBar_ = new QStatusBar(this);
|
||
statusBar_->setStyleSheet(QStringLiteral("QStatusBar { background: #161d2e; color: #8a94a6; }"));
|
||
setStatusBar(statusBar_);
|
||
|
||
// RDP 重连定时器
|
||
reconnectTimer_ = new QTimer(this);
|
||
reconnectTimer_->setSingleShot(true);
|
||
connect(reconnectTimer_, &QTimer::timeout, this, [this]() {
|
||
if (fsm_.current() == State::kReconnect && reconnectAttempts_ < kMaxReconnectAttempts) {
|
||
++reconnectAttempts_;
|
||
if (activeTicket_.protocol == Protocol::kMoonlight) {
|
||
startMoonlightSession(activeTicket_);
|
||
} else {
|
||
startRdpSession(activeTicket_);
|
||
}
|
||
} else if (fsm_.current() == State::kReconnect) {
|
||
stopSessions();
|
||
fsm_.transitionTo(State::kDesktopList, QStringLiteral("重连失败，已返回桌面列表"));
|
||
}
|
||
});
|
||
|
||
frameRefreshTimer_ = new QTimer(this);
|
||
frameRefreshTimer_->setInterval(33);
|
||
connect(frameRefreshTimer_, &QTimer::timeout, this, &MainWindow::onFrameRefresh);
|
||
frameRefreshTimer_->start();
|
||
}
|
||
|
||
void MainWindow::setupHotkey() {
|
||
// 全局热键 Ctrl+Alt+Shift+M 呼出管理菜单（方案 3.2 节）
|
||
auto* shortcut = new QShortcut(QKeySequence(QStringLiteral("Ctrl+Alt+Shift+M")), this);
|
||
shortcut->setContext(Qt::ApplicationShortcut);
|
||
connect(shortcut, &QShortcut::activated, this, [this]() { onMenuAction(0); });
|
||
}
|
||
|
||
void MainWindow::setupHeartbeat() {
|
||
// 定期写心跳文件，供看门狗 Monitor 判断主进程是否假死
|
||
// 对应会议纪要要求的双进程架构
|
||
const QString path = QStringLiteral("/tmp/vdi-kiosk.heartbeat");
|
||
heartbeatTimer_ = new QTimer(this);
|
||
heartbeatTimer_->setInterval(5000);
|
||
connect(heartbeatTimer_, &QTimer::timeout, this, [path]() {
|
||
QFile file(path);
|
||
if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
|
||
file.write(QByteArray::number(QDateTime::currentSecsSinceEpoch()));
|
||
file.close();
|
||
}
|
||
});
|
||
heartbeatTimer_->start();
|
||
}
|
||
|
||
void MainWindow::onStateChanged(State from, State to, const QString& detail) {
|
||
Q_UNUSED(from);
|
||
const QString stateName = QString::fromLatin1(stateToString(to));
|
||
updateStatusBar(detail.isEmpty() ? stateName : QStringLiteral("%1 %2").arg(stateName, detail));
|
||
|
||
switch (to) {
|
||
case State::kConfig:
|
||
showLogin();
|
||
break;
|
||
case State::kAuthenticating:
|
||
break;
|
||
case State::kDesktopList:
|
||
showDesktopList();
|
||
refreshDesktopList();
|
||
break;
|
||
case State::kConnecting:
|
||
if (stack_->currentWidget() != sessionView_->parentWidget()) {
|
||
stack_->setCurrentWidget(sessionView_->parentWidget());
|
||
}
|
||
sessionView_->setFocus(Qt::OtherFocusReason);
|
||
sessionOverlay_->setText(QStringLiteral("正在连接 %1 …").arg(activeTicket_.endpoint));
|
||
sessionOverlay_->show();
|
||
break;
|
||
case State::kSession:
|
||
sessionView_->setFocus(Qt::OtherFocusReason);
|
||
sessionOverlay_->hide();
|
||
break;
|
||
case State::kReconnect:
|
||
sessionOverlay_->setText(QStringLiteral("连接已断开，正在重连…"));
|
||
sessionOverlay_->show();
|
||
reconnectTimer_->start(kReconnectDelayMs);
|
||
break;
|
||
case State::kError:
|
||
stopSessions();
|
||
fsm_.transitionTo(State::kDesktopList, QStringLiteral("连接失败"));
|
||
if (desktopListPage_) {
|
||
desktopListPage_->setBusy(false);
|
||
desktopListPage_->setStatus(QStringLiteral("连接失败：%1").arg(detail), true);
|
||
}
|
||
break;
|
||
case State::kBoot:
|
||
break;
|
||
}
|
||
}
|
||
|
||
void MainWindow::updateStatusBar(const QString& text) {
|
||
statusBar_->showMessage(text);
|
||
}
|
||
|
||
void MainWindow::showLogin() {
|
||
stack_->setCurrentWidget(loginPage_);
|
||
if (loginPage_) {
|
||
loginPage_->setBusy(false);
|
||
loginPage_->setStatus(QStringLiteral("请输入用户名和密码登录"));
|
||
}
|
||
}
|
||
|
||
void MainWindow::showDesktopList() {
|
||
if (!desktopListPage_) {
|
||
return;
|
||
}
|
||
stack_->setCurrentWidget(desktopListPage_);
|
||
desktopListPage_->setCurrentUser(currentUser_);
|
||
desktopListPage_->setBusy(false);
|
||
}
|
||
|
||
void MainWindow::refreshDesktopList() {
|
||
desktopService_.listDesktops([this](std::vector<DesktopInfo> list, const QString& error) {
|
||
if (error.isEmpty()) {
|
||
desktops_ = list;
|
||
}
|
||
if (desktopListPage_) {
|
||
desktopListPage_->setDesktops(desktops_);
|
||
if (!error.isEmpty()) {
|
||
desktopListPage_->setStatus(error, true);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
void MainWindow::onLoginRequested(const QString& username, const QString& password) {
|
||
desktopService_.login(username, password, [this](const AuthResult& result) {
|
||
if (!loginPage_) {
|
||
return;
|
||
}
|
||
if (!result.ok) {
|
||
loginPage_->setBusy(false);
|
||
loginPage_->setStatus(result.message, true);
|
||
return;
|
||
}
|
||
currentUser_ = result.displayName;
|
||
fsm_.transitionTo(State::kAuthenticating, QStringLiteral("认证成功"));
|
||
fsm_.transitionTo(State::kDesktopList, QStringLiteral("欢迎 %1").arg(currentUser_));
|
||
});
|
||
}
|
||
|
||
void MainWindow::onDesktopSelected(const QString& desktopId) {
|
||
if (!fsm_.canConnect()) {
|
||
return;
|
||
}
|
||
desktopService_.createTicket(desktopId, [this](const ConnectionTicket& ticket,
|
||
const QString& error) {
|
||
if (!error.isEmpty()) {
|
||
if (desktopListPage_) {
|
||
desktopListPage_->setBusy(false);
|
||
desktopListPage_->setStatus(error, true);
|
||
}
|
||
return;
|
||
}
|
||
activeTicket_ = ticket;
|
||
reconnectAttempts_ = 0;
|
||
|
||
if (ticket.protocol == Protocol::kMoonlight) {
|
||
startMoonlightSession(ticket);
|
||
} else {
|
||
startRdpSession(ticket);
|
||
}
|
||
});
|
||
}
|
||
|
||
void MainWindow::onLogoutRequested() {
|
||
stopSessions();
|
||
desktopService_.logout();
|
||
currentUser_.clear();
|
||
fsm_.transitionTo(State::kConfig, QStringLiteral("已退出登录"));
|
||
}
|
||
|
||
void MainWindow::startRdpSession(const ConnectionTicket& ticket) {
|
||
++sessionEpoch_;
|
||
{
|
||
QMutexLocker locker(&frameMutex_);
|
||
latestFrame_ = QImage();
|
||
frameEpoch_ = sessionEpoch_;
|
||
frameWakePending_ = false;
|
||
}
|
||
if (fsm_.current() == State::kSession) {
|
||
fsm_.transitionTo(State::kReconnect, QStringLiteral("手动重新连接"));
|
||
}
|
||
if (!fsm_.transitionTo(State::kConnecting, ticket.endpoint)) {
|
||
if (fsm_.current() != State::kConnecting) {
|
||
return;
|
||
}
|
||
}
|
||
|
||
RdpOptions opts;
|
||
opts.server = ticket.endpoint.toStdString();
|
||
opts.username = ticket.username.toStdString();
|
||
opts.password = ticket.password.toStdString();
|
||
opts.keyboardLayout = keyboardLayout_;
|
||
opts.width = ticket.width;
|
||
opts.height = ticket.height;
|
||
opts.bpp = 32;
|
||
opts.fullscreen = true;
|
||
// 与 xfreerdp3 相同的 GFX 能力组合语义：
|
||
// FreeRDP 3.32.1 不接受单个管道名，必须成组。
|
||
opts.gfx = "progressive|RFX|AVC420|AVC444";
|
||
opts.ignoreCertificate = true; // POC 阶段；正式产品必须做证书校验
|
||
|
||
RdpCallbacks cb;
|
||
cb.onFrame = [this](const uint8_t* data, uint32_t width, uint32_t height, uint32_t stride,
|
||
uint32_t format) {
|
||
// 在 FreeRDP 线程中复制帧，不能把其内部缓冲区裸指针排队到 GUI 线程。
|
||
const QImage image = convertFrame(data, width, height, stride, format);
|
||
if (image.isNull()) {
|
||
return;
|
||
}
|
||
QMutexLocker locker(&frameMutex_);
|
||
latestFrame_ = image;
|
||
frameEpoch_ = sessionEpoch_;
|
||
if (frameWakePending_) {
|
||
return;
|
||
}
|
||
frameWakePending_ = true;
|
||
locker.unlock();
|
||
QMetaObject::invokeMethod(this, &MainWindow::onFrameWakeup, Qt::QueuedConnection);
|
||
};
|
||
cb.onState = [this](bool connected, const std::string& message) {
|
||
QMetaObject::invokeMethod(
|
||
this,
|
||
[this, connected, message]() {
|
||
onSessionState(connected, QString::fromStdString(message));
|
||
},
|
||
Qt::QueuedConnection);
|
||
};
|
||
|
||
rdpSession_ = std::make_unique<RdpSession>();
|
||
rdpSession_->start(opts, cb);
|
||
}
|
||
|
||
void MainWindow::startMoonlightSession(const ConnectionTicket& ticket) {
|
||
if (!fsm_.transitionTo(State::kConnecting, ticket.endpoint)) {
|
||
if (fsm_.current() != State::kConnecting) {
|
||
return;
|
||
}
|
||
}
|
||
// Moonlight 是外部全屏进程：Kiosk 画面停在"正在连接"覆盖层，
|
||
// 串流窗口由 moonlight-qt 自行置顶显示。
|
||
if (stack_->currentWidget() != sessionView_->parentWidget()) {
|
||
stack_->setCurrentWidget(sessionView_->parentWidget());
|
||
}
|
||
sessionOverlay_->setText(QStringLiteral("正在连接 %1 …").arg(ticket.endpoint));
|
||
sessionOverlay_->show();
|
||
|
||
MoonlightSession::Options opts;
|
||
opts.decoder = QStringLiteral("software"); // RK3528 无可用 V4L2 硬解设备
|
||
opts.videoCodec = QStringLiteral("H.264");
|
||
opts.audioOnHost = true;
|
||
|
||
moonlightSession_ = std::make_unique<MoonlightSession>(/*parent=*/nullptr);
|
||
moonlightSession_->setOptions(opts);
|
||
moonlightSession_->start(ticket, [this](bool running, const QString& message) {
|
||
QMetaObject::invokeMethod(
|
||
this,
|
||
[this, running, message]() { onMoonlightState(running, message); },
|
||
Qt::QueuedConnection);
|
||
});
|
||
}
|
||
|
||
void MainWindow::onMoonlightState(bool running, const QString& message) {
|
||
if (running) {
|
||
// 进程已拉起；串流窗口是否成功由 moonlight 自身展示
|
||
updateStatusBar(QStringLiteral("SESSION %1").arg(message));
|
||
return;
|
||
}
|
||
// 进程退出：回桌面列表
|
||
moonlightSession_.reset();
|
||
stopSessions();
|
||
if (fsm_.current() == State::kConnecting || fsm_.current() == State::kSession) {
|
||
fsm_.transitionTo(State::kDesktopList, message);
|
||
}
|
||
if (desktopListPage_) {
|
||
desktopListPage_->setBusy(false);
|
||
desktopListPage_->setStatus(message);
|
||
}
|
||
}
|
||
|
||
void MainWindow::onSessionState(bool connected, const QString& message) {
|
||
if (connected) {
|
||
reconnectAttempts_ = 0;
|
||
fsm_.transitionTo(State::kSession, message);
|
||
} else {
|
||
if (fsm_.current() == State::kConnecting) {
|
||
// 首次连接失败：回桌面列表并提示
|
||
stopSessions();
|
||
fsm_.transitionTo(State::kDesktopList, message);
|
||
if (desktopListPage_) {
|
||
desktopListPage_->setBusy(false);
|
||
desktopListPage_->setStatus(QStringLiteral("连接失败：%1").arg(message), true);
|
||
}
|
||
} else if (fsm_.current() == State::kSession) {
|
||
fsm_.transitionTo(State::kReconnect, message);
|
||
}
|
||
}
|
||
}
|
||
|
||
void MainWindow::onFrameWakeup() {
|
||
QMutexLocker locker(&frameMutex_);
|
||
frameWakePending_ = false;
|
||
}
|
||
|
||
void MainWindow::onFrameRefresh() {
|
||
QImage image;
|
||
uint64_t epoch = 0;
|
||
{
|
||
QMutexLocker locker(&frameMutex_);
|
||
image = latestFrame_;
|
||
epoch = frameEpoch_;
|
||
latestFrame_ = QImage();
|
||
frameWakePending_ = false;
|
||
}
|
||
if (epoch == sessionEpoch_) {
|
||
onFrameImage(image);
|
||
}
|
||
}
|
||
|
||
void MainWindow::onFrameImage(const QImage& image) {
|
||
if (image.isNull()) {
|
||
return;
|
||
}
|
||
lastFrame_ = image;
|
||
|
||
if (sessionView_) {
|
||
const QSize targetSize = sessionView_->size();
|
||
if (lastFrame_.size() == targetSize) {
|
||
sessionView_->setPixmap(QPixmap::fromImage(lastFrame_));
|
||
} else {
|
||
sessionView_->setPixmap(QPixmap::fromImage(lastFrame_).scaled(
|
||
targetSize, Qt::KeepAspectRatio, Qt::FastTransformation));
|
||
}
|
||
}
|
||
}
|
||
|
||
void MainWindow::onQuitRequested() {
|
||
stopSessions();
|
||
QApplication::quit();
|
||
}
|
||
|
||
void MainWindow::stopSessions() {
|
||
if (rdpSession_) {
|
||
rdpSession_->stop();
|
||
rdpSession_.reset();
|
||
}
|
||
if (moonlightSession_) {
|
||
moonlightSession_->stop();
|
||
moonlightSession_.reset();
|
||
}
|
||
QMutexLocker locker(&frameMutex_);
|
||
latestFrame_ = QImage();
|
||
lastFrame_ = QImage();
|
||
frameWakePending_ = false;
|
||
}
|
||
|
||
void MainWindow::onMenuAction(int action) {
|
||
switch (action) {
|
||
case 1: // 重新连接当前桌面
|
||
if (fsm_.canConnect() && !activeTicket_.desktopId.isEmpty()) {
|
||
reconnectAttempts_ = 0;
|
||
stopSessions();
|
||
if (activeTicket_.protocol == Protocol::kMoonlight) {
|
||
startMoonlightSession(activeTicket_);
|
||
} else {
|
||
startRdpSession(activeTicket_);
|
||
}
|
||
}
|
||
break;
|
||
case 2: // 断开回桌面列表
|
||
stopSessions();
|
||
if (fsm_.current() != State::kConfig) {
|
||
fsm_.transitionTo(State::kDesktopList, "已断开");
|
||
}
|
||
break;
|
||
case 3: // 退出终端
|
||
onQuitRequested();
|
||
break;
|
||
default: {
|
||
QMenu menu(this);
|
||
QAction* reconnect = menu.addAction(QStringLiteral("重新连接当前桌面"));
|
||
QAction* disconnect = menu.addAction(QStringLiteral("断开并返回桌面列表"));
|
||
menu.addSeparator();
|
||
QAction* quit = menu.addAction(QStringLiteral("退出终端"));
|
||
QAction* chosen = menu.exec(QCursor::pos());
|
||
if (chosen == reconnect) {
|
||
onMenuAction(1);
|
||
} else if (chosen == disconnect) {
|
||
onMenuAction(2);
|
||
} else if (chosen == quit) {
|
||
onMenuAction(3);
|
||
}
|
||
if (stack_->currentWidget() == sessionView_->parentWidget()) {
|
||
sessionView_->setFocus(Qt::OtherFocusReason);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
bool MainWindow::eventFilter(QObject* watched, QEvent* event) {
|
||
if (watched == sessionView_ && rdpSession_) {
|
||
if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {
|
||
auto* keyEvent = static_cast<QKeyEvent*>(event);
|
||
return forwardKeyEvent(keyEvent, event->type() == QEvent::KeyPress);
|
||
}
|
||
if (event->type() == QEvent::MouseMove || event->type() == QEvent::MouseButtonPress ||
|
||
event->type() == QEvent::MouseButtonRelease) {
|
||
return forwardMouseEvent(static_cast<QMouseEvent*>(event));
|
||
}
|
||
if (event->type() == QEvent::Wheel) {
|
||
return forwardMouseEvent(event);
|
||
}
|
||
}
|
||
return QMainWindow::eventFilter(watched, event);
|
||
}
|
||
|
||
bool MainWindow::forwardKeyEvent(QKeyEvent* event, bool pressed) {
|
||
if (!rdpSession_) {
|
||
return false;
|
||
}
|
||
const DWORD rdpScanCode =
|
||
freerdp_keyboard_get_rdp_scancode_from_x11_keycode(event->nativeScanCode());
|
||
if (rdpScanCode == RDP_SCANCODE_UNKNOWN) {
|
||
return false;
|
||
}
|
||
return rdpSession_->sendKeyEvent(pressed, event->isAutoRepeat(), rdpScanCode);
|
||
}
|
||
|
||
bool MainWindow::forwardMouseEvent(QEvent* event) {
|
||
if (!rdpSession_) {
|
||
return false;
|
||
}
|
||
uint16_t flags = 0;
|
||
QPoint pos = lastMousePosition_;
|
||
if (event->type() == QEvent::MouseMove) {
|
||
auto* mouse = static_cast<QMouseEvent*>(event);
|
||
pos = mouse->pos();
|
||
flags = PTR_FLAGS_MOVE;
|
||
} else if (event->type() == QEvent::MouseButtonPress ||
|
||
event->type() == QEvent::MouseButtonRelease) {
|
||
auto* mouse = static_cast<QMouseEvent*>(event);
|
||
pos = mouse->pos();
|
||
if (mouse->button() == Qt::LeftButton) flags |= PTR_FLAGS_BUTTON1;
|
||
if (mouse->button() == Qt::RightButton) flags |= PTR_FLAGS_BUTTON2;
|
||
if (mouse->button() == Qt::MiddleButton) flags |= PTR_FLAGS_BUTTON3;
|
||
if (event->type() == QEvent::MouseButtonPress) flags |= PTR_FLAGS_DOWN;
|
||
} else if (event->type() == QEvent::Wheel) {
|
||
auto* wheel = static_cast<QWheelEvent*>(event);
|
||
pos = wheel->position().toPoint();
|
||
flags = PTR_FLAGS_WHEEL;
|
||
if (wheel->angleDelta().y() < 0) flags |= PTR_FLAGS_WHEEL_NEGATIVE;
|
||
}
|
||
lastMousePosition_ = pos;
|
||
|
||
if (lastFrame_.isNull() || !sessionView_) {
|
||
return false;
|
||
}
|
||
const QSize sourceSize = lastFrame_.size();
|
||
const QSize viewSize = sessionView_->size();
|
||
const QSize displayedSize = sourceSize.scaled(viewSize, Qt::KeepAspectRatio);
|
||
const int offsetX = (viewSize.width() - displayedSize.width()) / 2;
|
||
const int offsetY = (viewSize.height() - displayedSize.height()) / 2;
|
||
if (pos.x() < offsetX || pos.y() < offsetY ||
|
||
pos.x() >= offsetX + displayedSize.width() ||
|
||
pos.y() >= offsetY + displayedSize.height()) {
|
||
return true;
|
||
}
|
||
const int remoteX = qBound(0,
|
||
(pos.x() - offsetX) * sourceSize.width() / displayedSize.width(),
|
||
sourceSize.width() - 1);
|
||
const int remoteY = qBound(0,
|
||
(pos.y() - offsetY) * sourceSize.height() / displayedSize.height(),
|
||
sourceSize.height() - 1);
|
||
return rdpSession_->sendMouseEvent(flags, static_cast<uint16_t>(remoteX),
|
||
static_cast<uint16_t>(remoteY));
|
||
}
|
||
|
||
} // namespace vdi
|