alex/rust_minifb
1
0
Fork 0
mirror of https://github.com/italicsjenga/rust_minifb.git synced 2024-12-23 19:31:30 +11:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'refs/remotes/origin/menu-api-rework'

Browse source
This commit is contained in:
Daniel Collin 2016-05-11 13:34:24 +02:00
parent a3b1a824e4 57906b26b8
commit 1dbcf2dee1
8 changed files with 684 additions and 588 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

70
examples/menu.rs
View file

@ -1,7 +1,7 @@
extern crate minifb; extern crate minifb;
use minifb::{Window, Key, Scale, WindowOptions, Menu}; use minifb::{Window, Key, Scale, WindowOptions, Menu};
use minifb::{MENU_KEY_CTRL, MENU_KEY_COMMAND}; use minifb::{MENU_KEY_CTRL};
const WIDTH: usize = 640; const WIDTH: usize = 640;
const HEIGHT: usize = 360; const HEIGHT: usize = 360;
@ -26,63 +26,23 @@ fn main() {
}) })
.expect("Unable to Open Window"); .expect("Unable to Open Window");
// Setup a sub menu let mut menu = Menu::new("Test").unwrap();
let mut sub = Menu::new("Select Color").unwrap();
let sub_menu = vec![ sub.add_item("Color 0", COLOR_0_ID).shortcut(Key::F1, 0).build();
Menu { sub.add_item("Color 1", COLOR_1_ID).shortcut(Key::F2, 0).build();
name: "Color 0", sub.add_item("Color 2", COLOR_2_ID).shortcut(Key::F7, 0).build();
key: Key::F1,
id: COLOR_0_ID,
..Menu::default()
},
Menu {
name: "Color 1",
key: Key::F2,
id: COLOR_1_ID,
..Menu::default()
},
Menu {
name: "Color 2",
key: Key::F12,
id: COLOR_2_ID,
..Menu::default()
},
];
// Main menu menu.add_item("Menu Test", MENU_TEST_ID).shortcut(Key::W, MENU_KEY_CTRL).build();
let menu = vec![ menu.add_separator();
Menu {
name: "Menu Test",
key: Key::W,
id: MENU_TEST_ID,
modifier: MENU_KEY_CTRL,
mac_mod: MENU_KEY_COMMAND,
..Menu::default()
},
Menu::separotor(),
Menu {
name: "Other menu!",
key: Key::S,
modifier: MENU_KEY_CTRL,
mac_mod: MENU_KEY_CTRL,
id: OTHER_MENU_ID,
..Menu::default()
},
Menu {
name: "Remove Menu",
key: Key::R,
id: CLOSE_MENU_ID,
..Menu::default()
},
Menu {
name: "Select Color",
sub_menu: Some(&sub_menu),
..Menu::default()
}
];
window.add_menu("Test", &menu).expect("Unable to add menu"); menu.add_item("Other Menu", OTHER_MENU_ID).shortcut(Key::W, MENU_KEY_CTRL).build();
menu.add_item("Remove Menu", CLOSE_MENU_ID).shortcut(Key::R, 0).build();
menu.add_sub_menu("Sub Test", &sub);
let menu_handle = window.add_menu(&menu);
let mut color_mul = 1; let mut color_mul = 1;
@ -106,7 +66,7 @@ fn main() {
} }
CLOSE_MENU_ID => { CLOSE_MENU_ID => {
println!("remove menu"); println!("remove menu");
window.remove_menu("Test").expect("Unable to remove menu"); window.remove_menu(menu_handle);
} }
_ => (), _ => (),
} }

2
src/key.rs
View file

@ -1,5 +1,5 @@
/// Key is used by the get key functions to check if some keys on the keyboard has been pressed /// Key is used by the get key functions to check if some keys on the keyboard has been pressed
#[derive(PartialEq, Clone, Copy)] #[derive(Debug, PartialEq, Clone, Copy)]
pub enum Key { pub enum Key {
Key0 = 0, Key0 = 0,
Key1 = 1, Key1 = 1,

163
src/lib.rs
View file

@ -75,13 +75,13 @@ pub mod os;
mod mouse_handler; mod mouse_handler;
mod key_handler; mod key_handler;
mod window_flags; mod window_flags;
mod menu; //mod menu;
pub use menu::Menu as Menu; //pub use menu::Menu as Menu;
pub use menu::MENU_KEY_COMMAND; //pub use menu::MENU_KEY_COMMAND;
pub use menu::MENU_KEY_WIN; //pub use menu::MENU_KEY_WIN;
pub use menu::MENU_KEY_SHIFT; //pub use menu::MENU_KEY_SHIFT;
pub use menu::MENU_KEY_CTRL; //pub use menu::MENU_KEY_CTRL;
pub use menu::MENU_KEY_ALT; //pub use menu::MENU_KEY_ALT;
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
@ -462,25 +462,28 @@ impl Window {
/// scope for this library to support. /// scope for this library to support.
/// ``` /// ```
/// ///
#[inline] #[inline]
pub fn add_menu(&mut self, menu_name: &str, menu: &Vec<Menu>) -> Result<()> { pub fn add_menu(&mut self, menu: &Menu) -> MenuHandle {
self.0.add_menu(menu_name, menu) self.0.add_menu(&menu.0)
} }
/// ///
/// Updates an existing menu created with [add_menu] /// Updates an existing menu created with [add_menu]
/// ///
/*
#[inline] #[inline]
pub fn update_menu(&mut self, menu_name: &str, menu: &Vec<Menu>) -> Result<()> { pub fn update_menu(&mut self, menu_name: &str, menu: &Vec<Menu>) -> Result<()> {
self.0.update_menu(menu_name, menu) self.0.update_menu(menu_name, menu)
} }
*/
/// ///
/// Remove a menu that has been added with [add_menu] /// Remove a menu that has been added with [add_menu]
/// ///
#[inline] #[inline]
pub fn remove_menu(&mut self, menu_name: &str) -> Result<()> { pub fn remove_menu(&mut self, handle: MenuHandle) {
self.0.remove_menu(menu_name) self.0.remove_menu(handle)
} }
/// ///
@ -492,6 +495,144 @@ impl Window {
} }
} }
/// Command key on Mac OS
pub const MENU_KEY_COMMAND: usize = 1;
/// Windows key on Windows
pub const MENU_KEY_WIN: usize = 2;
/// Shift key
pub const MENU_KEY_SHIFT: usize = 4;
/// Control key
pub const MENU_KEY_CTRL: usize = 8;
/// Alt key
pub const MENU_KEY_ALT: usize = 16;
const MENU_ID_SEPARATOR:usize = 0xffffffff;
pub struct Menu(imp::Menu);
#[derive(Copy, Clone)]
pub struct MenuItemHandle(pub u64);
#[derive(Copy, Clone, PartialEq)]
pub struct MenuHandle(pub u64);
impl Menu {
pub fn new(name: &str) -> Result<Menu> {
imp::Menu::new(name).map(Menu)
}
#[inline]
pub fn destroy_menu(&mut self) {
//self.0.destroy_menu()
}
#[inline]
pub fn add_sub_menu(&mut self, name: &str, menu: &Menu) {
self.0.add_sub_menu(name, &menu.0)
}
pub fn add_separator(&mut self) {
self.add_menu_item(&MenuItem { id: MENU_ID_SEPARATOR, ..MenuItem::default() });
}
#[inline]
pub fn add_menu_item(&mut self, item: &MenuItem) -> MenuItemHandle {
self.0.add_menu_item(item)
}
#[inline]
pub fn add_item(&mut self, name: &str, id: usize) -> MenuItem {
MenuItem {
id: id,
label: name.to_owned(),
menu: Some(self),
..MenuItem::default()
}
}
#[inline]
pub fn remove_item(&mut self, item: &MenuItemHandle) {
self.0.remove_item(item)
}
}
pub struct MenuItem<'a> {
pub id: usize,
pub label: String,
pub enabled: bool,
pub key: Key,
pub modifier: usize,
pub menu: Option<&'a mut Menu>,
}
impl<'a> Default for MenuItem<'a> {
fn default() -> Self {
MenuItem {
id: MENU_ID_SEPARATOR,
label: "".to_owned(),
enabled: true,
key: Key::Unknown,
modifier: 0,
menu: None,
}
}
}
impl<'a> Clone for MenuItem<'a> {
fn clone(&self) -> Self {
MenuItem {
id: self.id,
label: self.label.clone(),
enabled: self.enabled,
key: self.key,
modifier: self.modifier,
menu: None,
}
}
}
impl<'a> MenuItem<'a> {
pub fn new(name: &str, id: usize) -> MenuItem {
MenuItem {
id: id,
label: name.to_owned(),
..MenuItem::default()
}
}
#[inline]
pub fn shortcut(self, key: Key, modifier: usize) -> Self {
MenuItem {
key: key,
modifier: modifier,
.. self
}
}
#[inline]
pub fn separator(self) -> Self {
MenuItem {
id: MENU_ID_SEPARATOR,
.. self
}
}
#[inline]
pub fn enabled(self, enabled: bool) -> Self {
MenuItem {
enabled: enabled,
.. self
}
}
#[inline]
pub fn build(&mut self) -> MenuItemHandle {
let t = self.clone();
if let Some(ref mut menu) = self.menu {
menu.0.add_menu_item(&t)
} else {
MenuItemHandle(0)
}
}
}
// Impl for WindowOptions // Impl for WindowOptions
#[doc(hidden)] #[doc(hidden)]

