/*

 * AT-SPI - Assistive Technology Service Provider Interface

 * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)

 *

 * Copyright 2020 SUSE LLC.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

#include "atspi-device.h"

#include "atspi-device-a11y-manager.h"

#include "atspi-device-legacy.h"

#include "atspi-device-x11.h"

#include "atspi-private.h"

enum {

  PROP_0,

  PROP_APP_ID,

  NUM_PROPERTIES

};

static GParamSpec *obj_props[NUM_PROPERTIES];

typedef struct

{

  guint id;

  guint keycode;

  guint keysym;

  guint modifiers;

  AtspiKeyCallback callback;

  void *callback_data;

  GDestroyNotify callback_destroyed;

} AtspiKeyGrab;

typedef struct _AtspiDevicePrivate AtspiDevicePrivate;

struct _AtspiDevicePrivate

{

  GSList *key_watchers;

  GSList *keygrabs;

  guint last_grab_id;

  gchar *app_id;

};

GObjectClass *device_parent_class;

static void

{

static void

{

static gboolean

{

}

static void

{

#if !GLIB_CHECK_VERSION(2, 76, 0)

static inline gboolean

g_set_str (char **str_pointer,

           const char *new_str)

{

  char *copy;

  if (*str_pointer == new_str ||

      (*str_pointer && new_str && strcmp (*str_pointer, new_str) == 0))

    return FALSE;

  copy = g_strdup (new_str);

  g_free (*str_pointer);

  *str_pointer = copy;

  return TRUE;

}

#endif

static void

{

    {

    }

static void

{

    {

    }

static void

{

  /**

   * AtspiDevice:app-id:

   *

   * The application ID of the application that created this device.

   * The ID might be used for access control purposes

   * by some device backends.

   */

                         "Application ID",

                         "The application ID of the application that created this device",

                         NULL,

                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);

/**

 * atspi_device_new_full:

 * @app_id: (nullable): The application ID of the application that created this device.

 *

 * Creates a new #AtspiDevice with a specified app id.

 *

 * Returns: (transfer full): a pointer to a newly-created #AtspiDevice.

 *

 * Since: 2.55

 */

AtspiDevice *

{

#ifdef HAVE_X11

#endif

    {

    }

  else

    {

    }

}

/**

 * atspi_device_new:

 *

 * Creates a new #AtspiDevice.

 *

 * Returns: (transfer full): a pointer to a newly-created #AtspiDevice.

 */

AtspiDevice *

{

}

static gboolean

{

  /* The presence or lack thereof of locking modifiers should make no

     difference when testing, but other modifiers should match. If the

     keypress has modifiers that (a) the grab does not check for and (b) are

     not lock modifiers, then we reject the match. Alt + left arrow should not

     match a grab on left arrow, for instance, but whether numlock is on or

     off would be irrelevant. */

  else

}

gboolean

{

  GSList *l;

    {

    }

    {

        {

        }

    }

}

static gboolean

{

  GSList *l;

    {

    }

    {

    }

}

static guint

{

}

/**

 *atspi_device_add_key_grab:

 * @device: the device.

 * @kd: a #AtspiKeyDefinition specifying the key code to grab.

 * @callback: (scope notified) (allow-none): the function to call when the

 *            given key is pressed.

 * @user_data: Data to be passed to @callback.

 * @callback_destroyed: callback function to be called when @callback is

 *                      destroyed.

 *

 * Returns: an identifier that can be later used to remove the grab, or 0

 * if the key/modifier combination could not be grabbed.

 * Add a key grab for the given key/modifier combination.

 */

guint

{

  AtspiKeyGrab *grab;

}

/**

 * atspi_device_remove_key_grab:

 * @device: the device.

 * @id: the identifier of the grab to be removed.

 *

 * Removes the key grab specified by @id.

 */

void

{

  GSList *l;

    {

        {

        }

    }

}

/**

 *atspi_device_add_key_watcher:

 * @device: the device.

 * @callback: (scope notified) (closure user_data) (destroy callback_destroyed): the

 *   function to call when the given key is pressed.

 * @user_data: Data to be passed to @callback.

 * @callback_destroyed: callback function to be called when @callback is destroyed.

 *

 * Add a callback that will receive a notification whenever a key is

 * pressed or released.

 */

void

