fl_shortcut.cxx

Go to the documentation of this file.

//
// "$Id$"
//
// Shortcut support routines for the Fast Light Tool Kit (FLTK).
//
// Copyright 1998-2016 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file.  If this
// file is missing or damaged, see the license at:
//
//     http://www.fltk.org/COPYING.php
//
// Please report all bugs and problems on the following page:
//
//     http://www.fltk.org/str.php
//
 
// Code to test and parse fltk shortcut numbers.
//
// A shortcut is a keysym or'd with shift flags.  In the simplest
// sense a shortcut is matched if the shift state is exactly as
// given and the key returning that keysym is pressed.
//
// To make it easier to match some things it is more complex:
//
// Only FL_META, FL_ALT, FL_SHIFT, and FL_CTRL must be "off".  A
// zero in the other shift flags indicates "don't care".
//
// It also checks against the first character of Fl::event_text(),
// and zero for FL_SHIFT means "don't care".
// This allows punctuation shortcuts like "#" to work (rather than
// calling it "shift+3" on a US keyboard)
 
#include <FL/Fl.H>
#include <FL/Fl_Widget.H>
#include <FL/Fl_Button.H>
#include <FL/fl_draw.H>
#include <stdlib.h>
#include <ctype.h>
#include "flstring.h"
#if !defined(WIN32) && !defined(__APPLE__)
#include <FL/x.H>
#endif
 
int Fl::test_shortcut(unsigned int shortcut) {
  if (!shortcut) return 0;
 
  unsigned int v = shortcut & FL_KEY_MASK;
  if (((unsigned)fl_tolower(v))!=v) {
    shortcut |= FL_SHIFT;
  }
 
  int shift = Fl::event_state();
  // see if any required shift flags are off:
  if ((shortcut&shift) != (shortcut&0x7fff0000)) return 0;
  // record shift flags that are wrong:
  int mismatch = (shortcut^shift)&0x7fff0000;
  // these three must always be correct:
  if (mismatch&(FL_META|FL_ALT|FL_CTRL)) return 0;
 
  unsigned int key = shortcut & FL_KEY_MASK;
 
  // if shift is also correct, check for exactly equal keysyms:
  if (!(mismatch&(FL_SHIFT)) && key == (unsigned)Fl::event_key()) return 1;
 
  // try matching utf8, ignore shift:
  unsigned int firstChar = fl_utf8decode(Fl::event_text(), Fl::event_text()+Fl::event_length(), 0);
  if ( ! (FL_CAPS_LOCK&shift) && key==firstChar) return 1;
 
  // kludge so that Ctrl+'_' works (as opposed to Ctrl+'^_'):
  if ((shift&FL_CTRL) && key >= 0x3f && key <= 0x5F
      && firstChar==(key^0x40)) return 1; // firstChar should be within a-z
  return 0;
}
 