78
src/menu.rs
View file

@ -1,3 +1,4 @@
/*
use Key; use Key;
/// Command key on Mac OS /// Command key on Mac OS
@ -13,47 +14,42 @@ pub const MENU_KEY_ALT: usize = 16;
const MENU_ID_SEPARATOR:usize = 0xffffffff; const MENU_ID_SEPARATOR:usize = 0xffffffff;
/// #[cfg(target_os = "macos")]
/// Used to hold the data for creating menus for the Application use self::os::macos as imp;
/// #[cfg(target_os = "windows")]
pub struct Menu<'a> { use self::os::windows as imp;
/// Name of the menu item #[cfg(any(target_os="linux",
pub name: &'a str, target_os="freebsd",
/// User-defined Id thot will be sent back to the application in [get_menu_event] target_os="dragonfly",
pub id: usize, target_os="netbsd",
/// Shortcut key for the menu item target_os="openbsd"))]
pub key: Key, use self::os::unix as imp;
/// Modifier on Windows for the menu
pub modifier: usize,
/// Modifier on Mac OS
pub mac_mod: usize,
/// Menu item should be enabled on grayed out
pub enabled: bool,
/// Sub-menu. Vector of a sub-menu, otherwise None if no sub-menu
pub sub_menu: Option<&'a Vec<Menu<'a>>>,
}
impl<'a> Menu<'a> { pub struct Menu(imp::Menu);
pub fn separotor() -> Menu<'a> {
Menu { impl Menu {
id: MENU_ID_SEPARATOR, pub fn new(name: &name) -> Result<Menu> {
.. Self::default() imp::Menu::new(name).map(Menu)
} }
#[inline]
pub fn destroy_menu(&mut self) {
self.0.destroy_menu()
}
#[inline]
pub fn add_sub_menu(&mut self, menu: &Menu) {
self.0.add_sub_menu(menu)
}
#[inline]
pub fn add_item(&mut self, item: &mut MenuItem) {
self.0.add_item(item)
}
#[inline]
pub fn remove_item(&mut self, item: &mut MenuItem) {
self.0.remove_item(item)
} }
} }
*/
impl<'a> Default for Menu<'a> {
fn default() -> Menu<'a> {
Menu {
name: "",
id: 0,
key: Key::Unknown,
modifier: 0,
mac_mod: 0,
enabled: true,
sub_menu: None,
}
}
}

237
src/native/macosx/MacMiniFB.m
View file

