src/lib/elput/Elput.h

   1 #ifndef _ELPUT_H
   2 # define _ELPUT_H
   3
   4 # ifdef EFL_BETA_API_SUPPORT
   5 #  include <Eina.h>
   6
   7 #  ifdef EAPI
   8 #   undef EAPI
   9 #  endif
  10
  11 #  ifdef __GNUC__
  12 #   if __GNUC__ >= 4
  13 #    define EAPI __attribute__ ((visibility("default")))
  14 #   else
  15 #    define EAPI
  16 #   endif
  17 #  else
  18 #   define EAPI
  19 #  endif
  20
  21 typedef enum
  22 {
  23    ELPUT_DEVICE_CAPS_POINTER = (1 << 0),
  24    ELPUT_DEVICE_CAPS_KEYBOARD = (1 << 1),
  25    ELPUT_DEVICE_CAPS_TOUCH = (1 << 2),
  26    ELPUT_DEVICE_CAPS_TABLET_TOOL = (1 << 3),
  27    ELPUT_DEVICE_CAPS_TABLET_PAD = (1 << 4),
  28    ELPUT_DEVICE_CAPS_GESTURE = (1 << 5),
  29    ELPUT_DEVICE_CAPS_SWITCH = (1 << 6),
  30 } Elput_Device_Caps;
  31
  32 /* opaque structure to represent an input manager */
  33 typedef struct _Elput_Manager Elput_Manager;
  34
  35 /* opaque structure to represent an input seat */
  36 typedef struct _Elput_Seat Elput_Seat;
  37
  38 /* opaque structure to represent an input device */
  39 typedef struct _Elput_Device Elput_Device;
  40
  41 /* opaque structure to represent a keyboard */
  42 typedef struct _Elput_Keyboard Elput_Keyboard;
  43
  44 /* opaque structure to represent a mouse */
  45 typedef struct _Elput_Pointer Elput_Pointer;
  46
  47 /* opaque structure to represent a touch device */
  48 typedef struct _Elput_Touch Elput_Touch;
  49
  50 /* structure to represent event for seat capability changes */
  51 typedef struct _Elput_Event_Seat_Caps
  52 {
  53    int pointer_count;
  54    int keyboard_count;
  55    int touch_count;
  56    Elput_Seat *seat;
  57 } Elput_Event_Seat_Caps;
  58
  59 /* structure to represent event for seat frame */
  60 typedef struct _Elput_Event_Seat_Frame
  61 {
  62    Elput_Seat *seat;
  63 } Elput_Event_Seat_Frame;
  64
  65 /* structure to represent event for seat modifiers changes */
  66 typedef struct _Elput_Event_Modifiers_Send
  67 {
  68    unsigned int depressed;
  69    unsigned int latched;
  70    unsigned int locked;
  71    unsigned int group;
  72 } Elput_Event_Modifiers_Send;
  73
  74 typedef enum _Elput_Device_Change_Type
  75 {
  76    ELPUT_DEVICE_ADDED,
  77    ELPUT_DEVICE_REMOVED,
  78 } Elput_Device_Change_Type;
  79
  80 /* structure to represent event for device being added or removed */
  81 typedef struct _Elput_Event_Device_Change
  82 {
  83    Elput_Device *device;
  84    Elput_Device_Change_Type type;
  85 } Elput_Event_Device_Change;
  86
  87 /* structure to represent session active changes */
  88 typedef struct _Elput_Event_Session_Active
  89 {
  90    const char *session;
  91    Eina_Bool active : 1;
  92 } Elput_Event_Session_Active;
  93
  94 /** @since 1.19 */
  95 typedef struct Elput_Event_Pointer_Motion
  96 {
  97    uint64_t time_usec;
  98    double dx;
  99    double dy;
 100    double dx_unaccel;
 101    double dy_unaccel;
 102 } Elput_Event_Pointer_Motion;
 103
 104 /** @since 1.21 */
 105 typedef enum
 106 {
 107    ELPUT_SWITCH_TYPE_LID = 1,
 108    ELPUT_SWITCH_TYPE_TABLET_MODE,
 109 } Elput_Switch_Type;
 110
 111 /** @since 1.21 */
 112 typedef enum
 113 {
 114    ELPUT_SWITCH_STATE_OFF = 0,
 115    ELPUT_SWITCH_STATE_ON = 1,
 116 } Elput_Switch_State;
 117
 118 /** @since 1.21 */
 119 typedef struct _Elput_Event_Switch
 120 {
 121    Elput_Device *device;
 122    uint64_t time_usec;
 123    Elput_Switch_Type type;
 124    Elput_Switch_State state;
 125 } Elput_Event_Switch;
 126
 127
 128 EAPI extern int ELPUT_EVENT_SEAT_CAPS;
 129 EAPI extern int ELPUT_EVENT_SEAT_FRAME;
 130 EAPI extern int ELPUT_EVENT_MODIFIERS_SEND;
 131 EAPI extern int ELPUT_EVENT_DEVICE_CHANGE;
 132 EAPI extern int ELPUT_EVENT_SESSION_ACTIVE;
 133
 134 /** @since 1.19 */
 135 EAPI extern int ELPUT_EVENT_POINTER_MOTION;
 136
 137 /** @since 1.21 */
 138 EAPI extern int ELPUT_EVENT_SWITCH;
 139
 140 /**
 141  * @file
 142  * @brief Ecore functions for dealing with libinput
 143  *
 144  * @defgroup Elput_Group Elput - libinput integration
 145  * @ingroup Ecore
 146  *
 147  * Elput provides a wrapper and functions for using libinput
 148  *
 149  * @li @ref Elput_Init_Group
 150  * @li @ref Elput_Manager_Group
 151  * @li @ref Elput_Input_Group
 152  * @li @ref Elput_Touch_Group
 153  *
 154  */
 155
 156 /**
 157  * @defgroup Elput_Init_Group Library Init and Shutdown functions
 158  *
 159  * Functions that start and shutdown the Elput library
 160  */
 161
 162 /**
 163  * Initialize the Elput library
 164  *
 165  * @return The number of times the library has been initialized without being
 166  *         shutdown. 0 is returned if an error occurs.
 167  *
 168  * @ingroup Elput_Init_Group
 169  * @since 1.18
 170  */
 171 EAPI int elput_init(void);
 172
 173 /**
 174  * Shutdown the Elput library
 175  *
 176  * @return The number of times the library has been initialized without being
 177  *         shutdown. 0 is returned if an error occurs.
 178  *
 179  * @ingroup Elput_Init_Group
 180  * @since 1.18
 181  */
 182 EAPI int elput_shutdown(void);
 183
 184 /**
 185  * @defgroup Elput_Manager_Group Elput Manager
 186  *
 187  * Functions that deal with connecting, disconnecting, opening, closing
 188  * of input devices.
 189  */
 190
 191 /**
 192  * Create an input manager on the specified seat
 193  *
 194  * @param seat
 195  * @param tty
 196  *
 197  * @return A Elput_Manager on success, NULL on failure
 198  *
 199  * @ingroup Elput_Manager_Group
 200  * @since 1.18
 201  */
 202 EAPI Elput_Manager *elput_manager_connect(const char *seat, unsigned int tty);
 203
 204 /**
 205  * Disconnect an input manager
 206  *
 207  * @param manager
 208  *
 209  * @ingroup Elput_Manager_Group
 210  * @since 1.18
 211  */
 212 EAPI void elput_manager_disconnect(Elput_Manager *manager);
 213
 214 /**
 215  * Request input manager to open a file
 216  *
 217  * @param manager
 218  * @param path
 219  * @param flags
 220  *
 221  * @return Filedescriptor of opened file or -1 on failure
 222  *
 223  * @ingroup Elput_Manager_Group
 224  * @since 1.18
 225  */
 226 EAPI int elput_manager_open(Elput_Manager *manager, const char *path, int flags);
 227
 228 /**
 229  * Request input manager to close a file
 230  *
 231  * @param manager
 232  * @param fd
 233  *
 234  * @ingroup Elput_Manager_Group
 235  * @since 1.18
 236  */
 237 EAPI void elput_manager_close(Elput_Manager *manager, int fd);
 238
 239 /**
 240  * Request to switch to a given vt
 241  *
 242  * @param manager
 243  * @param vt
 244  *
 245  * @return EINA_TRUE on success, EINA_FALSE otherwise
 246  *
 247  * @ingroup Elput_Manager_Group
 248  * @since 1.18
 249  */
 250 EAPI Eina_Bool elput_manager_vt_set(Elput_Manager *manager, int vt);
 251
 252 /**
 253  * Get the list of seats from a manager
 254  *
 255  * @param manager
 256  *
 257  * @return An Eina_List of existing Elput_Seats or NULL on failure
 258  *
 259  * @ingroup Elput_Manager_Group
 260  * @since 1.18
 261  */
 262 EAPI const Eina_List *elput_manager_seats_get(Elput_Manager *manager);
 263
 264
 265 /**
 266  * Set which window to use for this input manager
 267  *
 268  * This function should be used to specify which window to set on the
 269  * input manager. Setting a window on the input manager is done so that
 270  * when we raise events (mouse movement, keyboard key, etc) then this
 271  * window is passed to the event structure as the window which the event
 272  * occurred on.
 273  *
 274  * @param manager
 275  * @param window
 276  *
 277  * @ingroup Elput_Manager_Group
 278  * @since 1.18
 279  */
 280 EAPI void elput_manager_window_set(Elput_Manager *manager, unsigned int window);
 281
 282 /**
 283  * @defgroup Elput_Input_Group Elput input functions
 284  *
 285  * Functions that deal with setup of inputs
 286  */
 287
 288 /**
 289  * Initialize input
 290  *
 291  * @param manager
 292  *
 293  * @return EINA_TRUE on success, EINA_FALSE on failure
 294  *
 295  * @ingroup Elput_Input_Group
 296  * @since 1.18
 297  */
 298 EAPI Eina_Bool elput_input_init(Elput_Manager *manager);
 299
 300 /**
 301  * Shutdown input
 302  *
 303  * @param manager
 304  *
 305  * @ingroup Elput_Input_Group
 306  * @since 1.18
 307  */
 308 EAPI void elput_input_shutdown(Elput_Manager *manager);
 309
 310 /**
 311  * Get the pointer position on a given seat
 312  *
 313  * @param manager
 314  * @param seat
 315  * @param x
 316  * @param y
 317  *
 318  * @ingroup Elput_Input_Group
 319  * @since 1.18
 320  */
 321 EAPI void elput_input_pointer_xy_get(Elput_Manager *manager, const char *seat, int *x, int *y);
 322
 323 /**
 324  * Set the pointer position on a given seat
 325  *
 326  * @param manager
 327  * @param seat
 328  * @param x
 329  * @param y
 330  *
 331  * @ingroup Elput_Input_Group
 332  * @since 1.18
 333  */
 334 EAPI void elput_input_pointer_xy_set(Elput_Manager *manager, const char *seat, int x, int y);
 335
 336 /**
 337  * Set the pointer left-handed mode
 338  *
 339  * @param manager
 340  * @param seat
 341  * @param left
 342  *
 343  * @return EINA_TRUE on success, EINA_FALSE otherwise
 344  *
 345  * @ingroup Elput_Input_Group
 346  * @since 1.18
 347  */
 348 EAPI Eina_Bool elput_input_pointer_left_handed_set(Elput_Manager *manager, const char *seat, Eina_Bool left);
 349
 350 /**
 351  * Set the maximum position of any existing mouse pointers
 352  *
 353  * @param manager
 354  * @param maxw
 355  * @param maxh
 356  *
 357  * @ingroup Elput_Input_Group
 358  * @since 1.18
 359  */
 360 EAPI void elput_input_pointer_max_set(Elput_Manager *manager, int maxw, int maxh);
 361
 362 /**
 363  * Set pointer value rotation
 364  *
 365  * @param manager
 366  * @param rotation
 367  *
 368  * @return EINA_TRUE on success, EINA_FALSE otherwise
 369  *
 370  * @ingroup Elput_Input_Group
 371  * @since 1.20
 372  */
 373 EAPI Eina_Bool elput_input_pointer_rotation_set(Elput_Manager *manager, int rotation);
 374
 375 /**
 376  * Set tap-to-click status
 377  *
 378  * @param manager
 379  * @param seat
 380  * @param enabled
 381  *
 382  * @return EINA_TRUE on success, EINA_FALSE otherwise
 383  *
 384  * @ingroup Elput_Input_Group
 385  * @since 1.22
 386  */
 387 EAPI void elput_input_touch_tap_to_click_enabled_set(Elput_Manager *manager, const char *seat, Eina_Bool enabled);
 388
 389 /**
 390  * Calibrate input devices for given screen size
 391  *
 392  * @param manager
 393  * @param w
 394  * @param h
 395  *
 396  * @ingroup Elput_Input_Group
 397  * @since 1.18
 398  */
 399 EAPI void elput_input_devices_calibrate(Elput_Manager *manager, int w, int h);
 400
 401 /**
 402  * Enable key remap functionality
 403  *
 404  * @param manager
 405  * @param enable
 406  *
 407  * @return EINA_TRUE on success, EINA_FALSE otherwise
 408  *
 409  * @ingroup Elput_Input_Group
 410  * @since 1.18
 411  */
 412 EAPI Eina_Bool elput_input_key_remap_enable(Elput_Manager *manager, Eina_Bool enable);
 413
 414 /**
 415  * Set a given set of keys as remapped keys
 416  *
 417  * @param manager
 418  * @param from_keys
 419  * @param to_keys
 420  * @param num
 421  *
 422  * @return EINA_TRUE on success, EINA_FALSE otherwise
 423  *
 424  * @ingroup Elput_Input_Group
 425  * @since 1.18
 426  */
 427 EAPI Eina_Bool elput_input_key_remap_set(Elput_Manager *manager, int *from_keys, int *to_keys, int num);
 428
 429 /**
 430  * Set info to be used for keyboards
 431  *
 432  * @param manager
 433  * @param context
 434  * @param keymap
 435  * @param group
 436  *
 437  * @ingroup Elput_Input_Group
 438  * @since 1.20
 439  */
 440 EAPI void elput_input_keyboard_info_set(Elput_Manager *manager, void *context, void *keymap, int group);
 441
 442 /**
 443  * Set group layout to be used for keyboards
 444  *
 445  * @param manager
 446  * @param group
 447  *
 448  * @ingroup Elput_Input_Group
 449  * @since 1.20
 450  */
 451 EAPI void elput_input_keyboard_group_set(Elput_Manager *manager, int group);
 452
 453 /**
 454  * Set the pointer acceleration profile
 455  *
 456  * @param manager
 457  * @param seat
 458  * @param profile
 459  *
 460  * @ingroup Elput_Input_Group
 461  * @since 1.19
 462  */
 463 EAPI void elput_input_pointer_accel_profile_set(Elput_Manager *manager, const char *seat, uint32_t profile);
 464
 465 /**
 466  * Set the pointer acceleration speed
 467  *
 468  * @param manager
 469  * @param seat
 470  * @param speed
 471  *
 472  * @ingroup Elput_Input_Group
 473  * @since 1.21
 474  */
 475 EAPI void elput_input_pointer_accel_speed_set(Elput_Manager *manager, const char *seat, double speed);
 476
 477 /**
 478  * @defgroup Elput_Touch_Group Configuration of touch devices
 479  *
 480  * Functions related to configuration of touch devices
 481  */
 482
 483 /**
 484  * Enable or disable tap-and-drag on this device.
 485  *
 486  * When enabled, a single-finger tap immediately followed by a finger
 487  * down results in a button down event, subsequent finger motion thus
 488  * triggers a drag. The button is released on finger up.
 489  *
 490  * @param device
 491  * @param enabled
 492  *
 493  * @return EINA_TRUE on success, EINA_FALSE otherwise
 494  *
 495  * @ingroup Elput_Touch_Group
 496  * @since 1.19
 497  */
 498 EAPI Eina_Bool elput_touch_drag_enabled_set(Elput_Device *device, Eina_Bool enabled);
 499
 500 /**
 501  * Get if tap-and-drag is enabled on this device.
 502  *
 503  * @param device
 504  *
 505  * @return EINA_TRUE if enabled, EINA_FALSE otherwise
 506  *
 507  * @ingroup Elput_Touch_Group
 508  * @since 1.19
 509  */
 510 EAPI Eina_Bool elput_touch_drag_enabled_get(Elput_Device *device);
 511
 512 /**
 513  * Enable or disable drag-lock during tapping on a device.
 514  *
 515  * When enabled, a finger may be lifted and put back on the touchpad
 516  * within a timeout and the drag process continues. When disabled,
 517  * lifting the finger during a tap-and-drag will immediately stop the
 518  * drag.
 519  *
 520  * @param device
 521  * @param enabled
 522  *
 523  * @return EINA_TRUE on success, EINA_FALSE otherwise
 524  *
 525  * @ingroup Elput_Touch_Group
 526  * @since 1.19
 527  */
 528 EAPI Eina_Bool elput_touch_drag_lock_enabled_set(Elput_Device *device, Eina_Bool enabled);
 529
 530 /**
 531  * Get if drag-lock is enabled on this device.
 532  *
 533  * @param device
 534  *
 535  * @return EINA_TRUE if enabled, EINA_FALSE otherwise
 536  *
 537  * @ingroup Elput_Touch_Group
 538  * @since 1.19
 539  */
 540 EAPI Eina_Bool elput_touch_drag_lock_enabled_get(Elput_Device *device);
 541
 542 /**
 543  * Enable or disable touchpad dwt (disable-while-typing) feature.
 544  *
 545  * When enabled, the device will be disabled while typing and for a
 546  * short period after.
 547  *
 548  * @param device
 549  * @param enabled
 550  *
 551  * @return EINA_TRUE on success, EINA_FALSE otherwise
 552  *
 553  * @ingroup Elput_Touch_Group
 554  * @since 1.19
 555  */
 556 EAPI Eina_Bool elput_touch_dwt_enabled_set(Elput_Device *device, Eina_Bool enabled);
 557
 558 /**
 559  * Get if touchpad dwt (disable-while-typing) is enabled.
 560  *
 561  * @param device
 562  *
 563  * @return EINA_TRUE if enabled, EINA_FALSE otherwise
 564  *
 565  * @ingroup Elput_Touch_Group
 566  * @since 1.19
 567  */
 568 EAPI Eina_Bool elput_touch_dwt_enabled_get(Elput_Device *device);
 569
 570 /**
 571  * Set the scroll method used for this device.
 572  *
 573  * The scroll method defines when to generate scroll axis events instead
 574  * of pointer motion events.
 575  *
 576  * @param device
 577  * @param method
 578  *
 579  * @return EINA_TRUE on success, EINA_FALSE otherwise
 580  *
 581  * @ingroup Elput_Touch_Group
 582  * @since 1.19
 583  */
 584 EAPI Eina_Bool elput_touch_scroll_method_set(Elput_Device *device, int method);
 585
 586 /**
 587  * Get the current scroll method set on a device
 588  *
 589  * @param device
 590  *
 591  * @return The current scroll method
 592  *
 593  * @ingroup Elput_Touch_Group
 594  * @since 1.19
 595  */
 596 EAPI int elput_touch_scroll_method_get(Elput_Device *device);
 597
 598 /**
 599  * Set the button click method for a device.
 600  *
 601  * The button click method defines when to generate software emulated
 602  * buttons
 603  *
 604  * @param device
 605  * @param method
 606  *
 607  * @return EINA_TRUE on success, EINA_FALSE otherwise
 608  *
 609  * @ingroup Elput_Touch_Group
 610  * @since 1.19
 611  */
 612 EAPI Eina_Bool elput_touch_click_method_set(Elput_Device *device, int method);
 613
 614 /**
 615  * Get the current button click method for a device
 616  *
 617  * @param device
 618  *
 619  * @return The current button click method
 620  *
 621  * @ingroup Elput_Touch_Group
 622  * @since 1.19
 623  */
 624 EAPI int elput_touch_click_method_get(Elput_Device *device);
 625
 626 /**
 627  * Enable or disable tap-to-click on a given device
 628  *
 629  * @param device
 630  * @param enabled
 631  *
 632  * @return EINA_TRUE on success, EINA_FALSE otherwise
 633  *
 634  * @ingroup Elput_Touch_Group
 635  * @since 1.19
 636  */
 637 EAPI Eina_Bool elput_touch_tap_enabled_set(Elput_Device *device, Eina_Bool enabled);
 638
 639 /**
 640  * Get if tap-to-click is enabled on a given device
 641  *
 642  * @param device
 643  *
 644  * @return EINA_TRUE if enabled, EINA_FALSE otherwise
 645  *
 646  * @ingroup Elput_Touch_Group
 647  * @since 1.19
 648  */
 649 EAPI Eina_Bool elput_touch_tap_enabled_get(Elput_Device *device);
 650
 651
 652 /**
 653  * @defgroup Elput_Device_Group Elput device functions
 654  *
 655  * Functions for getting attributes of devices
 656  */
 657
 658 /**
 659  * Get the seat object for a device
 660  * @param dev
 661  * @return The seat
 662  * @ingroup Elput_Device_Group
 663  * @since 1.20
 664  */
 665 EAPI Elput_Seat *elput_device_seat_get(const Elput_Device *dev);
 666
 667 /**
 668  * Get the caps for a device
 669  * @param dev
 670  * @return The caps, 0 on failure
 671  * @ingroup Elput_Device_Group
 672  * @since 1.20
 673  */
 674 EAPI Elput_Device_Caps elput_device_caps_get(const Elput_Device *dev);
 675
 676 /**
 677  * Return the output name associated with a given device
 678  *
 679  * @param device
 680  *
 681  * @return An Eina_Stringshare of the output name for this device, or NULL on error
 682  *
 683  * @ingroup Elput_Device_Group
 684  * @since 1.20
 685  */
 686 EAPI Eina_Stringshare *elput_device_output_name_get(Elput_Device *device);
 687
 688 /**
 689  * @defgroup Elput_Seat_Group Elput seat functions
 690  *
 691  * Functions for getting attributes of seats
 692  */
 693
 694 /**
 695  * Get the list of devices on a given seat
 696  *
 697  * @param seat
 698  *
 699  * @return An immutable list of existing Elput_Devices on a given seat or NULL on failure
 700  *
 701  * @ingroup Elput_Seat_Group
 702  * @since 1.20
 703  */
 704 EAPI const Eina_List *elput_seat_devices_get(const Elput_Seat *seat);
 705
 706 /**
 707  * Get the name of a given seat
 708  *
 709  * @param seat
 710  *
 711  * @return The name
 712  *
 713  * @ingroup Elput_Seat_Group
 714  * @since 1.20
 715  */
 716 EAPI Eina_Stringshare *elput_seat_name_get(const Elput_Seat *seat);
 717
 718 /**
 719  * Get the manager of a given seat
 720  *
 721  * @param seat
 722  *
 723  * @return The Elput_Manager
 724  *
 725  * @ingroup Elput_Seat_Group
 726  * @since 1.20
 727  */
 728 EAPI Elput_Manager *elput_seat_manager_get(const Elput_Seat *seat);
 729 # endif
 730
 731 # undef EAPI
 732 # define EAPI
 733
 734 #endif