gdk/gdk.key-values.lisp

   1 (in-package :gdk)
   2
   3 (defcfun (keymap-get-default "gdk_keymap_get_default") (g-object keymap))
   4
   5 (export 'keymap-get-default)
   6
   7 (defcfun (keymap-get-for-display "gdk_keymap_get_for_display") (g-object keymap)
   8   (display (g-object display)))
   9
  10 (export 'keymap-get-for-display)
  11
  12 (defcfun (keymap-lookup-key "gdk_keymap_lookup_key") :uint
  13   (keymap (g-object keymap))
  14   (key (g-boxed-foreign keymap-key)))
  15
  16 (export 'keymap-lookup-key)
  17
  18 (defcfun gdk_keymap_translate_keyboard_state :boolean
  19   (keymap (g-object keymap))
  20   (hardware-keycode :uint)
  21   (state modifier-type)
  22   (group :int)
  23   (keyval (:pointer :uint))
  24   (effective-group (:pointer :int))
  25   (level (:pointer :int))
  26   (consumed-modifiers (:pointer modifier-type)))
  27
  28 (defun keymap-translate-keyboard-state (keymap hardware-keycode state group)
  29   (with-foreign-objects ((keyval :uint) (effective-group :int) (level :int) (modifiers 'modifier-type))
  30     (if (gdk_keymap_translate_keyboard_state keymap hardware-keycode state group keyval effective-group level modifiers)
  31         (values (mem-ref keyval :uint)
  32                 (mem-ref effective-group :int)
  33                 (mem-ref level :int)
  34                 (mem-ref modifiers 'modifier-type)))))
  35
  36 (export 'keymap-translate-keyboard-state)
  37
  38 (defcfun gdk_keymap_get_entries_for_keyval :boolean
  39   (keymap (g-object keymap))
  40   (keyval :uint)
  41   (keys (:pointer (:pointer keymap-key-cstruct)))
  42   (n-keys (:pointer :int)))
  43
  44 (defun keymap-get-entries-for-keyval (keymap keyval)
  45   (with-foreign-objects ((keys :pointer) (n-keys :int))
  46     (when (gdk_keymap_get_entries_for_keyval keymap keyval keys n-keys)
  47       (let ((keys (mem-ref keys :pointer))
  48             (n-keys (mem-ref n-keys :int)))
  49         (prog1
  50             (iter (for i from 0 below n-keys)
  51                   (for keymap-key = (convert-from-foreign (inc-pointer keys (* i (foreign-type-size 'keymap-key-cstruct)))
  52                                                           '(g-boxed-foreign keymap-key)))
  53                   (collect keymap-key))
  54           (glib:g-free keys))))))
  55
  56 (export 'keymap-get-entries-for-keyval)
  57
  58 (defcfun gdk_keymap_get_entries_for_keycode :boolean
  59   (keymap (g-object keymap))
  60   (hardware-keycode :uint)
  61   (keys (:pointer (:pointer keymap-key-cstruct)))
  62   (keyvals (:pointer (:pointer :uint)))
  63   (n-entries (:pointer :int)))
  64
  65 (defun keymap-get-entries-for-keymap (keymap hardware-keycode)
  66   (with-foreign-objects ((keys :pointer) (keyvals :pointer) (n-keys :int))
  67     (when (gdk_keymap_get_entries_for_keycode keymap hardware-keycode keys keyvals n-keys)
  68       (let ((keys (mem-ref keys :pointer))
  69             (keyvals (mem-ref keyvals :pointer))
  70             (n-keys (mem-ref n-keys :int)))
  71         (prog1
  72             (iter (for i from 0 below n-keys)
  73                   (for keyval = (mem-aref keyvals :uint))
  74                   (for keymap-key = (convert-from-foreign (inc-pointer keys (* i (foreign-type-size 'keymap-key-cstruct)))
  75                                                           '(g-boxed-foreign keymap-key)))
  76                   (collect keymap-key into r-keys)
  77                   (collect keyval into r-keyvals)
  78                   (finally (return (values r-keys r-keyvals))))
  79           (glib:g-free keys)
  80           (glib:g-free keyvals))))))
  81
  82 (export 'keymap-get-entries-for-keymap)
  83
  84 (defcfun (keyval-name "gdk_keyval_name") (:string :free-from-foreign nil)
  85   (keyval :uint))
  86
  87 (export 'keyval-name)
  88
  89 (defcfun (keyval-from-name "gdk_keyval_from_name") :uint
  90   (keyval-name :string))
  91
  92 (export 'keyval-from-name)
  93
  94 (defcfun (keyval-to-upper "gdk_keyval_to_upper") :uint
  95   (keyval :uint))
  96
  97 (export 'keyval-to-upper)
  98
  99 (defcfun (keyval-to-lower "gdk_keyval_to_lower") :uint
 100   (keyval :uint))
 101
 102 (export 'keyval-to-lower)
 103
 104 (defcfun (keyval-is-upper "gdk_keyval_is_upper") :boolean
 105   (keyval :uint))
 106
 107 (export 'keyval-is-upper)
 108
 109 (defcfun (keyval-is-lower "gdk_keyval_is_lower") :boolean
 110   (keyval :uint))
 111
 112 ;; ignored:
 113 ;; void                gdk_keyval_convert_case             (guint symbol,
 114 ;;                                                          guint *lower,
 115 ;;                                                          guint *upper);
 116
 117 (define-foreign-type unichar ()
 118   ()
 119   (:actual-type :uint32)
 120   (:simple-parser unichar))
 121
 122 (defmethod translate-from-foreign (value (type unichar))
 123   (code-char value))
 124
 125 (defmethod translate-to-foreign (value (type unichar))
 126   (char-code value))
 127
 128 (defcfun (keyval-to-char "gdk_keyval_to_unicode") unichar
 129   (keyval :uint))
 130
 131 (export 'keyval-to-char)
 132
 133 (defcfun (char-to-keyval "gdk_unicode_to_keyval") :uint
 134   (char unichar))
 135
 136 (export 'char-to-keyval)