@ -1,7 +1,7 @@
#include "OSXWindow.h" #include "OSXWindow.h"
#include "OSXWindowFrameView.h" #include "OSXWindowFrameView.h"
#include <Cocoa/Cocoa.h> #include <Cocoa/Cocoa.h>
#include <Carbon/Carbon.h>
#include <unistd.h> #include <unistd.h>
static bool s_init = false; static bool s_init = false;
@ -240,7 +240,8 @@ static int update_events()
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static int generic_update(OSXWindow* win) { static int generic_update(OSXWindow* win)
{
int state = update_events(); int state = update_events();
if (win->shared_data) { if (win->shared_data) {
@ -383,54 +384,216 @@ int mfb_active_menu(void* window) {
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void mfb_add_menu(void* window, const char* name, void* m) static CFStringRef create_string_for_key(CGKeyCode keyCode)
{ {
OSXWindow* win = (OSXWindow*)window; TISInputSourceRef currentKeyboard = TISCopyCurrentKeyboardInputSource();
CFDataRef layoutData = TISGetInputSourceProperty(currentKeyboard, kTISPropertyUnicodeKeyLayoutData);
const char* n = strdup(name); if (!layoutData)
return 0;
NSString* ns_name = [NSString stringWithUTF8String: n]; const UCKeyboardLayout *keyboardLayout = (const UCKeyboardLayout *)CFDataGetBytePtr(layoutData);
NSMenu* main_menu = [NSApp mainMenu]; UInt32 keysDown = 0;
UniChar chars[4];
UniCharCount realLength;
NSMenuItem* windowMenuItem = [main_menu addItemWithTitle:@"" action:NULL keyEquivalent:@""]; UCKeyTranslate(keyboardLayout,
NSMenu* windowMenu = [[NSMenu alloc] initWithTitle:ns_name]; keyCode,
[NSApp setWindowsMenu:windowMenu]; kUCKeyActionDisplay,
[windowMenuItem setSubmenu:windowMenu]; 0,
LMGetKbdType(),
kUCKeyTranslateNoDeadKeysBit,
&keysDown,
sizeof(chars) / sizeof(chars[0]),
&realLength,
chars);
CFRelease(currentKeyboard);
MenuDesc* menu_desc = (MenuDesc*)m; return CFStringCreateWithCharacters(kCFAllocatorDefault, chars, 1);
[windowMenu setAutoenablesItems:NO];
build_submenu(windowMenu, menu_desc);
Menu* menu = &win->menu_data->menus[win->menu_data->menu_count++];
menu->name = n;
menu->menu = windowMenu;
menu->menu_item = windowMenuItem;
} }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void mfb_update_menu(void* window, const char* name, void* m) static NSString* convert_key_code_to_string(int key)
{ {
OSXWindow* win = (OSXWindow*)window; if (key < 128)
NSString* ns_name = [NSString stringWithUTF8String: name];
NSMenu* main_menu = [NSApp mainMenu];
int len = win->menu_data->menu_count;
for (int i = 0; i < len; ++i)
{ {
Menu* menu = &win->menu_data->menus[i]; NSString* charName = (NSString*)create_string_for_key(key);
if (!strcmp(menu->name, name)) { if (charName)
[menu->menu removeAllItems]; return charName;
build_submenu(menu->menu, (MenuDesc*)m);
return; return [NSString stringWithFormat:@"%c", (char)key];
}
} }
return [NSString stringWithFormat:@"%C", (uint16_t)key];
} }
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const uint32_t MENU_KEY_COMMAND = 1;
const uint32_t MENU_KEY_WIN = 2;
const uint32_t MENU_KEY_SHIFT= 4;
const uint32_t MENU_KEY_CTRL = 8;
const uint32_t MENU_KEY_ALT = 16;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static NSString* get_string_for_key(uint32_t t) {
unichar c = (unichar)t;
NSString* key = [NSString stringWithCharacters:&c length:1];
return key;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
uint64_t mfb_add_menu_item(
void* in_menu,
int32_t menu_id,
const char* item_name,
bool enabled,
uint32_t key,
uint32_t modfier)
{
NSMenu* menu = (NSMenu*)in_menu;
NSString* name = [NSString stringWithUTF8String: item_name];
if (menu_id == -1)
{
[menu addItem:[NSMenuItem separatorItem]];
}
else
{
NSString* key_string = 0;
int mask = 0;
NSMenuItem* newItem = [[NSMenuItem alloc] initWithTitle:name action:@selector(onMenuPress:) keyEquivalent:@""];
[newItem setTag:menu_id];
// This code may look a bit weird but is here for a reason:
//
// In order to make it easier to bulid cross-platform apps Ctrl is often used as
// default modifier on Windows/Nix* while it's Command on Mac. Now we when Ctrl
// is set we default to Command on Mac for that reason but if Command AND Ctrl is
// set we allow both Ctrl and Command to be used but then it's up to the developer
// to deal with diffrent shortcuts depending on OS.
//
if ((modfier & MENU_KEY_CTRL)) {
mask |= NSCommandKeyMask;
}
if ((modfier & MENU_KEY_CTRL) &&
(modfier & MENU_KEY_COMMAND)) {
mask |= NSControlKeyMask;
}
if (modfier & MENU_KEY_SHIFT) {
mask |= NSShiftKeyMask;
}
if (modfier & MENU_KEY_ALT) {
mask |= NSAlternateKeyMask;
}
switch (key) {
case 0x7a: { key_string = get_string_for_key(NSF1FunctionKey); break; } // F1
case 0x78: { key_string = get_string_for_key(NSF2FunctionKey); break; } // F2
case 0x63: { key_string = get_string_for_key(NSF3FunctionKey); break; } // F3
case 0x76: { key_string = get_string_for_key(NSF4FunctionKey); break; } // F4
case 0x60: { key_string = get_string_for_key(NSF5FunctionKey); break; } // F5
case 0x61: { key_string = get_string_for_key(NSF6FunctionKey); break; } // F6
case 0x62: { key_string = get_string_for_key(NSF7FunctionKey); break; } // F7
case 0x64: { key_string = get_string_for_key(NSF8FunctionKey); break; } // F8
case 0x65: { key_string = get_string_for_key(NSF9FunctionKey); break; } // F9
case 0x6d: { key_string = get_string_for_key(NSF10FunctionKey); break; } // F10
case 0x67: { key_string = get_string_for_key(NSF11FunctionKey); break; } // F11
case 0x6f: { key_string = get_string_for_key(NSF12FunctionKey); break; } // F12
case 0x7f: break;
default: {
key_string = convert_key_code_to_string(key);
}
}
if (key_string) {
[newItem setKeyEquivalentModifierMask: mask];
[newItem setKeyEquivalent:key_string];
}
if (enabled) {
[newItem setEnabled:YES];
} else {
[newItem setEnabled:NO];
}
[newItem setOnStateImage: newItem.offStateImage];
[menu addItem:newItem];
return (uint64_t)newItem;
}
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void mfb_add_sub_menu(void* parent_menu, const char* menu_name, void* attach_menu) {
NSMenu* parent = (NSMenu*)parent_menu;
NSMenu* attach = (NSMenu*)attach_menu;
NSString* name = [NSString stringWithUTF8String: menu_name];
NSMenuItem* newItem = [[NSMenuItem alloc] initWithTitle:name action:NULL keyEquivalent:@""];
[newItem setSubmenu:attach];
[parent addItem:newItem];
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void* mfb_create_menu(const char* name) {
NSString* ns_name = [NSString stringWithUTF8String: name];
NSMenu* menu = [[NSMenu alloc] initWithTitle:ns_name];
return (void*)menu;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void mfb_destroy_menu(void* menu_item, const char* name)
{
NSMenuItem* item = (NSMenuItem*)menu_item;
NSMenu* main_menu = [NSApp mainMenu];
[main_menu removeItem:item];
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void mfb_remove_menu_item(void* parent, uint64_t menu_item) {
NSMenu* menu = (NSMenu*)parent;
NSMenuItem* item = (NSMenuItem*)(uintptr_t)menu_item;
[menu removeItem:item];
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
uint64_t mfb_add_menu(void* window, void* m)
{
OSXWindow* win = (OSXWindow*)window;
NSMenu* menu = (NSMenu*)m;
NSMenu* main_menu = [NSApp mainMenu];
NSMenuItem* windowMenuItem = [main_menu addItemWithTitle:@"" action:NULL keyEquivalent:@""];
[NSApp setWindowsMenu:menu];
[windowMenuItem setSubmenu:menu];
return (uint64_t)menu;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void mfb_remove_menu_at(void* window, int index)
{
(void)window;
NSMenu* main_menu = [NSApp mainMenu];
[main_menu removeItemAtIndex:index];
}

162
src/native/macosx/OSXWindow.m
View file

@ -1,6 +1,5 @@
#import "OSXWindow.h" #import "OSXWindow.h"
#import "OSXWindowFrameView.h" #import "OSXWindowFrameView.h"
#include <Carbon/Carbon.h>
@implementation OSXWindow @implementation OSXWindow
@ -71,14 +70,6 @@
key_callback(rust_data, [event keyCode], 1); key_callback(rust_data, [event keyCode], 1);
} }
if (char_callback) {
NSString* characters = [event characters];
NSUInteger i, length = [characters length];
for (i = 0; i < length; i++)
char_callback(rust_data, [characters characterAtIndex:i]);
}
[super keyDown:event]; [super keyDown:event];
} }
@ -216,154 +207,7 @@
self->active_menu_id = menu_id; self->active_menu_id = menu_id;
} }
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static CFStringRef create_string_for_key(CGKeyCode keyCode)
{
TISInputSourceRef currentKeyboard = TISCopyCurrentKeyboardInputSource();
CFDataRef layoutData = TISGetInputSourceProperty(currentKeyboard, kTISPropertyUnicodeKeyLayoutData);
if (!layoutData)
return 0;
const UCKeyboardLayout *keyboardLayout = (const UCKeyboardLayout *)CFDataGetBytePtr(layoutData);
UInt32 keysDown = 0;
UniChar chars[4];
UniCharCount realLength;
UCKeyTranslate(keyboardLayout,
keyCode,
kUCKeyActionDisplay,
0,
LMGetKbdType(),
kUCKeyTranslateNoDeadKeysBit,
&keysDown,
sizeof(chars) / sizeof(chars[0]),
&realLength,
chars);
CFRelease(currentKeyboard);
return CFStringCreateWithCharacters(kCFAllocatorDefault, chars, 1);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static NSString* convert_key_code_to_string(int key)
{
if (key < 128)
{
NSString* charName = (NSString*)create_string_for_key(key);
if (charName)
return charName;
return [NSString stringWithFormat:@"%c", (char)key];
}
return [NSString stringWithFormat:@"%C", (uint16_t)key];
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const uint32_t MENU_KEY_COMMAND = 1;
const uint32_t MENU_KEY_WIN = 2;
const uint32_t MENU_KEY_SHIFT= 4;
const uint32_t MENU_KEY_CTRL = 8;
const uint32_t MENU_KEY_ALT = 16;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static NSString* get_string_for_key(uint32_t t) {
unichar c = (unichar)t;
NSString* key = [NSString stringWithCharacters:&c length:1];
return key;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void build_submenu(NSMenu* menu, MenuDesc* desc)
{
[menu removeAllItems];
while (desc->menu_id != -2)
{
NSString* name = [NSString stringWithUTF8String: desc->name];
if (desc->menu_id == -1)
{
[menu addItem:[NSMenuItem separatorItem]];
}
else if (desc->sub_menu)
{
NSMenuItem* newItem = [[NSMenuItem alloc] initWithTitle:name action:NULL keyEquivalent:@""];
NSMenu* newMenu = [[NSMenu alloc] initWithTitle:name];
[newItem setSubmenu:newMenu];
build_submenu(newMenu, desc->sub_menu);
[newMenu release];
[menu addItem:newItem];
[newItem release];
}
else
{
int mask = 0;
NSString* key = 0;
NSMenuItem* newItem = [[NSMenuItem alloc] initWithTitle:name action:@selector(onMenuPress:) keyEquivalent:@""];
[newItem setTag:desc->menu_id];
if (desc->modifier_mac & MENU_KEY_COMMAND) {
mask |= NSCommandKeyMask;
}
if (desc->modifier_mac & MENU_KEY_SHIFT) {
mask |= NSShiftKeyMask;
}
if (desc->modifier_mac & MENU_KEY_CTRL) {
mask |= NSControlKeyMask;
}
if (desc->modifier_mac & MENU_KEY_ALT) {
mask |= NSAlternateKeyMask;
}
switch (desc->key) {
case 0x7a: { key = get_string_for_key(NSF1FunctionKey); break; } // F1
case 0x78: { key = get_string_for_key(NSF2FunctionKey); break; } // F2
case 0x63: { key = get_string_for_key(NSF3FunctionKey); break; } // F3
case 0x76: { key = get_string_for_key(NSF4FunctionKey); break; } // F4
case 0x60: { key = get_string_for_key(NSF5FunctionKey); break; } // F5
case 0x61: { key = get_string_for_key(NSF6FunctionKey); break; } // F6
case 0x62: { key = get_string_for_key(NSF7FunctionKey); break; } // F7
case 0x64: { key = get_string_for_key(NSF8FunctionKey); break; } // F8
case 0x65: { key = get_string_for_key(NSF9FunctionKey); break; } // F9
case 0x6d: { key = get_string_for_key(NSF10FunctionKey); break; } // F10
case 0x67: { key = get_string_for_key(NSF11FunctionKey); break; } // F11
case 0x6f: { key = get_string_for_key(NSF12FunctionKey); break; } // F12
case 0x7f: break;
default: {
key = convert_key_code_to_string(desc->key);
}
}
if (key) {
[newItem setKeyEquivalentModifierMask: mask];
[newItem setKeyEquivalent:key];
}
if (desc->enabled) {
[newItem setEnabled:YES];
} else {
[newItem setEnabled:NO];
}
[newItem setOnStateImage: newItem.offStateImage];
[menu addItem:newItem];
[newItem release];
}
desc++;
}
}
@end @end

230
src/os/macos/mod.rs
View file

@ -4,13 +4,15 @@ use {MouseButton, MouseMode, Scale, Key, KeyRepeat, WindowOptions};
use key_handler::KeyHandler; use key_handler::KeyHandler;
use error::Error; use error::Error;
use Result; use Result;
// use MenuItem;
use InputCallback; use InputCallback;
use mouse_handler; use mouse_handler;
use window_flags; use window_flags;
use menu::Menu; use {MenuItem, MenuItemHandle, MenuHandle};
// use menu::Menu;
use libc::{c_void, c_char, c_uchar}; use libc::{c_void, c_char, c_uchar};
use std::ffi::{CString}; use std::ffi::CString;
use std::ptr; use std::ptr;
use std::mem; use std::mem;
use std::os::raw; use std::os::raw;
@ -148,40 +150,42 @@ static KEY_MAPPINGS: [Key; 128] = [
/* 7f */ Key::Unknown, /* 7f */ Key::Unknown,
]; ];
const STRING_SIZE: usize = 512;
#[repr(C)]
struct CMenu {
name: [i8; STRING_SIZE],
sub_menu: *mut raw::c_void,
id: raw::c_int,
key: raw::c_int,
special_key: raw::c_int,
modifier: raw::c_int,
mac_mod: raw::c_int,
enabled: raw::c_int,
}
#[link(name = "Cocoa", kind = "framework")] #[link(name = "Cocoa", kind = "framework")]
#[link(name = "Carbon", kind = "framework")] #[link(name = "Carbon", kind = "framework")]
extern { extern "C" {
fn mfb_open(name: *const c_char, width: u32, height: u32, flags: u32, scale: i32) -> *mut c_void; fn mfb_open(name: *const c_char,
width: u32,
height: u32,
flags: u32,
scale: i32)
-> *mut c_void;
fn mfb_close(window: *mut c_void); fn mfb_close(window: *mut c_void);
fn mfb_update(window: *mut c_void); fn mfb_update(window: *mut c_void);
fn mfb_update_with_buffer(window: *mut c_void, buffer: *const c_uchar); fn mfb_update_with_buffer(window: *mut c_void, buffer: *const c_uchar);
fn mfb_set_position(window: *mut c_void, x: i32, y: i32); fn mfb_set_position(window: *mut c_void, x: i32, y: i32);
fn mfb_set_key_callback(window: *mut c_void, target: *mut c_void, fn mfb_set_key_callback(window: *mut c_void,
cb: unsafe extern fn(*mut c_void, i32, i32), target: *mut c_void,
cb: unsafe extern fn(*mut c_void, u32)); cb: unsafe extern "C" fn(*mut c_void, i32, i32),
cb: unsafe extern "C" fn(*mut c_void, u32));
fn mfb_set_mouse_data(window_handle: *mut c_void, shared_data: *mut SharedData); fn mfb_set_mouse_data(window_handle: *mut c_void, shared_data: *mut SharedData);
fn mfb_should_close(window: *mut c_void) -> i32; fn mfb_should_close(window: *mut c_void) -> i32;
fn mfb_get_screen_size() -> u32; fn mfb_get_screen_size() -> u32;
fn mfb_is_active(window: *mut c_void) -> u32; fn mfb_is_active(window: *mut c_void) -> u32;
fn mfb_add_menu(window: *mut c_void, name: *const c_char, menu: *mut c_void); fn mfb_add_menu(window: *mut c_void, menu: *mut c_void) -> u64;
fn mfb_remove_menu(window: *mut c_void, name: *const c_char); fn mfb_add_sub_menu(parent_menu: *mut c_void, name: *const c_char, menu: *mut c_void);
fn mfb_update_menu(window: *mut c_void, name: *const c_char, menu: *mut c_void);
fn mfb_active_menu(window: *mut c_void) -> i32; fn mfb_active_menu(window: *mut c_void) -> i32;
fn mfb_create_menu(name: *const c_char) -> *mut c_void;
fn mfb_remove_menu_at(window: *mut c_void, index: i32);
fn mfb_add_menu_item(menu_item: *mut c_void,
menu_id: i32,
name: *const c_char,
enabled: bool,
key: u32,
modifier: u32)
-> u64;
fn mfb_remove_menu_item(menu: *mut c_void, item_handle: u64);
} }
#[derive(Default)] #[derive(Default)]
@ -202,6 +206,7 @@ pub struct Window {
pub shared_data: SharedData, pub shared_data: SharedData,
key_handler: KeyHandler, key_handler: KeyHandler,
pub has_set_data: bool, pub has_set_data: bool,
menus: Vec<MenuHandle>,
} }
unsafe extern "C" fn key_callback(window: *mut c_void, key: i32, state: i32) { unsafe extern "C" fn key_callback(window: *mut c_void, key: i32, state: i32) {
@ -241,7 +246,11 @@ impl Window {
unsafe { unsafe {
let scale_factor = Self::get_scale_factor(width, height, opts.scale) as usize; let scale_factor = Self::get_scale_factor(width, height, opts.scale) as usize;
let handle = mfb_open(n.as_ptr(), width as u32, height as u32, window_flags::get_flags(opts), scale_factor as i32); let handle = mfb_open(n.as_ptr(),
width as u32,
height as u32,
window_flags::get_flags(opts),
scale_factor as i32);
if handle == ptr::null_mut() { if handle == ptr::null_mut() {
return Err(Error::WindowCreate("Unable to open Window".to_owned())); return Err(Error::WindowCreate("Unable to open Window".to_owned()));
@ -253,10 +262,11 @@ impl Window {
shared_data: SharedData { shared_data: SharedData {
width: width as u32 * scale_factor as u32, width: width as u32 * scale_factor as u32,
height: height as u32 * scale_factor as u32, height: height as u32 * scale_factor as u32,
.. SharedData::default() ..SharedData::default()
}, },
key_handler: KeyHandler::new(), key_handler: KeyHandler::new(),
has_set_data: false, has_set_data: false,
menus: Vec::new(),
}) })
} }
} }
@ -277,7 +287,10 @@ impl Window {
unsafe { unsafe {
mfb_update_with_buffer(self.window_handle, buffer.as_ptr() as *const u8); mfb_update_with_buffer(self.window_handle, buffer.as_ptr() as *const u8);
Self::set_mouse_data(self); Self::set_mouse_data(self);
mfb_set_key_callback(self.window_handle, mem::transmute(self), key_callback, char_callback); mfb_set_key_callback(self.window_handle,
mem::transmute(self),
key_callback,
char_callback);
} }
} }
@ -287,7 +300,10 @@ impl Window {
unsafe { unsafe {
mfb_update(self.window_handle); mfb_update(self.window_handle);
Self::set_mouse_data(self); Self::set_mouse_data(self);
mfb_set_key_callback(self.window_handle, mem::transmute(self), key_callback, char_callback); mfb_set_key_callback(self.window_handle,
mem::transmute(self),
key_callback,
char_callback);
} }
} }
@ -297,7 +313,8 @@ impl Window {
} }
pub fn get_size(&self) -> (usize, usize) { pub fn get_size(&self) -> (usize, usize) {
(self.shared_data.width as usize, self.shared_data.height as usize) (self.shared_data.width as usize,
self.shared_data.height as usize)
} }
pub fn get_scroll_wheel(&self) -> Option<(f32, f32)> { pub fn get_scroll_wheel(&self) -> Option<(f32, f32)> {
@ -324,7 +341,12 @@ impl Window {
let w = self.shared_data.width as f32; let w = self.shared_data.width as f32;
let h = self.shared_data.height as f32; let h = self.shared_data.height as f32;
mouse_handler::get_pos(mode, self.shared_data.mouse_x, self.shared_data.mouse_y, s, w, h) mouse_handler::get_pos(mode,
self.shared_data.mouse_x,
self.shared_data.mouse_y,
s,
w,
h)
} }
#[inline] #[inline]
@ -358,7 +380,7 @@ impl Window {
} }
#[inline] #[inline]
pub fn set_input_callback(&mut self, callback: Box<InputCallback>) { pub fn set_input_callback(&mut self, callback: Box<InputCallback>) {
self.key_handler.set_input_callback(callback) self.key_handler.set_input_callback(callback)
} }
@ -372,40 +394,25 @@ impl Window {
} }
} }
pub fn add_menu(&mut self, name: &str, menu: &Vec<Menu>) -> Result<()> { pub fn add_menu(&mut self, menu: &Menu) -> MenuHandle {
let mut build_menu = Vec::<Vec<CMenu>>::new();
unsafe { unsafe {
Self::recursive_convert(&mut build_menu, &Some(menu)); let handle = MenuHandle(mfb_add_menu(self.window_handle, menu.menu_handle));
let menu_len = build_menu.len(); self.menus.push(handle);
mfb_add_menu(self.window_handle, handle
CString::new(name).unwrap().as_ptr(),
build_menu[menu_len - 1].as_mut_ptr() as *mut c_void);
} }
Ok(())
} }
pub fn update_menu(&mut self, name: &str, menu: &Vec<Menu>) -> Result<()> { pub fn remove_menu(&mut self, handle: MenuHandle) {
let mut build_menu = Vec::<Vec<CMenu>>::new(); for i in 0..self.menus.len() {
if self.menus[i] == handle {
unsafe { self.menus.remove(i);
Self::recursive_convert(&mut build_menu, &Some(menu)); unsafe {
let menu_len = build_menu.len(); // + 1 here as we always have a default menu we shouldn't remove
mfb_update_menu(self.window_handle, mfb_remove_menu_at(self.window_handle, (i + 1) as i32);
CString::new(name).unwrap().as_ptr(), }
build_menu[menu_len - 1].as_mut_ptr() as *mut c_void); return;
}
} }
Ok(())
}
pub fn remove_menu(&mut self, name: &str) -> Result<()> {
unsafe {
mfb_remove_menu(self.window_handle, CString::new(name).unwrap().as_ptr());
}
Ok(())
} }
#[inline] #[inline]
@ -450,8 +457,21 @@ impl Window {
return factor; return factor;
} }
}
unsafe fn map_key_to_menu_key(key: Key) -> i32 { pub struct Menu {
menu_handle: *mut c_void,
}
impl Menu {
pub fn new(name: &str) -> Result<Menu> {
unsafe {
let menu_name = CString::new(name).unwrap();
Ok(Menu { menu_handle: mfb_create_menu(menu_name.as_ptr()) })
}
}
unsafe fn map_key_to_menu_key(key: Key) -> u32 {
match key { match key {
Key::A => 0x00, Key::A => 0x00,
Key::S => 0x01, Key::S => 0x01,
@ -500,10 +520,10 @@ impl Window {
Key::N => 0x2d, Key::N => 0x2d,
Key::M => 0x2e, Key::M => 0x2e,
Key::Period => 0x2f, Key::Period => 0x2f,
//Key::Tab => 0x30, // Key::Tab => 0x30,
Key::Space => 0x31, Key::Space => 0x31,
//Key::Backspace => 0x33, // Key::Backspace => 0x33,
//Key::Escape => 0x35, // Key::Escape => 0x35,
Key::RightSuper => 0x36, Key::RightSuper => 0x36,
Key::LeftSuper => 0x37, Key::LeftSuper => 0x37,
Key::LeftShift => 0x38, Key::LeftShift => 0x38,
@ -513,7 +533,7 @@ impl Window {
Key::RightShift => 0x3c, Key::RightShift => 0x3c,
Key::RightAlt => 0x3d, Key::RightAlt => 0x3d,
Key::RightCtrl => 0x3e, Key::RightCtrl => 0x3e,
//Key::Equal => 0x51, // Key::Equal => 0x51,
Key::NumPad0 => 0x52, Key::NumPad0 => 0x52,
Key::NumPad1 => 0x53, Key::NumPad1 => 0x53,
Key::NumPad2 => 0x54, Key::NumPad2 => 0x54,
@ -537,23 +557,23 @@ impl Window {
Key::F15 => 0x71, Key::F15 => 0x71,
Key::Insert => 0x72, /* Really Help... */ Key::Insert => 0x72, /* Really Help... */
Key::Home => 0x73, Key::Home => 0x73,
//Key::PageUp => 0x74, // Key::PageUp => 0x74,
Key::Delete => 0x75, Key::Delete => 0x75,
Key::F4 => 0x76, Key::F4 => 0x76,
Key::End => 0x77, Key::End => 0x77,
Key::F2 => 0x78, Key::F2 => 0x78,
//Key::PageDown => 0x79, // Key::PageDown => 0x79,
Key::F1 => 0x7a, Key::F1 => 0x7a,
//Key::Left => 0x7b, // Key::Left => 0x7b,
//Key::Right => 0x7c, // Key::Right => 0x7c,
//Key::Down => 0x7d, // Key::Down => 0x7d,
//Key::Up => 0x7e, // Key::Up => 0x7e,
Key::Left => 0x2190, Key::Left => 0x2190,
Key::Up => 0x2191, Key::Up => 0x2191,
Key::Down => 0x2193, Key::Down => 0x2193,
Key::Right => 0x2192, Key::Right => 0x2192,
Key::Escape => 0x238b, Key::Escape => 0x238b,
//Key::Enter => 0x000d, // Key::Enter => 0x000d,
Key::Backspace => 0x232b, Key::Backspace => 0x232b,
Key::Tab => 0x21e4, Key::Tab => 0x21e4,
Key::PageUp => 0x21de, Key::PageUp => 0x21de,
@ -562,55 +582,31 @@ impl Window {
} }
} }
unsafe fn recursive_convert(menu_build_vec: &mut Vec<Vec<CMenu>>, in_menu: &Option<&Vec<Menu>>) -> *mut raw::c_void { pub fn add_sub_menu(&mut self, name: &str, sub_menu: &Menu) {
if in_menu.is_none() { unsafe {
return ptr::null_mut(); let menu_name = CString::new(name).unwrap();
mfb_add_sub_menu(self.menu_handle, menu_name.as_ptr(), sub_menu.menu_handle)
} }
}
let mut menu_build = Vec::<CMenu>::new(); pub fn add_menu_item(&mut self, item: &MenuItem) -> MenuItemHandle {
let menu_vec = in_menu.as_ref().unwrap(); unsafe {
let item_name = CString::new(item.label.as_str()).unwrap();
let conv_key = Self::map_key_to_menu_key(item.key);
for m in menu_vec.iter() { MenuItemHandle(mfb_add_menu_item(self.menu_handle,
let key_map = Self::map_key_to_menu_key(m.key); item.id as i32,
item_name.as_ptr(),
let mut menu = CMenu { item.enabled,
name: mem::uninitialized(), conv_key,
id: m.id as raw::c_int, item.modifier))
key: key_map as raw::c_int,
special_key: 0,
modifier: m.modifier as raw::c_int,
mac_mod: m.mac_mod as raw::c_int,
enabled: m.enabled as raw::c_int,
sub_menu : Self::recursive_convert(menu_build_vec, &m.sub_menu),
};
let name = CString::new(m.name).unwrap();
let name_len = m.name.len();
ptr::copy_nonoverlapping(name.as_ptr(),
menu.name.as_mut_ptr() as *mut i8,
name_len);
menu.name[name_len] = 0;
menu_build.push(menu);
} }
}
// end marker pub fn remove_item(&mut self, handle: &MenuItemHandle) {
unsafe {
menu_build.push(CMenu { mfb_remove_menu_item(self.menu_handle, handle.0);
name: [0; STRING_SIZE], }
id: -2,
key: 0,
special_key: 0,
modifier: 0,
mac_mod: 0,
enabled: 0,
sub_menu : ptr::null_mut(),
});
let ptr = menu_build.as_mut_ptr() as *mut raw::c_void ;
menu_build_vec.push(menu_build);
ptr
} }
} }

330
src/os/windows/mod.rs
View file

@ -10,10 +10,10 @@ const INVALID_ACCEL: usize = 0xffffffff;
use {Scale, Key, KeyRepeat, MouseButton, MouseMode, WindowOptions, InputCallback}; use {Scale, Key, KeyRepeat, MouseButton, MouseMode, WindowOptions, InputCallback};
use key_handler::KeyHandler; use key_handler::KeyHandler;
use menu::Menu;
use error::Error; use error::Error;
use Result; use Result;
use menu::{MENU_KEY_WIN, MENU_KEY_SHIFT, MENU_KEY_CTRL, MENU_KEY_ALT}; use {MenuItem, MenuItemHandle, MenuHandle};
use {MENU_KEY_WIN, MENU_KEY_SHIFT, MENU_KEY_CTRL, MENU_KEY_ALT};
use std::ptr; use std::ptr;
use std::os::windows::ffi::OsStrExt; use std::os::windows::ffi::OsStrExt;
@ -298,8 +298,7 @@ pub enum MinifbError {
} }
fn to_wstring(str: &str) -> Vec<u16> { fn to_wstring(str: &str) -> Vec<u16> {
let mut v: Vec<u16> = OsStr::new(str).encode_wide().chain(Some(0).into_iter()).collect(); let v: Vec<u16> = OsStr::new(str).encode_wide().chain(Some(0).into_iter()).collect();
v.push(0u16);
v v
} }
@ -311,11 +310,13 @@ struct MouseData {
pub scroll: f32, pub scroll: f32,
} }
/*
struct MenuStore { struct MenuStore {
name: String, name: String,
menu: HMENU, menu: HMENU,
accel_items: Vec<ACCEL>, accel_items: Vec<ACCEL>,
} }
*/
pub struct Window { pub struct Window {
mouse: MouseData, mouse: MouseData,
@ -326,7 +327,7 @@ pub struct Window {
scale_factor: i32, scale_factor: i32,
width: i32, width: i32,
height: i32, height: i32,
menus: Vec<MenuStore>, menus: Vec<Menu>,
key_handler: KeyHandler, key_handler: KeyHandler,
accel_table: HACCEL, accel_table: HACCEL,
accel_key: usize, accel_key: usize,
@ -338,6 +339,7 @@ pub struct Window {
#[allow(non_snake_case)] #[allow(non_snake_case)]
extern "system" { extern "system" {
fn TranslateAcceleratorW(hWnd: HWND, accel: *const ACCEL, pmsg: *const MSG) -> INT; fn TranslateAcceleratorW(hWnd: HWND, accel: *const ACCEL, pmsg: *const MSG) -> INT;
fn RemoveMenu(menu: HMENU, pos: UINT, flags: UINT) -> BOOL;
} }
impl Window { impl Window {
@ -635,6 +637,120 @@ impl Window {
return factor; return factor;
} }
//
// When attaching a menu to the window we need to resize it so
// the current client size is preserved and still show all pixels
//
unsafe fn adjust_window_size_for_menu(handle: HWND) {
let mut rect: winapi::RECT = mem::uninitialized();
let menu_height = user32::GetSystemMetrics(winapi::winuser::SM_CYMENU);
user32::GetWindowRect(handle, &mut rect);
user32::MoveWindow(handle,
rect.left,
rect.top,
rect.right - rect.left,
(rect.bottom - rect.top) + menu_height,
1);
}
unsafe fn set_accel_table(&mut self) {
let mut temp_accel_table = Vec::<ACCEL>::new();
for menu in self.menus.iter() {
for item in menu.accel_table.iter() {
println!("virt {} - cmd {} - key {}", item.fVirt, item.cmd, item.key);
temp_accel_table.push(item.clone());
}
}
if self.accel_table != ptr::null_mut() {
user32::DestroyAcceleratorTable(self.accel_table);
}
self.accel_table = user32::CreateAcceleratorTableW(temp_accel_table.as_mut_ptr(),
temp_accel_table.len() as i32);
println!("accel {:?}", self.accel_table);
}
pub fn add_menu(&mut self, menu: &Menu) -> MenuHandle {
unsafe {
let window = self.window.unwrap();
let mut main_menu = user32::GetMenu(window);
if main_menu == ptr::null_mut() {
main_menu = user32::CreateMenu();
user32::SetMenu(window, main_menu);
Self::adjust_window_size_for_menu(window);
}
user32::AppendMenuW(main_menu,
0x10,
menu.menu_handle as UINT_PTR,
menu.name.as_ptr());
self.menus.push(menu.clone());
// TODO: Setup accel table
//Self::add_menu_store(self, main_menu, menu_name, menu);
self.set_accel_table();
user32::DrawMenuBar(window);
}
// TODO: Proper handle
MenuHandle(menu.menu_handle as u64)
}
pub fn remove_menu(&mut self, handle: MenuHandle) {
let window = self.window.unwrap();
let main_menu = unsafe { user32::GetMenu(window) };
for i in 0..self.menus.len() {
if self.menus[i].menu_handle == handle.0 as HMENU {
unsafe {
println!("Removed menu at {}", i);
let _t = RemoveMenu(main_menu, i as UINT, 0);
user32::DrawMenuBar(self.window.unwrap());
}
self.menus.swap_remove(i);
return;
}
}
}
pub fn is_menu_pressed(&mut self) -> Option<usize> {
if self.accel_key == INVALID_ACCEL {
None
} else {
let t = self.accel_key;
self.accel_key = INVALID_ACCEL;
Some(t)
}
}
}
#[derive(Clone)]
pub struct Menu {
menu_handle: HMENU,
name: Vec<u16>,
accel_table: Vec<ACCEL>,
}
impl Menu {
pub fn new(name: &str) -> Result<Menu> {
unsafe {
Ok(Menu {
menu_handle: user32::CreatePopupMenu(),
name: to_wstring(name),
accel_table: Vec::new(),
})
}
}
fn map_key_to_vk_accel(key: Key) -> (raw::c_int, &'static str) { fn map_key_to_vk_accel(key: Key) -> (raw::c_int, &'static str) {
match key { match key {
Key::Key0 => (0x30, "0"), Key::Key0 => (0x30, "0"),
@ -748,27 +864,20 @@ impl Window {
} }
} }
pub fn add_sub_menu(&mut self, name: &str, menu: &Menu) {
// unsafe {
// When attaching a menu to the window we need to resize it so let menu_name = to_wstring(name);
// the current client size is preserved and still show all pixels user32::AppendMenuW(self.menu_handle,
// 0x10,
unsafe fn adjust_window_size_for_menu(handle: HWND) { menu.menu_handle as UINT_PTR,
let mut rect: winapi::RECT = mem::uninitialized(); menu_name.as_ptr());
self.accel_table.extend_from_slice(menu.accel_table.as_slice());
let menu_height = user32::GetSystemMetrics(winapi::winuser::SM_CYMENU); }
user32::GetWindowRect(handle, &mut rect);
user32::MoveWindow(handle,
rect.left,
rect.top,
rect.right - rect.left,
(rect.bottom - rect.top) + menu_height,
1);
} }
fn format_name(menu_item: &Menu, key_name: &'static str) -> String {
let mut name = menu_item.name.to_owned(); fn format_name(menu_item: &MenuItem, key_name: &'static str) -> String {
let mut name = menu_item.label.clone();
name.push_str("\t"); name.push_str("\t");
@ -793,16 +902,20 @@ impl Window {
name name
} }
fn is_key_virtual_range(key: raw::c_int) -> u32 { fn is_key_virtual_range(_key: raw::c_int) -> u32 {
/*
if (key >= 0x30 && key <= 0x30) || if (key >= 0x30 && key <= 0x30) ||
(key >= 0x41 && key <= 0x5a) { (key >= 0x41 && key <= 0x5a) {
1
} else {
0 0
} else {
1
} }
*/
1
} }
fn get_virt_key(menu_item: &Menu, key: raw::c_int) -> u32 { fn get_virt_key(menu_item: &MenuItem, key: raw::c_int) -> u32 {
let mut virt = Self::is_key_virtual_range(key); let mut virt = Self::is_key_virtual_range(key);
if (menu_item.modifier & MENU_KEY_ALT) == MENU_KEY_ALT { if (menu_item.modifier & MENU_KEY_ALT) == MENU_KEY_ALT {
@ -820,165 +933,48 @@ impl Window {
virt virt
} }
fn add_accel(accel_table: &mut Vec<ACCEL>, menu_item: &Menu) { fn add_accel(&mut self, vk: raw::c_int, menu_item: &MenuItem) {
let vk_accel = Self::map_key_to_vk_accel(menu_item.key); let vk_accel = Self::map_key_to_vk_accel(menu_item.key);
let virt = Self::get_virt_key(menu_item, vk_accel.0); let virt = Self::get_virt_key(menu_item, vk);
let accel = winuser::ACCEL { let accel = winuser::ACCEL {
fVirt: virt as BYTE, fVirt: virt as BYTE,
cmd: menu_item.id as WORD, cmd: menu_item.id as WORD,
key: vk_accel.0 as WORD }; key: vk_accel.0 as WORD };
accel_table.push(accel); self.accel_table.push(accel);
} }
unsafe fn add_menu_item(&mut self, parent_menu: HMENU, menu_item: &Menu) { pub fn add_menu_item(&mut self, menu_item: &MenuItem) -> MenuItemHandle {
let item_name = to_wstring(menu_item.name);
let vk_accel = Self::map_key_to_vk_accel(menu_item.key); let vk_accel = Self::map_key_to_vk_accel(menu_item.key);
match vk_accel.0 {
0 => {
user32::AppendMenuW(parent_menu, 0x10, menu_item.id as UINT_PTR, item_name.as_ptr());
},
_ => {
let menu_name = Self::format_name(menu_item, vk_accel.1);
let w_name = to_wstring(&menu_name);
user32::AppendMenuW(parent_menu, 0x10, menu_item.id as UINT_PTR, w_name.as_ptr());
}
}
}
unsafe fn set_accel_table(&mut self) {
let mut temp_accel_table = Vec::<ACCEL>::new();
for menu in self.menus.iter() {
for item in menu.accel_items.iter() {
println!("virt {} - cmd {} - key {}", item.fVirt, item.cmd, item.key);
temp_accel_table.push(item.clone());
}
}
if self.accel_table != ptr::null_mut() {
user32::DestroyAcceleratorTable(self.accel_table);
}
self.accel_table = user32::CreateAcceleratorTableW(temp_accel_table.as_mut_ptr(),
temp_accel_table.len() as i32);
}
unsafe fn recursive_add_menu(&mut self, parent_menu: HMENU, name: &str, menu: &Vec<Menu>) -> HMENU {
let menu_name = to_wstring(name);
let popup_menu = user32::CreatePopupMenu();
user32::AppendMenuW(parent_menu, 0x10, popup_menu as UINT_PTR, menu_name.as_ptr());
for m in menu.iter() {
if let Some(ref sub_menu) = m.sub_menu {
Self::recursive_add_menu(self, popup_menu, m.name, sub_menu);
} else {
if m.id == 0xffffffff {
user32::AppendMenuW(popup_menu, 0x800, 0, ptr::null()); // separator
} else {
Self::add_menu_item(self, popup_menu, m);
}
}
}
popup_menu
}
pub fn menu_exists(&mut self, menu_name: &str) -> bool {
for menu in self.menus.iter() {
if menu.name == menu_name {
return true;
}
}
false
}
fn clone_menu(accel_dest: &mut Vec<ACCEL>, menu: &Vec<Menu>) {
for m in menu.iter() {
if let Some(ref sub_menu) = m.sub_menu {
Self::clone_menu(accel_dest, sub_menu);
}
if m.key != Key::Unknown {
Self::add_accel(accel_dest, m);
}
}
}
unsafe fn add_menu_store(&mut self, parent_menu: HMENU, menu_name: &str, menu: &Vec<Menu>) {
let mut items = Vec::<ACCEL>::new();
let menu_handle = Self::recursive_add_menu(self, parent_menu, menu_name, menu);
Self::clone_menu(&mut items, menu);
self.menus.push(MenuStore {
name: menu_name.to_owned(),
menu: menu_handle,
accel_items: items
});
}
pub fn add_menu(&mut self, menu_name: &str, menu: &Vec<Menu>) -> Result<()> {
if Self::menu_exists(self, menu_name) {
return Err(Error::MenuExists(menu_name.to_owned()));
}
unsafe { unsafe {
let window = self.window.unwrap(); match vk_accel.0 {
let mut main_menu = user32::GetMenu(window); 0 => {
let item_name = to_wstring(&menu_item.label);
if main_menu == ptr::null_mut() { user32::AppendMenuW(self.menu_handle, 0x10, menu_item.id as UINT_PTR, item_name.as_ptr());
main_menu = user32::CreateMenu(); },
user32::SetMenu(window, main_menu); _ => {
Self::adjust_window_size_for_menu(window); let menu_name = Self::format_name(menu_item, vk_accel.1);
} let w_name = to_wstring(&menu_name);
user32::AppendMenuW(self.menu_handle, 0x10, menu_item.id as UINT_PTR, w_name.as_ptr());
Self::add_menu_store(self, main_menu, menu_name, menu); self.add_accel(vk_accel.0, menu_item);
Self::set_accel_table(self);
user32::DrawMenuBar(window);
}
Ok(())
}
pub fn update_menu(&mut self, menu_name: &str, menu: &Vec<Menu>) -> Result<()> {
try!(Self::remove_menu(self, menu_name));
Self::add_menu(self, menu_name, menu)
}
pub fn remove_menu(&mut self, menu_name: &str) -> Result<()> {
for i in 0..self.menus.len() {
if self.menus[i].name == menu_name {
unsafe {
user32::DestroyMenu(self.menus[i].menu);
user32::DrawMenuBar(self.window.unwrap());
self.menus.swap_remove(i);
break;
} }
} }
} }
// TODO: Proper return here // TODO: This is not correct and needs to be fixed if remove_item is added. The
Ok(()) // issue here is that AppendMenuW doesn't return a handle so it's hard to track
// in an easy way :(
MenuItemHandle(0)
} }
pub fn is_menu_pressed(&mut self) -> Option<usize> { pub fn remove_item(&mut self, _item: &MenuItemHandle) {
if self.accel_key == INVALID_ACCEL { panic!("remove item hasn't been implemented");
None
} else {
let t = self.accel_key;
self.accel_key = INVALID_ACCEL;
Some(t)
}
} }
} }
impl Drop for Window { impl Drop for Window {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {