ShuriZma
/
xenia-canary
mirror of https://github.com/xenia-canary/xenia-canary.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1431 from bwrsandman/linux_windowing 

Linux windowing fixes
This commit is contained in:
Triang3l 2021-08-26 23:01:38 +03:00 committed by GitHub
parent f6f524b814 7edfdc2672
commit cb13f0bae6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 185 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/xenia/app/premake5.lua
View File

@ -73,7 +73,6 @@ project("xenia-app")
"X11",
"xcb",
"X11-xcb",
"vulkan",
"SDL2",
})

5
src/xenia/cpu/hir/value.cc
View File

@ -395,9 +395,8 @@ void Value::MulHi(Value* other, bool is_unsigned) {
(uint32_t)other->constant.i32) >>
32);
} else {
constant.i32 =
(int32_t)(((int64_t)constant.i32 * (int64_t)other->constant.i32) >>
32);
constant.i32 = (int32_t)(
((int64_t)constant.i32 * (int64_t)other->constant.i32) >> 32);
}
break;
case INT64_TYPE:

2
src/xenia/cpu/ppc/ppc_emit_control.cc
View File

@ -810,6 +810,6 @@ void RegisterEmitCategoryControl() {
XEREGISTERINSTR(mtmsrd);
}
} // namespace ppc
} // namespace cpu
} // namespace cpu
} // namespace xe

7
src/xenia/cpu/xex_module.cc
View File

@ -832,10 +832,9 @@ int XexModule::ReadPEHeaders() {
// offsetof seems to be unable to find OptionalHeader.
#define offsetof1(type, member) ((std::size_t) & (((type*)0)->member))
#define IMAGE_FIRST_SECTION1(ntheader) \
((PIMAGE_SECTION_HEADER)((uint8_t*)ntheader + \
offsetof1(IMAGE_NT_HEADERS, OptionalHeader) + \
((PIMAGE_NT_HEADERS)(ntheader)) \
->FileHeader.SizeOfOptionalHeader))
((PIMAGE_SECTION_HEADER)( \
(uint8_t*)ntheader + offsetof1(IMAGE_NT_HEADERS, OptionalHeader) + \
((PIMAGE_NT_HEADERS)(ntheader))->FileHeader.SizeOfOptionalHeader))
// Quick scan to determine bounds of sections.
size_t upper_address = 0;

4
src/xenia/gpu/vulkan/premake5.lua
View File

@ -70,8 +70,6 @@ project("xenia-gpu-vulkan-trace-viewer")
"X11",
"xcb",
"X11-xcb",
"GL",
"vulkan",
})
filter("platforms:Windows")
@ -138,8 +136,6 @@ project("xenia-gpu-vulkan-trace-dump")
"X11",
"xcb",
"X11-xcb",
"GL",
"vulkan",
})
filter("platforms:Windows")

2
src/xenia/gpu/vulkan/vulkan_graphics_system.cc
View File