{

AtspiKeyDefinition *

{

  GSList *l;

    {

        {

        }

    }

}

/**

 * atspi_device_map_modifier:

 * @device: the device.

 * @keycode: the keycode to map.

 *

 * Maps the specified key code to a modifier so that it can be used in

 * conjunction with other keys to create a key grab. If the given keycode is

 * already mapped, then this function will return the modifier that is

 * currently mapped to the keycode, without doing anything else. Otherwise,

 * it will use the last modifier that AT-SPI used to map a key. If no keys

 * have yet been mapped using this device, then it will look for a modifier

 * that is not currently being used. If no unused modifier can be found,

 * then it will use the first modifier by default.

 *

 * Returns: the modifier that is now mapped to this keycode. This return

 * value can be passed to atspi_device_add_key_grab.

 */

guint

{

}

/**

 * atspi_device_unmap_modifier:

 * @device: the device.

 * @keycode: the keycode to unmap.

 *

 * Removes a mapped modifier from the given keycode.

 */

void

{

/**

 * atspi_device_get_modifier:

 * @device: the device.

 * @keycode: the keycode to map.

 *

 * Gets the modifier for a given keycode, if one exists. Does not create a new

 * mapping. This function should be used when the intention is to query a

 * locking modifier such as num lock via atspi_device_get_locked_modifiers,

 * rather than to add key grabs.

 *

 * Returns: the modifier that is mapped to this keycode.

 */

guint

{

}

/**

 * atspi_device_get_locked_modifiers:

 * @device: the device.

 *

 * Returns the locked modifiers (ie, num lock, caps lock) associated with this

 * keyboard.

 *

 * Returns: a guint of modifier flags.

 */

guint

{

}

/**

 * atspi_device_grab_keyboard:

 *

 * Attempts to grab the entire keyboard. This should only be done

 * temporarily, as it may conflict with other applications that also want to

 * grab the keyboard.

 *

 * Returns: #TRUE if successful, #FALSE otherwise.

 */

gboolean

{

}

/**

 * atspi_device_ungrab_keyboard:

 *

 * Removes a keyboard grab added via a call to atspi_device_add_keyboard.

 */

void

{

/**

 * atspi_device_generate_mouse_event:

 * @device: the device.

 * @obj: The #AtspiAccessible that should receive the click.

 * @x: a #gint indicating the x coordinate of the mouse event, relative to

 *     @obj..

 * @y: a #gint indicating the y coordinate of the mouse event, relative to

 *     @obj..

 * @name: a string indicating which mouse event to be synthesized

 *        (e.g. "b1p", "b1c", "b2r", "rel", "abs").

 * @error: (allow-none): a pointer to a %NULL #GError pointer, or %NULL

 *

 * Synthesizes a mouse event at a specific screen coordinate.

 * Most AT clients should use the #AccessibleAction interface when

 * tempted to generate mouse events, rather than this method.

 * Event names: b1p = button 1 press; b2r = button 2 release;

 *              b3c = button 3 click; b2d = button 2 double-click;

 *              abs = absolute motion; rel = relative motion.

 *

 * Since: 2.52

 **/

void

{

/**

 * atspi_device_map_keysym_modifier:

 * @device: the device.

 * @keysym: the XKB keysym to map.

 *

 * Maps the specified keysym to a modifier so that it can be used in

 * conjunction with other keys to create a key grab. If the given keysym is

 * already mapped, then this function will return the modifier that is

 * currently mapped to the keysym, without doing anything else. Otherwise,

 * it will use the last modifier that AT-SPI used to map a keysym. If no keys

 * have yet been mapped using this device, then it will look for a modifier

 * that is not currently being used. If no unused modifier can be found,

 * then it will use the first modifier by default.

 *

 * Returns: the modifier that is now mapped to this keysym. This return

 * value can be passed to atspi_device_add_key_grab.

 *

 * Since: 2.55

 */

guint

{

}

/**

 * atspi_device_unmap_keysym_modifier:

 * @device: the device.

 * @keysym: the XKB keysym to unmap.

 *

 * Removes a mapped modifier from the given keysym.

 *

 * Since: 2.55

 */

void

{

/**

 * atspi_device_get_keysym_modifier:

 * @device: the device.

 * @keysym: the XKB keysym to map.

 *

 * Gets the modifier for a given keysym, if one exists. Does not create a new

 * mapping. This function should be used when the intention is to query a

 * locking modifier such as num lock via atspi_device_get_locked_modifiers,

 * rather than to add key grabs.

 *

 * Returns: the modifier that is mapped to this keysym.

 *

 * Since: 2.55

 */

guint

{

}

/**

 * atspi_device_get_app_id:

 * @device: the device.

 * 

 * Returns the application ID of the device.

 * 

 * Since: 2.55

 */

const gchar *

{

}

/**

 * atspi_device_set_app_id:

 * @device: the device.

 * @app_id: the application ID.

 * 

 * Sets the application ID of the device.

 * 

 * Since: 2.55

 */

void

{