// This table must be in numeric order by fltk (X) keysym number:
struct Keyname {unsigned int key; const char* name;};
#if defined(WIN32)
static Keyname table[] = {
  {' ', "Space"},
  {FL_BackSpace, "Backspace"},
  {FL_Tab,  "Tab"},
  {0xff0b/*XK_Clear*/, "Clear"},
  {FL_Enter,    "Enter"}, // X says "Enter"
  {FL_Pause,    "Pause"},
  {FL_Scroll_Lock, "Scroll_Lock"},
  {FL_Escape,   "Escape"},
  {FL_Home, "Home"},
  {FL_Left, "Left"},
  {FL_Up,   "Up"},
  {FL_Right,    "Right"},
  {FL_Down, "Down"},
  {FL_Page_Up,  "Page_Up"}, // X says "Prior"
  {FL_Page_Down,"Page_Down"}, // X says "Next"
  {FL_End,  "End"},
  {FL_Print,    "Print"},
  {FL_Insert,   "Insert"},
  {FL_Menu, "Menu"},
  {FL_Num_Lock, "Num_Lock"},
  {FL_KP_Enter, "KP_Enter"},
  {FL_Shift_L,  "Shift_L"},
  {FL_Shift_R,  "Shift_R"},
  {FL_Control_L,"Control_L"},
  {FL_Control_R,"Control_R"},
  {FL_Caps_Lock,"Caps_Lock"},
  {FL_Meta_L,   "Meta_L"},
  {FL_Meta_R,   "Meta_R"},
  {FL_Alt_L,    "Alt_L"},
  {FL_Alt_R,    "Alt_R"},
  {FL_Delete,   "Delete"}
};
#elif defined(__APPLE__) 
static Keyname table[] = {
  //             v - this column may contain UTF-8 characters
  {' ',         "Space"},
  {FL_BackSpace,"\xe2\x8c\xab"}, // erase to the left
  {FL_Tab,  "\xe2\x87\xa5"}, // rightwards arrow to bar
  {0xff0b,      "\xe2\x8c\xa6"}, // erase to the right
  {FL_Enter,    "\xe2\x86\xa9"}, // leftwards arrow with hook
  {FL_Pause,    "Pause"},
  {FL_Scroll_Lock, "Scroll_Lock"},
  {FL_Escape,   "\xe2\x90\x9b"},
  {FL_Home, "\xe2\x86\x96"}, // north west arrow
  {FL_Left, "\xe2\x86\x90"}, // leftwards arrow
  {FL_Up,   "\xe2\x86\x91"}, // upwards arrow
  {FL_Right,    "\xe2\x86\x92"}, // rightwards arrow
  {FL_Down, "\xe2\x86\x93"}, // downwards arrow
  {FL_Page_Up,  "\xe2\x87\x9e"}, // upwards arrow with double stroke
  {FL_Page_Down,"\xe2\x87\x9f"}, // downwards arrow with double stroke
  {FL_End,  "\xe2\x86\x98"}, // south east arrow
  {FL_Print,    "Print"},
  {FL_Insert,   "Insert"},
  {FL_Menu, "Menu"},
  {FL_Num_Lock, "Num_Lock"},
  {FL_KP_Enter, "\xe2\x8c\xa4"}, // up arrow head between two horizontal bars
  {FL_Shift_L,  "Shift_L"},
  {FL_Shift_R,  "Shift_R"},
  {FL_Control_L,"Control_L"},
  {FL_Control_R,"Control_R"},
  {FL_Caps_Lock,"\xe2\x87\xaa"}, // upwards white arrow from bar
  {FL_Meta_L,   "Meta_L"},
  {FL_Meta_R,   "Meta_R"},
  {FL_Alt_L,    "Alt_L"},
  {FL_Alt_R,    "Alt_R"},
  {FL_Delete,   "\xe2\x8c\xa7"}  // x in a rectangle box
};
#endif
 
const char* fl_shortcut_label(unsigned int shortcut) {
  return fl_shortcut_label(shortcut, 0L);
}
 
/*
  This static function adds a modifier key name to a character
  buffer and returns the pointer behind the modifier name and a
  trailing '+' character.
 
  Exceptions:
   (1) Last character = '\' : remove it, done (don't add '+')
   (2) Last character = '+' : user added '+', don't add another one
 
  In case of buffer overflow the modifier key name is replaced with "..."
  if that fits or not added at all. This should rarely (never) happen.
*/
 
static char *add_modifier_key(char *p, const char *end, const char *name) {
  int ln = strlen(name);
  if (p+ln > end) {     // string too long
    if (p+4 <= end) {       // can replace with "..." ?
      strcpy(p,"...");
      p += 3;
    } else
      return p;
  } else {
    strcpy(p,name);
    p += ln;
  }
  if (p[-1] == '\\')        // remove (last) '\' character
    p--;
  else if (p[-1] == '+')    // don't add another '+' character
    {/*empty*/}
  else              // not a '\' or '+'
    *p++ = '+';         // add a '+' character
  return p;
}
 