@ -271,7 +271,7 @@ VulkanGraphicsSystem::CreateCommandProcessor() {
}
void VulkanGraphicsSystem::Swap(xe::ui::UIEvent* e) {
if (!command_processor_) {
if (!command_processor_ || !display_context_) {
return;
}

5
src/xenia/kernel/xam/xam_user.cc
View File

@ -277,9 +277,8 @@ uint32_t xeXamUserReadProfileSettingsEx(uint32_t title_id, uint32_t user_index,
auto setting = user_profile->GetSetting(setting_id);
std::memset(out_setting, 0, sizeof(X_USER_READ_PROFILE_SETTING));
out_setting->from = !setting || !setting->is_set ? 0
: setting->is_title_specific() ? 2
: 1;
out_setting->from =
!setting || !setting->is_set ? 0 : setting->is_title_specific() ? 2 : 1;
out_setting->user_index = static_cast<uint32_t>(user_index);
out_setting->setting_id = setting_id;

30
src/xenia/ui/loop_gtk.cc
View File

@ -17,15 +17,6 @@
namespace xe {
namespace ui {
class PostedFn {
public:
explicit PostedFn(std::function<void()> fn) : fn_(std::move(fn)) {}
void Call() { fn_(); }
private:
std::function<void()> fn_;
};
std::unique_ptr<Loop> Loop::Create() { return std::make_unique<GTKLoop>(); }
GTKLoop::GTKLoop() : thread_id_() {
@ -56,24 +47,33 @@ bool GTKLoop::is_on_loop_thread() {
}
gboolean _posted_fn_thunk(gpointer posted_fn) {
PostedFn* Fn = reinterpret_cast<PostedFn*>(posted_fn);
Fn->Call();
// convert gpointer back to std::function, call it, then free std::function
std::function<void()>* f =
reinterpret_cast<std::function<void()>*>(posted_fn);
std::function<void()>& func = *f;
func();
delete f;
// Tells GDK we don't want to run this again
return G_SOURCE_REMOVE;
}
void GTKLoop::Post(std::function<void()> fn) {
assert_true(thread_id_ != std::thread::id());
gdk_threads_add_idle(_posted_fn_thunk,
reinterpret_cast<gpointer>(new PostedFn(std::move(fn))));
// converting std::function to a generic pointer for gdk
gdk_threads_add_idle(_posted_fn_thunk, reinterpret_cast<gpointer>(
new std::function<void()>(fn)));
}
void GTKLoop::PostDelayed(std::function<void()> fn, uint64_t delay_millis) {
gdk_threads_add_timeout(
delay_millis, _posted_fn_thunk,
reinterpret_cast<gpointer>(new PostedFn(std::move(fn))));
reinterpret_cast<gpointer>(new std::function<void()>(fn)));
}
void GTKLoop::Quit() { assert_true(thread_id_ != std::thread::id()); }
void GTKLoop::Quit() {
assert_true(thread_id_ != std::thread::id());
Post([]() { gtk_main_quit(); });
}
void GTKLoop::AwaitQuit() { quit_fence_.Wait(); }

2
src/xenia/ui/vulkan/premake5.lua
View File

@ -56,6 +56,4 @@ project("xenia-ui-window-vulkan-demo")
"X11",
"xcb",
"X11-xcb",
"GL",
"vulkan",
})

10
src/xenia/ui/vulkan/vulkan_context.cc
View File

@ -25,7 +25,7 @@
#include "xenia/ui/vulkan/vulkan_util.h"
#include "xenia/ui/window.h"
#if XE_PLATFORM_LINUX
#if XE_PLATFORM_GNU_LINUX
#include "xenia/ui/window_gtk.h"
#include <X11/Xlib-xcb.h>
@ -71,14 +71,10 @@ bool VulkanContext::Initialize() {
status = ifn.vkCreateWin32SurfaceKHR(*provider->instance(), &create_info,
nullptr, &surface);
CheckResult(status, "vkCreateWin32SurfaceKHR");
#elif XE_PLATFORM_LINUX
#elif XE_PLATFORM_GNU_LINUX
#ifdef GDK_WINDOWING_X11
GtkWidget* window_handle =
static_cast<GtkWidget*>(target_window_->native_handle());
GdkDisplay* gdk_display = gtk_widget_get_display(window_handle);
assert(GDK_IS_X11_DISPLAY(gdk_display));
xcb_connection_t* connection =
XGetXCBConnection(gdk_x11_display_get_xdisplay(gdk_display));
dynamic_cast<GTKWindow*>(target_window_)->native_window_handle();
xcb_window_t window =
gdk_x11_window_get_xid(gtk_widget_get_window(window_handle));
VkXcbSurfaceCreateInfoKHR create_info;

2
src/xenia/ui/vulkan/vulkan_instance.cc
View File

@ -32,7 +32,7 @@
#include "xenia/base/platform_win.h"
#endif
#if XE_PLATFORM_LINUX
#if XE_PLATFORM_GNU_LINUX
#include "xenia/ui/window_gtk.h"
#endif

7
src/xenia/ui/vulkan/vulkan_provider.cc
View File

@ -52,11 +52,16 @@ bool VulkanProvider::Initialize() {
instance_ = std::make_unique<VulkanInstance>();
// Always enable the swapchain.
#if XE_PLATFORM_WIN32
#if XE_PLATFORM_GNU_LINUX || XE_PLATFORM_WIN32
instance_->DeclareRequiredExtension("VK_KHR_surface", Version::Make(0, 0, 0),
false);
#if XE_PLATFORM_GNU_LINUX
instance_->DeclareRequiredExtension("VK_KHR_xcb_surface",
Version::Make(0, 0, 0), false);
#elif XE_PLATFORM_WIN32
instance_->DeclareRequiredExtension("VK_KHR_win32_surface",
Version::Make(0, 0, 0), false);
#endif
#endif
// Attempt initialization and device query.

9
src/xenia/ui/window.h
View File

@ -14,6 +14,7 @@
#include <string>
#include "xenia/base/delegate.h"
#include "xenia/base/platform.h"
#include "xenia/ui/graphics_context.h"
#include "xenia/ui/loop.h"
#include "xenia/ui/menu_item.h"
@ -172,8 +173,16 @@ class Window {
Loop* loop_ = nullptr;
std::unique_ptr<MenuItem> main_menu_;
std::string title_;
#ifdef XE_PLATFORM_GNU_LINUX
// GTK must have a default value here that isn't 0
// TODO(Triang3l): Cleanup and unify this. May need to get the first resize
// message on various platforms.
int32_t width_ = 1280;
int32_t height_ = 720;
#else
int32_t width_ = 0;
int32_t height_ = 0;
#endif
bool has_focus_ = true;
bool is_cursor_visible_ = true;
bool is_imgui_input_enabled_ = false;

2
src/xenia/ui/window_demo.cc
View File

@ -71,7 +71,7 @@ int window_demo_main(const std::vector<std::string>& args) {
std::unique_ptr<GraphicsProvider> graphics_provider;
loop->PostSynchronous([&window, &graphics_provider]() {
// Create graphics provider and an initial context for the window.
// The window will finish initialization wtih the context (loading
// The window will finish initialization with the context (loading
// resources, etc).
graphics_provider = CreateDemoGraphicsProvider(window.get());
window->set_context(graphics_provider->CreateContext(window.get()));

182
src/xenia/ui/window_gtk.cc
View File

@ -7,9 +7,13 @@
******************************************************************************
*/
#include <algorithm>
#include <string>
#include <X11/Xlib-xcb.h>
#include "xenia/base/assert.h"
#include "xenia/base/clock.h"
#include "xenia/base/logging.h"
#include "xenia/base/platform_linux.h"
#include "xenia/ui/virtual_key.h"
@ -18,15 +22,6 @@
namespace xe {
namespace ui {
class FnWrapper {
public:
explicit FnWrapper(std::function<void()> fn) : fn_(std::move(fn)) {}
void Call() { fn_(); }
private:
std::function<void()> fn_;
};
std::unique_ptr<Window> Window::Create(Loop* loop, const std::string& title) {
return std::make_unique<GTKWindow>(loop, title);
}
@ -37,14 +32,16 @@ GTKWindow::GTKWindow(Loop* loop, const std::string& title)
GTKWindow::~GTKWindow() {
OnDestroy();
if (window_) {
gtk_widget_destroy(window_);
if (GTK_IS_WIDGET(window_)) {
gtk_widget_destroy(window_);
}
window_ = nullptr;
}
}
bool GTKWindow::Initialize() { return OnCreate(); }
void gtk_event_handler_(GtkWidget* widget, GdkEvent* event, gpointer data) {
gboolean gtk_event_handler(GtkWidget* widget, GdkEvent* event, gpointer data) {
GTKWindow* window = reinterpret_cast<GTKWindow*>(data);
switch (event->type) {
case GDK_OWNER_CHANGE:
@ -58,30 +55,80 @@ void gtk_event_handler_(GtkWidget* widget, GdkEvent* event, gpointer data) {
window->HandleKeyboard(&(event->key));
break;
case GDK_SCROLL:
case GDK_BUTTON_PRESS:
case GDK_MOTION_NOTIFY:
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
window->HandleMouse(&(event->any));
break;
case GDK_FOCUS_CHANGE:
window->HandleWindowFocus(&(event->focus_change));
break;
case GDK_CONFIGURE:
window->HandleWindowResize(&(event->configure));
// Only handle the event for the drawing area so we don't save
// a width and height that includes the menu bar on the full window
if (event->configure.window ==
gtk_widget_get_window(window->drawing_area_)) {
window->HandleWindowResize(&(event->configure));
}
break;
default:
// Do nothing
return;
break;
}
// Propagate the event to other handlers
return GDK_EVENT_PROPAGATE;
}
gboolean draw_callback(GtkWidget* widget, GdkFrameClock* frame_clock,
gpointer data) {
GTKWindow* window = reinterpret_cast<GTKWindow*>(data);
window->HandleWindowPaint();
return G_SOURCE_CONTINUE;
}
gboolean close_callback(GtkWidget* widget, gpointer data) {
GTKWindow* window = reinterpret_cast<GTKWindow*>(data);
window->Close();
return G_SOURCE_CONTINUE;
}
void GTKWindow::Create() {
// GTK optionally allows passing argv and argc here for parsing gtk specific
// options. We won't bother
window_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window_), (gchar*)title_.c_str());
gtk_window_set_default_size(GTK_WINDOW(window_), 1280, 720);
gtk_widget_show_all(window_);
g_signal_connect(G_OBJECT(window_), "destroy", G_CALLBACK(gtk_main_quit),
NULL);
g_signal_connect(G_OBJECT(window_), "event", G_CALLBACK(gtk_event_handler_),
gtk_window_set_resizable(GTK_WINDOW(window_), true);
gtk_window_set_title(GTK_WINDOW(window_), title_.c_str());
gtk_window_set_default_size(GTK_WINDOW(window_), width_, height_);
// Drawing area is where we will attach our vulkan/gl context
drawing_area_ = gtk_drawing_area_new();
// tick callback is for the refresh rate of the window
gtk_widget_add_tick_callback(drawing_area_, draw_callback,
reinterpret_cast<gpointer>(this), nullptr);
// Attach our event handler to both the main window (for keystrokes) and the
// drawing area (for mouse input, resize event, etc)
g_signal_connect(G_OBJECT(drawing_area_), "event",
G_CALLBACK(gtk_event_handler),
reinterpret_cast<gpointer>(this));
GdkDisplay* gdk_display = gtk_widget_get_display(window_);
assert(GDK_IS_X11_DISPLAY(gdk_display));
connection_ = XGetXCBConnection(gdk_x11_display_get_xdisplay(gdk_display));
g_signal_connect(G_OBJECT(window_), "event", G_CALLBACK(gtk_event_handler),
reinterpret_cast<gpointer>(this));
// When the window manager kills the window (ie, the user hits X)
g_signal_connect(G_OBJECT(window_), "destroy", G_CALLBACK(close_callback),
reinterpret_cast<gpointer>(this));
// Enable only keyboard events (so no mouse) for the top window
gtk_widget_set_events(window_, GDK_KEY_PRESS | GDK_KEY_RELEASE);
// Enable all events for the drawing area
gtk_widget_add_events(drawing_area_, GDK_ALL_EVENTS_MASK);
// Place the drawing area in a container (which later will hold the menu)
// then let it fill the whole area
box_ = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_end(GTK_BOX(box_), drawing_area_, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(window_), box_);
gtk_widget_show_all(window_);
}
bool GTKWindow::OnCreate() {
@ -94,8 +141,6 @@ void GTKWindow::OnDestroy() { super::OnDestroy(); }
void GTKWindow::OnClose() {
if (!closing_ && window_) {
closing_ = true;
gtk_widget_destroy(window_);
window_ = nullptr;
}
super::OnClose();
}
@ -123,7 +168,6 @@ void GTKWindow::ToggleFullscreen(bool fullscreen) {
}
fullscreen_ = fullscreen;
if (fullscreen) {
gtk_window_fullscreen(GTK_WINDOW(window_));
} else {
@ -140,7 +184,6 @@ void GTKWindow::set_bordered(bool enabled) {
// Don't screw with the borders if we're fullscreen.
return;
}
gtk_window_set_decorated(GTK_WINDOW(window_), enabled);
}
@ -171,31 +214,30 @@ void GTKWindow::set_focus(bool value) {
}
void GTKWindow::Resize(int32_t width, int32_t height) {
if (is_fullscreen()) {
// Cannot resize while in fullscreen.
return;
}
gtk_window_resize(GTK_WINDOW(window_), width, height);
super::Resize(width, height);
}
void GTKWindow::Resize(int32_t left, int32_t top, int32_t right,
int32_t bottom) {
// TODO(dougvj) Verify that this is the desired behavior from this call
if (is_fullscreen()) {
// Cannot resize while in fullscreen.
return;
}
gtk_window_move(GTK_WINDOW(window_), left, top);
gtk_window_resize(GTK_WINDOW(window_), left - right, top - bottom);
gtk_window_resize(GTK_WINDOW(window_), right - left, bottom - top);
super::Resize(left, top, right, bottom);
}
void GTKWindow::OnResize(UIEvent* e) {
int32_t width;
int32_t height;
gtk_window_get_size(GTK_WINDOW(window_), &width, &height);
if (width != width_ || height != height_) {
width_ = width;
height_ = height;
Layout();
}
super::OnResize(e);
}
void GTKWindow::OnResize(UIEvent* e) { super::OnResize(e); }
void GTKWindow::Invalidate() {
// gtk_widget_queue_draw(drawing_area_);
super::Invalidate();
// TODO(dougvj) I am not sure what this is supposed to do
}
void GTKWindow::Close() {
@ -203,20 +245,22 @@ void GTKWindow::Close() {
return;
}
closing_ = true;
Close();
OnClose();
gtk_widget_destroy(window_);
window_ = nullptr;
}
void GTKWindow::OnMainMenuChange() {
// We need to store the old handle for detachment
static GtkWidget* box = nullptr;
static int count = 0;
auto main_menu = reinterpret_cast<GTKMenuItem*>(main_menu_.get());
if (main_menu && !is_fullscreen()) {
if (box) gtk_widget_destroy(box);
GtkWidget* menu = main_menu->handle();
box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start(GTK_BOX(box), menu, FALSE, FALSE, 3);
gtk_container_add(GTK_CONTAINER(window_), box);
if (main_menu && main_menu->handle()) {
if (!is_fullscreen()) {
gtk_box_pack_start(GTK_BOX(box_), main_menu->handle(), FALSE, FALSE, 0);
gtk_widget_show_all(window_);
} else {
gtk_container_remove(GTK_CONTAINER(box_), main_menu->handle());
}
}
}
@ -234,9 +278,22 @@ bool GTKWindow::HandleWindowOwnerChange(GdkEventOwnerChange* event) {
return false;
}
bool GTKWindow::HandleWindowPaint() {
auto e = UIEvent(this);
OnPaint(&e);
return true;
}
bool GTKWindow::HandleWindowResize(GdkEventConfigure* event) {
if (event->type == GDK_CONFIGURE) {
int32_t width = event->width;
int32_t height = event->height;
auto e = UIEvent(this);
if (width != width_ || height != height_) {
width_ = width;
height_ = height;
Layout();
}
OnResize(&e);
return true;
}
@ -351,6 +408,7 @@ bool GTKWindow::HandleKeyboard(GdkEventKey* event) {
bool ctrl_pressed = modifiers & GDK_CONTROL_MASK;
bool alt_pressed = modifiers & GDK_META_MASK;
bool super_pressed = modifiers & GDK_SUPER_MASK;
uint32_t key_char = gdk_keyval_to_unicode(event->keyval);
// TODO(Triang3l): event->hardware_keycode to VirtualKey translation.
auto e = KeyEvent(this, VirtualKey(event->hardware_keycode), 1,
event->type == GDK_KEY_RELEASE, shift_pressed, ctrl_pressed,
@ -358,12 +416,13 @@ bool GTKWindow::HandleKeyboard(GdkEventKey* event) {
switch (event->type) {
case GDK_KEY_PRESS:
OnKeyDown(&e);
if (key_char > 0) {
OnKeyChar(&e);
}
break;
case GDK_KEY_RELEASE:
OnKeyUp(&e);
break;
// TODO(dougvj) GDK doesn't have a KEY CHAR event, so we will have to
// figure out its equivalent here to call OnKeyChar(&e);
default:
return false;
}
@ -377,23 +436,35 @@ std::unique_ptr<ui::MenuItem> MenuItem::Create(Type type,
return std::make_unique<GTKMenuItem>(type, text, hotkey, callback);
}
static void _menu_activate_callback(GtkWidget* menu, gpointer data) {
auto fn = reinterpret_cast<FnWrapper*>(data);
fn->Call();
delete fn;
static void _menu_activate_callback(GtkWidget* gtk_menu, gpointer data) {
GTKMenuItem* menu = reinterpret_cast<GTKMenuItem*>(data);
menu->Activate();
}
void GTKMenuItem::Activate() {
try {
callback_();
} catch (const std::bad_function_call& e) {
// Ignore
}
}
GTKMenuItem::GTKMenuItem(Type type, const std::string& text,
const std::string& hotkey,
std::function<void()> callback)
: MenuItem(type, text, hotkey, std::move(callback)) {
std::string label = text;
// TODO(dougvj) Would we ever need to escape underscores?
// Replace & with _ for gtk to see the memonic
std::replace(label.begin(), label.end(), '&', '_');
const gchar* gtk_label = reinterpret_cast<const gchar*>(label.c_str());
switch (type) {
case MenuItem::Type::kNormal:
default:
menu_ = gtk_menu_bar_new();
break;
case MenuItem::Type::kPopup:
menu_ = gtk_menu_item_new_with_label((gchar*)text.c_str());
menu_ = gtk_menu_item_new_with_mnemonic(gtk_label);
break;
case MenuItem::Type::kSeparator:
menu_ = gtk_separator_menu_item_new();
@ -403,12 +474,12 @@ GTKMenuItem::GTKMenuItem(Type type, const std::string& text,
if (!hotkey.empty()) {
full_name += "\t" + hotkey;
}
menu_ = gtk_menu_item_new_with_label((gchar*)full_name.c_str());
menu_ = gtk_menu_item_new_with_mnemonic(gtk_label);
break;
}
if (GTK_IS_MENU_ITEM(menu_))
g_signal_connect(menu_, "activate", G_CALLBACK(_menu_activate_callback),
(gpointer) new FnWrapper(callback));
(gpointer)this);
}
GTKMenuItem::~GTKMenuItem() {
@ -456,4 +527,5 @@ void GTKMenuItem::OnChildRemoved(MenuItem* generic_child_item) {
}
} // namespace ui
} // namespace xe

15
src/xenia/ui/window_gtk.h
View File

@ -15,6 +15,7 @@
#include <gdk/gdkx.h>
#include <gtk/gtk.h>
#include <xcb/xcb.h>
#include "xenia/base/platform_linux.h"
#include "xenia/ui/menu_item.h"
@ -31,9 +32,10 @@ class GTKWindow : public Window {
~GTKWindow() override;
NativePlatformHandle native_platform_handle() const override {
return nullptr;
return connection_;
}
NativeWindowHandle native_handle() const override { return window_; }
GtkWidget* native_window_handle() const { return drawing_area_; }
void EnableMainMenu() override {}
void DisableMainMenu() override {}
@ -74,14 +76,22 @@ class GTKWindow : public Window {
private:
void Create();
GtkWidget* window_;
GtkWidget* box_;
GtkWidget* drawing_area_;
xcb_connection_t* connection_;
// C Callback shims for GTK
friend gboolean gtk_event_handler(GtkWidget*, GdkEvent*, gpointer);
friend gboolean close_callback(GtkWidget*, gpointer);
friend gboolean draw_callback(GtkWidget*, GdkFrameClock*, gpointer);
friend void gtk_event_handler_(GtkWidget*, GdkEvent*, gpointer);
bool HandleMouse(GdkEventAny* event);
bool HandleKeyboard(GdkEventKey* event);
bool HandleWindowResize(GdkEventConfigure* event);
bool HandleWindowFocus(GdkEventFocus* event);
bool HandleWindowVisibility(GdkEventVisibility* event);
bool HandleWindowOwnerChange(GdkEventOwnerChange* event);
bool HandleWindowPaint();
bool closing_ = false;
bool fullscreen_ = false;
@ -95,6 +105,7 @@ class GTKMenuItem : public MenuItem {
GtkWidget* handle() { return menu_; }
using MenuItem::OnSelected;
void Activate();
void EnableMenuItem(Window& window) override {}
void DisableMenuItem(Window& window) override {}

1
src/xenia/ui/window_win.cc
View File

@ -447,6 +447,7 @@ void Win32Window::Close() {
closing_ = true;
OnClose();
DestroyWindow(hwnd_);
hwnd_ = nullptr;
}
void Win32Window::OnMainMenuChange() {