marko10_000
/
openclonk
forked from Mirrors/openclonk
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Qt Editor: Use qt widgets for viewports

qteditor
Sven Eberhardt 2016-03-08 21:21:34 -05:00
parent 63bbba06bb
commit f6ce50e9e7
12 changed files with 430 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -314,7 +314,6 @@ find_path(Qt5DIR qt.pro PATHS ${CMAKE_ADDITIONAL_DEPS_PATH}/qt-5.5.0)
find_package(Qt5Widgets PATHS ${Qt5DIR}/qtbase/lib/cmake/Qt5Widgets)
if(Qt5Widgets_FOUND)
SET(WITH_QT_EDITOR ${Qt5Widgets_FOUND} "Qt editor dialogues available")
add_definitions(-DWITH_QT_EDITOR)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTOUIC ON)
# As moc files are generated in the binary dir, tell CMake
@ -934,6 +933,8 @@ elseif(USE_WIN32_WINDOWS)
src/editor/C4ConsoleQtObjectListViewer.h
src/editor/C4ConsoleQtDefinitionListViewer.cpp
src/editor/C4ConsoleQtDefinitionListViewer.h
src/editor/C4ConsoleQtViewport.cpp
src/editor/C4ConsoleQtViewport.h
src/editor/C4ConsoleQtMainWindow.ui
src/editor/resource.qrc
${qt_editor_resources}
@ -1154,6 +1155,7 @@ if(USE_COCOA)
endif()
if(WITH_QT_EDITOR)
set_target_properties(openclonk PROPERTIES COMPILE_DEFINITIONS WITH_QT_EDITOR)
qt5_use_modules(openclonk Widgets)
endif()

4
src/editor/C4Console.cpp
View File

@ -515,6 +515,8 @@ void C4Console::InitGame()
EnableControls(fGameOpen);
UpdatePlayerMenu();
UpdateViewportMenu();
// Initial neutral viewport unless started with players
if (!Game.PlayerInfos.GetStartupCount()) ::Viewports.CreateViewport(NO_OWNER);
}
void C4Console::CloseGame()
@ -592,7 +594,7 @@ bool C4ConsoleGUI::Message(char const*, bool) {return 0;}
void C4ConsoleGUI::Out(char const*) {}
bool C4ConsoleGUI::PropertyDlgOpen() {return 0;}
void C4ConsoleGUI::PropertyDlgClose() {}
void C4ConsoleGUI::PropertyDlgUpdate(C4EditCursor::Selection &, bool) {}
void C4ConsoleGUI::PropertyDlgUpdate(class C4EditCursorSelection &, bool) {}
void C4ConsoleGUI::RecordingEnabled() {}
void C4ConsoleGUI::SetCaptionToFileName(char const*) {}
void C4ConsoleGUI::SetCursor(C4ConsoleGUI::Cursor) {}

1
src/editor/C4ConsoleGUI.h
View File

@ -151,6 +151,7 @@ public:
friend INT_PTR CALLBACK PropertyDlgProc(HWND hDlg, UINT Msg, WPARAM wParam, LPARAM lParam);
friend INT_PTR CALLBACK ConsoleDlgProc(HWND hDlg, UINT Msg, WPARAM wParam, LPARAM lParam);
friend class C4ToolsDlg;
friend class C4ConsoleQtMainWindow;
#endif
};

87
src/editor/C4ConsoleQtState.cpp
View File

@ -21,13 +21,13 @@
#include <C4ConsoleQtPropListViewer.h>
#include <C4ConsoleQtObjectListViewer.h>
#include <C4ConsoleQtDefinitionListViewer.h>
#include <C4ConsoleQtViewport.h>
#include <C4Console.h>
#include <StdRegistry.h>
#include <C4ViewportWindow.h>
#include <C4Landscape.h>
#include <C4PlayerList.h>
#include <C4Viewport.h>
#include <C4Object.h>
#include <C4Viewport.h>
/* String translation */
@ -89,68 +89,6 @@ void C4ConsoleOpenViewportAction::Execute()
}
/* Console viewports */
C4ConsoleViewportWidget::C4ConsoleViewportWidget(QMainWindow *parent, C4ViewportWindow *cvp)
: QDockWidget("", parent), cvp(cvp)
{
// Translated title
setWindowTitle(LoadResStr("IDS_CNS_VIEWPORT"));
#ifdef USE_WIN32_WINDOWS
// hack
window = QWindow::fromWinId(reinterpret_cast<WId>(cvp->hWindow));
QWidget *window_container = QWidget::createWindowContainer(window, parent, Qt::Widget);
window_container->setFocusPolicy(Qt::TabFocus);
setWidget(window_container);
#else
TODO
#endif
connect(this, SIGNAL(dockLocationChanged(bool)), this, SLOT(DockLocationChanged(bool)));
OnActiveChanged(true);
}
void C4ConsoleViewportWidget::OnActiveChanged(bool active)
{
// set color schemes for inactive / active viewport headers
QColor bgclr = QApplication::palette(this).color(QPalette::Highlight);
QColor fontclr = QApplication::palette(this).color(QPalette::HighlightedText);
if (active)
setStyleSheet(QString(
"QDockWidget::title { background: %1; padding: 5px; } QDockWidget { color: %2; font-weight: bold; }")
.arg(bgclr.name(), fontclr.name()));
else
setStyleSheet("");
}
void C4ConsoleViewportWidget::focusInEvent(QFocusEvent * event)
{
OnActiveChanged(true);
QDockWidget::focusInEvent(event);
}
void C4ConsoleViewportWidget::focusOutEvent(QFocusEvent * event)
{
OnActiveChanged(false);
QDockWidget::focusOutEvent(event);
}
void C4ConsoleViewportWidget::DockLocationChanged(Qt::DockWidgetArea new_area)
{
// Re-docked:
}
void C4ConsoleViewportWidget::closeEvent(QCloseEvent * event)
{
QDockWidget::closeEvent(event);
if (event->isAccepted())
{
if (cvp) cvp->Close();
cvp = NULL;
deleteLater();
}
}
/* Recursion check to avoid some crashing Qt re-entry */
class ExecRecursionCheck
@ -180,6 +118,22 @@ C4ConsoleQtMainWindow::C4ConsoleQtMainWindow(C4AbstractApp *app, C4ConsoleGUISta
#endif
}
#ifdef USE_WIN32_WINDOWS
bool ConsoleHandleWin32KeyboardMessage(MSG *msg); // in C4WindowWin32.cpp
#endif
bool C4ConsoleQtMainWindow::nativeEvent(const QByteArray &eventType, void *message, long *result)
{
#ifdef USE_WIN32_WINDOWS
MSG *msg = static_cast<MSG*>(message);
if (ConsoleHandleWin32KeyboardMessage(msg)) return true;
#else
TODO: Should implement this through native Qt keyboard signals instead of Win32 only
#endif
// Handle by Qt
return false;
}
void C4ConsoleQtMainWindow::closeEvent(QCloseEvent *event)
{
QMainWindow::closeEvent(event);
@ -425,6 +379,9 @@ bool C4ConsoleGUIState::CreateConsoleWindow(C4AbstractApp *app)
window->setCentralWidget(viewport_area);
window->setDockNestingEnabled(true);
viewport_area->setDockNestingEnabled(true);
QWidget *foo = new QWidget(viewport_area);
viewport_area->setCentralWidget(foo);
foo->hide();
// View models
property_model.reset(new C4ConsoleQtPropListModel());
@ -591,7 +548,7 @@ void C4ConsoleGUIState::ClearViewportMenu()
void C4ConsoleGUIState::AddViewport(C4ViewportWindow *cvp)
{
if (!viewport_area) return;
C4ConsoleViewportWidget *new_viewport = new C4ConsoleViewportWidget(viewport_area, cvp);
C4ConsoleQtViewportDockWidget *new_viewport = new C4ConsoleQtViewportDockWidget(viewport_area, cvp);
viewport_area->addDockWidget(Qt::BottomDockWidgetArea, new_viewport);
viewports.push_back(new_viewport);
new_viewport->setFocus();

32
src/editor/C4ConsoleQtState.h
View File

@ -81,34 +81,14 @@ public:
void Execute();
};
class C4ConsoleViewportWidget : public QDockWidget
{
Q_OBJECT
class C4ViewportWindow *cvp;
QWindow *window;
QPalette pal_inactive, pal_active;
protected:
virtual void focusInEvent(QFocusEvent * event);
virtual void focusOutEvent(QFocusEvent * event);
virtual QObject *focusObject() const { return window; }
public:
C4ConsoleViewportWidget(class QMainWindow *parent, class C4ViewportWindow *window);
virtual void closeEvent(QCloseEvent * event);
void OnActiveChanged(bool active);
class C4ViewportWindow *GetViewportWindow() const { return cvp; }
private slots:
void DockLocationChanged(Qt::DockWidgetArea new_area);
};
class C4ConsoleQtMainWindow : public QMainWindow
{
Q_OBJECT
class C4ConsoleGUIState *state;
protected:
bool nativeEvent(const QByteArray &eventType, void *message, long *result) override;
public:
C4ConsoleQtMainWindow(class C4AbstractApp *app, class C4ConsoleGUIState *state);
@ -165,7 +145,7 @@ public:
std::unique_ptr<class C4ConsoleQtPropListModel> property_model;
std::unique_ptr<class C4ConsoleQtObjectListModel> object_list_model;
std::unique_ptr<class C4ConsoleQtDefinitionListModel> definition_list_model;
std::list<C4ConsoleViewportWidget *> viewports;
std::list<class C4ConsoleQtViewportDockWidget *> viewports;
std::list<std::unique_ptr<C4ConsoleClientAction> > client_actions;
std::list<std::unique_ptr<C4ConsoleRemovePlayerAction> > player_actions;
std::list<std::unique_ptr<C4ConsoleOpenViewportAction> > viewport_actions;
@ -223,6 +203,10 @@ public:
void SetObjectSelection(class C4EditCursorSelection &rSelection);
void OnObjectListSelectionChanged(const QItemSelection & selected, const QItemSelection & deselected);
void OnCreatorCurrentChanged(const QModelIndex & current, const QModelIndex & previous);
#ifdef USE_WIN32_WINDOWS
bool HandleWin32KeyboardMessage(MSG *msg);
#endif
};
class C4ConsoleGUI::State : public C4ConsoleGUIState

275
src/editor/C4ConsoleQtViewport.cpp 100644
View File

@ -0,0 +1,275 @@
/*
* OpenClonk, http://www.openclonk.org
*
* Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
* Copyright (c) 2013, The OpenClonk Team and contributors
*
* Distributed under the terms of the ISC license; see accompanying file
* "COPYING" for details.
*
* "Clonk" is a registered trademark of Matthes Bender, used with permission.
* See accompanying file "TRADEMARK" for details.
*
* To redistribute this file separately, substitute the full license texts
* for the above references.
*/
/* Player and editor viewports in console */
#include <C4Include.h>
#include <C4Value.h>
#include <C4ConsoleQtViewport.h>
#include <C4Viewport.h>
#include <C4ViewportWindow.h>
#include <C4Console.h>
#include <C4MouseControl.h>
/* Console viewports */
C4ConsoleQtViewportView::C4ConsoleQtViewportView(class C4ConsoleQtViewportDockWidget *dock)
: QWidget(dock), dock(dock), cvp(dock->cvp ? dock->cvp->cvp : NULL)
{
setAutoFillBackground(false);
setAttribute(Qt::WA_NoSystemBackground, true);
setAttribute(Qt::WA_PaintOnScreen, true);
setAttribute(Qt::WA_NativeWindow, true);
setAttribute(Qt::WA_ShowWithoutActivating, true);
setWindowFlags(Qt::FramelessWindowHint);
setFocusPolicy(Qt::TabFocus);
setMouseTracking(true);
// Register for viewport
#ifdef USE_WIN32_WINDOWS
dock->cvp->hWindow = reinterpret_cast<HWND>(this->winId());
#else
TODO
#endif
}
bool C4ConsoleQtViewportView::IsPlayViewport() const
{
return (cvp && ::MouseControl.IsViewport(cvp)
&& (::Console.EditCursor.GetMode() == C4CNS_ModePlay));
}
void C4ConsoleQtViewportView::resizeEvent(QResizeEvent *resize_event)
{
QWidget::resizeEvent(resize_event);
if (cvp) dock->cvp->cvp->UpdateOutputSize();
}
bool C4ConsoleQtViewportView::nativeEvent(const QByteArray &eventType, void *message, long *result)
{
// Handle native Windows messages
#ifdef USE_WIN32_WINDOWS
MSG *msg = static_cast<MSG*>(message);
switch (msg->message)
{
//----------------------------------------------------------------------------------------------------------------------------------
case WM_HSCROLL:
switch (LOWORD(msg->wParam))
{
case SB_THUMBTRACK:
case SB_THUMBPOSITION: cvp->SetViewX(float(HIWORD(msg->wParam)) / cvp->GetZoom()); break;
case SB_LINELEFT: cvp->ScrollView(-ViewportScrollSpeed, 0.0f); break;
case SB_LINERIGHT: cvp->ScrollView(+ViewportScrollSpeed, 0.0f); break;
case SB_PAGELEFT: cvp->ScrollView(-cvp->ViewWdt / cvp->GetZoom(), 0.0f); break;
case SB_PAGERIGHT: cvp->ScrollView(+cvp->ViewWdt / cvp->GetZoom(), 0.0f); break;
}
cvp->Execute();
cvp->ScrollBarsByViewPosition();
return true;
//----------------------------------------------------------------------------------------------------------------------------------
case WM_VSCROLL:
switch (LOWORD(msg->wParam))
{
case SB_THUMBTRACK:
case SB_THUMBPOSITION: cvp->SetViewY(float(HIWORD(msg->wParam)) / cvp->GetZoom()); break;
case SB_LINEUP: cvp->ScrollView(0.0f, -ViewportScrollSpeed); break;
case SB_LINEDOWN: cvp->ScrollView(0.0f, +ViewportScrollSpeed); break;
case SB_PAGEUP: cvp->ScrollView(0.0f, -cvp->ViewWdt / cvp->GetZoom()); break;
case SB_PAGEDOWN: cvp->ScrollView(0.0f, +cvp->ViewWdt / cvp->GetZoom()); break;
}
cvp->Execute();
cvp->ScrollBarsByViewPosition();
return true;
//----------------------------------------------------------------------------------------------------------------------------------
}
#endif
return false;
}
// Get Shift state as Win32 wParam
uint32_t GetShiftWParam()
{
#ifdef USE_WIN32_WINDOWS
uint32_t result = 0;
if (GetKeyState(VK_CONTROL) < 0) result |= MK_CONTROL;
if (GetKeyState(VK_SHIFT) < 0) result |= MK_SHIFT;
if (GetKeyState(VK_MENU) < 0) result |= MK_ALT;
return result;
#else
TODO Get shift state
#endif
}
void C4ConsoleQtViewportView::mouseMoveEvent(QMouseEvent *eventMove)
{
if (IsPlayViewport())
{
bool is_in_drawrange = (Inside<int32_t>(eventMove->x() - cvp->DrawX, 0, cvp->ViewWdt - 1)
&& Inside<int32_t>(eventMove->y() - cvp->DrawY, 0, cvp->ViewHgt - 1));
this->setCursor(is_in_drawrange ? Qt::BlankCursor : Qt::CrossCursor);
C4GUI::MouseMove(C4MC_Button_None, eventMove->x(), eventMove->y(), GetShiftWParam(), cvp);
}
else
{
cvp->pWindow->EditCursorMove(eventMove->x(), eventMove->y(), GetShiftWParam());
}
}
void C4ConsoleQtViewportView::mousePressEvent(QMouseEvent *eventPress)
{
if (IsPlayViewport())
{
int32_t btn = C4MC_Button_None;
switch (eventPress->button())
{
case Qt::LeftButton: btn = C4MC_Button_LeftDown; break;
case Qt::RightButton: btn = C4MC_Button_RightDown; break;
}
C4GUI::MouseMove(btn, eventPress->x(), eventPress->y(), GetShiftWParam(), cvp);
}
else
{
// movement update needed before, so target is always up-to-date
cvp->pWindow->EditCursorMove(eventPress->x(), eventPress->y(), GetShiftWParam());
switch (eventPress->button())
{
case Qt::LeftButton: ::Console.EditCursor.LeftButtonDown(GetShiftWParam()); break;
case Qt::RightButton: ::Console.EditCursor.RightButtonDown(GetShiftWParam()); break;
}
}
}
void C4ConsoleQtViewportView::mouseDoubleClickEvent(QMouseEvent *eventPress)
{
if (IsPlayViewport())
{
int32_t btn = C4MC_Button_None;
switch (eventPress->button())
{
case Qt::LeftButton: btn = C4MC_Button_LeftDouble; break;
case Qt::RightButton: btn = C4MC_Button_RightDouble; break;
}
C4GUI::MouseMove(btn, eventPress->x(), eventPress->y(), GetShiftWParam(), cvp);
}
}
void C4ConsoleQtViewportView::mouseReleaseEvent(QMouseEvent *releaseEvent)
{
if (IsPlayViewport())
{
int32_t btn = C4MC_Button_None;
switch (releaseEvent->button())
{
case Qt::LeftButton: btn = C4MC_Button_LeftUp; break;
case Qt::RightButton: btn = C4MC_Button_RightUp; break;
}
C4GUI::MouseMove(btn, releaseEvent->x(), releaseEvent->y(), GetShiftWParam(), cvp);
}
else
{
switch (releaseEvent->button())
{
case Qt::LeftButton: ::Console.EditCursor.LeftButtonUp(GetShiftWParam()); break;
case Qt::RightButton: ::Console.EditCursor.RightButtonUp(GetShiftWParam()); break;
}
}
}
void C4ConsoleQtViewportView::wheelEvent(QWheelEvent *event)
{
if (IsPlayViewport())
{
int delta = event->delta() / 8;
if (!delta) delta = event->delta(); // abs(delta)<8?
uint32_t shift = (delta>0) ? (delta<<16) : uint32_t(delta<<16);
C4GUI::MouseMove(C4MC_Button_Wheel, event->x(), event->y(), shift, cvp);
}
else
{
// TODO zoom?
}
}
C4ConsoleQtViewportDockWidget::C4ConsoleQtViewportDockWidget(QMainWindow *parent, C4ViewportWindow *cvp)
: QDockWidget("", parent), cvp(cvp)
{
// Translated title
setWindowTitle(LoadResStr("IDS_CNS_VIEWPORT"));
// Actual view container
view = new C4ConsoleQtViewportView(this);
setWidget(view);
connect(this, SIGNAL(dockLocationChanged(bool)), this, SLOT(DockLocationChanged(bool)));
OnActiveChanged(true);
}
void C4ConsoleQtViewportDockWidget::OnActiveChanged(bool active)
{
// set color schemes for inactive / active viewport headers
QColor bgclr = QApplication::palette(this).color(QPalette::Highlight);
QColor fontclr = QApplication::palette(this).color(QPalette::HighlightedText);
if (active)
setStyleSheet(QString(
"QDockWidget::title { background: %1; padding: 5px; } QDockWidget { color: %2; font-weight: bold; }")
.arg(bgclr.name(), fontclr.name()));
else
setStyleSheet("");
}
void C4ConsoleQtViewportDockWidget::focusInEvent(QFocusEvent * event)
{
OnActiveChanged(true);
QDockWidget::focusInEvent(event);
}
void C4ConsoleQtViewportDockWidget::focusOutEvent(QFocusEvent * event)
{
OnActiveChanged(false);
QDockWidget::focusOutEvent(event);
}
void C4ConsoleQtViewportDockWidget::DockLocationChanged(Qt::DockWidgetArea new_area)
{
// Re-docked:
}
void C4ConsoleQtViewportDockWidget::closeEvent(QCloseEvent * event)
{
QDockWidget::closeEvent(event);
if (event->isAccepted())
{
if (cvp) cvp->Close();
cvp = NULL;
deleteLater();
}
}
#ifdef USE_WIN32_WINDOWS
bool ConsoleHandleWin32KeyboardMessage(MSG *msg); // in C4WindowWin32.cpp
#endif
bool C4ConsoleQtViewportDockWidget::nativeEvent(const QByteArray &eventType, void *message, long *result)
{
// Handle keyboard messages on detached viewport windows
#ifdef USE_WIN32_WINDOWS
MSG *msg = static_cast<MSG*>(message);
if (ConsoleHandleWin32KeyboardMessage(msg)) return true;
#else
TODO: Should implement this through native Qt keyboard signals
#endif
// Handle by Qt
return false;
}

77
src/editor/C4ConsoleQtViewport.h 100644
View File

@ -0,0 +1,77 @@
/*
* OpenClonk, http://www.openclonk.org
*
* Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
* Copyright (c) 2013, The OpenClonk Team and contributors
*
* Distributed under the terms of the ISC license; see accompanying file
* "COPYING" for details.
*
* "Clonk" is a registered trademark of Matthes Bender, used with permission.
* See accompanying file "TRADEMARK" for details.
*
* To redistribute this file separately, substitute the full license texts
* for the above references.
*/
/* Player and editor viewports in console */
#ifndef INC_C4ConsoleQtViewport
#define INC_C4ConsoleQtViewport
#ifdef WITH_QT_EDITOR
#include <C4Include.h> // needed for automoc
#include <C4ConsoleGUI.h> // for glew.h
#include <C4ConsoleQt.h>
class C4ConsoleQtViewportView : public QWidget
{
Q_OBJECT
class C4ConsoleQtViewportDockWidget *dock;
class C4Viewport *cvp;
private:
bool IsPlayViewport() const;
protected:
void resizeEvent(QResizeEvent *resize_event) override;
bool nativeEvent(const QByteArray &eventType, void *message, long *result) override;
void mouseMoveEvent(QMouseEvent *eventMove) override;
void mousePressEvent(QMouseEvent *eventPress) override;
void mouseDoubleClickEvent(QMouseEvent *eventPress) override;
void mouseReleaseEvent(QMouseEvent *releaseEvent) override;
void wheelEvent(QWheelEvent *event) override;
public:
C4ConsoleQtViewportView(class C4ConsoleQtViewportDockWidget *dock);
};
class C4ConsoleQtViewportDockWidget : public QDockWidget
{
Q_OBJECT
class C4ViewportWindow *cvp;
C4ConsoleQtViewportView *view;
QPalette pal_inactive, pal_active;
protected:
void focusInEvent(QFocusEvent * event) override;
void focusOutEvent(QFocusEvent * event) override;
bool nativeEvent(const QByteArray &eventType, void *message, long *result) override;
public:
C4ConsoleQtViewportDockWidget(class QMainWindow *parent, class C4ViewportWindow *window);
virtual void closeEvent(QCloseEvent * event);
void OnActiveChanged(bool active);
class C4ViewportWindow *GetViewportWindow() const { return cvp; }
private slots :
void DockLocationChanged(Qt::DockWidgetArea new_area);
friend C4ConsoleQtViewportView;
};
#endif // WITH_QT_EDITOR
#endif // INC_C4ConsoleQtViewport

5
src/editor/C4ViewportWindow.cpp
View File

@ -181,10 +181,7 @@ C4Window * C4ViewportWindow::Init(int32_t Player)
if (!result) return result;
pSurface = new C4Surface(&Application, this);
#ifdef WITH_QT_EDITOR
// embed into editor
::Console.AddViewport(this);
#else
#ifndef WITH_QT_EDITOR
// Position and size
RestorePosition(FormatString("Viewport%i", Player+1).getData(), Config.GetSubkeyPath("Console"));
#endif

4
src/editor/C4ViewportWindow.h
View File

@ -25,7 +25,11 @@
#ifdef USE_GTK
#include <gtk/gtk.h>
#endif
#ifdef WITH_QT_EDITOR
#define C4ViewportWindowStyle (WS_VISIBLE)
#else
#define C4ViewportWindowStyle (WS_VISIBLE | WS_POPUP | WS_SYSMENU | WS_CAPTION | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_SIZEBOX)
#endif
enum { ViewportScrollSpeed=10 };
class C4ViewportWindow: public C4Window

2
src/game/C4Viewport.h
View File

@ -113,6 +113,7 @@ protected:
void BlitOutput();
void AdjustZoomAndPosition();
public:
float GetZoom() const { return Zoom; }
void AdjustPosition(bool immediate = false);
C4ViewportWindow* GetWindow() {return pWindow.get();}
bool UpdateOutputSize();
@ -124,6 +125,7 @@ public:
friend class C4ViewportWindow;
friend class C4ViewportList;
friend class C4GraphicsSystem;
friend class C4ConsoleQtViewportView;
};
class C4ViewportList {

2
src/gui/C4GfxErrorDlg.cpp
View File

@ -116,7 +116,7 @@ static INT_PTR CALLBACK GfxErrProcedure(HWND hWnd, UINT Msg, WPARAM wParam, LPAR
memset(&siStartupInfo, 0, sizeof(siStartupInfo));
memset(&piProcessInfo, 0, sizeof(piProcessInfo));
siStartupInfo.cb = sizeof(siStartupInfo);
CreateProcessW(selfpath, L"",
CreateProcessW(selfpath, NULL,
NULL, NULL, FALSE, 0, NULL, Config.General.ExePath.GetWideChar(), &siStartupInfo, &piProcessInfo);
EndDialog(hWnd,2);
return TRUE;

38
src/platform/C4WindowWin32.cpp
View File

@ -240,6 +240,34 @@ LRESULT APIENTRY FullScreenWinProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM l
return DefWindowProcW(hwnd, uMsg, wParam, lParam);
}
static C4KeyCode msg2scancode(MSG *msg)
{
// compute scancode
C4KeyCode scancode = (((unsigned int)msg->lParam) >> 16) & 0xFF;
bool extended = ((msg->lParam & 0x01000000) != 0);
ConvertToUnixScancode(msg->wParam, &scancode, extended);
return scancode;
}
bool ConsoleHandleWin32KeyboardMessage(MSG *msg)
{
switch (msg->message)
{
case WM_KEYDOWN:
if (Game.DoKeyboardInput(msg2scancode(msg), KEYEV_Down, !!(msg->lParam & 0x20000000), GetKeyState(VK_CONTROL) < 0, GetKeyState(VK_SHIFT) < 0, !!(msg->lParam & 0x40000000), NULL)) return true;
break;
case WM_KEYUP:
if (Game.DoKeyboardInput(msg2scancode(msg), KEYEV_Up, !!(msg->lParam & 0x20000000), GetKeyState(VK_CONTROL) < 0, GetKeyState(VK_SHIFT) < 0, false, NULL)) return 0;
break;
case WM_SYSKEYDOWN:
if (msg->wParam == 18) break; // VK_MENU (Alt)
if (Game.DoKeyboardInput(msg2scancode(msg), KEYEV_Down, !!(msg->lParam & 0x20000000), GetKeyState(VK_CONTROL) < 0, GetKeyState(VK_SHIFT) < 0, !!(msg->lParam & 0x40000000), NULL)) return 0;
break;
}
return false;
}
LRESULT APIENTRY ViewportWinProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
// Determine viewport
@ -354,10 +382,6 @@ LRESULT APIENTRY ViewportWinProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lPa
return 0;
//----------------------------------------------------------------------------------------------------------------------------------
case WM_ACTIVATE:
#ifdef WITH_QT_EDITOR
// Notify editor that viewport needs to be drawn in activated state
::Console.OnViewportActiveChanged(cvp->GetWindow(), LOWORD(wParam) != WA_INACTIVE);
#endif
// Keep editing dialogs on top of the current viewport, but don't make them
// float on other windows (i.e., no HWND_TOPMOST).
// Also, don't use SetParent, since that activates the window, which in turn
@ -559,6 +583,10 @@ C4Window * C4Window::Init(C4Window::WindowKind windowKind, C4AbstractApp * pApp,
eKind = windowKind;
if (windowKind == W_Viewport)
{
#ifdef WITH_QT_EDITOR
// embed into editor: Viewport widget creation handled by C4ConsoleQt
::Console.AddViewport(static_cast<C4ViewportWindow *>(this));
#else
static bool fViewportClassRegistered = false;
if (!fViewportClassRegistered)
{
@ -586,7 +614,7 @@ C4Window * C4Window::Init(C4Window::WindowKind windowKind, C4AbstractApp * pApp,
CW_USEDEFAULT,CW_USEDEFAULT, size->Wdt, size->Hgt,
Console.hWindow,NULL,pApp->GetInstance(),NULL);
if(!hWindow) return NULL;
#endif
// We don't re-init viewport windows currently, so we don't need a child window
// for now: Render into main window.
renderwnd = hWindow;