const char* fl_shortcut_label(unsigned int shortcut, const char **eom) {
  static char buf[80];
  char *p = buf;
  char *end = &buf[sizeof(buf)-20]; // account for key name (max. ~10 + x)
  if (eom) *eom = p;
  if (!shortcut) {*p = 0; return buf;}
  // fix upper case shortcuts
  unsigned int key = shortcut & FL_KEY_MASK;
  if (((unsigned)fl_tolower(key)) != key) {
    shortcut |= FL_SHIFT;
  }
 
  // Add modifier key names.
  // Note: if necessary we could change the order here depending on the platform.
  // However, as discussed in fltk.development, the order appears to be the
  // same on all platforms, with exceptions in _some_ Linux applications.
 
  if (shortcut & FL_CTRL)  {p = add_modifier_key(p, end, fl_local_ctrl);}
  if (shortcut & FL_ALT)   {p = add_modifier_key(p, end, fl_local_alt);}
  if (shortcut & FL_SHIFT) {p = add_modifier_key(p, end, fl_local_shift);}
  if (shortcut & FL_META)  {p = add_modifier_key(p, end, fl_local_meta);}
  if (eom) *eom = p;
 
  // add key name
#if defined(WIN32) || defined(__APPLE__) // if not X
  if (key >= FL_F && key <= FL_F_Last) {
    *p++ = 'F';
    if (key > FL_F+9) *p++ = (key-FL_F)/10+'0';
    *p++ = (key-FL_F)%10 + '0';
  } else {
    // binary search the table for a match:
    int a = 0;
    int b = sizeof(table)/sizeof(*table);
    while (a < b) {
      int c = (a+b)/2;
      if (table[c].key == key) {
        if (p > buf) {
          strcpy(p,table[c].name); 
          return buf;
        } else {
          const char *sp = table[c].name;
          if (eom) *eom = sp;
          return sp;
        }
      }
      if (table[c].key < key) a = c+1;
      else b = c;
    }
    if (key >= FL_KP && key <= FL_KP_Last) {
      // mark keypad keys with KP_ prefix
      strcpy(p,"KP_"); p += 3;
      *p++ = uchar(key & 127);
    } else {
      // if none found, use the keystroke as a match:
      p += fl_utf8encode(fl_toupper(key), p); 
    }
  }
  *p = 0;
  return buf;
#else
  const char* q;
  if (key == FL_Enter || key == '\r') q="Enter";  // don't use Xlib's "Return":
  else if (key > 32 && key < 0x100) q = 0;
  else q = XKeysymToString(key);
  if (!q) {
    p += fl_utf8encode(fl_toupper(key), p); 
    *p = 0; 
    return buf;
  }
  if (p > buf) {
    strcpy(p,q); 
    return buf;
  } else {
    if (eom) *eom = q;
    return q;
  }
#endif
}
 
// Emulation of XForms named shortcuts
unsigned int fl_old_shortcut(const char* s) {
  if (!s || !*s) return 0;
  if (s[1]==0 && strchr("@!",s[0])) return s[0]; // maintain legacy behavior for "!" and "@"
  unsigned int n = 0;
  if (*s == '#') {n |= FL_ALT; s++;}
  if (*s == '+') {n |= FL_SHIFT; s++;}
  if (*s == '^') {n |= FL_CTRL; s++;}
  if (*s == '!') {n |= FL_META; s++;}    // added in 1.3.3
  if (*s == '@') {n |= FL_COMMAND; s++;} // added in 1.3.3
  if (*s && s[1]) return n | (int)strtol(s,0,0); // allow 0xf00 to get any key
  return n | *s;
}
 
// Tests for &x shortcuts in button labels:
 
unsigned int Fl_Widget::label_shortcut(const char *t) {
  if (!t) return 0;
  for (;;) {
    if (*t==0) return 0;
    if (*t=='&') {
      unsigned int s = fl_utf8decode(t+1, 0, 0);
      if (s==0) return 0;
      else if (s==(unsigned int)'&') t++;
      else return s;
    }
    t++;
  }
}
 
int Fl_Widget::test_shortcut(const char *t, const bool require_alt) {
  if (!t) return 0;
  // for menubars etc. shortcuts must work only if the Alt modifier is pressed
  if (require_alt && Fl::event_state(FL_ALT)==0) return 0;
  unsigned int c = fl_utf8decode(Fl::event_text(), Fl::event_text()+Fl::event_length(), 0);
#ifdef __APPLE__
  // this line makes underline shortcuts work the same way they do on MSWindow
  // and Linux. 
  if (c && Fl::event_state(FL_ALT)) 
    c = Fl::event_key();
#endif
  if (!c) return 0;
  unsigned int ls = label_shortcut(t);
  if (c == ls)
    return 1;
#ifdef __APPLE__
  // On OS X, we need to simulate the upper case keystroke as well
  if (Fl::event_state(FL_ALT) && c<128 && isalpha(c) && (unsigned)toupper(c)==ls)
    return 1;
#endif
  return 0;
}
 
int Fl_Widget::test_shortcut() {
  if (!(flags()&SHORTCUT_LABEL)) return 0;
  return test_shortcut(label());
}
 
//
// End of "$Id$".
//