diff options
33 files changed, 6112 insertions, 244 deletions
diff --git a/BUILDING.txt b/BUILDING.txt index 98c7c6b0..897a51a3 100644 --- a/BUILDING.txt +++ b/BUILDING.txt @@ -84,61 +84,17 @@ Build Requirements (Java) Building FLTK ============= -TigerVNC requires FLTK 1.3.0 (or later). Although it will build and work -with plain 1.3.0, to get full functionality and the best behaviour you +TigerVNC requires FLTK 1.3.2 (or later). Although it will build and work +with plain 1.3.2, to get full functionality and the best behaviour you need to build a patched version: 1. Check out FLTK 1.3.2 using Subversion: $ svn co http://svn.easysw.com/public/fltk/fltk/tags/release-1.3.2 fltk-1.3.2 -2. For full functionality, apply patches. Here's a shell script to do -that: - -#!/bin/bash -set -e -apply_patch() -{ - rm -f $2 - wget http://www.fltk.org/strfiles/$1/$2 - patch -p1 < $2 -} - -# Export dead key information from FLTK to the apps -# http://www.fltk.org/str.php?L2599 -apply_patch 2599 fltk-1_v4.3.x-keyboard-x11.patch -apply_patch 2599 fltk-1_v4.3.x-keyboard-win32.patch -apply_patch 2599 fltk-1_v6.3.x-keyboard-osx.patch - -# Notify applications of changes to the clipboard -# http://www.fltk.org/str.php?L2636 -apply_patch 2636 fltk-1.3.x-clipboard.patch -apply_patch 2636 fltk-1_v6.3.x-clipboard-x11.patch -apply_patch 2636 fltk-1_v3.3.x-clipboard-win32-fix.patch -apply_patch 2636 fltk-1_v2.3.x-clipboard-win32.patch -apply_patch 2636 fltk-1_v2.3.x-clipboard-osx.patch - -# Ability to convert a Fl_Pixmap to a Fl_RGB_Image -# http://www.fltk.org/str.php?L2659 -apply_patch 2659 pixmap_v2.patch - -# Support for custom cursors -# http://www.fltk.org/str.php?L2660 -apply_patch 2660 fltk-1_v5.3.x-cursor.patch - -# Improve modality interaction with WM -# http://www.fltk.org/str.php?L2802 -apply_patch 2802 fltk-1_v2.3.0-modal.patch - -# Window icons -# http://www.fltk.org/str.php?L2816 -apply_patch 2816 fltk-1_v3.3.0-icons.patch - -# Multihead -# http://fltk.org/str.php?L2860 -apply_patch 2860 fltk-1.3.x-screen_num.patch -apply_patch 2860 fltk-1_v3.3.x-multihead.patch - -### END SCRIPT ### +2. For full functionality, apply patches. All patches can be found in + the contrib/fltk/ directory. There are also some general fixes to + FLTK that can be found in the contrib/fltk/fixes/ directory that + might be useful. 3. Use CMake to build FLTK using the same procedures described below for building TigerVNC. The recipes in the "Build Recipes" section also apply. diff --git a/CMakeLists.txt b/CMakeLists.txt index ce0a00af..5f4ccd48 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -279,9 +279,6 @@ if(FLTK_FOUND) set(CMAKE_REQUIRED_INCLUDES ${FLTK_INCLUDE_DIR}) set(CMAKE_REQUIRED_LIBRARIES ${FLTK_LIBRARIES}) - # FLTK STR #2599 - check_cxx_source_compiles("#include <FL/Fl_Widget.H>\nint main(int c, char** v) { void (Fl_Widget::*foo)() = &Fl_Widget::set_simple_keyboard; return 0; }" HAVE_FLTK_DEAD_KEYS) - # FLTK STR #2636 check_cxx_source_compiles("#include <FL/Fl.H>\nint main(int c, char** v) { Fl::add_clipboard_notify(NULL, NULL); return 0; }" HAVE_FLTK_CLIPBOARD) @@ -303,6 +300,12 @@ if(FLTK_FOUND) # FLTK STR #2860 check_cxx_source_compiles("#include <FL/Fl_Window.H>\nint main(int c, char** v) { void (Fl_Window::*foo)(int,int,int,int) = &Fl_Window::fullscreen_screens; return 0; }" HAVE_FLTK_FULLSCREEN_SCREENS) + # FLTK STR #xxxx + check_cxx_source_compiles("#include <FL/Fl.H>\nint main(int c, char** v) { Fl::add_system_handler(NULL, NULL); return 0; }" HAVE_FLTK_XHANDLERS) + + # FLTK STR #xxxx + check_cxx_source_compiles("#include <FL/Fl.H>\nint main(int c, char** v) { Fl::disable_im(); return 0; }" HAVE_FLTK_IM) + set(CMAKE_REQUIRED_INCLUDES) set(CMAKE_REQUIRED_LIBRARIES) endif() diff --git a/common/rdr/Exception.cxx b/common/rdr/Exception.cxx index d70cd9fc..964bc333 100644 --- a/common/rdr/Exception.cxx +++ b/common/rdr/Exception.cxx @@ -50,7 +50,7 @@ Exception::Exception(const char *format, ...) { } SystemException::SystemException(const char* s, int err_) - : Exception(s), err(err_) + : Exception("%s", s), err(err_) { strncat(str_, ": ", len-1-strlen(str_)); #ifdef _WIN32 diff --git a/config.h.in b/config.h.in index 0c9e71a5..a50e723d 100644 --- a/config.h.in +++ b/config.h.in @@ -10,7 +10,6 @@ #cmakedefine HAVE_GNUTLS_DATUM_T #cmakedefine HAVE_GNUTLS_PK_ALGORITHM_T #cmakedefine HAVE_GNUTLS_SIGN_ALGORITHM_T -#cmakedefine HAVE_FLTK_DEAD_KEYS #cmakedefine HAVE_FLTK_CLIPBOARD #cmakedefine HAVE_FLTK_MEDIAKEYS #cmakedefine HAVE_FLTK_FULLSCREEN @@ -18,6 +17,8 @@ #cmakedefine HAVE_FLTK_CURSOR #cmakedefine HAVE_FLTK_WORK_AREA #cmakedefine HAVE_FLTK_ICONS +#cmakedefine HAVE_FLTK_XHANDLERS +#cmakedefine HAVE_FLTK_IM #cmakedefine HAVE_ACTIVE_DESKTOP_H #cmakedefine HAVE_ACTIVE_DESKTOP_L #cmakedefine ENABLE_NLS 1 diff --git a/contrib/fltk/01-str2636-fltk-1.3.x-clipboard.patch b/contrib/fltk/01-str2636-fltk-1.3.x-clipboard.patch new file mode 100644 index 00000000..3f12bc53 --- /dev/null +++ b/contrib/fltk/01-str2636-fltk-1.3.x-clipboard.patch @@ -0,0 +1,106 @@ +diff -up fltk-1.3.x-r8659/FL/Fl.H.orig fltk-1.3.x-r8659/FL/Fl.H +--- fltk-1.3.x-r8659/FL/Fl.H.orig 2011-05-17 16:25:56.671744548 +0200 ++++ fltk-1.3.x-r8659/FL/Fl.H 2011-05-17 16:26:05.709101536 +0200 +@@ -108,6 +108,9 @@ typedef int (*Fl_Args_Handler)(int argc, + \see Fl::event_dispatch(Fl_Event_Dispatch) */ + typedef int (*Fl_Event_Dispatch)(int event, Fl_Window *w); + ++/** Signature of add_clipboard_notify functions passed as parameters */ ++typedef void (*Fl_Clipboard_Notify_Handler)(int source, void *data); ++ + /** @} */ /* group callback_functions */ + + +@@ -744,6 +747,19 @@ public: + */ + static void paste(Fl_Widget &receiver, int source /*=0*/); // platform dependent + /** ++ FLTK will call the registered callback whenever there is a change to the ++ selection buffer or the clipboard. The source argument indicates which ++ of the two has changed. Only changes by other applications are reported. ++ \note Some systems require polling to monitor the clipboard and may ++ therefore have some delay in detecting changes. ++ */ ++ static void add_clipboard_notify(Fl_Clipboard_Notify_Handler h, void *data); ++ /** ++ Stop calling the specified callback when there are changes to the selection ++ buffer or the clipboard. ++ */ ++ static void remove_clipboard_notify(Fl_Clipboard_Notify_Handler h); ++ /** + Initiate a Drag And Drop operation. The selection buffer should be + filled with relevant data before calling this method. FLTK will + then initiate the system wide drag and drop handling. Dropped data +diff -up fltk-1.3.x-r8659/src/Fl.cxx.orig fltk-1.3.x-r8659/src/Fl.cxx +--- fltk-1.3.x-r8659/src/Fl.cxx.orig 2011-05-18 15:20:26.667291459 +0200 ++++ fltk-1.3.x-r8659/src/Fl.cxx 2011-05-18 16:31:15.522026086 +0200 +@@ -430,6 +430,69 @@ static char in_idle; + #endif + + //////////////////////////////////////////////////////////////// ++// Clipboard notifications ++ ++struct Clipboard_Notify { ++ Fl_Clipboard_Notify_Handler handler; ++ void *data; ++ struct Clipboard_Notify *next; ++}; ++ ++static struct Clipboard_Notify *clip_notify_list = NULL; ++ ++extern void fl_clipboard_notify_change(); // in Fl_<platform>.cxx ++ ++void Fl::add_clipboard_notify(Fl_Clipboard_Notify_Handler h, void *data) { ++ struct Clipboard_Notify *node; ++ ++ remove_clipboard_notify(h); ++ ++ node = new Clipboard_Notify; ++ ++ node->handler = h; ++ node->data = data; ++ node->next = clip_notify_list; ++ ++ clip_notify_list = node; ++ ++ fl_clipboard_notify_change(); ++} ++ ++void Fl::remove_clipboard_notify(Fl_Clipboard_Notify_Handler h) { ++ struct Clipboard_Notify *node, **prev; ++ ++ node = clip_notify_list; ++ prev = &clip_notify_list; ++ while (node != NULL) { ++ if (node->handler == h) { ++ *prev = node->next; ++ delete node; ++ ++ fl_clipboard_notify_change(); ++ ++ return; ++ } ++ ++ prev = &node->next; ++ node = node->next; ++ } ++} ++ ++bool fl_clipboard_notify_empty(void) { ++ return clip_notify_list == NULL; ++} ++ ++void fl_trigger_clipboard_notify(int source) { ++ struct Clipboard_Notify *node; ++ ++ node = clip_notify_list; ++ while (node != NULL) { ++ node->handler(source, node->data); ++ node = node->next; ++ } ++} ++ ++//////////////////////////////////////////////////////////////// + // wait/run/check/ready: + + void (*Fl::idle)(); // see Fl::add_idle.cxx for the add/remove functions diff --git a/contrib/fltk/02-str2636-fltk-1.3.x-clipboard-x11.patch b/contrib/fltk/02-str2636-fltk-1.3.x-clipboard-x11.patch new file mode 100644 index 00000000..9e253a3f --- /dev/null +++ b/contrib/fltk/02-str2636-fltk-1.3.x-clipboard-x11.patch @@ -0,0 +1,355 @@ +diff -up fltk-1.3.2/CMakeLists.txt.clp-x11 fltk-1.3.2/CMakeLists.txt +--- fltk-1.3.2/CMakeLists.txt.clp-x11 2012-09-13 16:19:01.000000000 +0200 ++++ fltk-1.3.2/CMakeLists.txt 2013-01-30 15:56:25.810663430 +0100 +@@ -515,6 +515,20 @@ else() + endif(OPTION_USE_XINERAMA) + + ####################################################################### ++if(X11_Xfixes_FOUND) ++ option(OPTION_USE_XFIXES "use lib XFIXES" ON) ++endif(X11_Xfixes_FOUND) ++ ++if(OPTION_USE_XFIXES) ++ set(HAVE_XFIXES ${X11_Xfixes_FOUND}) ++ include_directories(${X11_Xfixes_INCLUDE_PATH}) ++ list(APPEND FLTK_LDLIBS -lXfixes) ++ set(FLTK_XFIXES_FOUND TRUE) ++else() ++ set(FLTK_XFIXES_FOUND FALSE) ++endif(OPTION_USE_XFIXES) ++ ++####################################################################### + if(X11_Xft_FOUND) + option(OPTION_USE_XFT "use lib Xft" ON) + endif(X11_Xft_FOUND) +diff -up fltk-1.3.2/configh.cmake.in.clp-x11 fltk-1.3.2/configh.cmake.in +--- fltk-1.3.2/configh.cmake.in.clp-x11 2011-07-19 06:49:30.000000000 +0200 ++++ fltk-1.3.2/configh.cmake.in 2013-01-30 15:56:25.810663430 +0100 +@@ -108,6 +108,14 @@ + #define USE_XDBE HAVE_XDBE + + /* ++ * HAVE_XFIXES: ++ * ++ * Do we have the X fixes extension? ++ */ ++ ++#cmakedefine01 HAVE_XFIXES ++ ++/* + * __APPLE_QUARTZ__: + * + * If __APPLE_QUARTZ__ is defined, FLTK will be +diff -up fltk-1.3.2/configh.in.clp-x11 fltk-1.3.2/configh.in +--- fltk-1.3.2/configh.in.clp-x11 2011-10-04 11:21:47.000000000 +0200 ++++ fltk-1.3.2/configh.in 2013-01-30 15:56:25.810663430 +0100 +@@ -108,6 +108,14 @@ + #define USE_XDBE HAVE_XDBE + + /* ++ * HAVE_XFIXES: ++ * ++ * Do we have the X fixes extension? ++ */ ++ ++#define HAVE_XFIXES 0 ++ ++/* + * __APPLE_QUARTZ__: + * + * All Apple implementations are now based on Quartz and Cocoa, +diff -up fltk-1.3.2/configure.in.clp-x11 fltk-1.3.2/configure.in +--- fltk-1.3.2/configure.in.clp-x11 2013-01-30 15:56:25.802663573 +0100 ++++ fltk-1.3.2/configure.in 2013-01-30 15:56:25.810663430 +0100 +@@ -999,6 +999,16 @@ case $uname_GUI in + LIBS="-lXext $LIBS") + fi + ++ dnl Check for the Xfixes extension unless disabled... ++ AC_ARG_ENABLE(xfixes, [ --enable-xfixes turn on Xfixes support [default=yes]]) ++ ++ if test x$enable_xfixes != xno; then ++ AC_CHECK_HEADER(X11/extensions/Xfixes.h, AC_DEFINE(HAVE_XFIXES),, ++ [#include <X11/Xlib.h>]) ++ AC_CHECK_LIB(Xfixes, XFixesQueryExtension, ++ LIBS="-lXfixes $LIBS") ++ fi ++ + dnl Check for overlay visuals... + AC_PATH_PROG(XPROP, xprop) + AC_CACHE_CHECK(for X overlay visuals, ac_cv_have_overlay, +diff -up fltk-1.3.2/fluid/CMakeLists.txt.clp-x11 fltk-1.3.2/fluid/CMakeLists.txt +diff -up fltk-1.3.2/src/CMakeLists.txt.clp-x11 fltk-1.3.2/src/CMakeLists.txt +--- fltk-1.3.2/src/CMakeLists.txt.clp-x11 2013-01-30 16:06:00.785430590 +0100 ++++ fltk-1.3.2/src/CMakeLists.txt 2013-01-30 16:06:17.883126642 +0100 +@@ -243,6 +243,10 @@ if(HAVE_XINERAMA) + target_link_libraries(fltk ${X11_Xinerama_LIB}) + endif(HAVE_XINERAMA) + ++if(HAVE_XFIXES) ++ target_link_libraries(fltk ${X11_Xfixes_LIB}) ++endif(HAVE_XFIXES) ++ + if(USE_XFT) + target_link_libraries(fltk ${X11_Xft_LIB}) + endif(USE_XFT) +diff -up fltk-1.3.2/src/Fl_x.cxx.clp-x11 fltk-1.3.2/src/Fl_x.cxx +--- fltk-1.3.2/src/Fl_x.cxx.clp-x11 2013-01-30 15:56:25.793663733 +0100 ++++ fltk-1.3.2/src/Fl_x.cxx 2013-01-30 16:03:37.355981103 +0100 +@@ -53,6 +53,12 @@ static XRRUpdateConfiguration_type XRRUp + static int randrEventBase; // base of RandR-defined events + #endif + ++# if HAVE_XFIXES ++# include <X11/extensions/Xfixes.h> ++static int xfixes_event_base = 0; ++static bool have_xfixes = false; ++# endif ++ + static Fl_Xlib_Graphics_Driver fl_xlib_driver; + static Fl_Display_Device fl_xlib_display(&fl_xlib_driver); + Fl_Display_Device *Fl_Display_Device::_display = &fl_xlib_display;// the platform display +@@ -307,6 +313,9 @@ static Atom WM_PROTOCOLS; + static Atom fl_MOTIF_WM_HINTS; + static Atom TARGETS; + static Atom CLIPBOARD; ++static Atom TIMESTAMP; ++static Atom PRIMARY_TIMESTAMP; ++static Atom CLIPBOARD_TIMESTAMP; + Atom fl_XdndAware; + Atom fl_XdndSelection; + Atom fl_XdndEnter; +@@ -667,6 +676,9 @@ void fl_open_display(Display* d) { + fl_MOTIF_WM_HINTS = XInternAtom(d, "_MOTIF_WM_HINTS", 0); + TARGETS = XInternAtom(d, "TARGETS", 0); + CLIPBOARD = XInternAtom(d, "CLIPBOARD", 0); ++ TIMESTAMP = XInternAtom(d, "TIMESTAMP", 0); ++ PRIMARY_TIMESTAMP = XInternAtom(d, "PRIMARY_TIMESTAMP", 0); ++ CLIPBOARD_TIMESTAMP = XInternAtom(d, "CLIPBOARD_TIMESTAMP", 0); + fl_XdndAware = XInternAtom(d, "XdndAware", 0); + fl_XdndSelection = XInternAtom(d, "XdndSelection", 0); + fl_XdndEnter = XInternAtom(d, "XdndEnter", 0); +@@ -713,6 +725,15 @@ void fl_open_display(Display* d) { + #if !USE_COLORMAP + Fl::visual(FL_RGB); + #endif ++ ++#if HAVE_XFIXES ++ int error_base; ++ if (XFixesQueryExtension(fl_display, &xfixes_event_base, &error_base)) ++ have_xfixes = true; ++ else ++ have_xfixes = false; ++#endif ++ + #if USE_XRANDR + void *libxrandr_addr = dlopen("libXrandr.so.2", RTLD_LAZY); + if (!libxrandr_addr) libxrandr_addr = dlopen("libXrandr.so", RTLD_LAZY); +@@ -901,6 +922,107 @@ void Fl::copy(const char *stuff, int len + } + + //////////////////////////////////////////////////////////////// ++// Code for tracking clipboard changes: ++ ++static Time primary_timestamp = -1; ++static Time clipboard_timestamp = -1; ++ ++extern bool fl_clipboard_notify_empty(void); ++extern void fl_trigger_clipboard_notify(int source); ++ ++static void poll_clipboard_owner(void) { ++ Window xid; ++ ++#if HAVE_XFIXES ++ // No polling needed with Xfixes ++ if (have_xfixes) ++ return; ++#endif ++ ++ // No one is interested, so no point polling ++ if (fl_clipboard_notify_empty()) ++ return; ++ ++ // We need a window for this to work ++ if (!Fl::first_window()) ++ return; ++ xid = fl_xid(Fl::first_window()); ++ if (!xid) ++ return; ++ ++ // Request an update of the selection time for both the primary and ++ // clipboard selections. Magic continues when we get a SelectionNotify. ++ if (!fl_i_own_selection[0]) ++ XConvertSelection(fl_display, XA_PRIMARY, TIMESTAMP, PRIMARY_TIMESTAMP, ++ xid, fl_event_time); ++ if (!fl_i_own_selection[1]) ++ XConvertSelection(fl_display, CLIPBOARD, TIMESTAMP, CLIPBOARD_TIMESTAMP, ++ xid, fl_event_time); ++} ++ ++static void clipboard_timeout(void *data) ++{ ++ // No one is interested, so stop polling ++ if (fl_clipboard_notify_empty()) ++ return; ++ ++ poll_clipboard_owner(); ++ ++ Fl::repeat_timeout(0.5, clipboard_timeout); ++} ++ ++static void handle_clipboard_timestamp(int clipboard, Time time) ++{ ++ Time *timestamp; ++ ++ timestamp = clipboard ? &clipboard_timestamp : &primary_timestamp; ++ ++#if HAVE_XFIXES ++ if (!have_xfixes) ++#endif ++ { ++ // Initial scan, just store the value ++ if (*timestamp == (Time)-1) { ++ *timestamp = time; ++ return; ++ } ++ } ++ ++ // Same selection ++ if (time == *timestamp) ++ return; ++ ++ *timestamp = time; ++ ++ // The clipboard change is the event that caused us to request ++ // the clipboard data, so use that time as the latest event. ++ if (time > fl_event_time) ++ fl_event_time = time; ++ ++ // Something happened! Let's tell someone! ++ fl_trigger_clipboard_notify(clipboard); ++} ++ ++void fl_clipboard_notify_change() { ++ // Reset the timestamps if we've going idle so that you don't ++ // get a bogus immediate trigger next time they're activated. ++ if (fl_clipboard_notify_empty()) { ++ primary_timestamp = -1; ++ clipboard_timestamp = -1; ++ } else { ++#if HAVE_XFIXES ++ if (!have_xfixes) ++#endif ++ { ++ poll_clipboard_owner(); ++ ++ if (!Fl::has_timeout(clipboard_timeout)) ++ Fl::add_timeout(0.5, clipboard_timeout); ++ } ++ } ++} ++ ++//////////////////////////////////////////////////////////////// + + const XEvent* fl_xevent; // the current x event + ulong fl_event_time; // the last timestamp from an x event +@@ -1024,7 +1141,6 @@ int fl_handle(const XEvent& thisevent) + return 0; + + case SelectionNotify: { +- if (!fl_selection_requestor) return 0; + static unsigned char* buffer = 0; + if (buffer) {XFree(buffer); buffer = 0;} + long bytesread = 0; +@@ -1040,6 +1156,19 @@ int fl_handle(const XEvent& thisevent) + bytesread/4, 65536, 1, 0, + &actual, &format, &count, &remaining, + &portion)) break; // quit on error ++ ++ if ((fl_xevent->xselection.property == PRIMARY_TIMESTAMP) || ++ (fl_xevent->xselection.property == CLIPBOARD_TIMESTAMP)) { ++ if (portion && format == 32 && count == 1) { ++ Time t = *(unsigned int*)portion; ++ if (fl_xevent->xselection.property == CLIPBOARD_TIMESTAMP) ++ handle_clipboard_timestamp(1, t); ++ else ++ handle_clipboard_timestamp(0, t); ++ } ++ return true; ++ } ++ + if (actual == TARGETS || actual == XA_ATOM) { + Atom type = XA_STRING; + for (unsigned i = 0; i<count; i++) { +@@ -1076,6 +1205,9 @@ int fl_handle(const XEvent& thisevent) + buffer[bytesread] = 0; + convert_crlf(buffer, bytesread); + } ++ ++ if (!fl_selection_requestor) return 0; ++ + Fl::e_text = buffer ? (char*)buffer : (char *)""; + Fl::e_length = bytesread; + int old_event = Fl::e_number; +@@ -1096,6 +1228,7 @@ int fl_handle(const XEvent& thisevent) + case SelectionClear: { + int clipboard = fl_xevent->xselectionclear.selection == CLIPBOARD; + fl_i_own_selection[clipboard] = 0; ++ poll_clipboard_owner(); + return 1;} + + case SelectionRequest: { +@@ -1308,6 +1441,9 @@ int fl_handle(const XEvent& thisevent) + case FocusIn: + if (fl_xim_ic) XSetICFocus(fl_xim_ic); + event = FL_FOCUS; ++ // If the user has toggled from another application to this one, ++ // then it's a good time to check for clipboard changes. ++ poll_clipboard_owner(); + break; + + case FocusOut: +@@ -1676,6 +1812,25 @@ int fl_handle(const XEvent& thisevent) + } + } + ++#if HAVE_XFIXES ++ switch (xevent.type - xfixes_event_base) { ++ case XFixesSelectionNotify: { ++ // Someone feeding us bogus events? ++ if (!have_xfixes) ++ return true; ++ ++ XFixesSelectionNotifyEvent *selection_notify = (XFixesSelectionNotifyEvent *)&xevent; ++ ++ if ((selection_notify->selection == XA_PRIMARY) && !fl_i_own_selection[0]) ++ handle_clipboard_timestamp(0, selection_notify->selection_timestamp); ++ else if ((selection_notify->selection == CLIPBOARD) && !fl_i_own_selection[1]) ++ handle_clipboard_timestamp(1, selection_notify->selection_timestamp); ++ ++ return true; ++ } ++ } ++#endif ++ + return Fl::handle(event, window); + } + +@@ -1995,6 +2150,16 @@ void Fl_X::make_xid(Fl_Window* win, XVis + XChangeProperty(fl_display, xp->xid, net_wm_type, XA_ATOM, 32, PropModeReplace, (unsigned char*)&net_wm_type_kind, 1); + } + ++#if HAVE_XFIXES ++ // register for clipboard change notifications ++ if (have_xfixes && !win->parent()) { ++ XFixesSelectSelectionInput(fl_display, xp->xid, XA_PRIMARY, ++ XFixesSetSelectionOwnerNotifyMask); ++ XFixesSelectSelectionInput(fl_display, xp->xid, CLIPBOARD, ++ XFixesSetSelectionOwnerNotifyMask); ++ } ++#endif ++ + XMapWindow(fl_display, xp->xid); + if (showit) { + win->set_visible(); +diff -up fltk-1.3.2/test/CMakeLists.txt.clp-x11 fltk-1.3.2/test/CMakeLists.txt diff --git a/contrib/fltk/03-str2636-fltk-1.3.x-clipboard-win32-fix.patch b/contrib/fltk/03-str2636-fltk-1.3.x-clipboard-win32-fix.patch new file mode 100644 index 00000000..b41af794 --- /dev/null +++ b/contrib/fltk/03-str2636-fltk-1.3.x-clipboard-win32-fix.patch @@ -0,0 +1,135 @@ +diff -ur fltk-1.3.0r9110.org/src/Fl_win32.cxx fltk-1.3.0r9110/src/Fl_win32.cxx +--- fltk-1.3.0r9110.org/src/Fl_win32.cxx 2012-06-17 19:42:02.169422400 +0200 ++++ fltk-1.3.0r9110/src/Fl_win32.cxx 2012-06-17 19:43:38.286031455 +0200 +@@ -543,6 +543,37 @@ + const char* GetValue() const { return(out); } + }; + ++void fl_update_clipboard(void) { ++ Fl_Window *w1 = Fl::first_window(); ++ if (!w1) ++ return; ++ ++ HWND hwnd = fl_xid(w1); ++ ++ if (!OpenClipboard(hwnd)) ++ return; ++ ++ EmptyClipboard(); ++ ++ int utf16_len = fl_utf8toUtf16(fl_selection_buffer[1], ++ fl_selection_length[1], 0, 0); ++ ++ HGLOBAL hMem = GlobalAlloc(GHND, utf16_len * 2 + 2); // moveable and zero'ed mem alloc. ++ LPVOID memLock = GlobalLock(hMem); ++ ++ fl_utf8toUtf16(fl_selection_buffer[1], fl_selection_length[1], ++ (unsigned short*) memLock, utf16_len + 1); ++ ++ GlobalUnlock(hMem); ++ SetClipboardData(CF_UNICODETEXT, hMem); ++ ++ CloseClipboard(); ++ ++ // In case Windows managed to lob of a WM_DESTROYCLIPBOARD during ++ // the above. ++ fl_i_own_selection[1] = 1; ++} ++ + // call this when you create a selection: + void Fl::copy(const char *stuff, int len, int clipboard) { + if (!stuff || len<0) return; +@@ -560,25 +591,9 @@ + memcpy(fl_selection_buffer[clipboard], stuff, len); + fl_selection_buffer[clipboard][len] = 0; // needed for direct paste + fl_selection_length[clipboard] = len; +- if (clipboard) { +- // set up for "delayed rendering": +- if (OpenClipboard(NULL)) { +- // if the system clipboard works, use it +- int utf16_len = fl_utf8toUtf16(fl_selection_buffer[clipboard], fl_selection_length[clipboard], 0, 0); +- EmptyClipboard(); +- HGLOBAL hMem = GlobalAlloc(GHND, utf16_len * 2 + 2); // moveable and zero'ed mem alloc. +- LPVOID memLock = GlobalLock(hMem); +- fl_utf8toUtf16(fl_selection_buffer[clipboard], fl_selection_length[clipboard], (unsigned short*) memLock, utf16_len + 1); +- GlobalUnlock(hMem); +- SetClipboardData(CF_UNICODETEXT, hMem); +- CloseClipboard(); +- GlobalFree(hMem); +- fl_i_own_selection[clipboard] = 0; +- } else { +- // only if it fails, instruct paste() to use the internal buffers +- fl_i_own_selection[clipboard] = 1; +- } +- } ++ fl_i_own_selection[clipboard] = 1; ++ if (clipboard) ++ fl_update_clipboard(); + } + + // Call this when a "paste" operation happens: +@@ -1307,33 +1322,6 @@ + fl_i_own_selection[1] = 0; + return 1; + +- case WM_RENDERALLFORMATS: +- fl_i_own_selection[1] = 0; +- // Windoze seems unhappy unless I do these two steps. Documentation +- // seems to vary on whether opening the clipboard is necessary or +- // is in fact wrong: +- CloseClipboard(); +- OpenClipboard(NULL); +- // fall through... +- case WM_RENDERFORMAT: { +- HANDLE h; +- +-// int l = fl_utf_nb_char((unsigned char*)fl_selection_buffer[1], fl_selection_length[1]); +- int l = fl_utf8toUtf16(fl_selection_buffer[1], fl_selection_length[1], NULL, 0); // Pass NULL buffer to query length required +- h = GlobalAlloc(GHND, (l+1) * sizeof(unsigned short)); +- if (h) { +- unsigned short *g = (unsigned short*) GlobalLock(h); +-// fl_utf2unicode((unsigned char *)fl_selection_buffer[1], fl_selection_length[1], (xchar*)g); +- l = fl_utf8toUtf16(fl_selection_buffer[1], fl_selection_length[1], g, (l+1)); +- g[l] = 0; +- GlobalUnlock(h); +- SetClipboardData(CF_UNICODETEXT, h); +- } +- +- // Windoze also seems unhappy if I don't do this. Documentation very +- // unclear on what is correct: +- if (fl_msg.message == WM_RENDERALLFORMATS) CloseClipboard(); +- return 1;} + case WM_DISPLAYCHANGE: // occurs when screen configuration (number, position) changes + Fl::call_screen_init(); + Fl::handle(FL_SCREEN_CONFIGURATION_CHANGED, NULL); +diff -ur fltk-1.3.0r9110.org/src/Fl.cxx fltk-1.3.0r9110/src/Fl.cxx +--- fltk-1.3.0r9110.org/src/Fl.cxx 2012-06-17 19:42:02.173422595 +0200 ++++ fltk-1.3.0r9110/src/Fl.cxx 2012-06-17 19:42:02.317429497 +0200 +@@ -1420,7 +1420,9 @@ + //////////////////////////////////////////////////////////////// + // hide() destroys the X window, it does not do unmap! + +-#if !defined(WIN32) && USE_XFT ++#if defined(WIN32) ++extern void fl_update_clipboard(void); ++#elif USE_XFT + extern void fl_destroy_xft_draw(Window); + #endif + +@@ -1467,14 +1469,8 @@ + #if defined(WIN32) + // this little trick keeps the current clipboard alive, even if we are about + // to destroy the window that owns the selection. +- if (GetClipboardOwner()==ip->xid) { +- Fl_Window *w1 = Fl::first_window(); +- if (w1 && OpenClipboard(fl_xid(w1))) { +- EmptyClipboard(); +- SetClipboardData(CF_TEXT, NULL); +- CloseClipboard(); +- } +- } ++ if (GetClipboardOwner()==ip->xid) ++ fl_update_clipboard(); + // Send a message to myself so that I'll get out of the event loop... + PostMessage(ip->xid, WM_APP, 0, 0); + if (ip->private_dc) fl_release_dc(ip->xid, ip->private_dc); diff --git a/contrib/fltk/04-str2636-fltk-1.3.x-clipboard-win32.patch b/contrib/fltk/04-str2636-fltk-1.3.x-clipboard-win32.patch new file mode 100644 index 00000000..ac94779c --- /dev/null +++ b/contrib/fltk/04-str2636-fltk-1.3.x-clipboard-win32.patch @@ -0,0 +1,99 @@ +diff -ur fltk-1.3.0r9110.org/src/Fl.cxx fltk-1.3.0r9110/src/Fl.cxx +--- fltk-1.3.0r9110.org/src/Fl.cxx 2012-06-17 19:47:09.988183253 +0200 ++++ fltk-1.3.0r9110/src/Fl.cxx 2012-06-17 19:47:10.127189919 +0200 +@@ -1421,6 +1421,7 @@ + // hide() destroys the X window, it does not do unmap! + + #if defined(WIN32) ++extern void fl_clipboard_notify_untarget(HWND wnd); + extern void fl_update_clipboard(void); + #elif USE_XFT + extern void fl_destroy_xft_draw(Window); +@@ -1471,6 +1472,8 @@ + // to destroy the window that owns the selection. + if (GetClipboardOwner()==ip->xid) + fl_update_clipboard(); ++ // Make sure we unlink this window from the clipboard chain ++ fl_clipboard_notify_untarget(ip->xid); + // Send a message to myself so that I'll get out of the event loop... + PostMessage(ip->xid, WM_APP, 0, 0); + if (ip->private_dc) fl_release_dc(ip->xid, ip->private_dc); +diff -ur fltk-1.3.0r9110.org/src/Fl_win32.cxx fltk-1.3.0r9110/src/Fl_win32.cxx +--- fltk-1.3.0r9110.org/src/Fl_win32.cxx 2012-06-17 19:47:09.987183205 +0200 ++++ fltk-1.3.0r9110/src/Fl_win32.cxx 2012-06-17 19:47:19.069618739 +0200 +@@ -646,6 +646,38 @@ + } + } + ++static HWND clipboard_wnd = 0; ++static HWND next_clipboard_wnd = 0; ++ ++static bool initial_clipboard = true; ++ ++void fl_clipboard_notify_change() { ++ // No need to do anything here... ++} ++ ++void fl_clipboard_notify_target(HWND wnd) { ++ if (clipboard_wnd) ++ return; ++ ++ // We get one fake WM_DRAWCLIPBOARD immediately, which we therefore ++ // need to ignore. ++ initial_clipboard = true; ++ ++ clipboard_wnd = wnd; ++ next_clipboard_wnd = SetClipboardViewer(wnd); ++} ++ ++void fl_clipboard_notify_untarget(HWND wnd) { ++ if (wnd != clipboard_wnd) ++ return; ++ ++ ChangeClipboardChain(wnd, next_clipboard_wnd); ++ clipboard_wnd = next_clipboard_wnd = 0; ++ ++ if (Fl::first_window()) ++ fl_clipboard_notify_target(fl_xid(Fl::first_window())); ++} ++ + //////////////////////////////////////////////////////////////// + char fl_is_ime = 0; + void fl_get_codepage() +@@ -1327,6 +1359,27 @@ + Fl::handle(FL_SCREEN_CONFIGURATION_CHANGED, NULL); + return 0; + ++ case WM_CHANGECBCHAIN: ++ if ((hWnd == clipboard_wnd) && ++ (next_clipboard_wnd == (HWND)wParam)) { ++ next_clipboard_wnd = (HWND)lParam; ++ return 0; ++ } ++ break; ++ ++ case WM_DRAWCLIPBOARD: ++ // When the clipboard moves between two FLTK windows, ++ // fl_i_own_selection will temporarily be false as we are ++ // processing this message. Hence the need to use fl_find(). ++ if (!initial_clipboard && !fl_find(GetClipboardOwner())) ++ fl_trigger_clipboard_notify(1); ++ initial_clipboard = false; ++ ++ if (next_clipboard_wnd) ++ SendMessage(next_clipboard_wnd, WM_DRAWCLIPBOARD, wParam, lParam); ++ ++ return 0; ++ + default: + if (Fl::handle(0,0)) return 0; + break; +@@ -1685,6 +1738,8 @@ + x->next = Fl_X::first; + Fl_X::first = x; + ++ fl_clipboard_notify_target(x->xid); ++ + x->wait_for_expose = 1; + if (fl_show_iconic) {showit = 0; fl_show_iconic = 0;} + if (showit) { diff --git a/contrib/fltk/05-str2636-fltk-1.3.x-clipboard-osx.patch b/contrib/fltk/05-str2636-fltk-1.3.x-clipboard-osx.patch new file mode 100644 index 00000000..22e69396 --- /dev/null +++ b/contrib/fltk/05-str2636-fltk-1.3.x-clipboard-osx.patch @@ -0,0 +1,44 @@ +diff -bur fltk-1.3.0r9619.org/src/Fl_cocoa.mm fltk-1.3.0r9619/src/Fl_cocoa.mm +--- fltk-1.3.0r9619.org/src/Fl_cocoa.mm 2012-06-18 19:24:30.971688769 +0200 ++++ fltk-1.3.0r9619/src/Fl_cocoa.mm 2012-06-18 19:25:25.700310375 +0200 +@@ -1319,9 +1319,13 @@ + } + @end + ++static void clipboard_check(void); ++ + @implementation FLApplication + + (void)sendEvent:(NSEvent *)theEvent + { ++ // update clipboard status ++ clipboard_check(); + NSEventType type = [theEvent type]; + if (type == NSLeftMouseDown) { + fl_lock_function(); +@@ -2790,6 +2794,26 @@ + PasteboardCreate(kPasteboardClipboard, &myPasteboard); + } + ++extern void fl_trigger_clipboard_notify(int source); ++ ++void fl_clipboard_notify_change() { ++ // No need to do anything here... ++} ++ ++static void clipboard_check(void) ++{ ++ PasteboardSyncFlags flags; ++ ++ allocatePasteboard(); ++ flags = PasteboardSynchronize(myPasteboard); ++ ++ if (!(flags & kPasteboardModified)) ++ return; ++ if (flags & kPasteboardClientIsOwner) ++ return; ++ ++ fl_trigger_clipboard_notify(1); ++} + + /* + * create a selection diff --git a/contrib/fltk/06-str2659-pixmap.patch b/contrib/fltk/06-str2659-pixmap.patch new file mode 100644 index 00000000..30315138 --- /dev/null +++ b/contrib/fltk/06-str2659-pixmap.patch @@ -0,0 +1,554 @@ +diff -ur fltk-1.3.2.org/FL/Fl_Image.H fltk-1.3.2/FL/Fl_Image.H +--- fltk-1.3.2.org/FL/Fl_Image.H 2012-11-09 17:02:08.000000000 +0100 ++++ fltk-1.3.2/FL/Fl_Image.H 2013-01-16 14:40:51.543230638 +0100 +@@ -26,6 +26,7 @@ + #include <stdlib.h> + + class Fl_Widget; ++class Fl_Pixmap; + struct Fl_Menu_Item; + struct Fl_Label; + +@@ -203,6 +204,7 @@ + */ + Fl_RGB_Image(const uchar *bits, int W, int H, int D=3, int LD=0) : + Fl_Image(W,H,D), array(bits), alloc_array(0), id_(0), mask_(0) {data((const char **)&array, 1); ld(LD);} ++ Fl_RGB_Image(const Fl_Pixmap *pxm, Fl_Color bg=FL_GRAY); + virtual ~Fl_RGB_Image(); + virtual Fl_Image *copy(int W, int H); + Fl_Image *copy() { return copy(w(), h()); } +diff -ur fltk-1.3.2.org/src/fl_draw_pixmap.cxx fltk-1.3.2/src/fl_draw_pixmap.cxx +--- fltk-1.3.2.org/src/fl_draw_pixmap.cxx 2012-04-22 05:09:31.000000000 +0200 ++++ fltk-1.3.2/src/fl_draw_pixmap.cxx 2013-01-16 14:40:51.542230588 +0100 +@@ -58,99 +58,6 @@ + return 1; + } + +-#ifdef U64 +- +-// The callback from fl_draw_image to get a row of data passes this: +-struct pixmap_data { +- int w, h; +- const uchar*const* data; +- union { +- U64 colors[256]; +- U64* byte1[256]; +- }; +-}; +- +-// callback for 1 byte per pixel: +-static void cb1(void*v, int x, int y, int w, uchar* buf) { +- pixmap_data& d = *(pixmap_data*)v; +- const uchar* p = d.data[y]+x; +- U64* q = (U64*)buf; +- for (int X=w; X>0; X-=2, p += 2) { +- if (X>1) { +-# if WORDS_BIGENDIAN +- *q++ = (d.colors[p[0]]<<32) | d.colors[p[1]]; +-# else +- *q++ = (d.colors[p[1]]<<32) | d.colors[p[0]]; +-# endif +- } else { +-# if WORDS_BIGENDIAN +- *q++ = d.colors[p[0]]<<32; +-# else +- *q++ = d.colors[p[0]]; +-# endif +- } +- } +-} +- +-// callback for 2 bytes per pixel: +-static void cb2(void*v, int x, int y, int w, uchar* buf) { +- pixmap_data& d = *(pixmap_data*)v; +- const uchar* p = d.data[y]+2*x; +- U64* q = (U64*)buf; +- for (int X=w; X>0; X-=2) { +- U64* colors = d.byte1[*p++]; +- int index = *p++; +- if (X>1) { +- U64* colors1 = d.byte1[*p++]; +- int index1 = *p++; +-# if WORDS_BIGENDIAN +- *q++ = (colors[index]<<32) | colors1[index1]; +-# else +- *q++ = (colors1[index1]<<32) | colors[index]; +-# endif +- } else { +-# if WORDS_BIGENDIAN +- *q++ = colors[index]<<32; +-# else +- *q++ = colors[index]; +-# endif +- } +- } +-} +- +-#else // U32 +- +-// The callback from fl_draw_image to get a row of data passes this: +-struct pixmap_data { +- int w, h; +- const uchar*const* data; +- union { +- U32 colors[256]; +- U32* byte1[256]; +- }; +-}; +- +-// callback for 1 byte per pixel: +-static void cb1(void*v, int x, int y, int w, uchar* buf) { +- pixmap_data& d = *(pixmap_data*)v; +- const uchar* p = d.data[y]+x; +- U32* q = (U32*)buf; +- for (int X=w; X--;) *q++ = d.colors[*p++]; +-} +- +-// callback for 2 bytes per pixel: +-static void cb2(void*v, int x, int y, int w, uchar* buf) { +- pixmap_data& d = *(pixmap_data*)v; +- const uchar* p = d.data[y]+2*x; +- U32* q = (U32*)buf; +- for (int X=w; X--;) { +- U32* colors = d.byte1[*p++]; +- *q++ = colors[*p++]; +- } +-} +- +-#endif // U64 else U32 +- + uchar **fl_mask_bitmap; // if non-zero, create bitmap and store pointer here + + /** +@@ -200,34 +107,33 @@ + } + #endif + +-/** +- Draw XPM image data, with the top-left corner at the given position. +- \see fl_draw_pixmap(char* const* data, int x, int y, Fl_Color bg) +- */ +-int fl_draw_pixmap(const char*const* cdata, int x, int y, Fl_Color bg) { +- pixmap_data d; +- if (!fl_measure_pixmap(cdata, d.w, d.h)) return 0; ++int fl_convert_pixmap(const char*const* cdata, uchar* out, Fl_Color bg) { ++ int w, h; + const uchar*const* data = (const uchar*const*)(cdata+1); + int transparent_index = -1; ++ ++ if (!fl_measure_pixmap(cdata, w, h)) ++ return 0; ++ ++ if ((chars_per_pixel < 1) || (chars_per_pixel > 2)) ++ return 0; ++ ++ uchar colors[1<<(chars_per_pixel*8)][4]; ++ + #ifdef WIN32 + uchar *transparent_c = (uchar *)0; // such that transparent_c[0,1,2] are the RGB of the transparent color + color_count = 0; + used_colors = (uchar *)malloc(abs(ncolors)*3*sizeof(uchar)); + #endif + +- if (ncolors < 0) { // FLTK (non standard) compressed colormap ++ if (ncolors < 0) { ++ // FLTK (non standard) compressed colormap + ncolors = -ncolors; + const uchar *p = *data++; + // if first color is ' ' it is transparent (put it later to make + // it not be transparent): + if (*p == ' ') { +- uchar* c = (uchar*)&d.colors[(int)' ']; +-#ifdef U64 +- *(U64*)c = 0; +-# if WORDS_BIGENDIAN +- c += 4; +-# endif +-#endif ++ uchar* c = colors[(int)' ']; + transparent_index = ' '; + Fl::get_color(bg, c[0], c[1], c[2]); c[3] = 0; + #ifdef WIN32 +@@ -238,13 +144,7 @@ + } + // read all the rest of the colors: + for (int i=0; i < ncolors; i++) { +- uchar* c = (uchar*)&d.colors[*p++]; +-#ifdef U64 +- *(U64*)c = 0; +-# if WORDS_BIGENDIAN +- c += 4; +-# endif +-#endif ++ uchar* c = colors[*p++]; + #ifdef WIN32 + used_colors[3*color_count] = *p; + used_colors[3*color_count+1] = *(p+1); +@@ -254,69 +154,44 @@ + *c++ = *p++; + *c++ = *p++; + *c++ = *p++; +-#ifdef __APPLE_QUARTZ__ + *c = 255; +-#else +- *c = 0; +-#endif + } +- } else { // normal XPM colormap with names +- if (chars_per_pixel>1) memset(d.byte1, 0, sizeof(d.byte1)); ++ } else { ++ // normal XPM colormap with names + for (int i=0; i<ncolors; i++) { + const uchar *p = *data++; + // the first 1 or 2 characters are the color index: + int ind = *p++; + uchar* c; +- if (chars_per_pixel>1) { +-#ifdef U64 +- U64* colors = d.byte1[ind]; +- if (!colors) colors = d.byte1[ind] = new U64[256]; +-#else +- U32* colors = d.byte1[ind]; +- if (!colors) colors = d.byte1[ind] = new U32[256]; +-#endif +- c = (uchar*)&colors[*p]; +- ind = (ind<<8)|*p++; +- } else { +- c = (uchar *)&d.colors[ind]; +- } ++ if (chars_per_pixel>1) ++ ind = (ind<<8)|*p++; ++ c = colors[ind]; + // look for "c word", or last word if none: + const uchar *previous_word = p; + for (;;) { +- while (*p && isspace(*p)) p++; +- uchar what = *p++; +- while (*p && !isspace(*p)) p++; +- while (*p && isspace(*p)) p++; +- if (!*p) {p = previous_word; break;} +- if (what == 'c') break; +- previous_word = p; +- while (*p && !isspace(*p)) p++; ++ while (*p && isspace(*p)) p++; ++ uchar what = *p++; ++ while (*p && !isspace(*p)) p++; ++ while (*p && isspace(*p)) p++; ++ if (!*p) {p = previous_word; break;} ++ if (what == 'c') break; ++ previous_word = p; ++ while (*p && !isspace(*p)) p++; + } +-#ifdef U64 +- *(U64*)c = 0; +-# if WORDS_BIGENDIAN +- c += 4; +-# endif +-#endif +-#ifdef __APPLE_QUARTZ__ +- c[3] = 255; +-#endif + int parse = fl_parse_color((const char*)p, c[0], c[1], c[2]); ++ c[3] = 255; + if (parse) { + #ifdef WIN32 +- used_colors[3*color_count] = c[0]; +- used_colors[3*color_count+1] = c[1]; +- used_colors[3*color_count+2] = c[2]; +- color_count++; ++ used_colors[3*color_count] = c[0]; ++ used_colors[3*color_count+1] = c[1]; ++ used_colors[3*color_count+2] = c[2]; ++ color_count++; + #endif +- } +- else { ++ } else { + // assume "None" or "#transparent" for any errors +- // "bg" should be transparent... +- Fl::get_color(bg, c[0], c[1], c[2]); +-#ifdef __APPLE_QUARTZ__ ++ // "bg" should be transparent... ++ Fl::get_color(bg, c[0], c[1], c[2]); + c[3] = 0; +-#endif + transparent_index = ind; + #ifdef WIN32 + transparent_c = c; +@@ -324,7 +199,6 @@ + } + } + } +- d.data = data; + #ifdef WIN32 + if (transparent_c) { + make_unused_color(transparent_c[0], transparent_c[1], transparent_c[2]); +@@ -334,77 +208,76 @@ + make_unused_color(r, g, b); + } + #endif ++ ++ U32 *q = (U32*)out; ++ for (int Y = 0; Y < h; Y++) { ++ const uchar* p = data[Y]; ++ if (chars_per_pixel <= 1) { ++ for (int X = 0; X < w; X++) ++ memcpy(q++, colors[*p++], 4); ++ } else { ++ for (int X = 0; X < w; X++) { ++ int ind = (*p++)<<8; ++ ind |= *p++; ++ memcpy(q++, colors[ind], 4); ++ } ++ } ++ } + ++ return 1; ++} ++ ++/** ++ Draw XPM image data, with the top-left corner at the given position. ++ \see fl_draw_pixmap(char* const* data, int x, int y, Fl_Color bg) ++ */ ++int fl_draw_pixmap(const char*const* cdata, int x, int y, Fl_Color bg) { ++ int w, h; ++ ++ if (!fl_measure_pixmap(cdata, w, h)) ++ return 0; ++ ++ uchar buffer[w*h*4]; ++ ++ if (!fl_convert_pixmap(cdata, buffer, bg)) ++ return 0; ++ ++ // FIXME: Hack until fl_draw_image() supports alpha properly + #ifdef __APPLE_QUARTZ__ + if (Fl_Surface_Device::surface() == Fl_Display_Device::display_device()) { +- U32 *array = new U32[d.w * d.h], *q = array; +- for (int Y = 0; Y < d.h; Y++) { +- const uchar* p = data[Y]; +- if (chars_per_pixel <= 1) { +- for (int X = 0; X < d.w; X++) { +- *q++ = d.colors[*p++]; +- } +- } else { +- for (int X = 0; X < d.w; X++) { +- U32* colors = (U32*)d.byte1[*p++]; +- *q++ = colors[*p++]; +- } +- } +- } +- Fl_RGB_Image* rgb = new Fl_RGB_Image((uchar*)array, d.w, d.h, 4); ++ Fl_RGB_Image* rgb = new Fl_RGB_Image(buffer, w, h, 4); + rgb->draw(x, y); + delete rgb; +- delete[] array; +- } +- else { ++ } else { + #endif // __APPLE_QUARTZ__ +- + // build the mask bitmap used by Fl_Pixmap: +- if (fl_mask_bitmap && transparent_index >= 0) { +- int W = (d.w+7)/8; +- uchar* bitmap = new uchar[W * d.h]; ++ if (fl_mask_bitmap) { ++ int W = (w+7)/8; ++ uchar* bitmap = new uchar[W * h]; + *fl_mask_bitmap = bitmap; +- for (int Y = 0; Y < d.h; Y++) { +- const uchar* p = data[Y]; +- if (chars_per_pixel <= 1) { +- int dw = d.w; +- for (int X = 0; X < W; X++) { +- uchar b = (dw-->0 && *p++ != transparent_index); +- if (dw-->0 && *p++ != transparent_index) b |= 2; +- if (dw-->0 && *p++ != transparent_index) b |= 4; +- if (dw-->0 && *p++ != transparent_index) b |= 8; +- if (dw-->0 && *p++ != transparent_index) b |= 16; +- if (dw-->0 && *p++ != transparent_index) b |= 32; +- if (dw-->0 && *p++ != transparent_index) b |= 64; +- if (dw-->0 && *p++ != transparent_index) b |= 128; ++ const uchar *p = &buffer[3]; ++ uchar b = 0; ++ for (int Y = 0; Y < h; Y++) { ++ b = 0; ++ for (int X = 0, bit = 1; X < w; X++, p += 4) { ++ if (*p > 127) b |= bit; ++ bit <<= 1; ++ if (bit > 0x80 || X == w-1) { + *bitmap++ = b; +- } +- } else { +- uchar b = 0, bit = 1; +- for (int X = 0; X < d.w; X++) { +- int ind = *p++; +- ind = (ind<<8) | (*p++); +- if (ind != transparent_index) b |= bit; +- +- if (bit < 128) bit <<= 1; +- else { +- *bitmap++ = b; +- b = 0; +- bit = 1; ++ bit = 1; ++ b = 0; + } + } +- +- if (bit > 1) *bitmap++ = b; + } +- } ++ + } + +- fl_draw_image(chars_per_pixel==1 ? cb1 : cb2, &d, x, y, d.w, d.h, 4); ++ fl_draw_image(buffer, x, y, w, h, 4); ++ + #ifdef __APPLE_QUARTZ__ + } + #endif + +- if (chars_per_pixel > 1) for (int i = 0; i < 256; i++) delete[] d.byte1[i]; + return 1; + } + +diff -ur fltk-1.3.2.org/src/Fl_Image.cxx fltk-1.3.2/src/Fl_Image.cxx +--- fltk-1.3.2.org/src/Fl_Image.cxx 2012-11-09 17:02:08.000000000 +0100 ++++ fltk-1.3.2/src/Fl_Image.cxx 2013-01-16 14:41:38.404162795 +0100 +@@ -165,7 +165,22 @@ + // + size_t Fl_RGB_Image::max_size_ = ~((size_t)0); + +-/** The destructor free all memory and server resources that are used by the image. */ ++int fl_convert_pixmap(const char*const* cdata, uchar* out, Fl_Color bg); ++ ++/** The constructor creates a new RGBA image from the specified Fl_Pixmap. ++ ++ The RGBA image is built fully opaque except for the transparent area ++ of the pixmap that is assigned the \par bg color with full transparency */ ++Fl_RGB_Image::Fl_RGB_Image(const Fl_Pixmap *pxm, Fl_Color bg): ++ Fl_Image(pxm->w(), pxm->h(), 4), id_(0), mask_(0) ++{ ++ array = new uchar[w() * h() * d()]; ++ alloc_array = 1; ++ fl_convert_pixmap(pxm->data(), (uchar*)array, bg); ++ data((const char **)&array, 1); ++} ++ ++/** The destructor frees all memory and server resources that are used by the image. */ + Fl_RGB_Image::~Fl_RGB_Image() { + uncache(); + if (alloc_array) delete[] (uchar *)array; +diff -ur fltk-1.3.2.org/src/ps_image.cxx fltk-1.3.2/src/ps_image.cxx +--- fltk-1.3.2.org/src/ps_image.cxx 2011-07-19 06:49:30.000000000 +0200 ++++ fltk-1.3.2/src/ps_image.cxx 2013-01-16 14:40:51.541228080 +0100 +@@ -185,72 +185,38 @@ + + extern uchar **fl_mask_bitmap; + ++struct callback_data { ++ const uchar *data; ++ int D, LD; ++}; + +-void Fl_PostScript_Graphics_Driver::draw_image(const uchar *data, int ix, int iy, int iw, int ih, int D, int LD) { +- double x = ix, y = iy, w = iw, h = ih; + +- if (D<3){ //mono +- draw_image_mono(data, ix, iy, iw, ih, D, LD); +- return; +- } ++static void draw_image_cb(void *data, int x, int y, int w, uchar *buf) { ++ struct callback_data *cb_data; ++ const uchar *curdata; + ++ cb_data = (struct callback_data*)data; ++ curdata = cb_data->data + x*cb_data->D + y*cb_data->LD; + +- int i,j, k; ++ memcpy(buf, curdata, w*cb_data->D); ++} + +- fprintf(output,"save\n"); + +- const char * interpol; +- if (lang_level_>1){ +- if (interpolate_) +- interpol="true"; +- else +- interpol="false"; +- if (mask && lang_level_>2) +- fprintf(output, "%g %g %g %g %i %i %i %i %s CIM\n", x , y+h , w , -h , iw , ih, mx, my, interpol); +- else +- fprintf(output, "%g %g %g %g %i %i %s CII\n", x , y+h , w , -h , iw , ih, interpol); +- } else +- fprintf(output , "%g %g %g %g %i %i CI", x , y+h , w , -h , iw , ih); ++void Fl_PostScript_Graphics_Driver::draw_image(const uchar *data, int ix, int iy, int iw, int ih, int D, int LD) { ++ if (D<3){ //mono ++ draw_image_mono(data, ix, iy, iw, ih, D, LD); ++ return; ++ } + ++ struct callback_data cb_data; + + if (!LD) LD = iw*D; +- uchar *curmask=mask; +- +- for (j=0; j<ih;j++){ +- if (mask){ +- +- for (k=0;k<my/ih;k++){ +- for (i=0; i<((mx+7)/8);i++){ +- if (!(i%80)) fprintf(output, "\n"); +- fprintf(output, "%.2x",swap_byte(*curmask)); +- curmask++; +- } +- fprintf(output,"\n"); +- } +- } +- const uchar *curdata=data+j*LD; +- for (i=0 ; i<iw ; i++) { +- uchar r = curdata[0]; +- uchar g = curdata[1]; +- uchar b = curdata[2]; +- if (lang_level_<3 && D>3) { //can do mixing using bg_* colors) +- unsigned int a2 = curdata[3]; //must be int +- unsigned int a = 255-a2; +- r = (a2 * r + bg_r * a)/255; +- g = (a2 * g + bg_g * a)/255; +- b = (a2 * b + bg_b * a)/255; +- } +- if (!(i%40)) fprintf(output, "\n"); +- fprintf(output, "%.2x%.2x%.2x", r, g, b); +- curdata +=D; +- } +- fprintf(output,"\n"); +- +- } +- +- fprintf(output," >\nrestore\n" ); + ++ cb_data.data = data; ++ cb_data.D = D; ++ cb_data.LD = LD; + ++ draw_image(draw_image_cb, &cb_data, ix, iy, iw, ih, D); + } + + void Fl_PostScript_Graphics_Driver::draw_image(Fl_Draw_Image_Cb call, void *data, int ix, int iy, int iw, int ih, int D) { +@@ -325,6 +291,14 @@ + uchar g = curdata[1]; + uchar b = curdata[2]; + ++ if (lang_level_<3 && D>3) { //can do mixing using bg_* colors) ++ unsigned int a2 = curdata[3]; //must be int ++ unsigned int a = 255-a2; ++ r = (a2 * r + bg_r * a)/255; ++ g = (a2 * g + bg_g * a)/255; ++ b = (a2 * b + bg_b * a)/255; ++ } ++ + if (!(i%40)) fputs("\n", output); + fprintf(output, "%.2x%.2x%.2x", r, g, b); + diff --git a/contrib/fltk/07-str2660-fltk-1.3.x-cursor.patch b/contrib/fltk/07-str2660-fltk-1.3.x-cursor.patch new file mode 100644 index 00000000..8e990505 --- /dev/null +++ b/contrib/fltk/07-str2660-fltk-1.3.x-cursor.patch @@ -0,0 +1,1623 @@ +diff -up fltk-1.3.2/CMakeLists.txt.cursor fltk-1.3.2/CMakeLists.txt +--- fltk-1.3.2/CMakeLists.txt.cursor 2013-01-30 16:07:59.510320246 +0100 ++++ fltk-1.3.2/CMakeLists.txt 2013-01-30 16:07:59.528319926 +0100 +@@ -529,6 +529,20 @@ else() + endif(OPTION_USE_XFIXES) + + ####################################################################### ++if(X11_Xcursor_FOUND) ++ option(OPTION_USE_XCURSOR "use lib XCURSOR" ON) ++endif(X11_Xcursor_FOUND) ++ ++if(OPTION_USE_XCURSOR) ++ set(HAVE_XCURSOR ${X11_Xcursor_FOUND}) ++ include_directories(${X11_Xcursor_INCLUDE_PATH}) ++ list(APPEND FLTK_LDLIBS -lXcursor) ++ set(FLTK_XCURSOR_FOUND TRUE) ++else() ++ set(FLTK_XCURSOR_FOUND FALSE) ++endif(OPTION_USE_XCURSOR) ++ ++####################################################################### + if(X11_Xft_FOUND) + option(OPTION_USE_XFT "use lib Xft" ON) + endif(X11_Xft_FOUND) +diff -up fltk-1.3.2/configh.cmake.in.cursor fltk-1.3.2/configh.cmake.in +--- fltk-1.3.2/configh.cmake.in.cursor 2013-01-30 16:07:59.510320246 +0100 ++++ fltk-1.3.2/configh.cmake.in 2013-01-30 16:07:59.529319908 +0100 +@@ -116,6 +116,14 @@ + #cmakedefine01 HAVE_XFIXES + + /* ++ * HAVE_XCURSOR: ++ * ++ * Do we have the X cursor library? ++ */ ++ ++#cmakedefine01 HAVE_XCURSOR ++ ++/* + * __APPLE_QUARTZ__: + * + * If __APPLE_QUARTZ__ is defined, FLTK will be +diff -up fltk-1.3.2/configh.in.cursor fltk-1.3.2/configh.in +--- fltk-1.3.2/configh.in.cursor 2013-01-30 16:07:59.510320246 +0100 ++++ fltk-1.3.2/configh.in 2013-01-30 16:07:59.529319908 +0100 +@@ -116,6 +116,14 @@ + #define HAVE_XFIXES 0 + + /* ++ * HAVE_XCURSOR: ++ * ++ * Do we have the X cursor library? ++ */ ++ ++#define HAVE_XCURSOR 0 ++ ++/* + * __APPLE_QUARTZ__: + * + * All Apple implementations are now based on Quartz and Cocoa, +diff -up fltk-1.3.2/configure.in.cursor fltk-1.3.2/configure.in +--- fltk-1.3.2/configure.in.cursor 2013-01-30 16:07:59.511320228 +0100 ++++ fltk-1.3.2/configure.in 2013-01-30 16:07:59.529319908 +0100 +@@ -1009,6 +1009,16 @@ case $uname_GUI in + LIBS="-lXfixes $LIBS") + fi + ++ dnl Check for the Xcursor library unless disabled... ++ AC_ARG_ENABLE(xcursor, [ --enable-xcursor turn on Xcursor support [default=yes]]) ++ ++ if test x$enable_xcursor != xno; then ++ AC_CHECK_HEADER(X11/Xcursor/Xcursor.h, AC_DEFINE(HAVE_XCURSOR),, ++ [#include <X11/Xlib.h>]) ++ AC_CHECK_LIB(Xcursor, XcursorImageCreate, ++ LIBS="-lXcursor $LIBS") ++ fi ++ + dnl Check for overlay visuals... + AC_PATH_PROG(XPROP, xprop) + AC_CACHE_CHECK(for X overlay visuals, ac_cv_have_overlay, +diff -up fltk-1.3.2/FL/Enumerations.H.cursor fltk-1.3.2/FL/Enumerations.H +--- fltk-1.3.2/FL/Enumerations.H.cursor 2013-01-30 16:07:59.486320673 +0100 ++++ fltk-1.3.2/FL/Enumerations.H 2013-01-30 16:07:59.530319891 +0100 +@@ -879,35 +879,36 @@ inline Fl_Color fl_color_cube(int r, int + + /** The following constants define the mouse cursors that are available in FLTK. + +- The double-headed arrows are bitmaps provided by FLTK on X, the others +- are provided by system-defined cursors. ++ Cursors are provided by the system when available, or bitmaps built into ++ FLTK as a fallback. + + \todo enum Fl_Cursor needs maybe an image. + */ + enum Fl_Cursor { + FL_CURSOR_DEFAULT = 0, /**< the default cursor, usually an arrow. */ +- FL_CURSOR_ARROW = 35, /**< an arrow pointer. */ +- FL_CURSOR_CROSS = 66, /**< crosshair. */ +- FL_CURSOR_WAIT = 76, /**< watch or hourglass. */ +- FL_CURSOR_INSERT = 77, /**< I-beam. */ +- FL_CURSOR_HAND = 31, /**< hand (uparrow on MSWindows). */ +- FL_CURSOR_HELP = 47, /**< question mark. */ +- FL_CURSOR_MOVE = 27, /**< 4-pointed arrow. */ +- // fltk provides bitmaps for these: +- FL_CURSOR_NS = 78, /**< up/down arrow. */ +- FL_CURSOR_WE = 79, /**< left/right arrow. */ +- FL_CURSOR_NWSE = 80, /**< diagonal arrow. */ +- FL_CURSOR_NESW = 81, /**< diagonal arrow. */ +- FL_CURSOR_NONE =255, /**< invisible. */ +- // for back compatibility (non MSWindows ones): +- FL_CURSOR_N = 70, /**< for back compatibility. */ +- FL_CURSOR_NE = 69, /**< for back compatibility. */ +- FL_CURSOR_E = 49, /**< for back compatibility. */ +- FL_CURSOR_SE = 8, /**< for back compatibility. */ +- FL_CURSOR_S = 9, /**< for back compatibility. */ +- FL_CURSOR_SW = 7, /**< for back compatibility. */ +- FL_CURSOR_W = 36, /**< for back compatibility. */ +- FL_CURSOR_NW = 68 /**< for back compatibility. */ ++ FL_CURSOR_ARROW = 1, /**< an arrow pointer. */ ++ FL_CURSOR_CROSS = 2, /**< crosshair. */ ++ FL_CURSOR_WAIT = 3, /**< busy indicator (e.g. hourglass). */ ++ FL_CURSOR_INSERT = 4, /**< I-beam. */ ++ FL_CURSOR_HAND = 5, /**< pointing hand. */ ++ FL_CURSOR_HELP = 6, /**< question mark pointer. */ ++ FL_CURSOR_MOVE = 7, /**< 4-pointed arrow or hand. */ ++ ++ /* Resize indicators */ ++ FL_CURSOR_NS = 101, /**< up/down resize. */ ++ FL_CURSOR_WE = 102, /**< left/right resize. */ ++ FL_CURSOR_NWSE = 103, /**< diagonal resize. */ ++ FL_CURSOR_NESW = 104, /**< diagonal resize. */ ++ FL_CURSOR_NE = 110, /**< upwards, right resize. */ ++ FL_CURSOR_N = 111, /**< upwards resize. */ ++ FL_CURSOR_NW = 112, /**< upwards, left resize. */ ++ FL_CURSOR_E = 113, /**< leftwards resize. */ ++ FL_CURSOR_W = 114, /**< rightwards resize. */ ++ FL_CURSOR_SE = 115, /**< downwards, right resize. */ ++ FL_CURSOR_S = 116, /**< downwards resize. */ ++ FL_CURSOR_SW = 117, /**< downwards, left resize. */ ++ ++ FL_CURSOR_NONE = 255, /**< invisible. */ + }; + /*@}*/ // group: Cursors + +diff -up fltk-1.3.2/FL/fl_draw.H.cursor fltk-1.3.2/FL/fl_draw.H +--- fltk-1.3.2/FL/fl_draw.H.cursor 2012-05-08 18:15:34.000000000 +0200 ++++ fltk-1.3.2/FL/fl_draw.H 2013-01-30 16:07:59.530319891 +0100 +@@ -751,7 +751,8 @@ FL_EXPORT const char* fl_shortcut_label( + FL_EXPORT unsigned int fl_old_shortcut(const char* s); + FL_EXPORT void fl_overlay_rect(int x,int y,int w,int h); + FL_EXPORT void fl_overlay_clear(); +-FL_EXPORT void fl_cursor(Fl_Cursor, Fl_Color fg=FL_BLACK, Fl_Color bg=FL_WHITE); ++FL_EXPORT void fl_cursor(Fl_Cursor); ++FL_EXPORT void fl_cursor(Fl_Cursor, Fl_Color fg, Fl_Color bg=FL_WHITE); + FL_EXPORT const char* fl_expand_text(const char* from, char* buf, int maxbuf, + double maxw, int& n, double &width, + int wrap, int draw_symbols = 0); +diff -up fltk-1.3.2/FL/Fl_Window.H.cursor fltk-1.3.2/FL/Fl_Window.H +--- fltk-1.3.2/FL/Fl_Window.H.cursor 2012-11-06 21:46:14.000000000 +0100 ++++ fltk-1.3.2/FL/Fl_Window.H 2013-01-30 16:07:59.531319873 +0100 +@@ -28,6 +28,7 @@ + #define FL_DOUBLE_WINDOW 0xF1 ///< double window type id + + class Fl_X; ++class Fl_RGB_Image; + + /** + This widget produces an actual window. This can either be a main +@@ -81,7 +82,6 @@ class FL_EXPORT Fl_Window : public Fl_Gr + uchar size_range_set; + // cursor stuff + Fl_Cursor cursor_default; +- Fl_Color cursor_fg, cursor_bg; + void size_range_(); + void _Fl_Window(); // constructor innards + void fullscreen_x(); // platform-specific part of sending a window to full screen +@@ -466,14 +466,17 @@ public: + is different. + + The type Fl_Cursor is an enumeration defined in <FL/Enumerations.H>. +- (Under X you can get any XC_cursor value by passing +- Fl_Cursor((XC_foo/2)+1)). The colors only work on X, they are +- not implemented on WIN32. + +- For back compatibility only. ++ \see cursor(const Fl_RGB_Image*, int, int), default_cursor() + */ +- void cursor(Fl_Cursor, Fl_Color=FL_BLACK, Fl_Color=FL_WHITE); // platform dependent +- void default_cursor(Fl_Cursor, Fl_Color=FL_BLACK, Fl_Color=FL_WHITE); ++ void cursor(Fl_Cursor); ++ void cursor(const Fl_RGB_Image*, int, int); ++ void default_cursor(Fl_Cursor); ++ ++ /* for legacy compatibility */ ++ void cursor(Fl_Cursor c, Fl_Color, Fl_Color=FL_WHITE); ++ void default_cursor(Fl_Cursor c, Fl_Color, Fl_Color=FL_WHITE); ++ + static void default_callback(Fl_Window*, void* v); + + /** Returns the window width including any frame added by the window manager. +diff -up fltk-1.3.2/FL/mac.H.cursor fltk-1.3.2/FL/mac.H +--- fltk-1.3.2/FL/mac.H.cursor 2012-11-13 15:45:42.000000000 +0100 ++++ fltk-1.3.2/FL/mac.H 2013-01-30 16:07:59.531319873 +0100 +@@ -120,7 +120,8 @@ public: + void collapse(void); + WindowRef window_ref(void); + void set_key_window(void); +- void set_cursor(Fl_Cursor); ++ int set_cursor(Fl_Cursor); ++ int set_cursor(const Fl_RGB_Image*, int, int); + static CGImageRef CGImage_from_window_rect(Fl_Window *win, int x, int y, int w, int h); + static unsigned char *bitmap_from_window_rect(Fl_Window *win, int x, int y, int w, int h, int *bytesPerPixel); + static Fl_Region intersect_region_and_rect(Fl_Region current, int x,int y,int w, int h); +diff -up fltk-1.3.2/FL/win32.H.cursor fltk-1.3.2/FL/win32.H +--- fltk-1.3.2/FL/win32.H.cursor 2012-03-12 12:55:50.000000000 +0100 ++++ fltk-1.3.2/FL/win32.H 2013-01-30 16:07:59.531319873 +0100 +@@ -73,6 +73,7 @@ public: + int wait_for_expose; + HDC private_dc; // used for OpenGL + HCURSOR cursor; ++ int custom_cursor; + HDC saved_hdc; // saves the handle of the DC currently loaded + // static variables, static functions and member functions + static Fl_X* first; +@@ -83,6 +84,8 @@ public: + void flush() {w->flush();} + void set_minmax(LPMINMAXINFO minmax); + void mapraise(); ++ int set_cursor(Fl_Cursor); ++ int set_cursor(const Fl_RGB_Image*, int, int); + static Fl_X* make(Fl_Window*); + }; + extern FL_EXPORT HCURSOR fl_default_cursor; +diff -up fltk-1.3.2/FL/x.H.cursor fltk-1.3.2/FL/x.H +--- fltk-1.3.2/FL/x.H.cursor 2012-03-23 17:47:53.000000000 +0100 ++++ fltk-1.3.2/FL/x.H 2013-01-30 16:07:59.532319855 +0100 +@@ -154,6 +154,8 @@ public: + static Fl_X* i(const Fl_Window* wi) {return wi->i;} + void setwindow(Fl_Window* wi) {w=wi; wi->i=this;} + void sendxjunk(); ++ int set_cursor(Fl_Cursor); ++ int set_cursor(const Fl_RGB_Image*, int, int); + static void make_xid(Fl_Window*,XVisualInfo* =fl_visual, Colormap=fl_colormap); + static Fl_X* set_xid(Fl_Window*, Window); + // kludges to get around protection: +diff -up fltk-1.3.2/src/CMakeLists.txt.cursor fltk-1.3.2/src/CMakeLists.txt +--- fltk-1.3.2/src/CMakeLists.txt.cursor 2013-01-30 16:09:11.981032475 +0100 ++++ fltk-1.3.2/src/CMakeLists.txt 2013-01-30 16:09:26.497774461 +0100 +@@ -247,6 +247,10 @@ if(HAVE_XFIXES) + target_link_libraries(fltk ${X11_Xfixes_LIB}) + endif(HAVE_XFIXES) + ++if(HAVE_XCURSOR) ++ target_link_libraries(fltk ${X11_Xcursor_LIB}) ++endif(HAVE_XCURSOR) ++ + if(USE_XFT) + target_link_libraries(fltk ${X11_Xft_LIB}) + endif(USE_XFT) +diff -up fltk-1.3.2/src/Fl_cocoa.mm.cursor fltk-1.3.2/src/Fl_cocoa.mm +--- fltk-1.3.2/src/Fl_cocoa.mm.cursor 2013-01-30 16:07:59.522320033 +0100 ++++ fltk-1.3.2/src/Fl_cocoa.mm 2013-01-30 16:07:59.533319837 +0100 +@@ -98,7 +98,6 @@ Fl_Display_Device *Fl_Display_Device::_d + CGContextRef fl_gc = 0; + void *fl_system_menu; // this is really a NSMenu* + Fl_Sys_Menu_Bar *fl_sys_menu_bar = 0; +-void *fl_default_cursor; // this is really a NSCursor* + void *fl_capture = 0; // (NSWindow*) we need this to compensate for a missing(?) mouse capture + bool fl_show_iconic; // true if called from iconize() - shows the next created window in collapsed state + //int fl_disable_transient_for; // secret method of removing TRANSIENT_FOR +@@ -1392,8 +1391,6 @@ void fl_open_display() { + dequeue:YES]; + while (ign_event); + +- fl_default_cursor = [NSCursor arrowCursor]; +- + // bring the application into foreground without a 'CARB' resource + Boolean same_psn; + ProcessSerialNumber cur_psn, front_psn; +@@ -1698,6 +1695,7 @@ static void q_set_window_title(NSWindow + - (void)drawRect:(NSRect)rect; + - (BOOL)acceptsFirstResponder; + - (BOOL)acceptsFirstMouse:(NSEvent*)theEvent; ++- (void)resetCursorRects; + - (BOOL)performKeyEquivalent:(NSEvent*)theEvent; + - (void)mouseUp:(NSEvent *)theEvent; + - (void)rightMouseUp:(NSEvent *)theEvent; +@@ -1756,6 +1754,16 @@ static void q_set_window_title(NSWindow + Fl_Window *first = Fl::first_window(); + return (first == w || !first->modal()); + } ++- (void)resetCursorRects { ++ Fl_Window *w = [(FLWindow*)[self window] getFl_Window]; ++ Fl_X *i = Fl_X::i(w); ++ // We have to have at least one cursor rect for invalidateCursorRectsForView ++ // to work, hence the "else" clause. ++ if (i->cursor) ++ [self addCursorRect:[self visibleRect] cursor:(NSCursor*)i->cursor]; ++ else ++ [self addCursorRect:[self visibleRect] cursor:[NSCursor arrowCursor]]; ++} + - (void)mouseUp:(NSEvent *)theEvent { + cocoaMouseHandler(theEvent); + } +@@ -2331,7 +2339,7 @@ void Fl_X::make(Fl_Window* w) + x->other_xid = 0; + x->region = 0; + x->subRegion = 0; +- x->cursor = fl_default_cursor; ++ x->cursor = NULL; + x->gc = 0; // stay 0 for Quickdraw; fill with CGContext for Quartz + Fl_Window *win = w->window(); + Fl_X *xo = Fl_X::i(win); +@@ -2427,7 +2435,7 @@ void Fl_X::make(Fl_Window* w) + x->other_xid = 0; // room for doublebuffering image map. On OS X this is only used by overlay windows + x->region = 0; + x->subRegion = 0; +- x->cursor = fl_default_cursor; ++ x->cursor = NULL; + x->xidChildren = 0; + x->xidNext = 0; + x->gc = 0; +@@ -2974,6 +2982,10 @@ void Fl_X::map() { + Fl_X::relink(w, w->window() ); + w->redraw(); + } ++ if (cursor) { ++ [(NSCursor*)cursor release]; ++ cursor = NULL; ++ } + } + + void Fl_X::unmap() { +@@ -3078,68 +3090,106 @@ static NSImage *CGBitmapContextToNSImage + return [image autorelease]; + } + +-static NSCursor *PrepareCursor(NSCursor *cursor, CGContextRef (*f)() ) ++int Fl_X::set_cursor(Fl_Cursor c) + { +- if (cursor == nil) { +- CGContextRef c = f(); +- NSImage *image = CGBitmapContextToNSImage(c); +- fl_delete_offscreen( (Fl_Offscreen)c ); +- NSPoint pt = {[image size].width/2, [image size].height/2}; +- cursor = [[NSCursor alloc] initWithImage:image hotSpot:pt]; ++ if (cursor) { ++ [(NSCursor*)cursor release]; ++ cursor = NULL; + } +- return cursor; +-} + +-void Fl_X::set_cursor(Fl_Cursor c) +-{ +- NSCursor *icrsr; + switch (c) { +- case FL_CURSOR_CROSS: icrsr = [NSCursor crosshairCursor]; break; +- case FL_CURSOR_WAIT: +- static NSCursor *watch = nil; +- watch = PrepareCursor(watch, &Fl_X::watch_cursor_image); +- icrsr = watch; +- break; +- case FL_CURSOR_INSERT: icrsr = [NSCursor IBeamCursor]; break; +- case FL_CURSOR_N: icrsr = [NSCursor resizeUpCursor]; break; +- case FL_CURSOR_S: icrsr = [NSCursor resizeDownCursor]; break; +- case FL_CURSOR_NS: icrsr = [NSCursor resizeUpDownCursor]; break; +- case FL_CURSOR_HELP: +- static NSCursor *help = nil; +- help = PrepareCursor(help, &Fl_X::help_cursor_image); +- icrsr = help; +- break; +- case FL_CURSOR_HAND: icrsr = [NSCursor pointingHandCursor]; break; +- case FL_CURSOR_MOVE: icrsr = [NSCursor openHandCursor]; break; +- case FL_CURSOR_NE: +- case FL_CURSOR_SW: +- case FL_CURSOR_NESW: +- static NSCursor *nesw = nil; +- nesw = PrepareCursor(nesw, &Fl_X::nesw_cursor_image); +- icrsr = nesw; +- break; +- case FL_CURSOR_E: icrsr = [NSCursor resizeRightCursor]; break; +- case FL_CURSOR_W: icrsr = [NSCursor resizeLeftCursor]; break; +- case FL_CURSOR_WE: icrsr = [NSCursor resizeLeftRightCursor]; break; +- case FL_CURSOR_SE: +- case FL_CURSOR_NW: +- case FL_CURSOR_NWSE: +- static NSCursor *nwse = nil; +- nwse = PrepareCursor(nwse, &Fl_X::nwse_cursor_image); +- icrsr = nwse; +- break; +- case FL_CURSOR_NONE: +- static NSCursor *none = nil; +- none = PrepareCursor(none, &Fl_X::none_cursor_image); +- icrsr = none; +- break; +- case FL_CURSOR_ARROW: +- case FL_CURSOR_DEFAULT: +- default: icrsr = [NSCursor arrowCursor]; +- break; ++ case FL_CURSOR_ARROW: cursor = [NSCursor arrowCursor]; break; ++ case FL_CURSOR_CROSS: cursor = [NSCursor crosshairCursor]; break; ++ case FL_CURSOR_INSERT: cursor = [NSCursor IBeamCursor]; break; ++ case FL_CURSOR_HAND: cursor = [NSCursor pointingHandCursor]; break; ++ case FL_CURSOR_MOVE: cursor = [NSCursor openHandCursor]; break; ++ case FL_CURSOR_NS: cursor = [NSCursor resizeUpDownCursor]; break; ++ case FL_CURSOR_WE: cursor = [NSCursor resizeLeftRightCursor]; break; ++ case FL_CURSOR_N: cursor = [NSCursor resizeUpCursor]; break; ++ case FL_CURSOR_E: cursor = [NSCursor resizeRightCursor]; break; ++ case FL_CURSOR_W: cursor = [NSCursor resizeLeftCursor]; break; ++ case FL_CURSOR_S: cursor = [NSCursor resizeDownCursor]; break; ++ default: ++ return 0; ++ } ++ ++ [(NSCursor*)cursor retain]; ++ ++ [(NSWindow*)xid invalidateCursorRectsForView:[(NSWindow*)xid contentView]]; ++ ++ return 1; ++} ++ ++int Fl_X::set_cursor(const Fl_RGB_Image *image, int hotx, int hoty) { ++ if (cursor) { ++ [(NSCursor*)cursor release]; ++ cursor = NULL; ++ } ++ ++ if ((hotx < 0) || (hotx >= image->w())) ++ return 0; ++ if ((hoty < 0) || (hoty >= image->h())) ++ return 0; ++ ++ // OS X >= 10.6 can create a NSImage from a CGImage, but we need to ++ // support older versions, hence this pesky handling. ++ ++ NSBitmapImageRep *bitmap = [[NSBitmapImageRep alloc] ++ initWithBitmapDataPlanes:NULL ++ pixelsWide:image->w() ++ pixelsHigh:image->h() ++ bitsPerSample:8 ++ samplesPerPixel:image->d() ++ hasAlpha:!(image->d() & 1) ++ isPlanar:NO ++ colorSpaceName:(image->d()<=2) ? NSDeviceWhiteColorSpace : NSDeviceRGBColorSpace ++ bytesPerRow:(image->w() * image->d()) ++ bitsPerPixel:(image->d()*8)]; ++ ++ // Alpha needs to be premultiplied for this format ++ ++ const uchar *i = (const uchar*)*image->data(); ++ unsigned char *o = [bitmap bitmapData]; ++ for (int y = 0;y < image->h();y++) { ++ if (image->d() & 1) { ++ for (int x = 0;x < image->w();x++) { ++ unsigned int alpha; ++ if (image->d() == 4) { ++ alpha = i[3]; ++ *o++ = (unsigned char)((unsigned int)*i++ * alpha / 255); ++ *o++ = (unsigned char)((unsigned int)*i++ * alpha / 255); ++ } ++ ++ alpha = i[1]; ++ *o++ = (unsigned char)((unsigned int)*i++ * alpha / 255); ++ *o++ = alpha; ++ i++; ++ } ++ } else { ++ // No alpha, so we can just copy everything directly. ++ int len = image->w() * image->d(); ++ memcpy(o, i, len); ++ o += len; ++ i += len; ++ } ++ i += image->ld(); + } +- [icrsr set]; +- cursor = icrsr; ++ ++ NSImage *nsimage = [[NSImage alloc] ++ initWithSize:NSMakeSize(image->w(), image->h())]; ++ ++ [nsimage addRepresentation:bitmap]; ++ ++ cursor = [[NSCursor alloc] ++ initWithImage:nsimage ++ hotSpot:NSMakePoint(hotx, hoty)]; ++ ++ [(NSWindow*)xid invalidateCursorRectsForView:[(NSWindow*)xid contentView]]; ++ ++ [bitmap release]; ++ [nsimage release]; ++ ++ return 1; + } + + @interface FLaboutItemTarget : NSObject +diff -up fltk-1.3.2/src/fl_cursor.cxx.cursor fltk-1.3.2/src/fl_cursor.cxx +--- fltk-1.3.2/src/fl_cursor.cxx.cursor 2012-03-12 12:55:50.000000000 +0100 ++++ fltk-1.3.2/src/fl_cursor.cxx 2013-01-30 16:07:59.534319820 +0100 +@@ -24,297 +24,165 @@ + + #include <FL/Fl.H> + #include <FL/Fl_Window.H> ++#include <FL/Fl_Pixmap.H> ++#include <FL/Fl_RGB_Image.H> + #include <FL/x.H> +-#if !defined(WIN32) && !defined(__APPLE__) +-# include <X11/cursorfont.h> +-#endif + #include <FL/fl_draw.H> + ++#include "fl_cursor_wait.xpm" ++#include "fl_cursor_help.xpm" ++#include "fl_cursor_nwse.xpm" ++#include "fl_cursor_nesw.xpm" ++#include "fl_cursor_none.xpm" ++ + /** + Sets the cursor for the current window to the specified shape and colors. + The cursors are defined in the <FL/Enumerations.H> header file. + */ ++void fl_cursor(Fl_Cursor c) { ++ if (Fl::first_window()) Fl::first_window()->cursor(c); ++} ++ ++/* For back compatibility only. */ + void fl_cursor(Fl_Cursor c, Fl_Color fg, Fl_Color bg) { +- if (Fl::first_window()) Fl::first_window()->cursor(c,fg,bg); ++ fl_cursor(c); + } ++ ++ + /** +- Sets the default window cursor as well as its color. ++ Sets the default window cursor. This is the cursor that will be used ++ after the mouse pointer leaves a widget with a custom cursor set. + +- For back compatibility only. ++ \see cursor(const Fl_RGB_Image*, int, int), default_cursor() + */ +-void Fl_Window::default_cursor(Fl_Cursor c, Fl_Color fg, Fl_Color bg) { +-// if (c == FL_CURSOR_DEFAULT) c = FL_CURSOR_ARROW; +- ++void Fl_Window::default_cursor(Fl_Cursor c) { + cursor_default = c; +- cursor_fg = fg; +- cursor_bg = bg; ++ cursor(c); ++} ++ ++ ++void fallback_cursor(Fl_Window *w, Fl_Cursor c) { ++ const char **xpm; ++ int hotx, hoty; ++ ++ // The standard arrow is our final fallback, so something is broken ++ // if we get called back here with that as an argument. ++ if (c == FL_CURSOR_ARROW) ++ return; ++ ++ switch (c) { ++ case FL_CURSOR_WAIT: ++ xpm = (const char**)fl_cursor_wait_xpm; ++ hotx = 8; ++ hoty = 15; ++ break; ++ case FL_CURSOR_HELP: ++ xpm = (const char**)fl_cursor_help_xpm; ++ hotx = 1; ++ hoty = 3; ++ break; ++ case FL_CURSOR_NWSE: ++ xpm = (const char**)fl_cursor_nwse_xpm; ++ hotx = 7; ++ hoty = 7; ++ break; ++ case FL_CURSOR_NESW: ++ xpm = (const char**)fl_cursor_nesw_xpm; ++ hotx = 7; ++ hoty = 7; ++ break; ++ case FL_CURSOR_NONE: ++ xpm = (const char**)fl_cursor_none_xpm; ++ hotx = 0; ++ hoty = 0; ++ break; ++ default: ++ w->cursor(FL_CURSOR_ARROW); ++ return; ++ } + +- cursor(c, fg, bg); ++ Fl_Pixmap pxm(xpm); ++ Fl_RGB_Image image(&pxm); ++ ++ w->cursor(&image, hotx, hoty); + } + +-#ifdef WIN32 + +-# ifndef IDC_HAND +-# define IDC_HAND MAKEINTRESOURCE(32649) +-# endif // !IDC_HAND ++void Fl_Window::cursor(Fl_Cursor c) { ++ int ret; + +-void Fl_Window::cursor(Fl_Cursor c, Fl_Color c1, Fl_Color c2) { +- if (!shown()) return; + // the cursor must be set for the top level window, not for subwindows + Fl_Window *w = window(), *toplevel = this; +- while (w) { toplevel = w; w = w->window(); } +- if (toplevel != this) { toplevel->cursor(c, c1, c2); return; } +- // now set the actual cursor +- if (c == FL_CURSOR_DEFAULT) { +- c = cursor_default; +- } +- if (c > FL_CURSOR_NESW) { +- i->cursor = 0; +- } else if (c == FL_CURSOR_DEFAULT) { +- i->cursor = fl_default_cursor; +- } else { +- LPSTR n; +- switch (c) { +- case FL_CURSOR_ARROW: n = IDC_ARROW; break; +- case FL_CURSOR_CROSS: n = IDC_CROSS; break; +- case FL_CURSOR_WAIT: n = IDC_WAIT; break; +- case FL_CURSOR_INSERT: n = IDC_IBEAM; break; +- case FL_CURSOR_HELP: n = IDC_HELP; break; +- case FL_CURSOR_HAND: { +- OSVERSIONINFO osvi; +- +- // Get the OS version: Windows 98 and 2000 have a standard +- // hand cursor. +- memset(&osvi, 0, sizeof(OSVERSIONINFO)); +- osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); +- GetVersionEx(&osvi); +- +- if (osvi.dwMajorVersion > 4 || +- (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion > 0 && +- osvi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)) n = IDC_HAND; +- else n = IDC_UPARROW; +- } break; +- case FL_CURSOR_MOVE: n = IDC_SIZEALL; break; +- case FL_CURSOR_N: +- case FL_CURSOR_S: +- case FL_CURSOR_NS: n = IDC_SIZENS; break; +- case FL_CURSOR_NE: +- case FL_CURSOR_SW: +- case FL_CURSOR_NESW: n = IDC_SIZENESW; break; +- case FL_CURSOR_E: +- case FL_CURSOR_W: +- case FL_CURSOR_WE: n = IDC_SIZEWE; break; +- case FL_CURSOR_SE: +- case FL_CURSOR_NW: +- case FL_CURSOR_NWSE: n = IDC_SIZENWSE; break; +- default: n = IDC_NO; break; +- } +- i->cursor = LoadCursor(NULL, n); ++ ++ while (w) { ++ toplevel = w; ++ w = w->window(); + } +- SetCursor(i->cursor); +-} + +-#elif defined(__APPLE__) ++ if (toplevel != this) { ++ toplevel->cursor(c); ++ return; ++ } + +-#ifdef __BIG_ENDIAN__ +-# define E(x) x +-#elif defined __LITTLE_ENDIAN__ +-// Don't worry. This will be resolved at compile time +-# define E(x) (x>>8)|((x<<8)&0xff00) +-#else +-# error "Either __LITTLE_ENDIAN__ or __BIG_ENDIAN__ must be defined" +-#endif +- +-CGContextRef Fl_X::help_cursor_image(void) +-{ +- int w = 20, h = 20; +- Fl_Offscreen off = Fl_Quartz_Graphics_Driver::create_offscreen_with_alpha(w, h); +- fl_begin_offscreen(off); +- CGContextSetRGBFillColor( (CGContextRef)off, 0,0,0,0); +- fl_rectf(0,0,w,h); +- fl_color(FL_BLACK); +- fl_font(FL_COURIER_BOLD, 20); +- fl_draw("?", 1, h-1); +- fl_end_offscreen(); +- return (CGContextRef)off; +-} ++ if (c == FL_CURSOR_DEFAULT) ++ c = cursor_default; + +-CGContextRef Fl_X::none_cursor_image(void) +-{ +- int w = 20, h = 20; +- Fl_Offscreen off = Fl_Quartz_Graphics_Driver::create_offscreen_with_alpha(w, h); +- fl_begin_offscreen(off); +- CGContextSetRGBFillColor( (CGContextRef)off, 0,0,0,0); +- fl_rectf(0,0,w,h); +- fl_end_offscreen(); +- return (CGContextRef)off; +-} ++ if (!i) ++ return; + +-CGContextRef Fl_X::watch_cursor_image(void) +-{ +- int w, h, r = 5; +- w = 2*r+6; +- h = 4*r; +- Fl_Offscreen off = Fl_Quartz_Graphics_Driver::create_offscreen_with_alpha(w, h); +- fl_begin_offscreen(off); +- CGContextSetRGBFillColor( (CGContextRef)off, 0,0,0,0); +- fl_rectf(0,0,w,h); +- CGContextTranslateCTM( (CGContextRef)off, w/2, h/2); +- fl_color(FL_WHITE); +- fl_circle(0, 0, r+1); +- fl_color(FL_BLACK); +- fl_rectf(int(-r*0.7), int(-r*1.7), int(1.4*r), int(3.4*r)); +- fl_rectf(r-1, -1, 3, 3); +- fl_color(FL_WHITE); +- fl_pie(-r, -r, 2*r, 2*r, 0, 360); +- fl_color(FL_BLACK); +- fl_circle(0,0,r); +- fl_xyline(0, 0, int(-r*.7)); +- fl_xyline(0, 0, 0, int(-r*.7)); +- fl_end_offscreen(); +- return (CGContextRef)off; +-} ++ ret = i->set_cursor(c); ++ if (ret) ++ return; + +-CGContextRef Fl_X::nesw_cursor_image(void) +-{ +- int c = 7, r = 2*c; +- int w = r, h = r; +- Fl_Offscreen off = Fl_Quartz_Graphics_Driver::create_offscreen_with_alpha(w, h); +- fl_begin_offscreen(off); +- CGContextSetRGBFillColor( (CGContextRef)off, 0,0,0,0); +- fl_rectf(0,0,w,h); +- CGContextTranslateCTM( (CGContextRef)off, 0, h); +- CGContextScaleCTM( (CGContextRef)off, 1, -1); +- fl_color(FL_BLACK); +- fl_polygon(0, 0, c, 0, 0, c); +- fl_polygon(r, r, r, r-c, r-c, r); +- fl_line_style(FL_SOLID, 2, 0); +- fl_line(0,1, r,r+1); +- fl_line_style(FL_SOLID, 0, 0); +- fl_end_offscreen(); +- return (CGContextRef)off; ++ fallback_cursor(this, c); + } + +-CGContextRef Fl_X::nwse_cursor_image(void) +-{ +- int c = 7, r = 2*c; +- int w = r, h = r; +- Fl_Offscreen off = Fl_Quartz_Graphics_Driver::create_offscreen_with_alpha(w, h); +- fl_begin_offscreen(off); +- CGContextSetRGBFillColor( (CGContextRef)off, 0,0,0,0); +- fl_rectf(0,0,w,h); +- CGContextTranslateCTM( (CGContextRef)off, 0, h); +- CGContextScaleCTM( (CGContextRef)off, 1, -1); +- fl_color(FL_BLACK); +- fl_polygon(r-1, 0, r-1, c, r-1-c, 0); +- fl_polygon(-1, r, c-1, r, -1, r-c); +- fl_line_style(FL_SOLID, 2, 0); +- fl_line(r-1,1, -1,r+1); +- fl_line_style(FL_SOLID, 0, 0); +- fl_end_offscreen(); +- return (CGContextRef)off; +-} +- +-void Fl_Window::cursor(Fl_Cursor c, Fl_Color, Fl_Color) { +- if (c == FL_CURSOR_DEFAULT) { +- c = cursor_default; +- } +- if (i) i->set_cursor(c); +-} ++/** ++ Changes the cursor for this window. This always calls the system, if ++ you are changing the cursor a lot you may want to keep track of how ++ you set it in a static variable and call this only if the new cursor ++ is different. + +-#else ++ The default cursor will be used if the provided image cannot be used ++ as a cursor. + +-// I like the MSWindows resize cursors, so I duplicate them here: ++ \see cursor(Fl_Cursor), default_cursor() ++*/ ++void Fl_Window::cursor(const Fl_RGB_Image *image, int hotx, int hoty) { ++ int ret; + +-#define CURSORSIZE 16 +-#define HOTXY 7 +-static struct TableEntry { +- uchar bits[CURSORSIZE*CURSORSIZE/8]; +- uchar mask[CURSORSIZE*CURSORSIZE/8]; +- Cursor cursor; +-} table[] = { +- {{ // FL_CURSOR_NS +- 0x00, 0x00, 0x80, 0x01, 0xc0, 0x03, 0xe0, 0x07, 0x80, 0x01, 0x80, 0x01, +- 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, +- 0xe0, 0x07, 0xc0, 0x03, 0x80, 0x01, 0x00, 0x00}, +- { +- 0x80, 0x01, 0xc0, 0x03, 0xe0, 0x07, 0xf0, 0x0f, 0xf0, 0x0f, 0xc0, 0x03, +- 0xc0, 0x03, 0xc0, 0x03, 0xc0, 0x03, 0xc0, 0x03, 0xc0, 0x03, 0xf0, 0x0f, +- 0xf0, 0x0f, 0xe0, 0x07, 0xc0, 0x03, 0x80, 0x01}}, +- {{ // FL_CURSOR_EW +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x10, +- 0x0c, 0x30, 0xfe, 0x7f, 0xfe, 0x7f, 0x0c, 0x30, 0x08, 0x10, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, +- { +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x1c, 0x38, +- 0xfe, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, 0x1c, 0x38, 0x18, 0x18, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}, +- {{ // FL_CURSOR_NWSE +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x38, 0x00, 0x78, 0x00, +- 0xe8, 0x00, 0xc0, 0x01, 0x80, 0x03, 0x00, 0x17, 0x00, 0x1e, 0x00, 0x1c, +- 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, +- { +- 0x00, 0x00, 0x00, 0x00, 0xfc, 0x00, 0xfc, 0x00, 0x7c, 0x00, 0xfc, 0x00, +- 0xfc, 0x01, 0xec, 0x03, 0xc0, 0x37, 0x80, 0x3f, 0x00, 0x3f, 0x00, 0x3e, +- 0x00, 0x3f, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00}}, +- {{ // FL_CURSOR_NESW +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x1c, 0x00, 0x1e, +- 0x00, 0x17, 0x80, 0x03, 0xc0, 0x01, 0xe8, 0x00, 0x78, 0x00, 0x38, 0x00, +- 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, +- { +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x3f, 0x00, 0x3e, 0x00, 0x3f, +- 0x80, 0x3f, 0xc0, 0x37, 0xec, 0x03, 0xfc, 0x01, 0xfc, 0x00, 0x7c, 0x00, +- 0xfc, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00}}, +- {{0}, {0}} // FL_CURSOR_NONE & unknown +-}; ++ // the cursor must be set for the top level window, not for subwindows ++ Fl_Window *w = window(), *toplevel = this; + +-void Fl_Window::cursor(Fl_Cursor c, Fl_Color fg, Fl_Color bg) { +- if (!shown()) return; +- Cursor xc; +- int deleteit = 0; +- if (c == FL_CURSOR_DEFAULT) { +- c = cursor_default; +- fg = cursor_fg; +- bg = cursor_bg; ++ while (w) { ++ toplevel = w; ++ w = w->window(); + } + +- if (!c) { +- xc = None; +- } else { +- if (c >= FL_CURSOR_NS) { +- TableEntry *q = (c > FL_CURSOR_NESW) ? table+4 : table+(c-FL_CURSOR_NS); +- if (!(q->cursor)) { +- XColor dummy = { 0 }; +- Pixmap p = XCreateBitmapFromData(fl_display, +- RootWindow(fl_display, fl_screen), (const char*)(q->bits), +- CURSORSIZE, CURSORSIZE); +- Pixmap m = XCreateBitmapFromData(fl_display, +- RootWindow(fl_display, fl_screen), (const char*)(q->mask), +- CURSORSIZE, CURSORSIZE); +- q->cursor = XCreatePixmapCursor(fl_display, p,m,&dummy, &dummy, +- HOTXY, HOTXY); +- XFreePixmap(fl_display, m); +- XFreePixmap(fl_display, p); +- } +- xc = q->cursor; +- } else { +- xc = XCreateFontCursor(fl_display, (c-1)*2); +- deleteit = 1; +- } +- XColor fgc; +- uchar r,g,b; +- Fl::get_color(fg,r,g,b); +- fgc.red = r<<8; fgc.green = g<<8; fgc.blue = b<<8; +- XColor bgc; +- Fl::get_color(bg,r,g,b); +- bgc.red = r<<8; bgc.green = g<<8; bgc.blue = b<<8; +- XRecolorCursor(fl_display, xc, &fgc, &bgc); ++ if (toplevel != this) { ++ toplevel->cursor(image, hotx, hoty); ++ return; + } +- XDefineCursor(fl_display, fl_xid(this), xc); +- if (deleteit) XFreeCursor(fl_display, xc); ++ ++ if (!i) ++ return; ++ ++ ret = i->set_cursor(image, hotx, hoty); ++ if (ret) ++ return; ++ ++ cursor(FL_CURSOR_DEFAULT); + } + +-#endif ++/* For back compatibility only. */ ++void Fl_Window::cursor(Fl_Cursor c, Fl_Color, Fl_Color) { ++ cursor(c); ++}; ++ ++void Fl_Window::default_cursor(Fl_Cursor c, Fl_Color, Fl_Color) { ++ default_cursor(c); ++}; ++ + + // + // End of "$Id: fl_cursor.cxx 9278 2012-03-12 11:55:50Z manolo $". +diff -up fltk-1.3.2/src/fl_cursor_help.xpm.cursor fltk-1.3.2/src/fl_cursor_help.xpm +--- fltk-1.3.2/src/fl_cursor_help.xpm.cursor 2013-01-30 16:07:59.534319820 +0100 ++++ fltk-1.3.2/src/fl_cursor_help.xpm 2013-01-30 16:07:59.534319820 +0100 +@@ -0,0 +1,95 @@ ++/* XPM */ ++static const char * fl_cursor_help_xpm[] = { ++"16 27 65 1", ++" c None", ++". c #FFFFFF", ++"+ c #E2E2E2", ++"@ c #1C1C1C", ++"# c #E7E7E7", ++"$ c #000000", ++"% c #212121", ++"& c #EAEAEA", ++"* c #262626", ++"= c #EDEDED", ++"- c #2C2C2C", ++"; c #F0F0F0", ++"> c #333333", ++", c #F1F1F1", ++"' c #393939", ++") c #F3F3F3", ++"! c #404040", ++"~ c #484848", ++"{ c #F4F4F4", ++"] c #050505", ++"^ c #202020", ++"/ c #707070", ++"( c #F5F5F5", ++"_ c #040404", ++": c #E1E1E1", ++"< c #EEEEEE", ++"[ c #EFEFEF", ++"} c #FEFEFE", ++"| c #3D3D3D", ++"1 c #7E7E7E", ++"2 c #696969", ++"3 c #414141", ++"4 c #131313", ++"5 c #080808", ++"6 c #454545", ++"7 c #F2F2F2", ++"8 c #878787", ++"9 c #7D7D7D", ++"0 c #101010", ++"a c #111111", ++"b c #FDFDFD", ++"c c #8A8A8A", ++"d c #E6E6E6", ++"e c #7B7B7B", ++"f c #4C4C4C", ++"g c #5C5C5C", ++"h c #9F9F9F", ++"i c #F9F9F9", ++"j c #F7F7F7", ++"k c #B1B1B1", ++"l c #2E2E2E", ++"m c #767676", ++"n c #DCDCDC", ++"o c #DEDEDE", ++"p c #C7C7C7", ++"q c #1B1B1B", ++"r c #6B6B6B", ++"s c #575757", ++"t c #797979", ++"u c #020202", ++"v c #010101", ++"w c #FBFBFB", ++"x c #D7D7D7", ++"y c #D8D8D8", ++"z c #060606", ++" ", ++". ", ++".+ ", ++".@# ", ++".$%& ", ++".$$*= ", ++".$$$-; ", ++".$$$$>, ", ++".$$$$$') ", ++".$$$$$$!) ", ++".$$$$$$$~{ ", ++".$$$$]^^^/( ", ++".$$$$_:(<<[} ", ++".$$|1$2< ", ++".$3,(45[ ", ++".67 78$9, ", ++".7 {0a( .... ", ++"b ,c5[defgh, ", ++" )ijk_la$m.", ++" no.p$q.", ++" .r$s.", ++" .t$-= ", ++" 7uv+ ", ++" wxy. ", ++" :$z. ", ++" :$z. ", ++" .... "}; +diff -up fltk-1.3.2/src/fl_cursor_nesw.xpm.cursor fltk-1.3.2/src/fl_cursor_nesw.xpm +--- fltk-1.3.2/src/fl_cursor_nesw.xpm.cursor 2013-01-30 16:07:59.534319820 +0100 ++++ fltk-1.3.2/src/fl_cursor_nesw.xpm 2013-01-30 16:07:59.534319820 +0100 +@@ -0,0 +1,46 @@ ++/* XPM */ ++static const char * fl_cursor_nesw_xpm[] = { ++"15 15 28 1", ++" c None", ++". c #FFFFFF", ++"+ c #767676", ++"@ c #000000", ++"# c #4E4E4E", ++"$ c #0C0C0C", ++"% c #494949", ++"& c #4D4D4D", ++"* c #1B1B1B", ++"= c #515151", ++"- c #646464", ++"; c #363636", ++"> c #6A6A6A", ++", c #545454", ++"' c #585858", ++") c #242424", ++"! c #797979", ++"~ c #2E2E2E", ++"{ c #444444", ++"] c #3B3B3B", ++"^ c #0A0A0A", ++"/ c #595959", ++"( c #F7F7F7", ++"_ c #080808", ++": c #6B6B6B", ++"< c #FDFDFD", ++"[ c #FCFCFC", ++"} c #FEFEFE", ++" ..........", ++" .+@@@@@@.", ++" .#@@@@@.", ++" .$@@@@.", ++" .%@@@@@.", ++". .&@@@*@@.", ++".. .=@@@-.;@.", ++".>. .,@@@'. .).", ++".@!.'@@@#. ..", ++".@@~@@@{. .", ++".@@@@@]. ", ++".@@@@^. ", ++".@@@@@/( ", ++".______:( ", ++"<[[[[[[[[} "}; +diff -up fltk-1.3.2/src/fl_cursor_none.xpm.cursor fltk-1.3.2/src/fl_cursor_none.xpm +--- fltk-1.3.2/src/fl_cursor_none.xpm.cursor 2013-01-30 16:07:59.534319820 +0100 ++++ fltk-1.3.2/src/fl_cursor_none.xpm 2013-01-30 16:07:59.534319820 +0100 +@@ -0,0 +1,19 @@ ++/* XPM */ ++static const char * fl_cursor_none_xpm[] = { ++"15 15 1 1", ++" c None", ++" ", ++" ", ++" ", ++" ", ++" ", ++" ", ++" ", ++" ", ++" ", ++" ", ++" ", ++" ", ++" ", ++" ", ++" "}; +diff -up fltk-1.3.2/src/fl_cursor_nwse.xpm.cursor fltk-1.3.2/src/fl_cursor_nwse.xpm +--- fltk-1.3.2/src/fl_cursor_nwse.xpm.cursor 2013-01-30 16:07:59.534319820 +0100 ++++ fltk-1.3.2/src/fl_cursor_nwse.xpm 2013-01-30 16:07:59.535319802 +0100 +@@ -0,0 +1,46 @@ ++/* XPM */ ++static const char * fl_cursor_nwse_xpm[] = { ++"15 15 28 1", ++" c None", ++". c #FFFFFF", ++"+ c #000000", ++"@ c #767676", ++"# c #4E4E4E", ++"$ c #0C0C0C", ++"% c #494949", ++"& c #1B1B1B", ++"* c #4D4D4D", ++"= c #363636", ++"- c #646464", ++"; c #515151", ++"> c #242424", ++", c #585858", ++"' c #545454", ++") c #6A6A6A", ++"! c #797979", ++"~ c #444444", ++"{ c #2E2E2E", ++"] c #3B3B3B", ++"^ c #0A0A0A", ++"/ c #F7F7F7", ++"( c #595959", ++"_ c #6B6B6B", ++": c #080808", ++"< c #FEFEFE", ++"[ c #FCFCFC", ++"} c #FDFDFD", ++".......... ", ++".++++++@. ", ++".+++++#. ", ++".++++$. ", ++".+++++%. ", ++".++&+++*. .", ++".+=.-+++;. ..", ++".>. .,+++'. .).", ++".. .#+++,.!+.", ++". .~+++{++.", ++" .]+++++.", ++" .^++++.", ++" /(+++++.", ++" /_::::::.", ++" <[[[[[[[[}"}; +diff -up fltk-1.3.2/src/fl_cursor_wait.xpm.cursor fltk-1.3.2/src/fl_cursor_wait.xpm +--- fltk-1.3.2/src/fl_cursor_wait.xpm.cursor 2013-01-30 16:07:59.535319802 +0100 ++++ fltk-1.3.2/src/fl_cursor_wait.xpm 2013-01-30 16:07:59.535319802 +0100 +@@ -0,0 +1,72 @@ ++/* XPM */ ++static const char * fl_cursor_wait_xpm[] = { ++"17 32 37 1", ++" c None", ++". c #FFFFFF", ++"+ c #2E2E2E", ++"@ c #202020", ++"# c #F1F1F1", ++"$ c #2D2D2D", ++"% c #000000", ++"& c #EDEDED", ++"* c #585858", ++"= c #575757", ++"- c #FBFBFB", ++"; c #848484", ++"> c #B8B8B8", ++", c #E5E5E5", ++"' c #F7F7F7", ++") c #181818", ++"! c #F0F0F0", ++"~ c #616161", ++"{ c #B7B7B7", ++"] c #F5F5F5", ++"^ c #050505", ++"/ c #D4D4D4", ++"( c #EEEEEE", ++"_ c #595959", ++": c #7B7B7B", ++"< c #E9E9E9", ++"[ c #131313", ++"} c #E3E3E3", ++"| c #767676", ++"1 c #505050", ++"2 c #F3F3F3", ++"3 c #2A2A2A", ++"4 c #070707", ++"5 c #343434", ++"6 c #939393", ++"7 c #191919", ++"8 c #6A6A6A", ++".................", ++".+@@@@@@@@@@@@@+.", ++".................", ++" #$%%%%%%%%%%%$# ", ++" &*%%%%%%%%%%%=& ", ++" -;%%%%%%%%%%%;- ", ++" >%%%%%%%%%%%> ", ++" ,%%%%%%%%%%%, ", ++" ')%%%%%%%%%)' ", ++" !~%%%%%%%%%~! ", ++" {%%%%%%%%%{ ", ++" ]^/...../^] ", ++" (_:.....:_( ", ++" <[}...}[< ", ++" !|1...1|! ", ++" 2[3.3[2 ", ++" 2[%.%[2 ", ++" !|%%.%%|! ", ++" <4%%.%%4< ", ++" (_%%%.%%%_( ", ++" ]^%%%.%%%^] ", ++" {%%%%.%%%%{ ", ++" !~%%%%.%%%%~! ", ++" ')%%%%.%%%%)' ", ++" ,%%56{.{65%%, ", ++" >%*.......*%> ", ++" -;7&.......&7;- ", ++" &*8.........8=& ", ++" #$%%%%%%%%%%%$# ", ++".................", ++".+@@@@@@@@@@@@@+.", ++"................."}; +diff -up fltk-1.3.2/src/Fl_win32.cxx.cursor fltk-1.3.2/src/Fl_win32.cxx +--- fltk-1.3.2/src/Fl_win32.cxx.cursor 2013-01-30 16:07:59.519320086 +0100 ++++ fltk-1.3.2/src/Fl_win32.cxx 2013-01-30 16:07:59.536319784 +0100 +@@ -1633,7 +1633,6 @@ void fl_fix_focus(); // in Fl.cxx + + char fl_show_iconic; // hack for Fl_Window::iconic() + // int fl_background_pixel = -1; // color to use for background +-HCURSOR fl_default_cursor; + UINT fl_wake_msg = 0; + int fl_disable_transient_for; // secret method of removing TRANSIENT_FOR + +@@ -1682,7 +1681,7 @@ Fl_X* Fl_X::make(Fl_Window* w) { + if (!w->icon()) + w->icon((void *)LoadIcon(NULL, IDI_APPLICATION)); + wcw.hIcon = wcw.hIconSm = (HICON)w->icon(); +- wcw.hCursor = fl_default_cursor = LoadCursor(NULL, IDC_ARROW); ++ wcw.hCursor = LoadCursor(NULL, IDC_ARROW); + //uchar r,g,b; Fl::get_color(FL_GRAY,r,g,b); + //wc.hbrBackground = (HBRUSH)CreateSolidBrush(RGB(r,g,b)); + wcw.hbrBackground = NULL; +@@ -1774,7 +1773,8 @@ Fl_X* Fl_X::make(Fl_Window* w) { + x->setwindow(w); + x->region = 0; + x->private_dc = 0; +- x->cursor = fl_default_cursor; ++ x->cursor = LoadCursor(NULL, IDC_ARROW); ++ x->custom_cursor = 0; + if (!fl_codepage) fl_get_codepage(); + + WCHAR *lab = NULL; +@@ -2025,6 +2025,153 @@ void Fl_Window::label(const char *name,c + } + + //////////////////////////////////////////////////////////////// ++ ++#ifndef IDC_HAND ++# define IDC_HAND MAKEINTRESOURCE(32649) ++#endif // !IDC_HAND ++ ++int Fl_X::set_cursor(Fl_Cursor c) { ++ LPSTR n; ++ HCURSOR new_cursor; ++ ++ if (c == FL_CURSOR_NONE) ++ new_cursor = NULL; ++ else { ++ switch (c) { ++ case FL_CURSOR_ARROW: n = IDC_ARROW; break; ++ case FL_CURSOR_CROSS: n = IDC_CROSS; break; ++ case FL_CURSOR_WAIT: n = IDC_WAIT; break; ++ case FL_CURSOR_INSERT: n = IDC_IBEAM; break; ++ case FL_CURSOR_HAND: n = IDC_HAND; break; ++ case FL_CURSOR_HELP: n = IDC_HELP; break; ++ case FL_CURSOR_MOVE: n = IDC_SIZEALL; break; ++ case FL_CURSOR_N: ++ case FL_CURSOR_S: ++ // FIXME: Should probably have fallbacks for these instead ++ case FL_CURSOR_NS: n = IDC_SIZENS; break; ++ case FL_CURSOR_NE: ++ case FL_CURSOR_SW: ++ // FIXME: Dito. ++ case FL_CURSOR_NESW: n = IDC_SIZENESW; break; ++ case FL_CURSOR_E: ++ case FL_CURSOR_W: ++ // FIXME: Dito. ++ case FL_CURSOR_WE: n = IDC_SIZEWE; break; ++ case FL_CURSOR_SE: ++ case FL_CURSOR_NW: ++ // FIXME: Dito. ++ case FL_CURSOR_NWSE: n = IDC_SIZENWSE; break; ++ default: ++ return 0; ++ } ++ ++ new_cursor = LoadCursor(NULL, n); ++ if (new_cursor == NULL) ++ return 0; ++ } ++ ++ if ((cursor != NULL) && custom_cursor) ++ DestroyIcon(cursor); ++ ++ cursor = new_cursor; ++ custom_cursor = 0; ++ ++ SetCursor(cursor); ++ ++ return 1; ++} ++ ++int Fl_X::set_cursor(const Fl_RGB_Image *image, int hotx, int hoty) { ++ BITMAPV5HEADER bi; ++ HBITMAP bitmap, mask; ++ DWORD *bits; ++ HCURSOR new_cursor; ++ ++ if ((hotx < 0) || (hotx >= image->w())) ++ return 0; ++ if ((hoty < 0) || (hoty >= image->h())) ++ return 0; ++ ++ memset(&bi, 0, sizeof(BITMAPV5HEADER)); ++ ++ bi.bV5Size = sizeof(BITMAPV5HEADER); ++ bi.bV5Width = image->w(); ++ bi.bV5Height = -image->h(); // Negative for top-down ++ bi.bV5Planes = 1; ++ bi.bV5BitCount = 32; ++ bi.bV5Compression = BI_BITFIELDS; ++ bi.bV5RedMask = 0x00FF0000; ++ bi.bV5GreenMask = 0x0000FF00; ++ bi.bV5BlueMask = 0x000000FF; ++ bi.bV5AlphaMask = 0xFF000000; ++ ++ HDC hdc; ++ ++ hdc = GetDC(NULL); ++ bitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0); ++ ReleaseDC(NULL, hdc); ++ ++ if (bits == NULL) ++ return 0; ++ ++ const uchar *i = (const uchar*)*image->data(); ++ for (int y = 0;y < image->h();y++) { ++ for (int x = 0;x < image->w();x++) { ++ switch (image->d()) { ++ case 1: ++ *bits = (0xff<<24) | (i[0]<<16) | (i[0]<<8) | i[0]; ++ break; ++ case 2: ++ *bits = (i[1]<<24) | (i[0]<<16) | (i[0]<<8) | i[0]; ++ break; ++ case 3: ++ *bits = (0xff<<24) | (i[0]<<16) | (i[1]<<8) | i[2]; ++ break; ++ case 4: ++ *bits = (i[3]<<24) | (i[0]<<16) | (i[1]<<8) | i[2]; ++ break; ++ } ++ i += image->d(); ++ bits++; ++ } ++ i += image->ld(); ++ } ++ ++ // A mask bitmap is still needed even though it isn't used ++ mask = CreateBitmap(image->w(),image->h(),1,1,NULL); ++ if (mask == NULL) { ++ DeleteObject(bitmap); ++ return 0; ++ } ++ ++ ICONINFO ii; ++ ++ ii.fIcon = FALSE; ++ ii.xHotspot = hotx; ++ ii.yHotspot = hoty; ++ ii.hbmMask = mask; ++ ii.hbmColor = bitmap; ++ ++ new_cursor = CreateIconIndirect(&ii); ++ ++ DeleteObject(bitmap); ++ DeleteObject(mask); ++ ++ if (new_cursor == NULL) ++ return 0; ++ ++ if ((cursor != NULL) && custom_cursor) ++ DestroyIcon(cursor); ++ ++ cursor = new_cursor; ++ custom_cursor = 1; ++ ++ SetCursor(cursor); ++ ++ return 1; ++} ++ ++//////////////////////////////////////////////////////////////// + // Implement the virtual functions for the base Fl_Window class: + + // If the box is a filled rectangle, we can make the redisplay *look* +diff -up fltk-1.3.2/src/Fl_Window.cxx.cursor fltk-1.3.2/src/Fl_Window.cxx +--- fltk-1.3.2/src/Fl_Window.cxx.cursor 2012-11-06 21:46:14.000000000 +0100 ++++ fltk-1.3.2/src/Fl_Window.cxx 2013-01-30 16:07:59.536319784 +0100 +@@ -62,8 +62,6 @@ void Fl_Window::_Fl_Window() { + Fl_Window::Fl_Window(int X,int Y,int W, int H, const char *l) + : Fl_Group(X, Y, W, H, l) { + cursor_default = FL_CURSOR_DEFAULT; +- cursor_fg = FL_BLACK; +- cursor_bg = FL_WHITE; + + _Fl_Window(); + set_flag(FORCE_POSITION); +@@ -73,8 +71,6 @@ Fl_Window::Fl_Window(int W, int H, const + // fix common user error of a missing end() with current(0): + : Fl_Group((Fl_Group::current(0),0), 0, W, H, l) { + cursor_default = FL_CURSOR_DEFAULT; +- cursor_fg = FL_BLACK; +- cursor_bg = FL_WHITE; + + _Fl_Window(); + clear_visible(); +diff -up fltk-1.3.2/src/Fl_x.cxx.cursor fltk-1.3.2/src/Fl_x.cxx +--- fltk-1.3.2/src/Fl_x.cxx.cursor 2013-01-30 16:07:59.512320211 +0100 ++++ fltk-1.3.2/src/Fl_x.cxx 2013-01-30 16:07:59.537319766 +0100 +@@ -59,6 +59,11 @@ static int xfixes_event_base = 0; + static bool have_xfixes = false; + # endif + ++# include <X11/cursorfont.h> ++ ++# if HAVE_XCURSOR ++# include <X11/Xcursor/Xcursor.h> ++# endif + static Fl_Xlib_Graphics_Driver fl_xlib_driver; + static Fl_Display_Device fl_xlib_display(&fl_xlib_driver); + Fl_Display_Device *Fl_Display_Device::_display = &fl_xlib_display;// the platform display +@@ -2259,6 +2264,94 @@ void Fl_Window::size_range_() { + } + + //////////////////////////////////////////////////////////////// ++ ++int Fl_X::set_cursor(Fl_Cursor c) { ++ unsigned int shape; ++ Cursor xc; ++ ++ switch (c) { ++ case FL_CURSOR_ARROW: shape = XC_left_ptr; break; ++ case FL_CURSOR_CROSS: shape = XC_tcross; break; ++ case FL_CURSOR_WAIT: shape = XC_watch; break; ++ case FL_CURSOR_INSERT: shape = XC_xterm; break; ++ case FL_CURSOR_HAND: shape = XC_hand2; break; ++ case FL_CURSOR_HELP: shape = XC_question_arrow; break; ++ case FL_CURSOR_MOVE: shape = XC_fleur; break; ++ case FL_CURSOR_NS: shape = XC_sb_v_double_arrow; break; ++ case FL_CURSOR_WE: shape = XC_sb_h_double_arrow; break; ++ case FL_CURSOR_NE: shape = XC_top_right_corner; break; ++ case FL_CURSOR_N: shape = XC_top_side; break; ++ case FL_CURSOR_NW: shape = XC_top_left_corner; break; ++ case FL_CURSOR_E: shape = XC_right_side; break; ++ case FL_CURSOR_W: shape = XC_left_side; break; ++ case FL_CURSOR_SE: shape = XC_bottom_right_corner; break; ++ case FL_CURSOR_S: shape = XC_bottom_side; break; ++ case FL_CURSOR_SW: shape = XC_bottom_left_corner; break; ++ default: ++ return 0; ++ } ++ ++ xc = XCreateFontCursor(fl_display, shape); ++ XDefineCursor(fl_display, xid, xc); ++ XFreeCursor(fl_display, xc); ++ ++ return 1; ++} ++ ++int Fl_X::set_cursor(const Fl_RGB_Image *image, int hotx, int hoty) { ++#if ! HAVE_XCURSOR ++ return 0; ++#else ++ XcursorImage *cursor; ++ Cursor xc; ++ ++ if ((hotx < 0) || (hotx >= image->w())) ++ return 0; ++ if ((hoty < 0) || (hoty >= image->h())) ++ return 0; ++ ++ cursor = XcursorImageCreate(image->w(), image->h()); ++ if (!cursor) ++ return 0; ++ ++ const uchar *i = (const uchar*)*image->data(); ++ XcursorPixel *o = cursor->pixels; ++ for (int y = 0;y < image->h();y++) { ++ for (int x = 0;x < image->w();x++) { ++ switch (image->d()) { ++ case 1: ++ *o = (0xff<<24) | (i[0]<<16) | (i[0]<<8) | i[0]; ++ break; ++ case 2: ++ *o = (i[1]<<24) | (i[0]<<16) | (i[0]<<8) | i[0]; ++ break; ++ case 3: ++ *o = (0xff<<24) | (i[0]<<16) | (i[1]<<8) | i[2]; ++ break; ++ case 4: ++ *o = (i[3]<<24) | (i[0]<<16) | (i[1]<<8) | i[2]; ++ break; ++ } ++ i += image->d(); ++ o++; ++ } ++ i += image->ld(); ++ } ++ ++ cursor->xhot = hotx; ++ cursor->yhot = hoty; ++ ++ xc = XcursorImageLoadCursor(fl_display, cursor); ++ XDefineCursor(fl_display, xid, xc); ++ XFreeCursor(fl_display, xc); ++ ++ XcursorImageDestroy(cursor); ++ ++ return 1; ++#endif ++} ++ ++//////////////////////////////////////////////////////////////// + + // returns pointer to the filename, or null if name ends with '/' + const char *fl_filename_name(const char *name) { +diff -up fltk-1.3.2/test/cursor.cxx.cursor fltk-1.3.2/test/cursor.cxx +--- fltk-1.3.2/test/cursor.cxx.cursor 2011-07-19 06:49:30.000000000 +0200 ++++ fltk-1.3.2/test/cursor.cxx 2013-01-30 16:07:59.537319766 +0100 +@@ -23,8 +23,6 @@ + #include <FL/fl_draw.H> + #include <FL/Fl_Box.H> + +-Fl_Color fg = FL_BLACK; +-Fl_Color bg = FL_WHITE; + Fl_Cursor cursor = FL_CURSOR_DEFAULT; + + Fl_Hor_Value_Slider *cursor_slider; +@@ -32,7 +30,7 @@ Fl_Hor_Value_Slider *cursor_slider; + void choice_cb(Fl_Widget *, void *v) { + cursor = (Fl_Cursor)(fl_intptr_t)v; + cursor_slider->value(cursor); +- fl_cursor(cursor,fg,bg); ++ fl_cursor(cursor); + } + + Fl_Menu_Item choices[] = { +@@ -48,8 +46,6 @@ Fl_Menu_Item choices[] = { + {"FL_CURSOR_WE",0,choice_cb,(void*)FL_CURSOR_WE}, + {"FL_CURSOR_NWSE",0,choice_cb,(void*)FL_CURSOR_NWSE}, + {"FL_CURSOR_NESW",0,choice_cb,(void*)FL_CURSOR_NESW}, +- {"FL_CURSOR_NONE",0,choice_cb,(void*)FL_CURSOR_NONE}, +-#if 0 + {"FL_CURSOR_N",0,choice_cb,(void*)FL_CURSOR_N}, + {"FL_CURSOR_NE",0,choice_cb,(void*)FL_CURSOR_NE}, + {"FL_CURSOR_E",0,choice_cb,(void*)FL_CURSOR_E}, +@@ -58,26 +54,14 @@ Fl_Menu_Item choices[] = { + {"FL_CURSOR_SW",0,choice_cb,(void*)FL_CURSOR_SW}, + {"FL_CURSOR_W",0,choice_cb,(void*)FL_CURSOR_W}, + {"FL_CURSOR_NW",0,choice_cb,(void*)FL_CURSOR_NW}, +-#endif ++ {"FL_CURSOR_NONE",0,choice_cb,(void*)FL_CURSOR_NONE}, + {0} + }; + + void setcursor(Fl_Widget *o, void *) { + Fl_Hor_Value_Slider *slider = (Fl_Hor_Value_Slider *)o; + cursor = Fl_Cursor((int)slider->value()); +- fl_cursor(cursor,fg,bg); +-} +- +-void setfg(Fl_Widget *o, void *) { +- Fl_Hor_Value_Slider *slider = (Fl_Hor_Value_Slider *)o; +- fg = Fl_Color((int)slider->value()); +- fl_cursor(cursor,fg,bg); +-} +- +-void setbg(Fl_Widget *o, void *) { +- Fl_Hor_Value_Slider *slider = (Fl_Hor_Value_Slider *)o; +- bg = Fl_Color((int)slider->value()); +- fl_cursor(cursor,fg,bg); ++ fl_cursor(cursor); + } + + // draw the label without any ^C or \nnn conversions: +@@ -103,29 +87,11 @@ int main(int argc, char **argv) { + slider1.align(FL_ALIGN_LEFT); + slider1.step(1); + slider1.precision(0); +- slider1.bounds(0,100); ++ slider1.bounds(0,255); + slider1.value(0); + slider1.callback(setcursor); + slider1.value(cursor); + +- Fl_Hor_Value_Slider slider2(80,220,310,30,"fgcolor:"); +- slider2.align(FL_ALIGN_LEFT); +- slider2.step(1); +- slider2.precision(0); +- slider2.bounds(0,255); +- slider2.value(0); +- slider2.callback(setfg); +- slider2.value(fg); +- +- Fl_Hor_Value_Slider slider3(80,260,310,30,"bgcolor:"); +- slider3.align(FL_ALIGN_LEFT); +- slider3.step(1); +- slider3.precision(0); +- slider3.bounds(0,255); +- slider3.value(0); +- slider3.callback(setbg); +- slider3.value(bg); +- + #if 0 + // draw the manual's diagram of cursors... + window.size(400,800); diff --git a/contrib/fltk/08-str2802-fltk-1.3.0-modal.patch b/contrib/fltk/08-str2802-fltk-1.3.0-modal.patch new file mode 100644 index 00000000..7b1b7913 --- /dev/null +++ b/contrib/fltk/08-str2802-fltk-1.3.0-modal.patch @@ -0,0 +1,75 @@ +diff -bur fltk-1.3.0r9619.org/src/Fl_cocoa.mm fltk-1.3.0r9619/src/Fl_cocoa.mm +--- fltk-1.3.0r9619.org/src/Fl_cocoa.mm 2012-06-19 12:54:43.694231638 +0200 ++++ fltk-1.3.0r9619/src/Fl_cocoa.mm 2012-06-19 12:57:05.899048602 +0200 +@@ -697,12 +697,9 @@ + return NO; // prevent the caption to be redrawn as active on click + // when another modal window is currently the key win + +- return !(w->tooltip_window() || w->menu_window()); ++ return !w->tooltip_window(); + } + +-// TODO see if we really need a canBecomeMainWindow ... +-#if 0 +- + - (BOOL)canBecomeMainWindow + { + if (Fl::modal_ && (Fl::modal_ != w)) +@@ -711,7 +708,6 @@ + + return !(w->tooltip_window() || w->menu_window()); + } +-#endif + + @end + +diff -bur fltk-1.3.0r9619.org/src/Fl_win32.cxx fltk-1.3.0r9619/src/Fl_win32.cxx +--- fltk-1.3.0r9619.org/src/Fl_win32.cxx 2012-06-19 12:54:43.696231735 +0200 ++++ fltk-1.3.0r9619/src/Fl_win32.cxx 2012-06-19 12:54:43.803236862 +0200 +@@ -1065,6 +1065,10 @@ + break; + + case WM_SETFOCUS: ++ if ((Fl::modal_) && (Fl::modal_ != window)) { ++ SetFocus(fl_xid(Fl::modal_)); ++ return 0; ++ } + Fl::handle(FL_FOCUS, window); + break; + +@@ -1826,6 +1830,11 @@ + Fl::e_number = old_event; + w->redraw(); // force draw to happen + } ++ ++ // Needs to be done before ShowWindow() to get the correct behaviour ++ // when we get WM_SETFOCUS. ++ if (w->modal()) {Fl::modal_ = w; fl_fix_focus();} ++ + // If we've captured the mouse, we dont want to activate any + // other windows from the code, or we lose the capture. + ShowWindow(x->xid, !showit ? SW_SHOWMINNOACTIVE : +@@ -1843,7 +1852,6 @@ + } + } + +- if (w->modal()) {Fl::modal_ = w; fl_fix_focus();} + return x; + } + +diff -bur fltk-1.3.0r9619.org/src/Fl_x.cxx fltk-1.3.0r9619/src/Fl_x.cxx +--- fltk-1.3.0r9619.org/src/Fl_x.cxx 2012-06-19 12:54:43.697231783 +0200 ++++ fltk-1.3.0r9619/src/Fl_x.cxx 2012-06-19 12:54:43.804236911 +0200 +@@ -2101,6 +2101,12 @@ + while (wp->parent()) wp = wp->window(); + XSetTransientForHint(fl_display, xp->xid, fl_xid(wp)); + if (!wp->visible()) showit = 0; // guess that wm will not show it ++ if (win->modal()) { ++ Atom net_wm_state = XInternAtom (fl_display, "_NET_WM_STATE", 0); ++ Atom net_wm_state_skip_taskbar = XInternAtom (fl_display, "_NET_WM_STATE_MODAL", 0); ++ XChangeProperty (fl_display, xp->xid, net_wm_state, XA_ATOM, 32, ++ PropModeAppend, (unsigned char*) &net_wm_state_skip_taskbar, 1); ++ } + } + + // Make sure that borderless windows do not show in the task bar diff --git a/contrib/fltk/09-str2816-fltk-1.3.0-icons.patch b/contrib/fltk/09-str2816-fltk-1.3.0-icons.patch new file mode 100644 index 00000000..20b30b8b --- /dev/null +++ b/contrib/fltk/09-str2816-fltk-1.3.0-icons.patch @@ -0,0 +1,645 @@ +diff -ur fltk-1.3.2.org/FL/Fl_Window.H fltk-1.3.2/FL/Fl_Window.H +--- fltk-1.3.2.org/FL/Fl_Window.H 2013-01-16 10:49:40.904228200 +0100 ++++ fltk-1.3.2/FL/Fl_Window.H 2013-01-16 10:49:55.554353925 +0100 +@@ -22,6 +22,10 @@ + #ifndef Fl_Window_H + #define Fl_Window_H + ++#ifdef WIN32 ++#include <windows.h> ++#endif ++ + #include "Fl_Group.H" + + #define FL_WINDOW 0xF0 ///< window type id all subclasses have type() >= this +@@ -73,9 +77,19 @@ + friend class Fl_X; + Fl_X *i; // points at the system-specific stuff + ++ struct icon_data { ++ const void *legacy_icon; ++ Fl_RGB_Image **icons; ++ int count; ++#ifdef WIN32 ++ HICON big_icon; ++ HICON small_icon; ++#endif ++ }; ++ + const char* iconlabel_; + char* xclass_; +- const void* icon_; ++ struct icon_data *icon_; + // size_range stuff: + int minw, minh, maxw, maxh; + int dw, dh, aspect; +@@ -121,6 +135,8 @@ + */ + int force_position() const { return ((flags() & FORCE_POSITION)?1:0); } + ++ void free_icons(); ++ + public: + + /** +@@ -350,6 +366,18 @@ + static const char *default_xclass(); + const char* xclass() const; + void xclass(const char* c); ++ ++ static void default_icon(const Fl_RGB_Image*); ++ static void default_icons(const Fl_RGB_Image*[], int); ++ void icon(const Fl_RGB_Image*); ++ void icons(const Fl_RGB_Image*[], int); ++ ++#ifdef WIN32 ++ static void default_icons(HICON big_icon, HICON small_icon); ++ void icons(HICON big_icon, HICON small_icon); ++#endif ++ ++ /* for legacy compatibility */ + const void* icon() const; + void icon(const void * ic); + +diff -ur fltk-1.3.2.org/FL/mac.H fltk-1.3.2/FL/mac.H +--- fltk-1.3.2.org/FL/mac.H 2013-01-16 10:49:40.904228200 +0100 ++++ fltk-1.3.2/FL/mac.H 2013-01-16 10:49:55.554353925 +0100 +@@ -120,6 +120,9 @@ + void collapse(void); + WindowRef window_ref(void); + void set_key_window(void); ++ // OS X doesn't have per window icons ++ static void set_default_icons(const Fl_RGB_Image*[], int) {}; ++ void set_icons() {}; + int set_cursor(Fl_Cursor); + int set_cursor(const Fl_RGB_Image*, int, int); + static CGImageRef CGImage_from_window_rect(Fl_Window *win, int x, int y, int w, int h); +diff -ur fltk-1.3.2.org/FL/win32.H fltk-1.3.2/FL/win32.H +--- fltk-1.3.2.org/FL/win32.H 2013-01-16 10:49:40.904228200 +0100 ++++ fltk-1.3.2/FL/win32.H 2013-01-16 10:49:55.555355617 +0100 +@@ -84,6 +84,9 @@ + void flush() {w->flush();} + void set_minmax(LPMINMAXINFO minmax); + void mapraise(); ++ static void set_default_icons(const Fl_RGB_Image*[], int); ++ static void set_default_icons(HICON, HICON); ++ void set_icons(); + int set_cursor(Fl_Cursor); + int set_cursor(const Fl_RGB_Image*, int, int); + static Fl_X* make(Fl_Window*); +diff -ur fltk-1.3.2.org/FL/x.H fltk-1.3.2/FL/x.H +--- fltk-1.3.2.org/FL/x.H 2013-01-16 10:49:40.904228200 +0100 ++++ fltk-1.3.2/FL/x.H 2013-01-16 10:49:55.555355617 +0100 +@@ -154,6 +154,8 @@ + static Fl_X* i(const Fl_Window* wi) {return wi->i;} + void setwindow(Fl_Window* wi) {w=wi; wi->i=this;} + void sendxjunk(); ++ static void set_default_icons(const Fl_RGB_Image*[], int); ++ void set_icons(); + int set_cursor(Fl_Cursor); + int set_cursor(const Fl_RGB_Image*, int, int); + static void make_xid(Fl_Window*,XVisualInfo* =fl_visual, Colormap=fl_colormap); +diff -ur fltk-1.3.2.org/src/Fl.cxx fltk-1.3.2/src/Fl.cxx +--- fltk-1.3.2.org/src/Fl.cxx 2013-01-16 10:49:40.895228113 +0100 ++++ fltk-1.3.2/src/Fl.cxx 2013-01-16 10:49:55.556137979 +0100 +@@ -1530,6 +1530,8 @@ + if (xclass_) { + free(xclass_); + } ++ free_icons(); ++ delete icon_; + } + + // FL_SHOW and FL_HIDE are called whenever the visibility of this widget +diff -ur fltk-1.3.2.org/src/Fl_win32.cxx fltk-1.3.2/src/Fl_win32.cxx +--- fltk-1.3.2.org/src/Fl_win32.cxx 2013-01-16 10:49:40.911227539 +0100 ++++ fltk-1.3.2/src/Fl_win32.cxx 2013-01-16 10:49:55.556137979 +0100 +@@ -1804,6 +1804,8 @@ + ); + if (lab) free(lab); + ++ x->set_icons(); ++ + if (w->fullscreen_active()) { + /* We need to make sure that the fullscreen is created on the + default monitor, ie the desktop where the shortcut is located +@@ -2034,71 +2036,19 @@ + + //////////////////////////////////////////////////////////////// + +-#ifndef IDC_HAND +-# define IDC_HAND MAKEINTRESOURCE(32649) +-#endif // !IDC_HAND +- +-int Fl_X::set_cursor(Fl_Cursor c) { +- LPSTR n; +- HCURSOR new_cursor; +- +- if (c == FL_CURSOR_NONE) +- new_cursor = NULL; +- else { +- switch (c) { +- case FL_CURSOR_ARROW: n = IDC_ARROW; break; +- case FL_CURSOR_CROSS: n = IDC_CROSS; break; +- case FL_CURSOR_WAIT: n = IDC_WAIT; break; +- case FL_CURSOR_INSERT: n = IDC_IBEAM; break; +- case FL_CURSOR_HAND: n = IDC_HAND; break; +- case FL_CURSOR_HELP: n = IDC_HELP; break; +- case FL_CURSOR_MOVE: n = IDC_SIZEALL; break; +- case FL_CURSOR_N: +- case FL_CURSOR_S: +- // FIXME: Should probably have fallbacks for these instead +- case FL_CURSOR_NS: n = IDC_SIZENS; break; +- case FL_CURSOR_NE: +- case FL_CURSOR_SW: +- // FIXME: Dito. +- case FL_CURSOR_NESW: n = IDC_SIZENESW; break; +- case FL_CURSOR_E: +- case FL_CURSOR_W: +- // FIXME: Dito. +- case FL_CURSOR_WE: n = IDC_SIZEWE; break; +- case FL_CURSOR_SE: +- case FL_CURSOR_NW: +- // FIXME: Dito. +- case FL_CURSOR_NWSE: n = IDC_SIZENWSE; break; +- default: +- return 0; +- } +- +- new_cursor = LoadCursor(NULL, n); +- if (new_cursor == NULL) +- return 0; +- } +- +- if ((cursor != NULL) && custom_cursor) +- DestroyIcon(cursor); +- +- cursor = new_cursor; +- custom_cursor = 0; +- +- SetCursor(cursor); +- +- return 1; +-} +- +-int Fl_X::set_cursor(const Fl_RGB_Image *image, int hotx, int hoty) { ++static HICON image_to_icon(const Fl_RGB_Image *image, bool is_icon=true, ++ int hotx = 0, int hoty = 0) { + BITMAPV5HEADER bi; + HBITMAP bitmap, mask; + DWORD *bits; +- HCURSOR new_cursor; ++ HICON icon; + ++ if (!is_icon) { + if ((hotx < 0) || (hotx >= image->w())) +- return 0; ++ return NULL; + if ((hoty < 0) || (hoty >= image->h())) +- return 0; ++ return NULL; ++ } + + memset(&bi, 0, sizeof(BITMAPV5HEADER)); + +@@ -2120,7 +2070,7 @@ + ReleaseDC(NULL, hdc); + + if (bits == NULL) +- return 0; ++ return NULL; + + const uchar *i = (const uchar*)*image->data(); + for (int y = 0;y < image->h();y++) { +@@ -2149,22 +2099,206 @@ + mask = CreateBitmap(image->w(),image->h(),1,1,NULL); + if (mask == NULL) { + DeleteObject(bitmap); +- return 0; ++ return NULL; + } + + ICONINFO ii; + +- ii.fIcon = FALSE; ++ ii.fIcon = is_icon; + ii.xHotspot = hotx; + ii.yHotspot = hoty; + ii.hbmMask = mask; + ii.hbmColor = bitmap; + +- new_cursor = CreateIconIndirect(&ii); ++ icon = CreateIconIndirect(&ii); + + DeleteObject(bitmap); + DeleteObject(mask); + ++ if (icon == NULL) ++ return NULL; ++ ++ return icon; ++} ++ ++//////////////////////////////////////////////////////////////// ++ ++static HICON default_big_icon = NULL; ++static HICON default_small_icon = NULL; ++ ++const Fl_RGB_Image *find_best_icon(int ideal_width, ++ const Fl_RGB_Image *icons[], int count) { ++ const Fl_RGB_Image *best; ++ ++ best = NULL; ++ ++ for (int i = 0;i < count;i++) { ++ if (best == NULL) ++ best = icons[i]; ++ else { ++ if (best->w() < ideal_width) { ++ if (icons[i]->w() > best->w()) ++ best = icons[i]; ++ } else { ++ if ((icons[i]->w() >= ideal_width) && ++ (icons[i]->w() < best->w())) ++ best = icons[i]; ++ } ++ } ++ } ++ ++ return best; ++} ++ ++void Fl_X::set_default_icons(const Fl_RGB_Image *icons[], int count) { ++ const Fl_RGB_Image *best_big, *best_small; ++ ++ if (default_big_icon != NULL) ++ DestroyIcon(default_big_icon); ++ if (default_small_icon != NULL) ++ DestroyIcon(default_small_icon); ++ ++ best_big = find_best_icon(GetSystemMetrics(SM_CXICON), icons, count); ++ best_small = find_best_icon(GetSystemMetrics(SM_CXSMICON), icons, count); ++ ++ if (best_big != NULL) ++ default_big_icon = image_to_icon(best_big); ++ else ++ default_big_icon = NULL; ++ ++ if (best_small != NULL) ++ default_small_icon = image_to_icon(best_small); ++ else ++ default_small_icon = NULL; ++} ++ ++void Fl_X::set_default_icons(HICON big_icon, HICON small_icon) { ++ if (default_big_icon != NULL) ++ DestroyIcon(default_big_icon); ++ if (default_small_icon != NULL) ++ DestroyIcon(default_small_icon); ++ ++ if (big_icon != NULL) ++ default_big_icon = CopyIcon(big_icon); ++ if (small_icon != NULL) ++ default_small_icon = CopyIcon(small_icon); ++} ++ ++void Fl_X::set_icons() { ++ HICON big_icon, small_icon; ++ ++ big_icon = NULL; ++ small_icon = NULL; ++ ++ if (w->icon_->count) { ++ const Fl_RGB_Image *best_big, *best_small; ++ ++ best_big = find_best_icon(GetSystemMetrics(SM_CXICON), ++ (const Fl_RGB_Image **)w->icon_->icons, ++ w->icon_->count); ++ best_small = find_best_icon(GetSystemMetrics(SM_CXSMICON), ++ (const Fl_RGB_Image **)w->icon_->icons, ++ w->icon_->count); ++ ++ if (best_big != NULL) ++ big_icon = image_to_icon(best_big); ++ if (best_small != NULL) ++ small_icon = image_to_icon(best_small); ++ } else { ++ big_icon = default_big_icon; ++ small_icon = default_small_icon; ++ } ++ ++ if (big_icon != NULL) ++ SendMessage(xid, WM_SETICON, ICON_BIG, (LPARAM)big_icon); ++ if (small_icon != NULL) ++ SendMessage(xid, WM_SETICON, ICON_SMALL, (LPARAM)small_icon); ++ ++ if (w->icon_->count) { ++ if (big_icon != NULL) ++ DestroyIcon(big_icon); ++ if (small_icon != NULL) ++ DestroyIcon(small_icon); ++ } ++} ++ ++void Fl_Window::default_icons(HICON big_icon, HICON small_icon) { ++ Fl_X::set_default_icons(big_icon, small_icon); ++} ++ ++void Fl_Window::icons(HICON big_icon, HICON small_icon) { ++ free_icons(); ++ ++ if (big_icon != NULL) ++ icon_->big_icon = CopyIcon(big_icon); ++ if (small_icon != NULL) ++ icon_->small_icon = CopyIcon(small_icon); ++ ++ if (i) ++ i->set_icons(); ++} ++ ++//////////////////////////////////////////////////////////////// ++ ++#ifndef IDC_HAND ++# define IDC_HAND MAKEINTRESOURCE(32649) ++#endif // !IDC_HAND ++ ++int Fl_X::set_cursor(Fl_Cursor c) { ++ LPSTR n; ++ HCURSOR new_cursor; ++ ++ if (c == FL_CURSOR_NONE) ++ new_cursor = NULL; ++ else { ++ switch (c) { ++ case FL_CURSOR_ARROW: n = IDC_ARROW; break; ++ case FL_CURSOR_CROSS: n = IDC_CROSS; break; ++ case FL_CURSOR_WAIT: n = IDC_WAIT; break; ++ case FL_CURSOR_INSERT: n = IDC_IBEAM; break; ++ case FL_CURSOR_HAND: n = IDC_HAND; break; ++ case FL_CURSOR_HELP: n = IDC_HELP; break; ++ case FL_CURSOR_MOVE: n = IDC_SIZEALL; break; ++ case FL_CURSOR_N: ++ case FL_CURSOR_S: ++ // FIXME: Should probably have fallbacks for these instead ++ case FL_CURSOR_NS: n = IDC_SIZENS; break; ++ case FL_CURSOR_NE: ++ case FL_CURSOR_SW: ++ // FIXME: Dito. ++ case FL_CURSOR_NESW: n = IDC_SIZENESW; break; ++ case FL_CURSOR_E: ++ case FL_CURSOR_W: ++ // FIXME: Dito. ++ case FL_CURSOR_WE: n = IDC_SIZEWE; break; ++ case FL_CURSOR_SE: ++ case FL_CURSOR_NW: ++ // FIXME: Dito. ++ case FL_CURSOR_NWSE: n = IDC_SIZENWSE; break; ++ default: ++ return 0; ++ } ++ ++ new_cursor = LoadCursor(NULL, n); ++ if (new_cursor == NULL) ++ return 0; ++ } ++ ++ if ((cursor != NULL) && custom_cursor) ++ DestroyIcon(cursor); ++ ++ cursor = new_cursor; ++ custom_cursor = 0; ++ ++ SetCursor(cursor); ++ ++ return 1; ++} ++ ++int Fl_X::set_cursor(const Fl_RGB_Image *image, int hotx, int hoty) { ++ HCURSOR new_cursor; ++ ++ new_cursor = image_to_icon(image, false, hotx, hoty); + if (new_cursor == NULL) + return 0; + +diff -ur fltk-1.3.2.org/src/Fl_Window.cxx fltk-1.3.2/src/Fl_Window.cxx +--- fltk-1.3.2.org/src/Fl_Window.cxx 2013-01-16 10:49:40.908130903 +0100 ++++ fltk-1.3.2/src/Fl_Window.cxx 2013-01-16 10:49:55.557353865 +0100 +@@ -23,6 +23,7 @@ + #include <config.h> + #include <FL/Fl.H> + #include <FL/x.H> ++#include <FL/Fl_RGB_Image.H> + #include <FL/Fl_Window.H> + #include <stdlib.h> + #include "flstring.h" +@@ -45,7 +46,8 @@ + } + i = 0; + xclass_ = 0; +- icon_ = 0; ++ icon_ = new icon_data; ++ memset(icon_, 0, sizeof(*icon_)); + iconlabel_ = 0; + resizable(0); + size_range_set = 0; +@@ -264,16 +266,68 @@ + } + } + ++void Fl_Window::default_icon(const Fl_RGB_Image *icon) { ++ default_icons(&icon, 1); ++} ++ ++void Fl_Window::default_icons(const Fl_RGB_Image **icons, int count) { ++ Fl_X::set_default_icons(icons, count); ++} ++ ++void Fl_Window::icon(const Fl_RGB_Image *icon) { ++ icons(&icon, 1); ++} ++ ++void Fl_Window::icons(const Fl_RGB_Image **icons, int count) { ++ free_icons(); ++ ++ if (count > 0) { ++ icon_->icons = new Fl_RGB_Image*[count]; ++ icon_->count = count; ++ // FIXME: Fl_RGB_Image lacks const modifiers on methods ++ for (int i = 0;i < count;i++) ++ icon_->icons[i] = (Fl_RGB_Image*)((Fl_RGB_Image*)icons[i])->copy(); ++ } ++ ++ if (i) ++ i->set_icons(); ++} ++ + /** Gets the current icon window target dependent data. */ + const void *Fl_Window::icon() const { +- return icon_; ++ return icon_->legacy_icon; + } + + /** Sets the current icon window target dependent data. */ + void Fl_Window::icon(const void * ic) { +- icon_ = ic; ++ free_icons(); ++ icon_->legacy_icon = ic; + } + ++void Fl_Window::free_icons() { ++ int i; ++ ++ icon_->legacy_icon = 0L; ++ ++ if (icon_->icons) { ++ for (i = 0;i < icon_->count;i++) ++ delete icon_->icons[i]; ++ delete [] icon_->icons; ++ icon_->icons = 0L; ++ } ++ ++ icon_->count = 0; ++ ++#ifdef WIN32 ++ if (icon_->big_icon) ++ DestroyIcon(icon_->big_icon); ++ if (icon_->small_icon) ++ DestroyIcon(icon_->small_icon); ++ ++ icon_->big_icon = NULL; ++ icon_->small_icon = NULL; ++#endif ++} + + // + // End of "$Id: Fl_Window.cxx 9706 2012-11-06 20:46:14Z matt $". +diff -ur fltk-1.3.2.org/src/Fl_x.cxx fltk-1.3.2/src/Fl_x.cxx +--- fltk-1.3.2.org/src/Fl_x.cxx 2013-01-16 10:49:40.912227213 +0100 ++++ fltk-1.3.2/src/Fl_x.cxx 2013-01-16 10:49:55.558137113 +0100 +@@ -345,6 +345,7 @@ + Atom fl_NET_WM_STATE; + Atom fl_NET_WM_STATE_FULLSCREEN; + Atom fl_NET_WORKAREA; ++Atom fl_NET_WM_ICON; + + /* + X defines 32-bit-entities to have a format value of max. 32, +@@ -709,6 +710,7 @@ + fl_NET_WM_STATE = XInternAtom(d, "_NET_WM_STATE", 0); + fl_NET_WM_STATE_FULLSCREEN = XInternAtom(d, "_NET_WM_STATE_FULLSCREEN", 0); + fl_NET_WORKAREA = XInternAtom(d, "_NET_WORKAREA", 0); ++ fl_NET_WM_ICON = XInternAtom(d, "_NET_WM_ICON", 0); + + if (sizeof(Atom) < 4) + atom_bits = sizeof(Atom) * 8; +@@ -2138,12 +2140,14 @@ + fl_show_iconic = 0; + showit = 0; + } +- if (win->icon()) { +- hints->icon_pixmap = (Pixmap)win->icon(); ++ if (win->icon_->legacy_icon) { ++ hints->icon_pixmap = (Pixmap)win->icon_->legacy_icon; + hints->flags |= IconPixmapHint; + } + XSetWMHints(fl_display, xp->xid, hints); + XFree(hints); ++ ++ xp->set_icons(); + } + + // set the window type for menu and tooltip windows to avoid animations (compiz) +@@ -2263,6 +2267,93 @@ + + //////////////////////////////////////////////////////////////// + ++static unsigned long *default_net_wm_icons = 0L; ++static size_t default_net_wm_icons_size = 0; ++ ++void icons_to_property(const Fl_RGB_Image *icons[], int count, ++ unsigned long **property, size_t *len) { ++ size_t sz; ++ unsigned long *data; ++ ++ sz = 0; ++ for (int i = 0;i < count;i++) ++ sz += 2 + icons[i]->w() * icons[i]->h(); ++ ++ // FIXME: Might want to sort the icons ++ ++ *property = data = new unsigned long[sz]; ++ *len = sz; ++ ++ for (int i = 0;i < count;i++) { ++ const Fl_RGB_Image *image; ++ ++ image = icons[i]; ++ ++ data[0] = image->w(); ++ data[1] = image->h(); ++ data += 2; ++ ++ const uchar *in = (const uchar*)*image->data(); ++ for (int y = 0;y < image->h();y++) { ++ for (int x = 0;x < image->w();x++) { ++ switch (image->d()) { ++ case 1: ++ *data = ( 0xff<<24) | (in[0]<<16) | (in[0]<<8) | in[0]; ++ break; ++ case 2: ++ *data = (in[1]<<24) | (in[0]<<16) | (in[0]<<8) | in[0]; ++ break; ++ case 3: ++ *data = ( 0xff<<24) | (in[0]<<16) | (in[1]<<8) | in[2]; ++ break; ++ case 4: ++ *data = (in[3]<<24) | (in[0]<<16) | (in[1]<<8) | in[2]; ++ break; ++ } ++ in += image->d(); ++ data++; ++ } ++ in += image->ld(); ++ } ++ } ++} ++ ++void Fl_X::set_default_icons(const Fl_RGB_Image *icons[], int count) { ++ if (default_net_wm_icons) { ++ delete [] default_net_wm_icons; ++ default_net_wm_icons = 0L; ++ default_net_wm_icons_size = 0; ++ } ++ ++ if (count > 0) ++ icons_to_property(icons, count, ++ &default_net_wm_icons, &default_net_wm_icons_size); ++} ++ ++void Fl_X::set_icons() { ++ unsigned long *net_wm_icons; ++ size_t net_wm_icons_size; ++ ++ if (w->icon_->count) { ++ icons_to_property((const Fl_RGB_Image **)w->icon_->icons, w->icon_->count, ++ &net_wm_icons, &net_wm_icons_size); ++ } else { ++ net_wm_icons = default_net_wm_icons; ++ net_wm_icons_size = default_net_wm_icons_size; ++ } ++ ++ XChangeProperty (fl_display, xid, fl_NET_WM_ICON, XA_CARDINAL, 32, ++ PropModeReplace, (unsigned char*) net_wm_icons, net_wm_icons_size); ++ ++ if (w->icon_->count) { ++ delete [] net_wm_icons; ++ net_wm_icons = 0L; ++ net_wm_icons_size = 0; ++ } ++} ++ ++//////////////////////////////////////////////////////////////// ++ + int Fl_X::set_cursor(Fl_Cursor c) { + unsigned int shape; + Cursor xc; diff --git a/contrib/fltk/10-str2860-fltk-1.3.x-screen_num.patch b/contrib/fltk/10-str2860-fltk-1.3.x-screen_num.patch new file mode 100644 index 00000000..c157af61 --- /dev/null +++ b/contrib/fltk/10-str2860-fltk-1.3.x-screen_num.patch @@ -0,0 +1,131 @@ +diff -up fltk-1.3.0r9619/FL/Fl.H.screen_num fltk-1.3.0r9619/FL/Fl.H +--- fltk-1.3.0r9619/FL/Fl.H.screen_num 2012-07-03 13:49:28.663085580 +0200 ++++ fltk-1.3.0r9619/FL/Fl.H 2012-07-03 13:49:28.731084402 +0200 +@@ -806,6 +806,8 @@ public: + static void screen_xywh(int &X, int &Y, int &W, int &H, int mx, int my); + static void screen_xywh(int &X, int &Y, int &W, int &H, int n); + static void screen_xywh(int &X, int &Y, int &W, int &H, int mx, int my, int mw, int mh); ++ static int screen_num(int x, int y); ++ static int screen_num(int x, int y, int w, int h); + static void screen_dpi(float &h, float &v, int n=0); + static void screen_work_area(int &X, int &Y, int &W, int &H, int mx, int my); + static void screen_work_area(int &X, int &Y, int &W, int &H, int n); +diff -up fltk-1.3.0r9619/src/screen_xywh.cxx.screen_num fltk-1.3.0r9619/src/screen_xywh.cxx +--- fltk-1.3.0r9619/src/screen_xywh.cxx.screen_num 2012-03-23 17:47:53.000000000 +0100 ++++ fltk-1.3.0r9619/src/screen_xywh.cxx 2012-07-03 13:58:01.947195396 +0200 +@@ -215,21 +215,6 @@ int Fl::screen_count() { + return num_screens ? num_screens : 1; + } + +-static int find_screen_with_point(int mx, int my) { +- int screen = 0; +- if (num_screens < 0) screen_init(); +- +- for (int i = 0; i < num_screens; i ++) { +- int sx, sy, sw, sh; +- Fl::screen_xywh(sx, sy, sw, sh, i); +- if ((mx >= sx) && (mx < (sx+sw)) && (my >= sy) && (my < (sy+sh))) { +- screen = i; +- break; +- } +- } +- return screen; +-} +- + /** + Gets the bounding box of a screen + that contains the specified screen position \p mx, \p my +@@ -237,7 +222,7 @@ static int find_screen_with_point(int mx + \param[in] mx, my the absolute screen position + */ + void Fl::screen_xywh(int &X, int &Y, int &W, int &H, int mx, int my) { +- screen_xywh(X, Y, W, H, find_screen_with_point(mx, my)); ++ screen_xywh(X, Y, W, H, screen_num(mx, my)); + } + + +@@ -248,7 +233,7 @@ void Fl::screen_xywh(int &X, int &Y, int + \param[in] mx, my the absolute screen position + */ + void Fl::screen_work_area(int &X, int &Y, int &W, int &H, int mx, int my) { +- screen_work_area(X, Y, W, H, find_screen_with_point(mx, my)); ++ screen_work_area(X, Y, W, H, screen_num(mx, my)); + } + + /** +@@ -321,6 +306,38 @@ void Fl::screen_xywh(int &X, int &Y, int + #endif // WIN32 + } + ++/** ++ Gets the screen bounding rect for the screen ++ which intersects the most with the rectangle ++ defined by \p mx, \p my, \p mw, \p mh. ++ \param[out] X,Y,W,H the corresponding screen bounding box ++ \param[in] mx, my, mw, mh the rectangle to search for intersection with ++ \see void screen_xywh(int &X, int &Y, int &W, int &H, int n) ++ */ ++void Fl::screen_xywh(int &X, int &Y, int &W, int &H, int mx, int my, int mw, int mh) { ++ screen_xywh(X, Y, W, H, screen_num(mx, my, mw, mh)); ++} ++ ++/** ++ Gets the screen number of a screen ++ that contains the specified screen position \p x, \p y ++ \param[in] x, y the absolute screen position ++*/ ++int Fl::screen_num(int x, int y) { ++ int screen = 0; ++ if (num_screens < 0) screen_init(); ++ ++ for (int i = 0; i < num_screens; i ++) { ++ int sx, sy, sw, sh; ++ Fl::screen_xywh(sx, sy, sw, sh, i); ++ if ((x >= sx) && (x < (sx+sw)) && (y >= sy) && (y < (sy+sh))) { ++ screen = i; ++ break; ++ } ++ } ++ return screen; ++} ++ + static inline float fl_intersection(int x1, int y1, int w1, int h1, + int x2, int y2, int w2, int h2) { + if(x1+w1 < x2 || x2+w2 < x1 || y1+h1 < y2 || y2+h2 < y1) +@@ -333,30 +350,27 @@ static inline float fl_intersection(int + } + + /** +- Gets the screen bounding rect for the screen ++ Gets the screen number for the screen + which intersects the most with the rectangle +- defined by \p mx, \p my, \p mw, \p mh. +- \param[out] X,Y,W,H the corresponding screen bounding box +- \param[in] mx, my, mw, mh the rectangle to search for intersection with +- \see void screen_xywh(int &X, int &Y, int &W, int &H, int n) ++ defined by \p x, \p y, \p w, \p h. ++ \param[in] x, y, w, h the rectangle to search for intersection with + */ +-void Fl::screen_xywh(int &X, int &Y, int &W, int &H, int mx, int my, int mw, int mh) { ++int Fl::screen_num(int x, int y, int w, int h) { + int best_screen = 0; + float best_intersection = 0.; + for(int i = 0; i < Fl::screen_count(); i++) { + int sx, sy, sw, sh; + Fl::screen_xywh(sx, sy, sw, sh, i); +- float sintersection = fl_intersection(mx, my, mw, mh, sx, sy, sw, sh); ++ float sintersection = fl_intersection(x, y, w, h, sx, sy, sw, sh); + if(sintersection > best_intersection) { + best_screen = i; + best_intersection = sintersection; + } + } +- screen_xywh(X, Y, W, H, best_screen); ++ return best_screen; + } + + +- + /** + Gets the screen resolution in dots-per-inch for the given screen. + \param[out] h, v horizontal and vertical resolution diff --git a/contrib/fltk/11-str2860-fltk-1.3.x-multihead.patch b/contrib/fltk/11-str2860-fltk-1.3.x-multihead.patch new file mode 100644 index 00000000..e4a010aa --- /dev/null +++ b/contrib/fltk/11-str2860-fltk-1.3.x-multihead.patch @@ -0,0 +1,468 @@ +diff -urp fltk-1.3.2.org/FL/Fl_Window.H fltk-1.3.2/FL/Fl_Window.H +--- fltk-1.3.2.org/FL/Fl_Window.H 2013-01-16 10:52:33.017228122 +0100 ++++ fltk-1.3.2/FL/Fl_Window.H 2013-01-16 10:52:47.876478968 +0100 +@@ -54,7 +54,7 @@ class Fl_RGB_Image; + class FL_EXPORT Fl_Window : public Fl_Group { + + static char *default_xclass_; +- // Note: we must use separate statements for each of the following 4 variables, ++ // Note: we must use separate statements for each of the following 8 variables, + // with the static attribute, otherwise MS VC++ 2008/2010 complains :-( + // AlbrechtS 04/2012 + #if FLTK_ABI_VERSION < 10301 +@@ -73,6 +73,22 @@ class FL_EXPORT Fl_Window : public Fl_Gr + static // when these members are static, ABI compatibility with 1.3.0 is respected + #endif + int no_fullscreen_h; ++#if FLTK_ABI_VERSION < 10302 ++ static // when these members are static, ABI compatibility with 1.3.0 is respected ++#endif ++ int fullscreen_screen_top; ++#if FLTK_ABI_VERSION < 10302 ++ static // when these members are static, ABI compatibility with 1.3.0 is respected ++#endif ++ int fullscreen_screen_bottom; ++#if FLTK_ABI_VERSION < 10302 ++ static // when these members are static, ABI compatibility with 1.3.0 is respected ++#endif ++ int fullscreen_screen_left; ++#if FLTK_ABI_VERSION < 10302 ++ static // when these members are static, ABI compatibility with 1.3.0 is respected ++#endif ++ int fullscreen_screen_right; + + friend class Fl_X; + Fl_X *i; // points at the system-specific stuff +@@ -430,13 +446,15 @@ public: + */ + void show(int argc, char **argv); + /** +- Makes the window completely fill the screen, without any window +- manager border visible. You must use fullscreen_off() to undo +- this. ++ Makes the window completely fill one or more screens, without any ++ window manager border visible. You must use fullscreen_off() to ++ undo this. + + \note On some platforms, this can result in the keyboard being + grabbed. The window may also be recreated, meaning hide() and + show() will be called. ++ ++ \see void Fl_Window::fullscreen_screens() + */ + void fullscreen(); + /** +@@ -453,6 +471,17 @@ public: + */ + unsigned int fullscreen_active() const { return flags() & FULLSCREEN; } + /** ++ Sets which screens should be used when this window is in fullscreen ++ mode. The window will be resized to the top of the screen with index ++ \p top, the bottom of the screen with index \p bottom, etc. ++ ++ If this method is never called, or if any argument is < 0, then the ++ window will be resized to fill the screen it is currently on. ++ ++ \see void Fl_Window::fullscreen() ++ */ ++ void fullscreen_screens(int top, int bottom, int left, int right); ++ /** + Iconifies the window. If you call this when shown() is false + it will show() it as an icon. If the window is already + iconified this does nothing. +diff -urp fltk-1.3.2.org/FL/win32.H fltk-1.3.2/FL/win32.H +--- fltk-1.3.2.org/FL/win32.H 2013-01-16 10:52:33.017228122 +0100 ++++ fltk-1.3.2/FL/win32.H 2013-01-16 10:52:47.876478968 +0100 +@@ -80,6 +80,7 @@ public: + static Fl_X* i(const Fl_Window* w) {return w->i;} + static int fake_X_wm(const Fl_Window* w,int &X, int &Y, + int &bt,int &bx,int &by); ++ void make_fullscreen(int X, int Y, int W, int H); + void setwindow(Fl_Window* wi) {w=wi; wi->i=this;} + void flush() {w->flush();} + void set_minmax(LPMINMAXINFO minmax); +diff -urp fltk-1.3.2.org/src/Fl_cocoa.mm fltk-1.3.2/src/Fl_cocoa.mm +--- fltk-1.3.2.org/src/Fl_cocoa.mm 2013-01-16 10:52:33.014229574 +0100 ++++ fltk-1.3.2/src/Fl_cocoa.mm 2013-01-16 10:52:47.877480606 +0100 +@@ -2438,9 +2438,32 @@ void Fl_X::make(Fl_Window* w) + + NSRect crect; + if (w->fullscreen_active()) { +- int sx, sy, sw, sh; +- Fl::screen_xywh(sx, sy, sw, sh, w->x(), w->y(), w->w(), w->h()); +- w->resize(sx, sy, sw, sh); ++ int top, bottom, left, right; ++ int sx, sy, sw, sh, X, Y, W, H; ++ ++ top = w->fullscreen_screen_top; ++ bottom = w->fullscreen_screen_bottom; ++ left = w->fullscreen_screen_left; ++ right = w->fullscreen_screen_right; ++ ++ if ((top < 0) || (bottom < 0) || (left < 0) || (right < 0)) { ++ top = Fl::screen_num(w->x(), w->y(), w->w(), w->h()); ++ bottom = top; ++ left = top; ++ right = top; ++ } ++ ++ Fl::screen_xywh(sx, sy, sw, sh, top); ++ Y = sy; ++ Fl::screen_xywh(sx, sy, sw, sh, bottom); ++ H = sy + sh - Y; ++ Fl::screen_xywh(sx, sy, sw, sh, left); ++ X = sx; ++ Fl::screen_xywh(sx, sy, sw, sh, right); ++ W = sx + sw - X; ++ ++ w->resize(X, Y, W, H); ++ + winstyle = NSBorderlessWindowMask; + winlevel = NSStatusWindowLevel; + } +diff -urp fltk-1.3.2.org/src/Fl_win32.cxx fltk-1.3.2/src/Fl_win32.cxx +--- fltk-1.3.2.org/src/Fl_win32.cxx 2013-01-16 10:52:33.019230734 +0100 ++++ fltk-1.3.2/src/Fl_win32.cxx 2013-01-16 10:52:47.878480504 +0100 +@@ -1493,7 +1493,6 @@ int Fl_X::fake_X_wm(const Fl_Window* w,i + Y+=yoff; + + if (w->fullscreen_active()) { +- X = Y = 0; + bx = by = bt = 0; + } + +@@ -1547,19 +1546,42 @@ void Fl_Window::resize(int X,int Y,int W + } + } + +-static void make_fullscreen(Fl_Window *w, Window xid, int X, int Y, int W, int H) { ++void Fl_X::make_fullscreen(int X, int Y, int W, int H) { ++ int top, bottom, left, right; + int sx, sy, sw, sh; +- Fl::screen_xywh(sx, sy, sw, sh, X, Y, W, H); ++ ++ top = w->fullscreen_screen_top; ++ bottom = w->fullscreen_screen_bottom; ++ left = w->fullscreen_screen_left; ++ right = w->fullscreen_screen_right; ++ ++ if ((top < 0) || (bottom < 0) || (left < 0) || (right < 0)) { ++ top = Fl::screen_num(X, Y, W, H); ++ bottom = top; ++ left = top; ++ right = top; ++ } ++ ++ Fl::screen_xywh(sx, sy, sw, sh, top); ++ Y = sy; ++ Fl::screen_xywh(sx, sy, sw, sh, bottom); ++ H = sy + sh - Y; ++ Fl::screen_xywh(sx, sy, sw, sh, left); ++ X = sx; ++ Fl::screen_xywh(sx, sy, sw, sh, right); ++ W = sx + sw - X; ++ + DWORD flags = GetWindowLong(xid, GWL_STYLE); + flags = flags & ~(WS_THICKFRAME|WS_CAPTION); + SetWindowLong(xid, GWL_STYLE, flags); ++ + // SWP_NOSENDCHANGING is so that we can override size limits +- SetWindowPos(xid, HWND_TOP, sx, sy, sw, sh, SWP_NOSENDCHANGING | SWP_FRAMECHANGED); ++ SetWindowPos(xid, HWND_TOP, X, Y, W, H, SWP_NOSENDCHANGING | SWP_FRAMECHANGED); + } + + void Fl_Window::fullscreen_x() { + _set_fullscreen(); +- make_fullscreen(this, fl_xid(this), x(), y(), w(), h()); ++ i->make_fullscreen(x(), y(), w(), h()); + Fl::handle(FL_FULLSCREEN, this); + } + +@@ -1814,8 +1836,8 @@ Fl_X* Fl_X::make(Fl_Window* w) { + monitor the window was placed on. */ + RECT rect; + GetWindowRect(x->xid, &rect); +- make_fullscreen(w, x->xid, rect.left, rect.top, +- rect.right - rect.left, rect.bottom - rect.top); ++ x->make_fullscreen(rect.left, rect.top, ++ rect.right - rect.left, rect.bottom - rect.top); + } + + x->next = Fl_X::first; +diff -urp fltk-1.3.2.org/src/Fl_Window_fullscreen.cxx fltk-1.3.2/src/Fl_Window_fullscreen.cxx +--- fltk-1.3.2.org/src/Fl_Window_fullscreen.cxx 2012-11-06 21:46:14.000000000 +0100 ++++ fltk-1.3.2/src/Fl_Window_fullscreen.cxx 2013-01-16 10:52:47.879480608 +0100 +@@ -36,6 +36,10 @@ int Fl_Window::no_fullscreen_x = 0; + int Fl_Window::no_fullscreen_y = 0; + int Fl_Window::no_fullscreen_w = 0; + int Fl_Window::no_fullscreen_h = 0; ++int Fl_Window::fullscreen_screen_top = -1; ++int Fl_Window::fullscreen_screen_bottom = -1; ++int Fl_Window::fullscreen_screen_left = -1; ++int Fl_Window::fullscreen_screen_right = -1; + #endif + + void Fl_Window::border(int b) { +@@ -95,6 +99,23 @@ void Fl_Window::fullscreen_off() { + fullscreen_off(no_fullscreen_x, no_fullscreen_y, no_fullscreen_w, no_fullscreen_h); + } + ++void Fl_Window::fullscreen_screens(int top, int bottom, int left, int right) { ++ if ((top < 0) || (bottom < 0) || (left < 0) || (right < 0)) { ++ fullscreen_screen_top = -1; ++ fullscreen_screen_bottom = -1; ++ fullscreen_screen_left = -1; ++ fullscreen_screen_right = -1; ++ } else { ++ fullscreen_screen_top = top; ++ fullscreen_screen_bottom = bottom; ++ fullscreen_screen_left = left; ++ fullscreen_screen_right = right; ++ } ++ ++ if (shown() && (flags() & Fl_Widget::FULLSCREEN)) ++ fullscreen_x(); ++} ++ + + // + // End of "$Id: Fl_Window_fullscreen.cxx 9706 2012-11-06 20:46:14Z matt $". +diff -urp fltk-1.3.2.org/src/Fl_x.cxx fltk-1.3.2/src/Fl_x.cxx +--- fltk-1.3.2.org/src/Fl_x.cxx 2013-01-16 10:52:33.020228202 +0100 ++++ fltk-1.3.2/src/Fl_x.cxx 2013-01-16 10:52:47.880480556 +0100 +@@ -344,6 +344,7 @@ Atom fl_NET_WM_ICON_NAME; // utf8 aware + Atom fl_NET_SUPPORTING_WM_CHECK; + Atom fl_NET_WM_STATE; + Atom fl_NET_WM_STATE_FULLSCREEN; ++Atom fl_NET_WM_FULLSCREEN_MONITORS; + Atom fl_NET_WORKAREA; + Atom fl_NET_WM_ICON; + +@@ -709,6 +710,7 @@ void fl_open_display(Display* d) { + fl_NET_SUPPORTING_WM_CHECK = XInternAtom(d, "_NET_SUPPORTING_WM_CHECK", 0); + fl_NET_WM_STATE = XInternAtom(d, "_NET_WM_STATE", 0); + fl_NET_WM_STATE_FULLSCREEN = XInternAtom(d, "_NET_WM_STATE_FULLSCREEN", 0); ++ fl_NET_WM_FULLSCREEN_MONITORS = XInternAtom(d, "_NET_WM_FULLSCREEN_MONITORS", 0); + fl_NET_WORKAREA = XInternAtom(d, "_NET_WORKAREA", 0); + fl_NET_WM_ICON = XInternAtom(d, "_NET_WM_ICON", 0); + +@@ -1872,22 +1874,30 @@ void Fl_Window::resize(int X,int Y,int W + #define _NET_WM_STATE_ADD 1 /* add/set property */ + #define _NET_WM_STATE_TOGGLE 2 /* toggle property */ + +-static void send_wm_state_event(Window wnd, int add, Atom prop) { ++static void send_wm_event(Window wnd, Atom message, ++ unsigned long d0, unsigned long d1=0, ++ unsigned long d2=0, unsigned long d3=0, ++ unsigned long d4=0) { + XEvent e; + e.xany.type = ClientMessage; + e.xany.window = wnd; +- e.xclient.message_type = fl_NET_WM_STATE; ++ e.xclient.message_type = message; + e.xclient.format = 32; +- e.xclient.data.l[0] = add ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE; +- e.xclient.data.l[1] = prop; +- e.xclient.data.l[2] = 0; +- e.xclient.data.l[3] = 0; +- e.xclient.data.l[4] = 0; ++ e.xclient.data.l[0] = d0; ++ e.xclient.data.l[1] = d1; ++ e.xclient.data.l[2] = d2; ++ e.xclient.data.l[3] = d3; ++ e.xclient.data.l[4] = d4; + XSendEvent(fl_display, RootWindow(fl_display, fl_screen), + 0, SubstructureNotifyMask | SubstructureRedirectMask, + &e); + } + ++static void send_wm_state_event(Window wnd, int add, Atom prop) { ++ send_wm_event(wnd, fl_NET_WM_STATE, ++ add ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE, prop); ++} ++ + int Fl_X::ewmh_supported() { + static int result = -1; + +@@ -1911,6 +1921,22 @@ int Fl_X::ewmh_supported() { + /* Change an existing window to fullscreen */ + void Fl_Window::fullscreen_x() { + if (Fl_X::ewmh_supported()) { ++ int top, bottom, left, right; ++ ++ top = fullscreen_screen_top; ++ bottom = fullscreen_screen_bottom; ++ left = fullscreen_screen_left; ++ right = fullscreen_screen_right; ++ ++ if ((top < 0) || (bottom < 0) || (left < 0) || (right < 0)) { ++ top = Fl::screen_num(x(), y(), w(), h()); ++ bottom = top; ++ left = top; ++ right = top; ++ } ++ ++ send_wm_event(fl_xid(this), fl_NET_WM_FULLSCREEN_MONITORS, ++ top, bottom, left, right); + send_wm_state_event(fl_xid(this), 1, fl_NET_WM_STATE_FULLSCREEN); + } else { + _set_fullscreen(); +@@ -1997,7 +2023,7 @@ void Fl_X::make_xid(Fl_Window* win, XVis + // force the window to be on-screen. Usually the X window manager + // does this, but a few don't, so we do it here for consistency: + int scr_x, scr_y, scr_w, scr_h; +- Fl::screen_xywh(scr_x, scr_y, scr_w, scr_h, X, Y); ++ Fl::screen_xywh(scr_x, scr_y, scr_w, scr_h, X, Y, W, H); + + if (win->border()) { + // ensure border is on screen: +@@ -2026,6 +2052,23 @@ void Fl_X::make_xid(Fl_Window* win, XVis + return; + } + ++ // Compute which screen(s) we should be on if we want to go fullscreen ++ int fullscreen_top, fullscreen_bottom, fullscreen_left, fullscreen_right; ++ ++ fullscreen_top = win->fullscreen_screen_top; ++ fullscreen_bottom = win->fullscreen_screen_bottom; ++ fullscreen_left = win->fullscreen_screen_left; ++ fullscreen_right = win->fullscreen_screen_right; ++ ++ if ((fullscreen_top < 0) || (fullscreen_bottom < 0) || ++ (fullscreen_left < 0) || (fullscreen_right < 0)) { ++ fullscreen_top = Fl::screen_num(X, Y, W, H); ++ fullscreen_bottom = fullscreen_top; ++ fullscreen_left = fullscreen_top; ++ fullscreen_right = fullscreen_top; ++ } ++ ++ + ulong root = win->parent() ? + fl_xid(win->window()) : RootWindow(fl_display, fl_screen); + +@@ -2049,9 +2092,17 @@ void Fl_X::make_xid(Fl_Window* win, XVis + // border, and cannot grab without an existing window. Besides, + // there is no clear_override(). + if (win->flags() & Fl_Widget::FULLSCREEN && !Fl_X::ewmh_supported()) { ++ int sx, sy, sw, sh; + attr.override_redirect = 1; + mask |= CWOverrideRedirect; +- Fl::screen_xywh(X, Y, W, H, X, Y, W, H); ++ Fl::screen_xywh(sx, sy, sw, sh, fullscreen_left); ++ X = sx; ++ Fl::screen_xywh(sx, sy, sw, sh, fullscreen_right); ++ W = sx + sw - X; ++ Fl::screen_xywh(sx, sy, sw, sh, fullscreen_top); ++ Y = sy; ++ Fl::screen_xywh(sx, sy, sw, sh, fullscreen_bottom); ++ H = sy + sh - Y; + } + + if (fl_background_pixel >= 0) { +@@ -2122,6 +2173,13 @@ void Fl_X::make_xid(Fl_Window* win, XVis + + // If asked for, create fullscreen + if (win->flags() & Fl_Widget::FULLSCREEN && Fl_X::ewmh_supported()) { ++ unsigned long data[4]; ++ data[0] = fullscreen_top; ++ data[1] = fullscreen_bottom; ++ data[2] = fullscreen_left; ++ data[3] = fullscreen_right; ++ XChangeProperty (fl_display, xp->xid, fl_NET_WM_FULLSCREEN_MONITORS, XA_ATOM, 32, ++ PropModeReplace, (unsigned char*) data, 4); + XChangeProperty (fl_display, xp->xid, fl_NET_WM_STATE, XA_ATOM, 32, + PropModeAppend, (unsigned char*) &fl_NET_WM_STATE_FULLSCREEN, 1); + } +diff -urp fltk-1.3.2.org/test/fullscreen.cxx fltk-1.3.2/test/fullscreen.cxx +--- fltk-1.3.2.org/test/fullscreen.cxx 2012-06-14 17:09:46.000000000 +0200 ++++ fltk-1.3.2/test/fullscreen.cxx 2013-01-16 10:52:47.881104801 +0100 +@@ -127,7 +127,7 @@ class fullscreen_window : public Fl_Sing + fullscreen_window(int W, int H, const char *t=0); + int handle (int e); + Fl_Toggle_Light_Button *b3; +- ++ Fl_Toggle_Light_Button *b4; + }; + + fullscreen_window::fullscreen_window(int W, int H, const char *t) : Fl_Single_Window(W, H, t) { +@@ -170,23 +170,54 @@ void border_cb(Fl_Widget *o, void *p) { + #endif + } + +-int px,py,pw,ph; + Fl_Button *border_button; + void fullscreen_cb(Fl_Widget *o, void *p) { + Fl_Window *w = (Fl_Window *)p; + int d = ((Fl_Button *)o)->value(); + if (d) { +- px = w->x(); +- py = w->y(); +- pw = w->w(); +- ph = w->h(); ++ if (((fullscreen_window*)w)->b4->value()) { ++ int top, bottom, left, right; ++ int top_y, bottom_y, left_x, right_x; ++ ++ int sx, sy, sw, sh; ++ ++ top = bottom = left = right = 0; ++ ++ Fl::screen_xywh(sx, sy, sw, sh, 0); ++ top_y = sy; ++ bottom_y = sy + sh; ++ left_x = sx; ++ right_x = sx + sw; ++ ++ for (int i = 1;i < Fl::screen_count();i++) { ++ Fl::screen_xywh(sx, sy, sw, sh, i); ++ if (sy < top_y) { ++ top = i; ++ top_y = sy; ++ } ++ if ((sy + sh) > bottom_y) { ++ bottom = i; ++ bottom_y = sy + sh; ++ } ++ if (sx < left_x) { ++ left = i; ++ left_x = sx; ++ } ++ if ((sx + sw) > right_x) { ++ right = i; ++ right_x = sx + sw; ++ } ++ } ++ ++ w->fullscreen_screens(top, bottom, left, right); ++ } else { ++ w->fullscreen_screens(-1, -1, -1, -1); ++ } + w->fullscreen(); +- w->override(); + #ifndef WIN32 // update our border state in case border was turned off + border_button->value(w->border()); + #endif + } else { +- //w->fullscreen_off(px,py,pw,ph); + w->fullscreen_off(); + } + } +@@ -219,7 +250,7 @@ void exit_cb(Fl_Widget *, void *) { + exit(0); + } + +-#define NUMB 7 ++#define NUMB 8 + + int twowindow = 0; + int initfull = 0; +@@ -284,6 +315,9 @@ int main(int argc, char **argv) { + window.b3->callback(fullscreen_cb,w); + y+=30; + ++ window.b4 = new Fl_Toggle_Light_Button(50,y,window.w()-60,30,"All Screens"); ++ y+=30; ++ + Fl_Button eb(50,y,window.w()-60,30,"Exit"); + eb.callback(exit_cb); + y+=30; diff --git a/contrib/fltk/12-fltk-1.3.2-xhandlers.patch b/contrib/fltk/12-fltk-1.3.2-xhandlers.patch new file mode 100644 index 00000000..0ac3fe4b --- /dev/null +++ b/contrib/fltk/12-fltk-1.3.2-xhandlers.patch @@ -0,0 +1,210 @@ +diff -up fltk-1.3.2/FL/Fl.H.xhandlers fltk-1.3.2/FL/Fl.H +--- fltk-1.3.2/FL/Fl.H.xhandlers 2014-07-22 15:23:18.087334467 +0200 ++++ fltk-1.3.2/FL/Fl.H 2014-07-22 15:23:18.094334589 +0200 +@@ -96,6 +96,9 @@ typedef void (*Fl_FD_Handler)(FL_SOCKET + /** Signature of add_handler functions passed as parameters */ + typedef int (*Fl_Event_Handler)(int event); + ++/** Signature of add_system_handler functions passed as parameters */ ++typedef int (*Fl_System_Handler)(void *event, void *data); ++ + /** Signature of set_abort functions passed as parameters */ + typedef void (*Fl_Abort_Handler)(const char *format,...); + +@@ -712,6 +715,8 @@ public: + static void focus(Fl_Widget*); + static void add_handler(Fl_Event_Handler h); + static void remove_handler(Fl_Event_Handler h); ++ static void add_system_handler(Fl_System_Handler h, void *data); ++ static void remove_system_handler(Fl_System_Handler h); + static void event_dispatch(Fl_Event_Dispatch d); + static Fl_Event_Dispatch event_dispatch(); + /** @} */ +diff -up fltk-1.3.2/src/Fl_cocoa.mm.xhandlers fltk-1.3.2/src/Fl_cocoa.mm +--- fltk-1.3.2/src/Fl_cocoa.mm.xhandlers 2014-07-22 15:23:18.089334502 +0200 ++++ fltk-1.3.2/src/Fl_cocoa.mm 2014-07-22 15:23:18.095334607 +0200 +@@ -1269,6 +1269,8 @@ void fl_open_callback(void (*cb)(const c + } + @end + ++extern int fl_send_system_handlers(void *e); ++ + static void clipboard_check(void); + + @implementation FLApplication +@@ -1276,6 +1278,10 @@ static void clipboard_check(void); + { + // update clipboard status + clipboard_check(); ++ ++ if (fl_send_system_handlers(theEvent)) ++ return; ++ + NSEventType type = [theEvent type]; + if (type == NSLeftMouseDown) { + fl_lock_function(); +diff -up fltk-1.3.2/src/Fl.cxx.xhandlers fltk-1.3.2/src/Fl.cxx +--- fltk-1.3.2/src/Fl.cxx.xhandlers 2014-07-22 15:23:18.085334432 +0200 ++++ fltk-1.3.2/src/Fl.cxx 2014-07-22 15:23:18.095334607 +0200 +@@ -891,6 +891,83 @@ static int send_handlers(int e) { + return 0; + } + ++ ++//////////////////////////////////////////////////////////////// ++// System event handlers: ++ ++ ++struct system_handler_link { ++ Fl_System_Handler handle; ++ void *data; ++ system_handler_link *next; ++}; ++ ++ ++static system_handler_link *sys_handlers = 0; ++ ++ ++/** ++ \brief Install a function to intercept system events. ++ ++ FLTK calls each of these functions as soon as a new system event is ++ received. The processing will stop at the first function to return ++ non-zero. If all functions return zero then the event is passed on ++ for normal handling by FLTK. ++ ++ Each function will be called with a pointer to the system event as ++ the first argument and \p data as the second argument. The system ++ event pointer will always be void *, but will point to different ++ objects depending on the platform: ++ - X11: XEvent ++ - Windows: MSG ++ - OS X: NSEvent ++ ++ \param ha The event handler function to register ++ \param data User data to include on each call ++ ++ \see Fl::remove_system_handler(Fl_System_Handler) ++*/ ++void Fl::add_system_handler(Fl_System_Handler ha, void *data) { ++ system_handler_link *l = new system_handler_link; ++ l->handle = ha; ++ l->data = data; ++ l->next = sys_handlers; ++ sys_handlers = l; ++} ++ ++ ++/** ++ Removes a previously added system event handler. ++ ++ \param ha The event handler function to remove ++ ++ \see Fl::add_system_handler(Fl_System_Handler) ++*/ ++void Fl::remove_system_handler(Fl_System_Handler ha) { ++ system_handler_link *l, *p; ++ ++ // Search for the handler in the list... ++ for (l = sys_handlers, p = 0; l && l->handle != ha; p = l, l = l->next); ++ ++ if (l) { ++ // Found it, so remove it from the list... ++ if (p) p->next = l->next; ++ else sys_handlers = l->next; ++ ++ // And free the record... ++ delete l; ++ } ++} ++ ++int fl_send_system_handlers(void *e) { ++ for (const system_handler_link *hl = sys_handlers; hl; hl = hl->next) { ++ if (hl->handle(e, hl->data)) ++ return 1; ++ } ++ return 0; ++} ++ ++ + //////////////////////////////////////////////////////////////// + + Fl_Widget* fl_oldfocus; // kludge for Fl_Group... +diff -up fltk-1.3.2/src/Fl_win32.cxx.xhandlers fltk-1.3.2/src/Fl_win32.cxx +--- fltk-1.3.2/src/Fl_win32.cxx.xhandlers 2014-07-22 15:23:18.092334554 +0200 ++++ fltk-1.3.2/src/Fl_win32.cxx 2014-07-22 15:24:44.682843610 +0200 +@@ -336,6 +336,8 @@ void* Fl::thread_message() { + return r; + } + ++extern int fl_send_system_handlers(void *e); ++ + IActiveIMMApp *fl_aimm = NULL; + MSG fl_msg; + +@@ -401,26 +403,25 @@ int fl_wait(double time_to_wait) { + + // Execute the message we got, and all other pending messages: + // have_message = PeekMessage(&fl_msg, NULL, 0, 0, PM_REMOVE); +- have_message = PeekMessageW(&fl_msg, NULL, 0, 0, PM_REMOVE); +- if (have_message > 0) { +- while (have_message != 0 && have_message != -1) { +- // Let applications treat WM_QUIT identical to SIGTERM on *nix +- if (fl_msg.message == WM_QUIT) +- raise(SIGTERM); +- if (fl_msg.message == fl_wake_msg) { +- // Used for awaking wait() from another thread +- thread_message_ = (void*)fl_msg.wParam; +- Fl_Awake_Handler func; +- void *data; +- while (Fl::get_awake_handler_(func, data)==0) { +- func(data); +- } +- } +- +- TranslateMessage(&fl_msg); +- DispatchMessageW(&fl_msg); +- have_message = PeekMessageW(&fl_msg, NULL, 0, 0, PM_REMOVE); ++ while ((have_message = PeekMessageW(&fl_msg, NULL, 0, 0, PM_REMOVE)) > 0) { ++ if (fl_send_system_handlers(&fl_msg)) ++ continue; ++ ++ // Let applications treat WM_QUIT identical to SIGTERM on *nix ++ if (fl_msg.message == WM_QUIT) ++ raise(SIGTERM); ++ ++ if (fl_msg.message == fl_wake_msg) { ++ // Used for awaking wait() from another thread ++ thread_message_ = (void*)fl_msg.wParam; ++ Fl_Awake_Handler func; ++ void *data; ++ while (Fl::get_awake_handler_(func, data)==0) ++ func(data); + } ++ ++ TranslateMessage(&fl_msg); ++ DispatchMessageW(&fl_msg); + } + Fl::flush(); + +diff -up fltk-1.3.2/src/Fl_x.cxx.xhandlers fltk-1.3.2/src/Fl_x.cxx +--- fltk-1.3.2/src/Fl_x.cxx.xhandlers 2014-07-22 15:23:18.093334572 +0200 ++++ fltk-1.3.2/src/Fl_x.cxx 2014-07-22 15:23:18.096334624 +0200 +@@ -188,6 +188,8 @@ void Fl::remove_fd(int n) { + remove_fd(n, -1); + } + ++extern int fl_send_system_handlers(void *e); ++ + #if CONSOLIDATE_MOTION + static Fl_Window* send_motion; + extern Fl_Window* fl_xmousewin; +@@ -198,6 +200,8 @@ static void do_queued_events() { + while (XEventsQueued(fl_display,QueuedAfterReading)) { + XEvent xevent; + XNextEvent(fl_display, &xevent); ++ if (fl_send_system_handlers(&xevent)) ++ continue; + fl_handle(xevent); + } + // we send FL_LEAVE only if the mouse did not enter some other window: diff --git a/contrib/fltk/13-fltk-1.3.2-im.patch b/contrib/fltk/13-fltk-1.3.2-im.patch new file mode 100644 index 00000000..efacc42b --- /dev/null +++ b/contrib/fltk/13-fltk-1.3.2-im.patch @@ -0,0 +1,582 @@ +diff -up fltk-1.3.2/FL/Fl.H.im fltk-1.3.2/FL/Fl.H +--- fltk-1.3.2/FL/Fl.H.im 2014-09-10 14:40:05.193265424 +0200 ++++ fltk-1.3.2/FL/Fl.H 2014-09-10 14:40:05.196265471 +0200 +@@ -699,6 +699,17 @@ public: + static int event_inside(const Fl_Widget*); + static int test_shortcut(Fl_Shortcut); + ++ /** ++ Enables the system input methods facilities. This is the default. ++ \see disable_im() ++ */ ++ static void enable_im(); ++ /** ++ Disables the system input methods facilities. ++ \see enable_im() ++ */ ++ static void disable_im(); ++ + // event destinations: + static int handle(int, Fl_Window*); + static int handle_(int, Fl_Window*); +diff -up fltk-1.3.2/FL/win32.H.im fltk-1.3.2/FL/win32.H +--- fltk-1.3.2/FL/win32.H.im 2014-09-10 14:40:05.186265315 +0200 ++++ fltk-1.3.2/FL/win32.H 2014-09-10 14:40:05.196265471 +0200 +@@ -102,6 +102,8 @@ extern FL_EXPORT void fl_save_dc( HWND w + + inline Window fl_xid(const Fl_Window* w) { Fl_X *temp = Fl_X::i(w); return temp ? temp->xid : 0; } + ++extern FL_EXPORT void fl_open_display(); ++ + #else + FL_EXPORT Window fl_xid_(const Fl_Window* w); + #define fl_xid(w) fl_xid_(w) +diff -up fltk-1.3.2/src/Fl_cocoa.mm.im fltk-1.3.2/src/Fl_cocoa.mm +--- fltk-1.3.2/src/Fl_cocoa.mm.im 2014-09-10 14:40:05.193265424 +0200 ++++ fltk-1.3.2/src/Fl_cocoa.mm 2014-09-10 14:43:41.103642243 +0200 +@@ -88,6 +88,7 @@ static void createAppleMenu(void); + static Fl_Region MacRegionMinusRect(Fl_Region r, int x,int y,int w,int h); + static void cocoaMouseHandler(NSEvent *theEvent); + static int calc_mac_os_version(); ++static void im_update(void); + + static Fl_Quartz_Graphics_Driver fl_quartz_driver; + static Fl_Display_Device fl_quartz_display(&fl_quartz_driver); +@@ -108,6 +109,30 @@ int fl_mac_os_version = calc_mac_os_vers + static int got_events = 0; + static Fl_Window* resize_from_system; + static int main_screen_height; // height of menubar-containing screen used to convert between Cocoa and FLTK global screen coordinates ++static int im_enabled = -1; ++ ++// Carbon functions and definitions ++ ++typedef void *TSMDocumentID; ++ ++extern "C" enum { ++ kTSMDocumentEnabledInputSourcesPropertyTag = 'enis' // from Carbon/TextServices.h ++}; ++ ++// Undocumented voodoo. Taken from Mozilla. ++static const int smEnableRomanKybdsOnly = -23; ++ ++typedef TSMDocumentID (*TSMGetActiveDocument_type)(void); ++static TSMGetActiveDocument_type TSMGetActiveDocument; ++typedef OSStatus (*TSMSetDocumentProperty_type)(TSMDocumentID, OSType, UInt32, void*); ++static TSMSetDocumentProperty_type TSMSetDocumentProperty; ++typedef OSStatus (*TSMRemoveDocumentProperty_type)(TSMDocumentID, OSType); ++static TSMRemoveDocumentProperty_type TSMRemoveDocumentProperty; ++typedef CFArrayRef (*TISCreateASCIICapableInputSourceList_type)(void); ++static TISCreateASCIICapableInputSourceList_type TISCreateASCIICapableInputSourceList; ++ ++typedef void (*KeyScript_type)(short); ++static KeyScript_type KeyScript; + + #if CONSOLIDATE_MOTION + static Fl_Window* send_motion; +@@ -978,6 +1003,7 @@ void fl_open_callback(void (*cb)(const c + #endif + { + BOOL seen_open_file; ++ TSMDocumentID currentDoc; + } + - (void)windowDidMove:(NSNotification *)notif; + - (void)windowDidResize:(NSNotification *)notif; +@@ -991,6 +1017,7 @@ void fl_open_callback(void (*cb)(const c + - (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication*)sender; + - (void)applicationDidBecomeActive:(NSNotification *)notify; + - (void)applicationDidChangeScreenParameters:(NSNotification *)aNotification; ++- (void)applicationDidUpdate:(NSNotification *)aNotification; + - (void)applicationWillResignActive:(NSNotification *)notify; + - (void)applicationWillHide:(NSNotification *)notify; + - (void)applicationWillUnhide:(NSNotification *)notify; +@@ -1175,6 +1202,23 @@ void fl_open_callback(void (*cb)(const c + } + Fl::handle(FL_SCREEN_CONFIGURATION_CHANGED, NULL); + } ++- (void)applicationDidUpdate:(NSNotification *)aNotification ++{ ++ if ((fl_mac_os_version >= 100500) && (im_enabled != -1) && ++ (TSMGetActiveDocument != NULL)) { ++ TSMDocumentID newDoc; ++ // It is extremely unclear when Cocoa decides to create/update ++ // the input context, but debugging reveals that it is done ++ // by NSApplication:updateWindows. So check if the input context ++ // has shifted after each such run so that we can update our ++ // input methods status. ++ newDoc = TSMGetActiveDocument(); ++ if (newDoc != currentDoc) { ++ im_update(); ++ currentDoc = newDoc; ++ } ++ } ++} + - (void)applicationWillResignActive:(NSNotification *)notify + { + fl_lock_function(); +@@ -1322,6 +1365,13 @@ void fl_open_display() { + static char beenHereDoneThat = 0; + if ( !beenHereDoneThat ) { + beenHereDoneThat = 1; ++ ++ TSMGetActiveDocument = (TSMGetActiveDocument_type)Fl_X::get_carbon_function("TSMGetActiveDocument"); ++ TSMSetDocumentProperty = (TSMSetDocumentProperty_type)Fl_X::get_carbon_function("TSMSetDocumentProperty"); ++ TSMRemoveDocumentProperty = (TSMRemoveDocumentProperty_type)Fl_X::get_carbon_function("TSMRemoveDocumentProperty"); ++ TISCreateASCIICapableInputSourceList = (TISCreateASCIICapableInputSourceList_type)Fl_X::get_carbon_function("TISCreateASCIICapableInputSourceList"); ++ ++ KeyScript = (KeyScript_type)Fl_X::get_carbon_function("KeyScript"); + + BOOL need_new_nsapp = (NSApp == nil); + if (need_new_nsapp) [NSApplication sharedApplication]; +@@ -1390,6 +1440,66 @@ void fl_open_display() { + void fl_close_display() { + } + ++// Force a "Roman" or "ASCII" keyboard, which both the Mozilla and ++// Safari people seem to think implies turning off advanced IME stuff ++// (see nsTSMManager::SyncKeyScript in Mozilla and enableSecureTextInput ++// in Safari/Webcore). Should be good enough for us then... ++ ++static void im_update(void) { ++ if (fl_mac_os_version >= 100500) { ++ TSMDocumentID doc; ++ ++ if ((TSMGetActiveDocument == NULL) || ++ (TSMSetDocumentProperty == NULL) || ++ (TSMRemoveDocumentProperty == NULL) || ++ (TISCreateASCIICapableInputSourceList == NULL)) ++ return; ++ ++ doc = TSMGetActiveDocument(); ++ ++ if (im_enabled) ++ TSMRemoveDocumentProperty(doc, kTSMDocumentEnabledInputSourcesPropertyTag); ++ else { ++ CFArrayRef inputSources; ++ ++ inputSources = TISCreateASCIICapableInputSourceList(); ++ TSMSetDocumentProperty(doc, kTSMDocumentEnabledInputSourcesPropertyTag, ++ sizeof(CFArrayRef), &inputSources); ++ CFRelease(inputSources); ++ } ++ } else { ++ if (KeyScript == NULL) ++ return; ++ ++ if (im_enabled) ++ KeyScript(smKeyEnableKybds); ++ else ++ KeyScript(smEnableRomanKybdsOnly); ++ } ++} ++ ++void Fl::enable_im() { ++ fl_open_display(); ++ ++ im_enabled = 1; ++ ++ if (fl_mac_os_version >= 100500) ++ [NSApp updateWindows]; ++ else ++ im_update(); ++} ++ ++void Fl::disable_im() { ++ fl_open_display(); ++ ++ im_enabled = 0; ++ ++ if (fl_mac_os_version >= 100500) ++ [NSApp updateWindows]; ++ else ++ im_update(); ++} ++ + + // Gets the border sizes and the titlebar size + static void get_window_frame_sizes(int &bx, int &by, int &bt) { +diff -up fltk-1.3.2/src/Fl.cxx.im fltk-1.3.2/src/Fl.cxx +--- fltk-1.3.2/src/Fl.cxx.im 2014-09-10 14:40:05.194265440 +0200 ++++ fltk-1.3.2/src/Fl.cxx 2014-09-10 14:40:05.197265486 +0200 +@@ -593,45 +593,6 @@ int Fl::run() { + return 0; + } + +-#ifdef WIN32 +- +-// Function to initialize COM/OLE for usage. This must be done only once. +-// We define a flag to register whether we called it: +-static char oleInitialized = 0; +- +-// This calls the Windows function OleInitialize() exactly once. +-void fl_OleInitialize() { +- if (!oleInitialized) { +- OleInitialize(0L); +- oleInitialized = 1; +- } +-} +- +-// This calls the Windows function OleUninitialize() only, if +-// OleInitialize has been called before. +-void fl_OleUninitialize() { +- if (oleInitialized) { +- OleUninitialize(); +- oleInitialized = 0; +- } +-} +- +-class Fl_Win32_At_Exit { +-public: +- Fl_Win32_At_Exit() { } +- ~Fl_Win32_At_Exit() { +- fl_free_fonts(); // do some WIN32 cleanup +- fl_cleanup_pens(); +- fl_OleUninitialize(); +- fl_brush_action(1); +- fl_cleanup_dc_list(); +- } +-}; +-static Fl_Win32_At_Exit win32_at_exit; +-#endif +- +- +- + /** + Waits until "something happens" and then returns. Call this + repeatedly to "run" your program. You can also check what happened +diff -up fltk-1.3.2/src/Fl_Native_File_Chooser_WIN32.cxx.im fltk-1.3.2/src/Fl_Native_File_Chooser_WIN32.cxx +--- fltk-1.3.2/src/Fl_Native_File_Chooser_WIN32.cxx.im 2012-06-26 09:03:46.000000000 +0200 ++++ fltk-1.3.2/src/Fl_Native_File_Chooser_WIN32.cxx 2014-09-10 14:40:05.197265486 +0200 +@@ -34,6 +34,7 @@ LPCWSTR utf8towchar(const char *in); //M + char *wchartoutf8(LPCWSTR in); //MG + + #include <FL/Fl_Native_File_Chooser.H> ++#include <FL/x.H> + + #define LCURLY_CHR '{' + #define RCURLY_CHR '}' +@@ -41,8 +42,6 @@ char *wchartoutf8(LPCWSTR in); //MG + #define RBRACKET_CHR ']' + #define MAXFILTERS 80 + +-void fl_OleInitialize(); // in Fl.cxx (Windows only) +- + // STATIC: PRINT WINDOWS 'DOUBLE NULL' STRING (DEBUG) + #ifdef DEBUG + static void dnullprint(char *wp) { +@@ -471,7 +470,7 @@ int CALLBACK Fl_Native_File_Chooser::Dir + // SHOW DIRECTORY BROWSER + int Fl_Native_File_Chooser::showdir() { + // initialize OLE only once +- fl_OleInitialize(); // init needed by BIF_USENEWUI ++ fl_open_display(); // init needed by BIF_USENEWUI + ClearBINF(); + clear_pathnames(); + // PARENT WINDOW +diff -up fltk-1.3.2/src/Fl_win32.cxx.im fltk-1.3.2/src/Fl_win32.cxx +--- fltk-1.3.2/src/Fl_win32.cxx.im 2014-09-10 14:40:05.194265440 +0200 ++++ fltk-1.3.2/src/Fl_win32.cxx 2014-09-10 14:40:05.197265486 +0200 +@@ -60,8 +60,6 @@ + #include <ole2.h> + #include <shellapi.h> + +-#include "aimm.h" +- + // + // USE_ASYNC_SELECT - define it if you have WSAAsyncSelect()... + // USE_ASYNC_SELECT is OBSOLETED in 1.3 for the following reasons: +@@ -121,27 +119,24 @@ static HMODULE get_wsock_mod() { + * size and link dependencies. + */ + static HMODULE s_imm_module = 0; ++typedef BOOL (WINAPI* flTypeImmAssociateContextEx)(HWND, HIMC, DWORD); ++static flTypeImmAssociateContextEx flImmAssociateContextEx = 0; + typedef HIMC (WINAPI* flTypeImmGetContext)(HWND); + static flTypeImmGetContext flImmGetContext = 0; + typedef BOOL (WINAPI* flTypeImmSetCompositionWindow)(HIMC, LPCOMPOSITIONFORM); + static flTypeImmSetCompositionWindow flImmSetCompositionWindow = 0; + typedef BOOL (WINAPI* flTypeImmReleaseContext)(HWND, HIMC); + static flTypeImmReleaseContext flImmReleaseContext = 0; +-typedef BOOL (WINAPI* flTypeImmIsIME)(HKL); +-static flTypeImmIsIME flImmIsIME = 0; + +-static HMODULE get_imm_module() { +- if (!s_imm_module) { +- s_imm_module = LoadLibrary("IMM32.DLL"); +- if (!s_imm_module) +- Fl::fatal("FLTK Lib Error: IMM32.DLL file not found!\n\n" +- "Please check your input method manager library accessibility."); +- flImmGetContext = (flTypeImmGetContext)GetProcAddress(s_imm_module, "ImmGetContext"); +- flImmSetCompositionWindow = (flTypeImmSetCompositionWindow)GetProcAddress(s_imm_module, "ImmSetCompositionWindow"); +- flImmReleaseContext = (flTypeImmReleaseContext)GetProcAddress(s_imm_module, "ImmReleaseContext"); +- flImmIsIME = (flTypeImmIsIME)GetProcAddress(s_imm_module, "ImmIsIME"); +- } +- return s_imm_module; ++static void get_imm_module() { ++ s_imm_module = LoadLibrary("IMM32.DLL"); ++ if (!s_imm_module) ++ Fl::fatal("FLTK Lib Error: IMM32.DLL file not found!\n\n" ++ "Please check your input method manager library accessibility."); ++ flImmAssociateContextEx = (flTypeImmAssociateContextEx)GetProcAddress(s_imm_module, "ImmAssociateContextEx"); ++ flImmGetContext = (flTypeImmGetContext)GetProcAddress(s_imm_module, "ImmGetContext"); ++ flImmSetCompositionWindow = (flTypeImmSetCompositionWindow)GetProcAddress(s_imm_module, "ImmSetCompositionWindow"); ++ flImmReleaseContext = (flTypeImmReleaseContext)GetProcAddress(s_imm_module, "ImmReleaseContext"); + } + + // USE_TRACK_MOUSE - define NO_TRACK_MOUSE if you don't have +@@ -259,7 +254,9 @@ void fl_set_spot(int font, int size, int + Fl_Window* tw = win; + while (tw->parent()) tw = tw->window(); // find top level window + +- get_imm_module(); ++ if (!tw->shown()) ++ return; ++ + HIMC himc = flImmGetContext(fl_xid(tw)); + + if (himc) { +@@ -338,7 +335,6 @@ void* Fl::thread_message() { + + extern int fl_send_system_handlers(void *e); + +-IActiveIMMApp *fl_aimm = NULL; + MSG fl_msg; + + // This is never called with time_to_wait < 0.0. +@@ -441,6 +437,58 @@ int fl_ready() { + return get_wsock_mod() ? s_wsock_select(0,&fdt[0],&fdt[1],&fdt[2],&t) : 0; + } + ++void fl_open_display() { ++ static char beenHereDoneThat = 0; ++ ++ if (beenHereDoneThat) ++ return; ++ ++ beenHereDoneThat = 1; ++ ++ OleInitialize(0L); ++ ++ get_imm_module(); ++} ++ ++class Fl_Win32_At_Exit { ++public: ++ Fl_Win32_At_Exit() { } ++ ~Fl_Win32_At_Exit() { ++ fl_free_fonts(); // do some WIN32 cleanup ++ fl_cleanup_pens(); ++ OleUninitialize(); ++ fl_brush_action(1); ++ fl_cleanup_dc_list(); ++ } ++}; ++static Fl_Win32_At_Exit win32_at_exit; ++ ++static char im_enabled = 1; ++ ++void Fl::enable_im() { ++ fl_open_display(); ++ ++ Fl_X* i = Fl_X::first; ++ while (i) { ++ flImmAssociateContextEx(i->xid, 0, IACE_DEFAULT); ++ i = i->next; ++ } ++ ++ im_enabled = 1; ++} ++ ++void Fl::disable_im() { ++ fl_open_display(); ++ ++ Fl_X* i = Fl_X::first; ++ while (i) { ++ flImmAssociateContextEx(i->xid, 0, 0); ++ i = i->next; ++ } ++ ++ im_enabled = 0; ++} ++ + //////////////////////////////////////////////////////////////// + + int Fl::x() +@@ -683,7 +731,6 @@ void fl_clipboard_notify_untarget(HWND w + } + + //////////////////////////////////////////////////////////////// +-char fl_is_ime = 0; + void fl_get_codepage() + { + HKL hkl = GetKeyboardLayout(0); +@@ -691,14 +738,8 @@ void fl_get_codepage() + + GetLocaleInfo (LOWORD(hkl), LOCALE_IDEFAULTANSICODEPAGE, ld, 6); + DWORD ccp = atol(ld); +- fl_is_ime = 0; + + fl_codepage = ccp; +- if (fl_aimm) { +- fl_aimm->GetCodePageA(GetKeyboardLayout(0), &fl_codepage); +- } else if (get_imm_module() && flImmIsIME(hkl)) { +- fl_is_ime = 1; +- } + } + + HWND fl_capture; +@@ -1564,6 +1605,8 @@ int fl_disable_transient_for; // secret + Fl_X* Fl_X::make(Fl_Window* w) { + Fl_Group::current(0); // get rid of very common user bug: forgot end() + ++ fl_open_display(); ++ + // if the window is a subwindow and our parent is not mapped yet, we + // mark this window visible, so that mapping the parent at a later + // point in time will call this function again to finally map the subwindow. +@@ -1767,16 +1810,10 @@ Fl_X* Fl_X::make(Fl_Window* w) { + (Fl::grab() || (styleEx & WS_EX_TOOLWINDOW)) ? SW_SHOWNOACTIVATE : SW_SHOWNORMAL); + + // Register all windows for potential drag'n'drop operations +- fl_OleInitialize(); + RegisterDragDrop(x->xid, flIDropTarget); + +- if (!fl_aimm) { +- CoCreateInstance(CLSID_CActiveIMM, NULL, CLSCTX_INPROC_SERVER, +- IID_IActiveIMMApp, (void**) &fl_aimm); +- if (fl_aimm) { +- fl_aimm->Activate(TRUE); +- } +- } ++ if (!im_enabled) ++ flImmAssociateContextEx(x->xid, 0, 0); + + return x; + } +diff -up fltk-1.3.2/src/Fl_x.cxx.im fltk-1.3.2/src/Fl_x.cxx +--- fltk-1.3.2/src/Fl_x.cxx.im 2014-09-10 14:40:05.194265440 +0200 ++++ fltk-1.3.2/src/Fl_x.cxx 2014-09-10 14:40:05.198265502 +0200 +@@ -313,6 +313,7 @@ XVisualInfo *fl_visual; + Colormap fl_colormap; + XIM fl_xim_im = 0; + XIC fl_xim_ic = 0; ++Window fl_xim_win = 0; + char fl_is_over_the_spot = 0; + static XRectangle status_area; + +@@ -603,6 +604,55 @@ void fl_init_xim() { + if(xim_styles) XFree(xim_styles); + } + ++void fl_xim_deactivate(void); ++ ++void fl_xim_activate(Window xid) { ++ if (!fl_xim_im) ++ return; ++ ++ // If the focused window has changed, then use the brute force method ++ // of completely recreating the input context. ++ if (fl_xim_win != xid) { ++ fl_xim_deactivate(); ++ ++ fl_new_ic(); ++ fl_xim_win = xid; ++ ++ XSetICValues(fl_xim_ic, ++ XNFocusWindow, fl_xim_win, ++ XNClientWindow, fl_xim_win, ++ NULL); ++ } ++ ++ fl_set_spot(spotf, spots, spot.x, spot.y, spot.width, spot.height); ++} ++ ++void fl_xim_deactivate(void) { ++ if (!fl_xim_ic) ++ return; ++ ++ XDestroyIC(fl_xim_ic); ++ fl_xim_ic = NULL; ++ ++ fl_xim_win = 0; ++} ++ ++void Fl::enable_im() { ++ Fl_Window *win; ++ ++ win = Fl::first_window(); ++ if (win && win->shown()) { ++ fl_xim_activate(fl_xid(win)); ++ XSetICFocus(fl_xim_ic); ++ } else { ++ fl_new_ic(); ++ } ++} ++ ++void Fl::disable_im() { ++ fl_xim_deactivate(); ++} ++ + void fl_open_display() { + if (fl_display) return; + +@@ -1053,10 +1103,9 @@ int fl_handle(const XEvent& thisevent) + XEvent xevent = thisevent; + fl_xevent = &thisevent; + Window xid = xevent.xany.window; +- static Window xim_win = 0; + + if (fl_xim_ic && xevent.type == DestroyNotify && +- xid != xim_win && !fl_find(xid)) ++ xid != fl_xim_win && !fl_find(xid)) + { + XIM xim_im; + xim_im = XOpenIM(fl_display, NULL, NULL, NULL); +@@ -1072,46 +1121,9 @@ int fl_handle(const XEvent& thisevent) + } + + if (fl_xim_ic && (xevent.type == FocusIn)) +- { +-#define POOR_XIM +-#ifdef POOR_XIM +- if (xim_win != xid) +- { +- xim_win = xid; +- XDestroyIC(fl_xim_ic); +- fl_xim_ic = NULL; +- fl_new_ic(); +- XSetICValues(fl_xim_ic, +- XNFocusWindow, xevent.xclient.window, +- XNClientWindow, xid, +- NULL); +- } +- fl_set_spot(spotf, spots, spot.x, spot.y, spot.width, spot.height); +-#else +- if (Fl::first_window() && Fl::first_window()->modal()) { +- Window x = fl_xid(Fl::first_window()); +- if (x != xim_win) { +- xim_win = x; +- XSetICValues(fl_xim_ic, +- XNFocusWindow, xim_win, +- XNClientWindow, xim_win, +- NULL); +- fl_set_spot(spotf, spots, spot.x, spot.y, spot.width, spot.height); +- } +- } else if (xim_win != xid && xid) { +- xim_win = xid; +- XSetICValues(fl_xim_ic, +- XNFocusWindow, xevent.xclient.window, +- XNClientWindow, xid, +- //XNFocusWindow, xim_win, +- //XNClientWindow, xim_win, +- NULL); +- fl_set_spot(spotf, spots, spot.x, spot.y, spot.width, spot.height); +- } +-#endif +- } ++ fl_xim_activate(xid); + +- if ( XFilterEvent((XEvent *)&xevent, 0) ) ++ if (fl_xim_ic && XFilterEvent((XEvent *)&xevent, 0)) + return(1); + + #if USE_XRANDR diff --git a/contrib/patches/0001-Add-BUILD_STATIC-feature-from-TigerVNC-to-optionally.patch b/contrib/fltk/fixes/0001-Add-BUILD_STATIC-feature-from-TigerVNC-to-optionally.patch index 9aac0372..9aac0372 100644 --- a/contrib/patches/0001-Add-BUILD_STATIC-feature-from-TigerVNC-to-optionally.patch +++ b/contrib/fltk/fixes/0001-Add-BUILD_STATIC-feature-from-TigerVNC-to-optionally.patch diff --git a/contrib/patches/0002-Fl_cocoa.mm-depends-on-some-Carbon-functions-so-we-n.patch b/contrib/fltk/fixes/0002-Fl_cocoa.mm-depends-on-some-Carbon-functions-so-we-n.patch index 6607d578..6607d578 100644 --- a/contrib/patches/0002-Fl_cocoa.mm-depends-on-some-Carbon-functions-so-we-n.patch +++ b/contrib/fltk/fixes/0002-Fl_cocoa.mm-depends-on-some-Carbon-functions-so-we-n.patch diff --git a/contrib/patches/0003-We-need-to-unset-CMAKE_REQUIRED_LIBRARIES-after-chec.patch b/contrib/fltk/fixes/0003-We-need-to-unset-CMAKE_REQUIRED_LIBRARIES-after-chec.patch index 4d824d75..4d824d75 100644 --- a/contrib/patches/0003-We-need-to-unset-CMAKE_REQUIRED_LIBRARIES-after-chec.patch +++ b/contrib/fltk/fixes/0003-We-need-to-unset-CMAKE_REQUIRED_LIBRARIES-after-chec.patch diff --git a/contrib/patches/0004-str-2917-fix-macosx-10.6-build-issue.patch b/contrib/fltk/fixes/0004-str-2917-fix-macosx-10.6-build-issue.patch index 6ebc4089..6ebc4089 100644 --- a/contrib/patches/0004-str-2917-fix-macosx-10.6-build-issue.patch +++ b/contrib/fltk/fixes/0004-str-2917-fix-macosx-10.6-build-issue.patch diff --git a/vncviewer/CMakeLists.txt b/vncviewer/CMakeLists.txt index 9b815a39..ca1fbafe 100644 --- a/vncviewer/CMakeLists.txt +++ b/vncviewer/CMakeLists.txt @@ -41,7 +41,7 @@ else() set(VNCVIEWER_SOURCES ${VNCVIEWER_SOURCES} X11PixelBuffer.cxx) endif() -if(WIN32) +if(WIN32 AND NOT CMAKE_BUILD_TYPE STREQUAL "Debug") add_executable(vncviewer WIN32 ${VNCVIEWER_SOURCES}) else() add_executable(vncviewer ${VNCVIEWER_SOURCES}) diff --git a/vncviewer/Viewport.cxx b/vncviewer/Viewport.cxx index cd8b1bc3..32ed543c 100644 --- a/vncviewer/Viewport.cxx +++ b/vncviewer/Viewport.cxx @@ -30,6 +30,7 @@ // FLTK can pull in the X11 headers on some systems #ifndef XK_VoidSymbol +#define XK_LATIN1 #define XK_MISCELLANY #define XK_XKB_KEYS #include <rfb/keysymdef.h> @@ -39,6 +40,15 @@ #include <rfb/XF86keysym.h> #endif +#ifndef NoSymbol +#define NoSymbol 0 +#endif + +// Missing in at least some versions of MinGW +#ifndef MAPVK_VK_TO_VSC +#define MAPVK_VK_TO_VSC 0 +#endif + #include "Viewport.h" #include "CConn.h" #include "OptionsDialog.h" @@ -67,10 +77,15 @@ #include <FL/Fl_Menu.H> #include <FL/Fl_Menu_Button.H> +#ifdef __APPLE__ +#include "cocoa.h" +#endif + #ifdef WIN32 #include "win32.h" #endif + using namespace rfb; using namespace rdr; @@ -82,21 +97,24 @@ enum { ID_EXIT, ID_FULLSCREEN, ID_RESIZE, ID_CTRL, ID_ALT, ID_MENUKEY, ID_CTRLALTDEL, ID_REFRESH, ID_OPTIONS, ID_INFO, ID_ABOUT, ID_DISMISS }; +// Fake key presses use this value and above +static const int fakeKeyBase = 0x200; + Viewport::Viewport(int w, int h, const rfb::PixelFormat& serverPF, CConn* cc_) : Fl_Widget(0, 0, w, h), cc(cc_), frameBuffer(NULL), lastPointerPos(0, 0), lastButtonMask(0), cursor(NULL), menuCtrlKey(false), menuAltKey(false) { -// FLTK STR #2599 must be fixed for proper dead keys support -#ifdef HAVE_FLTK_DEAD_KEYS - set_simple_keyboard(); -#endif - // FLTK STR #2636 gives us the ability to monitor clipboard changes #ifdef HAVE_FLTK_CLIPBOARD Fl::add_clipboard_notify(handleClipboardChange, this); #endif +#ifdef HAVE_FLTK_XHANDLERS + // We need to intercept keyboard events early + Fl::add_system_handler(handleSystemEvent, this); +#endif + frameBuffer = createFramebuffer(w, h); assert(frameBuffer); @@ -129,6 +147,10 @@ Viewport::~Viewport() // again later when this object is already gone. Fl::remove_timeout(handlePointerTimeout, this); +#ifdef HAVE_FLTK_XHANDLERS + Fl::remove_system_handler(handleSystemEvent); +#endif + #ifdef HAVE_FLTK_CLIPBOARD Fl::remove_clipboard_notify(handleClipboardChange); #endif @@ -388,6 +410,9 @@ int Viewport::handle(int event) return 1; case FL_FOCUS: +#ifdef HAVE_FLTK_IM + Fl::disable_im(); +#endif // Yes, we would like some focus please! return 1; @@ -395,26 +420,18 @@ int Viewport::handle(int event) // Release all keys that were pressed as that generally makes most // sense (e.g. Alt+Tab where we only see the Alt press) while (!downKeySym.empty()) - handleKeyEvent(downKeySym.begin()->first, downKeySym.begin()->first, - "", false); + handleKeyRelease(downKeySym.begin()->first); +#ifdef HAVE_FLTK_IM + Fl::enable_im(); +#endif return 1; case FL_KEYDOWN: - if (menuKeyCode && (Fl::event_key() == menuKeyCode)) { - popupContextMenu(); - return 1; - } - - handleKeyEvent(Fl::event_key(), Fl::event_original_key(), - Fl::event_text(), true); + handleFLTKKeyPress(); return 1; case FL_KEYUP: - if (menuKeyCode && (Fl::event_key() == menuKeyCode)) - return 1; - - handleKeyEvent(Fl::event_key(), Fl::event_original_key(), - Fl::event_text(), false); + handleKeyRelease(Fl::event_original_key()); return 1; } @@ -491,9 +508,305 @@ void Viewport::handlePointerTimeout(void *data) } -rdr::U32 Viewport::translateKeyEvent(int keyCode, int origKeyCode, const char *keyText) +void Viewport::handleKeyPress(int keyCode, rdr::U32 keySym) +{ + static bool menuRecursion = false; + + // Prevent recursion if the menu wants to send its own + // activation key. + if (menuKeySym && (keySym == menuKeySym) && !menuRecursion) { + menuRecursion = true; + popupContextMenu(); + menuRecursion = false; + return; + } + + if (viewOnly) + return; + +#ifdef __APPLE__ + // Alt on OS X behaves more like AltGr on other systems, and to get + // sane behaviour we should translate things in that manner for the + // remote VNC server. However that means we lose the ability to use + // Alt as a shortcut modifier. Do what RealVNC does and hijack the + // left command key as an Alt replacement. + switch (keySym) { + case XK_Super_L: + keySym = XK_Alt_L; + break; + case XK_Super_R: + keySym = XK_Super_L; + break; + case XK_Alt_L: + keySym = XK_Mode_switch; + break; + case XK_Alt_R: + keySym = XK_ISO_Level3_Shift; + break; + } +#endif + +#ifdef WIN32 + // Ugly hack alert! + // + // Windows doesn't have a proper AltGr, but handles it using fake + // Ctrl+Alt. Unfortunately X11 doesn't generally like the combination + // Ctrl+Alt+AltGr, which we usually end up with when Xvnc tries to + // get everything in the correct state. Cheat and temporarily release + // Ctrl and Alt when we send some other symbol. + bool ctrlPressed, altPressed; + DownMap::iterator iter; + + ctrlPressed = false; + altPressed = false; + for (iter = downKeySym.begin();iter != downKeySym.end();++iter) { + if (iter->second == XK_Control_L) + ctrlPressed = true; + else if (iter->second == XK_Alt_R) + altPressed = true; + } + + if (ctrlPressed && altPressed) { + vlog.debug("Faking release of AltGr (Ctrl_L+Alt_R)"); + try { + cc->writer()->keyEvent(XK_Control_L, false); + cc->writer()->keyEvent(XK_Alt_R, false); + } catch (rdr::Exception& e) { + vlog.error("%s", e.str()); + exit_vncviewer(e.str()); + } + } +#endif + + // Because of the way keyboards work, we cannot expect to have the same + // symbol on release as when pressed. This breaks the VNC protocol however, + // so we need to keep track of what keysym a key _code_ generated on press + // and send the same on release. + downKeySym[keyCode] = keySym; + +#if defined(WIN32) || defined(__APPLE__) + vlog.debug("Key pressed: 0x%04x => 0x%04x", keyCode, keySym); +#else + vlog.debug("Key pressed: 0x%04x => XK_%s (0x%04x)", + keyCode, XKeysymToString(keySym), keySym); +#endif + + try { + cc->writer()->keyEvent(keySym, true); + } catch (rdr::Exception& e) { + vlog.error("%s", e.str()); + exit_vncviewer(e.str()); + } + +#ifdef WIN32 + // Ugly hack continued... + if (ctrlPressed && altPressed) { + vlog.debug("Restoring AltGr state"); + try { + cc->writer()->keyEvent(XK_Control_L, true); + cc->writer()->keyEvent(XK_Alt_R, true); + } catch (rdr::Exception& e) { + vlog.error("%s", e.str()); + exit_vncviewer(e.str()); + } + } +#endif +} + + +void Viewport::handleKeyRelease(int keyCode) +{ + DownMap::iterator iter; + + if (viewOnly) + return; + + iter = downKeySym.find(keyCode); + if (iter == downKeySym.end()) { + // These occur somewhat frequently so let's not spam them unless + // logging is turned up. + vlog.debug("Unexpected release of key code %d", keyCode); + return; + } + +#if defined(WIN32) || defined(__APPLE__) + vlog.debug("Key released: 0x%04x => 0x%04x", keyCode, iter->second); +#else + vlog.debug("Key released: 0x%04x => XK_%s (0x%04x)", + keyCode, XKeysymToString(iter->second), iter->second); +#endif + + try { + cc->writer()->keyEvent(iter->second, false); + } catch (rdr::Exception& e) { + vlog.error("%s", e.str()); + exit_vncviewer(e.str()); + } + + downKeySym.erase(iter); +} + + +int Viewport::handleSystemEvent(void *event, void *data) +{ + Viewport *self = (Viewport *)data; + Fl_Widget *focus; + + assert(self); + + focus = Fl::grab(); + if (!focus) + focus = Fl::focus(); + if (!focus) + return 0; + + if (focus != self) + return 0; + + assert(event); + +#if defined(WIN32) + MSG *msg = (MSG*)event; + + if ((msg->message == WM_KEYDOWN) || (msg->message == WM_SYSKEYDOWN)) { + UINT vKey; + bool isExtended; + int keyCode; + rdr::U32 keySym; + + vKey = msg->wParam; + isExtended = (msg->lParam & (1 << 24)) != 0; + + keyCode = ((msg->lParam >> 16) & 0xff); + + // Windows sets the scan code to 0x00 for multimedia keys, so we + // have to do a reverse lookup based on the vKey. + if (keyCode == 0x00) { + keyCode = MapVirtualKey(vKey, MAPVK_VK_TO_VSC); + if (keyCode == 0x00) { + vlog.error(_("No scan code for %svirtual key 0x%02x"), + isExtended?"extended ":"", (int)vKey); + return 1; + } + } + + if (isExtended) + keyCode |= 0x100; + + keySym = win32_vkey_to_keysym(vKey, isExtended); + if (keySym == NoSymbol) { + vlog.error(_("No symbol for %svirtual key 0x%02x"), + isExtended?"extended ":"", (int)vKey); + return 1; + } + + self->handleKeyPress(keyCode, keySym); + + return 1; + } else if ((msg->message == WM_KEYUP) || (msg->message == WM_SYSKEYUP)) { + UINT vKey; + bool isExtended; + int keyCode; + + vKey = msg->wParam; + isExtended = (msg->lParam & (1 << 24)) != 0; + + keyCode = ((msg->lParam >> 16) & 0xff); + if (keyCode == 0x00) + keyCode = MapVirtualKey(vKey, MAPVK_VK_TO_VSC); + if (isExtended) + keyCode |= 0x100; + + self->handleKeyRelease(keyCode); + + return 1; + } +#elif defined(__APPLE__) + if (cocoa_is_keyboard_event(event)) { + int keyCode; + + keyCode = cocoa_event_keycode(event); + + if (cocoa_is_key_press(event)) { + rdr::U32 keySym; + + keySym = cocoa_event_keysym(event); + if (keySym == NoSymbol) { + vlog.error(_("No symbol for key code 0x%02x (in the current state)"), + (int)keyCode); + return 1; + } + + self->handleKeyPress(keyCode, keySym); + + // We don't get any release events for CapsLock, so we have to + // send the release right away. + if (keySym == XK_Caps_Lock) + self->handleKeyRelease(keyCode); + } else { + self->handleKeyRelease(keyCode); + } + + return 1; + } +#else + XEvent *xevent = (XEvent*)event; + + if (xevent->type == KeyPress) { + char str; + KeySym keysym; + + XLookupString(&xevent->xkey, &str, 1, &keysym, NULL); + if (keysym == NoSymbol) { + vlog.error(_("No symbol for key code %d (in the current state)"), + (int)xevent->xkey.keycode); + return 1; + } + + switch (keysym) { + // For the first few years, there wasn't a good consensus on what the + // Windows keys should be mapped to for X11. So we need to help out a + // bit and map all variants to the same key... + case XK_Meta_L: + case XK_Hyper_L: + keysym = XK_Super_L; + break; + case XK_Meta_R: + case XK_Hyper_R: + keysym = XK_Super_R; + break; + // There has been several variants for Shift-Tab over the years. + // RFB states that we should always send a normal tab. + case XK_ISO_Left_Tab: + keysym = XK_Tab; + break; + } + + self->handleKeyPress(xevent->xkey.keycode, keysym); + return 1; + } else if (xevent->type == KeyRelease) { + self->handleKeyRelease(xevent->xkey.keycode); + return 1; + } +#endif + + return 0; +} + + +rdr::U32 Viewport::translateKeyEvent(void) { unsigned ucs; + int keyCode, origKeyCode; + const char *keyText; + int keyTextLen; + + keyCode = Fl::event_key(); + origKeyCode = Fl::event_original_key(); + keyText = Fl::event_text(); + keyTextLen = Fl::event_length(); + + vlog.debug("FLTK key %d (%d) '%s'[%d]", origKeyCode, keyCode, keyText, keyTextLen); // First check for function keys if ((keyCode > FL_F) && (keyCode <= FL_F_Last)) @@ -537,23 +850,6 @@ rdr::U32 Viewport::translateKeyEvent(int keyCode, int origKeyCode, const char *k } } -#ifdef __APPLE__ - // Alt on OS X behaves more like AltGr on other systems, and to get - // sane behaviour we should translate things in that manner for the - // remote VNC server. However that means we lose the ability to use - // Alt as a shortcut modifier. Do what RealVNC does and hijack the - // left command key as an Alt replacement. - switch (keyCode) { - case FL_Meta_L: - return XK_Alt_L; - case FL_Meta_R: - return XK_Super_L; - case FL_Alt_L: - case FL_Alt_R: - return XK_ISO_Level3_Shift; - } -#endif - #if defined(WIN32) || defined(__APPLE__) // X11 fairly consistently uses XK_KP_Separator for comma and // XK_KP_Decimal for period. Windows and OS X are a different matter @@ -700,9 +996,24 @@ rdr::U32 Viewport::translateKeyEvent(int keyCode, int origKeyCode, const char *k } // Unknown special key? - if (keyText[0] == '\0') { + if (keyTextLen == 0) { vlog.error(_("Unknown FLTK key code %d (0x%04x)"), keyCode, keyCode); - return XK_VoidSymbol; + return NoSymbol; + } + + // Control character? + if ((keyTextLen == 1) && ((keyText[0] < 0x20) | (keyText[0] == 0x7f))) { + if (keyText[0] == 0x00) + return XK_2; + else if (keyText[0] < 0x1b) { + if (!!Fl::event_state(FL_SHIFT) != !!Fl::event_state(FL_CAPS_LOCK)) + return keyText[0] + XK_A - 0x01; + else + return keyText[0] + XK_a - 0x01; + } else if (keyText[0] < 0x20) + return keyText[0] + XK_3 - 0x1b; + else + return XK_8; } // Look up the symbol the key produces and translate that from Unicode @@ -710,7 +1021,7 @@ rdr::U32 Viewport::translateKeyEvent(int keyCode, int origKeyCode, const char *k if (fl_utf_nb_char((const unsigned char*)keyText, strlen(keyText)) != 1) { vlog.error(_("Multiple characters given for key code %d (0x%04x): '%s'"), keyCode, keyCode, keyText); - return XK_VoidSymbol; + return NoSymbol; } ucs = fl_utf8decode(keyText, NULL, NULL); @@ -718,113 +1029,19 @@ rdr::U32 Viewport::translateKeyEvent(int keyCode, int origKeyCode, const char *k } -void Viewport::handleKeyEvent(int keyCode, int origKeyCode, const char *keyText, bool down) +void Viewport::handleFLTKKeyPress(void) { rdr::U32 keySym; - if (viewOnly) - return; - - // Because of the way keyboards work, we cannot expect to have the same - // symbol on release as when pressed. This breaks the VNC protocol however, - // so we need to keep track of what keysym a key _code_ generated on press - // and send the same on release. - if (!down) { - DownMap::iterator iter; - - iter = downKeySym.find(origKeyCode); - if (iter == downKeySym.end()) { - vlog.error(_("Unexpected release of FLTK key code %d (0x%04x)"), - origKeyCode, origKeyCode); - return; - } - - vlog.debug("Key released: 0x%04x => 0x%04x", origKeyCode, iter->second); - - try { - cc->writer()->keyEvent(iter->second, false); - } catch (rdr::Exception& e) { - vlog.error("%s", e.str()); - exit_vncviewer(e.str()); - } - - downKeySym.erase(iter); - - return; - } - - keySym = translateKeyEvent(keyCode, origKeyCode, keyText); - if (keySym == XK_VoidSymbol) - return; - -#ifdef WIN32 - // Ugly hack alert! - // - // Windows doesn't have a proper AltGr, but handles it using fake - // Ctrl+Alt. Unfortunately X11 doesn't generally like the combination - // Ctrl+Alt+AltGr, which we usually end up with when Xvnc tries to - // get everything in the correct state. Cheat and temporarily release - // Ctrl and Alt whenever we get a key with a symbol. - bool need_cheat = true; - - if (keyText[0] == '\0') - need_cheat = false; - else if ((downKeySym.find(FL_Control_L) == downKeySym.end()) && - (downKeySym.find(FL_Control_R) == downKeySym.end())) - need_cheat = false; - else if ((downKeySym.find(FL_Alt_L) == downKeySym.end()) && - (downKeySym.find(FL_Alt_R) == downKeySym.end())) - need_cheat = false; - - if (need_cheat) { - vlog.debug("Faking release of AltGr (Ctrl+Alt)"); - try { - if (downKeySym.find(FL_Control_L) != downKeySym.end()) - cc->writer()->keyEvent(XK_Control_L, false); - if (downKeySym.find(FL_Control_R) != downKeySym.end()) - cc->writer()->keyEvent(XK_Control_R, false); - if (downKeySym.find(FL_Alt_L) != downKeySym.end()) - cc->writer()->keyEvent(XK_Alt_L, false); - if (downKeySym.find(FL_Alt_R) != downKeySym.end()) - cc->writer()->keyEvent(XK_Alt_R, false); - } catch (rdr::Exception& e) { - vlog.error("%s", e.str()); - exit_vncviewer(e.str()); - } - } +#ifdef HAVE_FLTK_XHANDLERS + return; #endif - vlog.debug("Key pressed: 0x%04x (0x%04x) '%s' => 0x%04x", - origKeyCode, keyCode, keyText, keySym); - - downKeySym[origKeyCode] = keySym; - - try { - cc->writer()->keyEvent(keySym, down); - } catch (rdr::Exception& e) { - vlog.error("%s", e.str()); - exit_vncviewer(e.str()); - } + keySym = translateKeyEvent(); + if (keySym == NoSymbol) + return; -#ifdef WIN32 - // Ugly hack continued... - if (need_cheat) { - vlog.debug("Restoring AltGr state"); - try { - if (downKeySym.find(FL_Control_L) != downKeySym.end()) - cc->writer()->keyEvent(XK_Control_L, true); - if (downKeySym.find(FL_Control_R) != downKeySym.end()) - cc->writer()->keyEvent(XK_Control_R, true); - if (downKeySym.find(FL_Alt_L) != downKeySym.end()) - cc->writer()->keyEvent(XK_Alt_L, true); - if (downKeySym.find(FL_Alt_R) != downKeySym.end()) - cc->writer()->keyEvent(XK_Alt_R, true); - } catch (rdr::Exception& e) { - vlog.error(e.str()); - exit_vncviewer(e.str()); - } - } -#endif + handleKeyPress(Fl::event_original_key(), keySym); } @@ -849,7 +1066,7 @@ void Viewport::initContextMenu() contextMenu->add(_("Alt"), 0, NULL, (void*)ID_ALT, FL_MENU_TOGGLE | (menuAltKey?FL_MENU_VALUE:0)); - if (menuKeyCode) { + if (menuKeySym) { char sendMenuKey[64]; snprintf(sendMenuKey, 64, _("Send %s"), (const char *)menuKey); contextMenu->add(sendMenuKey, 0, NULL, (void*)ID_MENUKEY, 0); @@ -918,25 +1135,31 @@ void Viewport::popupContextMenu() window()->size(w(), h()); break; case ID_CTRL: - handleKeyEvent(FL_Control_L, FL_Control_L, "", m->value()); + if (m->value()) + handleKeyPress(fakeKeyBase + 0, XK_Control_L); + else + handleKeyRelease(fakeKeyBase + 0); menuCtrlKey = !menuCtrlKey; break; case ID_ALT: - handleKeyEvent(FL_Alt_L, FL_Alt_L, "", m->value()); + if (m->value()) + handleKeyPress(fakeKeyBase + 1, XK_Alt_L); + else + handleKeyRelease(fakeKeyBase + 1); menuAltKey = !menuAltKey; break; case ID_MENUKEY: - handleKeyEvent(menuKeyCode, menuKeyCode, "", true); - handleKeyEvent(menuKeyCode, menuKeyCode, "", false); + handleKeyPress(fakeKeyBase + 2, menuKeySym); + handleKeyRelease(fakeKeyBase + 2); break; case ID_CTRLALTDEL: - handleKeyEvent(FL_Control_L, FL_Control_L, "", true); - handleKeyEvent(FL_Alt_L, FL_Alt_L, "", true); - handleKeyEvent(FL_Delete, FL_Delete, "", true); + handleKeyPress(fakeKeyBase + 3, XK_Control_L); + handleKeyPress(fakeKeyBase + 4, XK_Alt_L); + handleKeyPress(fakeKeyBase + 5, XK_Delete); - handleKeyEvent(FL_Delete, FL_Delete, "", false); - handleKeyEvent(FL_Alt_L, FL_Alt_L, "", false); - handleKeyEvent(FL_Control_L, FL_Control_L, "", false); + handleKeyRelease(fakeKeyBase + 5); + handleKeyRelease(fakeKeyBase + 4); + handleKeyRelease(fakeKeyBase + 3); break; case ID_REFRESH: cc->refreshFramebuffer(); @@ -962,7 +1185,7 @@ void Viewport::popupContextMenu() void Viewport::setMenuKey() { - menuKeyCode = getMenuKeyCode(); + getMenuKey(&menuKeyCode, &menuKeySym); } diff --git a/vncviewer/Viewport.h b/vncviewer/Viewport.h index 0523cd14..8e60da65 100644 --- a/vncviewer/Viewport.h +++ b/vncviewer/Viewport.h @@ -70,8 +70,13 @@ private: void handlePointerEvent(const rfb::Point& pos, int buttonMask); static void handlePointerTimeout(void *data); - rdr::U32 translateKeyEvent(int keyCode, int origKeyCode, const char *keyText); - void handleKeyEvent(int keyCode, int origKeyCode, const char *keyText, bool down); + void handleKeyPress(int keyCode, rdr::U32 keySym); + void handleKeyRelease(int keyCode); + + static int handleSystemEvent(void *event, void *data); + + rdr::U32 translateKeyEvent(void); + void handleFLTKKeyPress(void); void initContextMenu(); void popupContextMenu(); @@ -91,6 +96,7 @@ private: typedef std::map<int, rdr::U32> DownMap; DownMap downKeySym; + rdr::U32 menuKeySym; int menuKeyCode; Fl_Menu_Button *contextMenu; diff --git a/vncviewer/cocoa.h b/vncviewer/cocoa.h index 87980823..e9101f34 100644 --- a/vncviewer/cocoa.h +++ b/vncviewer/cocoa.h @@ -22,4 +22,11 @@ int cocoa_capture_display(Fl_Window *win, bool all_displays); void cocoa_release_display(Fl_Window *win); +int cocoa_is_keyboard_event(const void *event); + +int cocoa_is_key_press(const void *event); + +int cocoa_event_keycode(const void *event); +int cocoa_event_keysym(const void *event); + #endif diff --git a/vncviewer/cocoa.mm b/vncviewer/cocoa.mm index 2b50ecfe..e9e09683 100644 --- a/vncviewer/cocoa.mm +++ b/vncviewer/cocoa.mm @@ -25,6 +25,17 @@ #include <FL/x.H> #import <Cocoa/Cocoa.h> +#import <Carbon/Carbon.h> + +#define XK_LATIN1 +#define XK_MISCELLANY +#define XK_XKB_KEYS +#include <rfb/keysymdef.h> +#include <rfb/XF86keysym.h> + +#include "keysym2ucs.h" + +#define NoSymbol 0 static bool captured = false; @@ -100,3 +111,374 @@ void cocoa_release_display(Fl_Window *win) if ([nsw level] != newlevel) [nsw setLevel:newlevel]; } + +int cocoa_is_keyboard_event(const void *event) +{ + NSEvent *nsevent; + + nsevent = (NSEvent*)event; + + switch ([nsevent type]) { + case NSKeyDown: + case NSKeyUp: + case NSFlagsChanged: + return 1; + default: + return 0; + } +} + +int cocoa_is_key_press(const void *event) +{ + NSEvent *nsevent; + + nsevent = (NSEvent*)event; + + if ([nsevent type] == NSKeyDown) + return 1; + + if ([nsevent type] == NSFlagsChanged) { + UInt32 mask; + + // We don't see any event on release of CapsLock + if ([nsevent keyCode] == 0x39) + return 1; + + // These are entirely undocumented, but I cannot find any other way + // of differentiating between left and right keys + switch ([nsevent keyCode]) { + case 0x36: + mask = 0x0010; + break; + case 0x37: + mask = 0x0008; + break; + case 0x38: + mask = 0x0002; + break; + case 0x39: + // We don't see any event on release of CapsLock + return 1; + case 0x3A: + mask = 0x0020; + break; + case 0x3B: + mask = 0x0001; + break; + case 0x3C: + mask = 0x0004; + break; + case 0x3D: + mask = 0x0040; + break; + case 0x3E: + mask = 0x2000; + break; + default: + return 0; + } + + if ([nsevent modifierFlags] & mask) + return 1; + else + return 0; + } + + return 0; +} + +int cocoa_event_keycode(const void *event) +{ + NSEvent *nsevent; + + nsevent = (NSEvent*)event; + + return [nsevent keyCode]; +} + +static NSString *key_translate(UInt16 keyCode, UInt32 modifierFlags) +{ + const UCKeyboardLayout *layout; + OSStatus err; + + layout = NULL; + +#if (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5) + TISInputSourceRef keyboard; + CFDataRef uchr; + + keyboard = TISCopyCurrentKeyboardInputSource(); + uchr = (CFDataRef)TISGetInputSourceProperty(keyboard, + kTISPropertyUnicodeKeyLayoutData); + if (uchr == NULL) + return nil; + + layout = (const UCKeyboardLayout*)CFDataGetBytePtr(uchr); +#else // MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 + KeyboardLayoutRef old_layout; + int kind; + + err = KLGetCurrentKeyboardLayout(&old_layout); + if (err != noErr) + return nil; + + err = KLGetKeyboardLayoutProperty(old_layout, kKLKind, + (const void**)&kind); + if (err != noErr) + return nil; + + // Old, crufty layout format? + if (kind == kKLKCHRKind) { + void *kchr_layout; + + UInt32 chars, state; + char buf[3]; + + unichar result[16]; + ByteCount in_len, out_len; + + err = KLGetKeyboardLayoutProperty(old_layout, kKLKCHRData, + (const void**)&kchr_layout); + if (err != noErr) + return nil; + + state = 0; + + keyCode &= 0x7f; + modifierFlags &= 0xff00; + + chars = KeyTranslate(kchr_layout, keyCode | modifierFlags, &state); + + // Dead key? + if (state != 0) { + // We have no fool proof way of asking what dead key this is. + // Assume we get a spacing equivalent if we press the + // same key again, and try to deduce something from that. + chars = KeyTranslate(kchr_layout, keyCode | modifierFlags, &state); + } + + buf[0] = (chars >> 16) & 0xff; + buf[1] = chars & 0xff; + buf[2] = '\0'; + + if (buf[0] == '\0') { + buf[0] = buf[1]; + buf[1] = '\0'; + } + + // The data is now in some layout specific encoding. Need to convert + // this to unicode. + + ScriptCode script; + TextEncoding encoding; + TECObjectRef converter; + + script = (ScriptCode)GetScriptManagerVariable(smKeyScript); + + err = UpgradeScriptInfoToTextEncoding(script, kTextLanguageDontCare, + kTextRegionDontCare, NULL, + &encoding); + if (err != noErr) + return nil; + + err = TECCreateConverter(&converter, encoding, kTextEncodingUnicodeV4_0); + if (err != noErr) + return nil; + + in_len = strlen(buf); + out_len = sizeof(result); + + err = TECConvertText(converter, (ConstTextPtr)buf, in_len, &in_len, + (TextPtr)result, out_len, &out_len); + + TECDisposeConverter(converter); + + if (err != noErr) + return nil; + + return [NSString stringWithCharacters:result + length:(out_len / sizeof(unichar))]; + } + + if ((kind != kKLKCHRuchrKind) && (kind != kKLuchrKind)) + return nil; + + err = KLGetKeyboardLayoutProperty(old_layout, kKLuchrData, + (const void**)&layout); + if (err != noErr) + return nil; +#endif // MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 + + if (layout == NULL) + return nil; + + UInt32 dead_state; + UniCharCount max_len, actual_len; + UniChar string[255]; + + dead_state = 0; + max_len = sizeof(string)/sizeof(*string); + + modifierFlags = (modifierFlags >> 8) & 0xff; + + err = UCKeyTranslate(layout, keyCode, kUCKeyActionDown, modifierFlags, + LMGetKbdType(), 0, &dead_state, max_len, &actual_len, + string); + if (err != noErr) + return nil; + + // Dead key? + if (dead_state != 0) { + // We have no fool proof way of asking what dead key this is. + // Assume we get a spacing equivalent if we press the + // same key again, and try to deduce something from that. + err = UCKeyTranslate(layout, keyCode, kUCKeyActionDown, modifierFlags, + LMGetKbdType(), 0, &dead_state, max_len, &actual_len, + string); + if (err != noErr) + return nil; + } + + return [NSString stringWithCharacters:string length:actual_len]; +} + +// FIXME: We use hard coded values here as the constants didn't appear +// in the OS X headers until 10.5. +static const int kvk_map[][2] = { + { 0x24, XK_Return }, + { 0x30, XK_Tab }, + { 0x31, XK_space }, + { 0x33, XK_BackSpace }, + { 0x35, XK_Escape }, + // This one is undocumented for unknown reasons + { 0x36, XK_Super_R }, + { 0x37, XK_Super_L }, + { 0x38, XK_Shift_L }, + { 0x39, XK_Caps_Lock }, + { 0x3A, XK_Alt_L }, + { 0x3B, XK_Control_L }, + { 0x3C, XK_Shift_R }, + { 0x3D, XK_Alt_R }, + { 0x3E, XK_Control_R }, + { 0x40, XK_F17 }, + { 0x48, XF86XK_AudioRaiseVolume }, + { 0x49, XF86XK_AudioLowerVolume }, + { 0x4A, XF86XK_AudioMute }, + { 0x4F, XK_F18 }, + { 0x50, XK_F19 }, + { 0x5A, XK_F20 }, + { 0x60, XK_F5 }, + { 0x61, XK_F6 }, + { 0x62, XK_F7 }, + { 0x63, XK_F3 }, + { 0x64, XK_F8 }, + { 0x65, XK_F9 }, + { 0x67, XK_F11 }, + { 0x69, XK_F13 }, + { 0x6A, XK_F16 }, + { 0x6B, XK_F14 }, + { 0x6D, XK_F10 }, + // Also undocumented + { 0x6E, XK_Menu }, + { 0x6F, XK_F12 }, + { 0x71, XK_F15 }, + // Should we send Insert here? + { 0x72, XK_Help }, + { 0x73, XK_Home }, + { 0x74, XK_Page_Up }, + { 0x75, XK_Delete }, + { 0x76, XK_F4 }, + { 0x77, XK_End }, + { 0x78, XK_F2 }, + { 0x79, XK_Page_Down }, + { 0x7A, XK_F1 }, + { 0x7B, XK_Left }, + { 0x7C, XK_Right }, + { 0x7D, XK_Down }, + { 0x7E, XK_Up }, + // The OS X headers claim these keys are not layout independent. + // Could it be because of the state of the decimal key? + /* { 0x41, XK_KP_Decimal }, */ // see below + { 0x43, XK_KP_Multiply }, + { 0x45, XK_KP_Add }, + // OS X doesn't have NumLock, so is this really correct? + { 0x47, XK_Num_Lock }, + { 0x4B, XK_KP_Divide }, + { 0x4C, XK_KP_Enter }, + { 0x4E, XK_KP_Subtract }, + { 0x51, XK_KP_Equal }, + { 0x52, XK_KP_0 }, + { 0x53, XK_KP_1 }, + { 0x54, XK_KP_2 }, + { 0x55, XK_KP_3 }, + { 0x56, XK_KP_4 }, + { 0x57, XK_KP_5 }, + { 0x58, XK_KP_6 }, + { 0x59, XK_KP_7 }, + { 0x5B, XK_KP_8 }, + { 0x5C, XK_KP_9 }, +}; + +int cocoa_event_keysym(const void *event) +{ + NSEvent *nsevent; + + UInt16 key_code; + int i; + + NSString *chars; + UInt32 modifiers; + + nsevent = (NSEvent*)event; + + key_code = [nsevent keyCode]; + + // Start with keys that either don't generate a symbol, or + // generate the same symbol as some other key. + for (i = 0;i < sizeof(kvk_map)/sizeof(kvk_map[0]);i++) { + if (key_code == kvk_map[i][0]) + return kvk_map[i][1]; + } + + // OS X always sends the same key code for the decimal key on the + // num pad, but X11 wants different keysyms depending on if it should + // be a comma or full stop. + if (key_code == 0x41) { + switch ([[nsevent charactersIgnoringModifiers] UTF8String][0]) { + case ',': + return XK_KP_Separator; + case '.': + return XK_KP_Decimal; + default: + return NoSymbol; + } + } + + // We want a "normal" symbol out of the event, which basically means + // we only respect the shift and alt/altgr modifiers. Cocoa can help + // us if we only wanted shift, but as we also want alt/altgr, we'll + // have to do some lookup ourselves. This matches our behaviour on + // other platforms. + + modifiers = 0; + if ([nsevent modifierFlags] & NSAlphaShiftKeyMask) + modifiers |= alphaLock; + if ([nsevent modifierFlags] & NSShiftKeyMask) + modifiers |= shiftKey; + if ([nsevent modifierFlags] & NSAlternateKeyMask) + modifiers |= optionKey; + + chars = key_translate(key_code, modifiers); + if (chars == nil) + return NoSymbol; + + // FIXME: Some dead keys are given as NBSP + combining character + if ([chars length] != 1) + return NoSymbol; + + // Dead key? + if ([[nsevent characters] length] == 0) + return ucs2keysym(ucs2combining([chars characterAtIndex:0])); + + return ucs2keysym([chars characterAtIndex:0]); +} diff --git a/vncviewer/keysym2ucs.c b/vncviewer/keysym2ucs.c index d12eb491..d91df677 100644 --- a/vncviewer/keysym2ucs.c +++ b/vncviewer/keysym2ucs.c @@ -34,10 +34,19 @@ #include "keysym2ucs.h" +#define NoSymbol 0 + struct codepair { unsigned short keysym; unsigned short ucs; -} keysymtab[] = { +}; + +struct combiningpair { + unsigned short spacing; + unsigned short combining; +}; + +static const struct codepair keysymtab[] = { { 0x01a1, 0x0104 }, /* Aogonek Ą LATIN CAPITAL LETTER A WITH OGONEK */ { 0x01a2, 0x02d8 }, /* breve ˘ BREVE */ { 0x01a3, 0x0141 }, /* Lstroke Ł LATIN CAPITAL LETTER L WITH STROKE */ @@ -823,12 +832,37 @@ struct codepair { { 0xfe5a, 0x030c }, /* COMBINING CARON */ { 0xfe5b, 0x0327 }, /* COMBINING CEDILLA */ { 0xfe5c, 0x0328 }, /* COMBINING OGONEK */ - { 0xfe5d, 0x1da5 }, /* MODIFIER LETTER SMALL IOTA */ + { 0xfe5d, 0x0345 }, /* COMBINING GREEK YPOGEGRAMMENI */ { 0xfe5e, 0x3099 }, /* COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK */ { 0xfe5f, 0x309a }, /* COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK */ { 0xfe60, 0x0323 }, /* COMBINING DOT BELOW */ }; +static const struct combiningpair combinetab[] = { + { 0x0060, 0x0300 }, /* GRAVE ACCENT ` COMBINING GRAVE ACCENT */ + { 0x00b4, 0x0301 }, /* ACUTE ACCENT ´ COMBINING ACUTE ACCENT */ + { 0x0027, 0x0301 }, /* APOSTROPHE ' COMBINING ACUTE ACCENT */ + { 0x0384, 0x0301 }, /* GREEK TONOS ΄ COMBINING ACUTE ACCENT */ + { 0x005e, 0x0302 }, /* CIRCUMFLEX ACCENT ^ COMBINING CIRCUMFLEX ACCENT */ + { 0x007e, 0x0303 }, /* TILDE ~ COMBINING TILDE */ + { 0x00af, 0x0304 }, /* MACRON ¯ COMBINING MACRON */ + { 0x02d8, 0x0306 }, /* BREVE ˘ COMBINING BREVE */ + { 0x02d9, 0x0307 }, /* DOT ABOVE ˙ COMBINING DOT ABOVE */ + { 0x00a8, 0x0308 }, /* DIAERESIS ¨ COMBINING DIAERESIS */ + { 0x0022, 0x0308 }, /* QUOTATION MARK " COMBINING DIAERESIS */ + { 0x02da, 0x030a }, /* RING ABOVE ˚ COMBINING RING ABOVE */ + { 0x00b0, 0x030a }, /* DEGREE SIGN ° COMBINING RING ABOVE */ + { 0x02dd, 0x030b }, /* DOUBLE ACUTE ACCENT ˝ COMBINING DOUBLE ACUTE ACCENT */ + { 0x02c7, 0x030c }, /* CARON ˇ COMBINING CARON */ + { 0x00b8, 0x0327 }, /* CEDILLA ¸ COMBINING CEDILLA */ + { 0x02db, 0x0328 }, /* OGONEK ¸ COMBINING OGONEK */ + { 0x037a, 0x0345 }, /* GREEK YPOGEGRAMMENI ͺ COMBINING GREEK YPOGEGRAMMENI */ + { 0x309b, 0x3099 }, /* KATAKANA-HIRAGANA VOICED SOUND MARK ゛COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK */ + { 0x309c, 0x309a }, /* KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK ゜COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK */ + { 0x002e, 0x0323 }, /* FULL STOP . COMBINING DOT BELOW */ + { 0x0385, 0x0344 }, /* GREEK DIALYTIKA TONOS ΅ COMBINING GREEK DIALYTIKA TONOS */ +}; + unsigned keysym2ucs(unsigned keysym) { int min = 0; @@ -884,5 +918,21 @@ unsigned ucs2keysym(unsigned ucs) return ucs | 0x01000000; /* no matching keysym value found */ - return 0xFFFFFF; + return NoSymbol; +} + +unsigned ucs2combining(unsigned spacing) +{ + int cur = 0; + int max = sizeof(combinetab) / sizeof(struct combiningpair) - 1; + + /* linear search in table */ + while (cur <= max) { + if (combinetab[cur].spacing == spacing) + return combinetab[cur].combining; + cur++; + } + + /* no matching Unicode value found */ + return -1; } diff --git a/vncviewer/keysym2ucs.h b/vncviewer/keysym2ucs.h index a09165b9..01a7ddb0 100644 --- a/vncviewer/keysym2ucs.h +++ b/vncviewer/keysym2ucs.h @@ -10,6 +10,8 @@ extern "C" { unsigned keysym2ucs(unsigned keysym); unsigned ucs2keysym(unsigned ucs); +unsigned ucs2combining(unsigned spacing); + #ifdef __cplusplus } #endif diff --git a/vncviewer/menukey.cxx b/vncviewer/menukey.cxx index 2e3a568a..9c52f5e7 100644 --- a/vncviewer/menukey.cxx +++ b/vncviewer/menukey.cxx @@ -20,31 +20,37 @@ #include <string.h> #include <FL/Fl.H> +// FLTK can pull in the X11 headers on some systems +#ifndef XK_VoidSymbol +#define XK_MISCELLANY +#include <rfb/keysymdef.h> +#endif + #include "menukey.h" #include "parameters.h" static const MenuKeySymbol menuSymbols[] = { - {"F1", FL_F + 1}, - {"F2", FL_F + 2}, - {"F3", FL_F + 3}, - {"F4", FL_F + 4}, - {"F5", FL_F + 5}, - {"F6", FL_F + 6}, - {"F7", FL_F + 7}, - {"F8", FL_F + 8}, - {"F9", FL_F + 9}, - {"F10", FL_F + 10}, - {"F11", FL_F + 11}, - {"F12", FL_F + 12}, - {"Pause", FL_Pause}, - {"Print", FL_Print}, - {"Scroll_Lock", FL_Scroll_Lock}, - {"Escape", FL_Escape}, - {"Insert", FL_Insert}, - {"Delete", FL_Delete}, - {"Home", FL_Home}, - {"Page_Up", FL_Page_Up}, - {"Page_Down", FL_Page_Down}, + {"F1", FL_F + 1, XK_F1}, + {"F2", FL_F + 2, XK_F2}, + {"F3", FL_F + 3, XK_F3}, + {"F4", FL_F + 4, XK_F4}, + {"F5", FL_F + 5, XK_F5}, + {"F6", FL_F + 6, XK_F6}, + {"F7", FL_F + 7, XK_F7}, + {"F8", FL_F + 8, XK_F8}, + {"F9", FL_F + 9, XK_F9}, + {"F10", FL_F + 10, XK_F10}, + {"F11", FL_F + 11, XK_F11}, + {"F12", FL_F + 12, XK_F12}, + {"Pause", FL_Pause, XK_Pause}, + {"Print", FL_Print, XK_Print}, + {"Scroll_Lock", FL_Scroll_Lock, XK_Scroll_Lock}, + {"Escape", FL_Escape, XK_Escape}, + {"Insert", FL_Insert, XK_Insert}, + {"Delete", FL_Delete, XK_Delete}, + {"Home", FL_Home, XK_Home}, + {"Page_Up", FL_Page_Up, XK_Page_Up}, + {"Page_Down", FL_Page_Down, XK_Page_Down}, }; int getMenuKeySymbolCount() @@ -57,15 +63,19 @@ const MenuKeySymbol* getMenuKeySymbols() return menuSymbols; } -int getMenuKeyCode() +void getMenuKey(int *keycode, rdr::U32 *keysym) { - const char *menuKeyStr; - int menuKeyCode = 0; + const char *menuKeyStr; - menuKeyStr = menuKey; - for(int i = 0; i < getMenuKeySymbolCount(); i++) - if (!strcmp(menuSymbols[i].name, menuKeyStr)) - menuKeyCode = menuSymbols[i].keycode; + menuKeyStr = menuKey; + for(int i = 0; i < getMenuKeySymbolCount(); i++) { + if (!strcmp(menuSymbols[i].name, menuKeyStr)) { + *keycode = menuSymbols[i].keycode; + *keysym = menuSymbols[i].keysym; + return; + } + } - return menuKeyCode; + *keycode = 0; + *keysym = 0; } diff --git a/vncviewer/menukey.h b/vncviewer/menukey.h index ecb46ed6..fcc51353 100644 --- a/vncviewer/menukey.h +++ b/vncviewer/menukey.h @@ -18,12 +18,15 @@ #ifndef __KEYSYM_H__ #define __KEYSYM_H__ +#include <rdr/types.h> + typedef struct { const char* name; int keycode; + rdr::U32 keysym; } MenuKeySymbol; -int getMenuKeyCode(); +void getMenuKey(int *keycode, rdr::U32 *keysym); int getMenuKeySymbolCount(); const MenuKeySymbol* getMenuKeySymbols(); diff --git a/vncviewer/vncviewer.cxx b/vncviewer/vncviewer.cxx index 3f039379..82286ab8 100644 --- a/vncviewer/vncviewer.cxx +++ b/vncviewer/vncviewer.cxx @@ -36,6 +36,11 @@ #define mkdir(path, mode) _mkdir(path) #endif +#if !defined(WIN32) && !defined(__APPLE__) +#include <X11/Xlib.h> +#include <X11/XKBlib.h> +#endif + #include <rfb/Logger_stdio.h> #include <rfb/SecurityClient.h> #include <rfb/Security.h> @@ -386,6 +391,11 @@ int main(int argc, char** argv) init_fltk(); +#if !defined(WIN32) && !defined(__APPLE__) + fl_open_display(); + XkbSetDetectableAutoRepeat(fl_display, True, NULL); +#endif + Configuration::enableViewerParams(); /* Load the default parameter settings */ diff --git a/vncviewer/win32.c b/vncviewer/win32.c index d75cc578..cf4dc49a 100644 --- a/vncviewer/win32.c +++ b/vncviewer/win32.c @@ -19,6 +19,20 @@ #include <windows.h> +#define XK_MISCELLANY +#define XK_XKB_KEYS +#include <rfb/keysymdef.h> +#include <rfb/XF86keysym.h> + +#include "keysym2ucs.h" + +#define NoSymbol 0 + +// Missing in at least some versions of MinGW +#ifndef MAPVK_VK_TO_CHAR +#define MAPVK_VK_TO_CHAR 2 +#endif + static HANDLE thread; static DWORD thread_id; @@ -113,3 +127,175 @@ void win32_disable_lowlevel_keyboard(HWND hwnd) CloseHandle(thread); thread = NULL; } + +static const int vkey_map[][3] = { + { VK_BACK, XK_BackSpace, NoSymbol }, + { VK_TAB, XK_Tab, NoSymbol }, + { VK_CLEAR, XK_Clear, NoSymbol }, + { VK_RETURN, XK_Return, XK_KP_Enter }, + { VK_SHIFT, XK_Shift_L, NoSymbol }, + { VK_CONTROL, XK_Control_L, XK_Control_R }, + { VK_MENU, XK_Alt_L, XK_Alt_R }, + { VK_PAUSE, XK_Pause, NoSymbol }, + { VK_CAPITAL, XK_Caps_Lock, NoSymbol }, + /* FIXME: IME keys */ + { VK_ESCAPE, XK_Escape, NoSymbol }, + { VK_PRIOR, XK_KP_Prior, XK_Prior }, + { VK_NEXT, XK_KP_Next, XK_Next }, + { VK_END, XK_KP_End, XK_End }, + { VK_HOME, XK_KP_Home, XK_Home }, + { VK_LEFT, XK_KP_Left, XK_Left }, + { VK_UP, XK_KP_Up, XK_Up }, + { VK_RIGHT, XK_KP_Right, XK_Right }, + { VK_DOWN, XK_KP_Down, XK_Down }, + { VK_SNAPSHOT, XK_Print, NoSymbol }, + { VK_INSERT, XK_KP_Insert, XK_Insert }, + { VK_DELETE, XK_KP_Delete, XK_Delete }, + { VK_LWIN, NoSymbol, XK_Super_L }, + { VK_RWIN, NoSymbol, XK_Super_R }, + { VK_APPS, NoSymbol, XK_Menu }, + { VK_SLEEP, NoSymbol, XF86XK_Sleep }, + { VK_NUMPAD0, XK_KP_0, NoSymbol }, + { VK_NUMPAD1, XK_KP_1, NoSymbol }, + { VK_NUMPAD2, XK_KP_2, NoSymbol }, + { VK_NUMPAD3, XK_KP_3, NoSymbol }, + { VK_NUMPAD4, XK_KP_4, NoSymbol }, + { VK_NUMPAD5, XK_KP_5, NoSymbol }, + { VK_NUMPAD6, XK_KP_6, NoSymbol }, + { VK_NUMPAD7, XK_KP_7, NoSymbol }, + { VK_NUMPAD8, XK_KP_8, NoSymbol }, + { VK_NUMPAD9, XK_KP_9, NoSymbol }, + { VK_MULTIPLY, XK_KP_Multiply, NoSymbol }, + { VK_ADD, XK_KP_Add, NoSymbol }, + { VK_SUBTRACT, XK_KP_Subtract, NoSymbol }, + { VK_DIVIDE, NoSymbol, XK_KP_Divide }, + /* VK_SEPARATOR and VK_DECIMAL left out on purpose. See further down. */ + { VK_F1, XK_F1, NoSymbol }, + { VK_F2, XK_F2, NoSymbol }, + { VK_F3, XK_F3, NoSymbol }, + { VK_F4, XK_F4, NoSymbol }, + { VK_F5, XK_F5, NoSymbol }, + { VK_F6, XK_F6, NoSymbol }, + { VK_F7, XK_F7, NoSymbol }, + { VK_F8, XK_F8, NoSymbol }, + { VK_F9, XK_F9, NoSymbol }, + { VK_F10, XK_F10, NoSymbol }, + { VK_F11, XK_F11, NoSymbol }, + { VK_F12, XK_F12, NoSymbol }, + { VK_F13, XK_F13, NoSymbol }, + { VK_F14, XK_F14, NoSymbol }, + { VK_F15, XK_F15, NoSymbol }, + { VK_F16, XK_F16, NoSymbol }, + { VK_F17, XK_F17, NoSymbol }, + { VK_F18, XK_F18, NoSymbol }, + { VK_F19, XK_F19, NoSymbol }, + { VK_F20, XK_F20, NoSymbol }, + { VK_F21, XK_F21, NoSymbol }, + { VK_F22, XK_F22, NoSymbol }, + { VK_F23, XK_F23, NoSymbol }, + { VK_F24, XK_F24, NoSymbol }, + { VK_NUMLOCK, NoSymbol, XK_Num_Lock }, + { VK_SCROLL, XK_Scroll_Lock, NoSymbol }, + { VK_BROWSER_BACK, NoSymbol, XF86XK_Back }, + { VK_BROWSER_FORWARD, NoSymbol, XF86XK_Forward }, + { VK_BROWSER_REFRESH, NoSymbol, XF86XK_Refresh }, + { VK_BROWSER_STOP, NoSymbol, XF86XK_Stop }, + { VK_BROWSER_SEARCH, NoSymbol, XF86XK_Search }, + { VK_BROWSER_FAVORITES, NoSymbol, XF86XK_Favorites }, + { VK_BROWSER_HOME, NoSymbol, XF86XK_HomePage }, + { VK_VOLUME_MUTE, NoSymbol, XF86XK_AudioMute }, + { VK_VOLUME_DOWN, NoSymbol, XF86XK_AudioLowerVolume }, + { VK_VOLUME_UP, NoSymbol, XF86XK_AudioRaiseVolume }, + { VK_MEDIA_NEXT_TRACK, NoSymbol, XF86XK_AudioNext }, + { VK_MEDIA_PREV_TRACK, NoSymbol, XF86XK_AudioPrev }, + { VK_MEDIA_STOP, NoSymbol, XF86XK_AudioStop }, + { VK_MEDIA_PLAY_PAUSE, NoSymbol, XF86XK_AudioPlay }, + { VK_LAUNCH_MAIL, NoSymbol, XF86XK_Mail }, + { VK_LAUNCH_APP2, NoSymbol, XF86XK_Calculator }, +}; + +int win32_vkey_to_keysym(UINT vkey, int extended) +{ + int i; + + BYTE state[256]; + int ret; + WCHAR wstr[10]; + + // Start with keys that either don't generate a symbol, or + // generate the same symbol as some other key. + for (i = 0;i < sizeof(vkey_map)/sizeof(vkey_map[0]);i++) { + if (vkey == vkey_map[i][0]) { + if (extended) + return vkey_map[i][2]; + else + return vkey_map[i][1]; + } + } + + // Windows is not consistent in which virtual key it uses for + // the numpad decimal key, and this is not likely to be fixed: + // http://blogs.msdn.com/michkap/archive/2006/09/13/752377.aspx + // + // To get X11 behaviour, we instead look at the text generated + // by they key. + if ((vkey == VK_DECIMAL) || (vkey == VK_SEPARATOR)) { + UINT ch; + + ch = MapVirtualKey(vkey, MAPVK_VK_TO_CHAR); + switch (ch) { + case ',': + return XK_KP_Separator; + case '.': + return XK_KP_Decimal; + default: + return NoSymbol; + } + } + + // MapVirtualKey() doesn't look at modifiers, so it is + // insufficient for mapping most keys to a symbol. ToUnicode() + // does what we want though. Unfortunately it keeps state, so + // we have to be careful around dead characters. + + GetKeyboardState(state); + + // Pressing Ctrl wreaks havoc with the symbol lookup, so turn + // that off. But AltGr shows up as Ctrl+Alt in Windows, so keep + // Ctrl if Alt is active. + if (!(state[VK_LCONTROL] & 0x80) || !(state[VK_RMENU] & 0x80)) + state[VK_CONTROL] = state[VK_LCONTROL] = state[VK_RCONTROL] = 0; + + // FIXME: Multi character results, like U+0644 U+0627 + // on Arabic layout + ret = ToUnicode(vkey, 0, state, wstr, sizeof(wstr)/sizeof(wstr[0]), 0); + + if (ret == 0) { + // Most Ctrl+Alt combinations will fail to produce a symbol, so + // try it again with Ctrl unconditionally disabled. + state[VK_CONTROL] = state[VK_LCONTROL] = state[VK_RCONTROL] = 0; + ret = ToUnicode(vkey, 0, state, wstr, sizeof(wstr)/sizeof(wstr[0]), 0); + } + + if (ret == 1) + return ucs2keysym(wstr[0]); + + if (ret == -1) { + WCHAR dead_char; + + dead_char = wstr[0]; + + // Need to clear out the state that the dead key has caused. + // This is the recommended method by Microsoft's engineers: + // http://blogs.msdn.com/b/michkap/archive/2007/10/27/5717859.aspx + do { + ret = ToUnicode(vkey, 0, state, wstr, sizeof(wstr)/sizeof(wstr[0]), 0); + } while (ret < 0); + + // Dead keys are represented by their spacing equivalent + // (or something similar depending on the layout) + return ucs2keysym(ucs2combining(dead_char)); + } + + return NoSymbol; +} diff --git a/vncviewer/win32.h b/vncviewer/win32.h index 35be77b5..01487085 100644 --- a/vncviewer/win32.h +++ b/vncviewer/win32.h @@ -30,6 +30,8 @@ extern "C" { int win32_enable_lowlevel_keyboard(HWND hwnd); void win32_disable_lowlevel_keyboard(HWND hwnd); +int win32_vkey_to_keysym(UINT vkey, int extended); + }; #endif |