/*

 * AT-SPI - Assistive Technology Service Provider Interface

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

 *

 * Copyright 2001, 2002 Sun Microsystems Inc.,

 * Copyright 2001, 2002 Ximian, Inc.

 *

 * 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.

 */

/* atspi_registry.c: Global functions wrapping the registry */

#include "atspi-private.h"

/**

 * AtspiRegistry:

 *

 * A service through which applications providing accessibility services

 * can rendezvous with consumers of those services.

 *

 * A service through which applications providing accessibility services (servers)

 * can rendezvous with consumers of those services (Assistive Technologies). The

 * atspi-registry is the first "port of call" for accessible applications and for

 * assistive technologies wishing to query and interact with those applications.

 */

typedef struct

{

  AtspiDeviceListener *listener;

  GArray *key_set;

  AtspiKeyMaskType modmask;

  AtspiKeyEventMask event_types;

  gint sync_type;

} DeviceListenerEntry;

typedef struct

{

  AtspiGenerateMouseEventCB callback;

  void *callback_data;

} AtspiGenerateMouseEventClosure;

static GList *device_listeners;

/**

 * atspi_get_desktop_count:

 *

 * Gets the number of virtual desktops.

 * NOTE: multiple virtual desktops are not implemented yet; as a

 * consequence, this function always returns 1.

 *

 * Returns: a #gint indicating the number of active virtual desktops.

 **/

gint

{

}

/**

 * atspi_get_desktop:

 * @i: a #gint indicating which of the accessible desktops is to be returned.

 *

 * Gets the virtual desktop indicated by index @i.

 * NOTE: currently multiple virtual desktops are not implemented;

 * as a consequence, any @i value different from 0 will not return a

 * virtual desktop - instead it will return NULL.

 *

 * Returns: (transfer full): a pointer to the @i-th virtual desktop's

 * #AtspiAccessible representation.

 **/

AtspiAccessible *

{

}

/**

 * atspi_get_desktop_list:

 *

 * Gets the list of virtual desktops.  On return, @list will point

 *     to a newly-created, NULL terminated array of virtual desktop

 *     pointers.

 *     It is the responsibility of the caller to free this array when

 *     it is no longer needed.

 * NOTE: currently multiple virtual desktops are not implemented;

 * this implementation always returns a #Garray with a single

 * #AtspiAccessible desktop.

 *

 * Returns: (element-type AtspiAccessible*) (transfer full): a #GArray of

 * desktops.

 **/

GArray *

{

  AtspiAccessible *desktop;

}

static gboolean

{

  AtspiEventListenerMode listener_mode;

                     atspi_path_dec, atspi_interface_dec,

                     "RegisterKeystrokeListener",

                     "oa(iisi)uu(bbb)=>b", path, e->key_set,

                     d_modmask, d_event_types, &listener_mode,

                     &retval);

}

static void

{

static void

{

  GList *l;

    {

        {

        }

      else

    }

/**

 * atspi_register_keystroke_listener:

 * @listener:  a pointer to the #AtspiDeviceListener for which

 *             keystroke events are requested.

 * @key_set: (element-type AtspiKeyDefinition) (allow-none): a pointer to the

 *        #AtspiKeyDefinition array indicating which keystroke events are

 *        requested, or NULL

 *        to indicate that all keycodes and keyvals for the specified

 *        modifier set are to be included.

 * @modmask:   an #AtspiKeyMaskType mask indicating which

 *             key event modifiers must be set in combination with @keys,

 *             events will only be reported for key events for which all

 *             modifiers in @modmask are set.  If you wish to listen for

 *             events with multiple modifier combinations, you must call

 *             #atspi_register_keystroke_listener once for each

 *             combination.

 * @event_types: an #AtspiKeyMaskType mask indicating which

 *             types of key events are requested (%ATSPI_KEY_PRESSED etc.).

 * @sync_type: an #AtspiKeyListenerSyncType parameter indicating

 *             the behavior of the notification/listener transaction.

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

 *

 * Registers a listener for keystroke events, either pre-emptively for

 *             all windows (%ATSPI_KEYLISTENER_ALL_WINDOWS),

 *             non-preemptively (%ATSPI_KEYLISTENER_NOSYNC), or

 *             pre-emptively at the toolkit level (%ATSPI_KEYLISTENER_CANCONSUME).

 *             If ALL_WINDOWS or CANCONSUME are used, the event is consumed

 *             upon receipt if one of @listener's callbacks returns %TRUE

 *             (other sync_type values may be available in the future).

 *

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

 **/

gboolean

                                   GArray *key_set,

                                   AtspiKeyMaskType modmask,

                                   AtspiKeyEventMask event_types,

                                   AtspiKeyListenerSyncType sync_type,

                                   GError **error)

{

  DeviceListenerEntry *e;

    {

      gint i;

                                      key_set->len);

        {

            {

            }

          else

            {

            }

        }

    }

  else

    {

    }

}

/**

 * atspi_deregister_keystroke_listener:

 * @listener: a pointer to the #AtspiDeviceListener for which

 *            keystroke events are requested.

 * @key_set: (element-type AtspiKeyDefinition) (allow-none): a pointer to the

 *        #AtspiKeyDefinition array indicating which keystroke events are

 *        requested, or %NULL

 *        to indicate that all keycodes and keyvals for the specified

 *        modifier set are to be included.

 * @modmask:  the key modifier mask for which this listener is to be

 *            'deregistered' (of type #AtspiKeyMaskType).

 * @event_types: an #AtspiKeyMaskType mask indicating which

 *             types of key events were requested (%ATSPI_KEY_PRESSED, etc.).

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

 *

 * Removes a keystroke event listener from the registry's listener queue,

 *            ceasing notification of events with modifiers matching @modmask.

 *

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

 **/

gboolean

                                     GArray *key_set,

                                     AtspiKeyMaskType modmask,

                                     AtspiKeyEventMask event_types,

                                     GError **error)

{

  GArray *d_key_set;

  gchar *path;

  gint i;

  GList *l;

    {

    }

  /* copy the keyval filter values from the C api into the DBind KeySet */

    {

        {

            {

            }

          else

            {

            }

        }

    }

  else

    {

    }

                     atspi_path_dec, atspi_interface_dec,

                     "DeregisterKeystrokeListener",

                     "oa(iisi)uu", path, d_key_set, d_modmask,

                     d_event_types);

    {

      /* TODO: This code is all wrong / doesn't match what is in

       *       deviceeventcontroller.c. It would be nice to deprecate these methods

       *       in favor of methods that return an ID for the registration that can

       *       be passed to a deregister function, for instance. */

        }

      else

    }

}

/**

 * atspi_register_device_event_listener:

 *

 * This function does nothing and should not be called.

 *

 * Returns: Always returns %FALSE.

 **/

gboolean

                                      AtspiDeviceEventMask event_types,

                                      void *filter,

                                      GError **error)

{

  /* See https://gitlab.gnome.org/GNOME/at-spi2-core/-/issues/94 for why this code is removed */

}

/**

 * atspi_deregister_device_event_listener:

 * @listener: a pointer to the #AtspiDeviceListener for which

 *            device events are requested.

 * @filter: (allow-none): Unused parameter.

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

 *

 * Removes a device event listener from the registry's listener queue,

 *            ceasing notification of events of the specified type.

 *

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

 **/

gboolean

                                        void *filter,

                                        GError **error)

{

  /* See https://gitlab.gnome.org/GNOME/at-spi2-core/-/issues/94 for why this code is removed */

}

/**

 * atspi_generate_keyboard_event:

 * @keyval: a #gint indicating the keycode or keysym or modifier mask of the

 *           key event being synthesized.

 * @keystring: (allow-none): an (optional) UTF-8 string which, if

 *           @synth_type is %ATSPI_KEY_STRING, indicates a 'composed'

 *           keyboard input string being synthesized; this type of

 *           keyboard event synthesis does not emulate hardware

 *           keypresses but injects the string as though a composing

 *           input method (such as XIM) were used.

 * @synth_type: an #AtspiKeySynthType flag indicating whether @keyval

 *           is to be interpreted as a keysym rather than a keycode

 *           (%ATSPI_KEY_SYM) or a string (%ATSPI_KEY_STRING) or a modifier

 *           mask (%ATSPI_KEY_LOCKMODIFIERS and %ATSPI_KEY_UNLOCKMODIFIERS), or

 *           whether to synthesize %ATSPI_KEY_PRESS,

 *           %ATSPI_KEY_RELEASE, or both (%ATSPI_KEY_PRESSRELEASE).

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

 *

 * Synthesizes a keyboard event (as if a hardware keyboard event occurred in the

 * current UI context).

 *

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

 **/

gboolean

                               const gchar *keystring,

                               AtspiKeySynthType synth_type,

                               GError **error)

{

  DBusError d_error;

    {

    }

}

/**

 * atspi_generate_mouse_event:

 * @x: a #glong indicating the screen x coordinate of the mouse event.

 * @y: a #glong indicating the screen y coordinate of the mouse event.

 * @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.

 *

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

 **/

gboolean

{

  DBusError d_error;

                               atspi_path_dec, atspi_interface_dec,

                               "GenerateMouseEvent", &d_error, "iis",

                               d_x, d_y, name);

    {

    }

}

static void

{

/**

 * atspi_generate_mouse_event_async:

 * @x: a #glong indicating the screen x coordinate of the mouse event.

 * @y: a #glong indicating the screen y coordinate of the mouse event.

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

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

 * @callback: (scope notified) (allow-none): a callback to be called when a

 * reply is received. May be NULL.

 * @callback_data: (closure) (allow-none): data to be passed to @callback.

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

 *

 * Like atspi_generate_mouse_event, but asynchronous.

 **/

void

{

  DBusMessage *message;

                                          atspi_path_dec, atspi_interface_dec,

                                          "GenerateMouseEvent");

    {

    }

    {

    }

}

/**

 * atspi_set_reference_window:

 * @accessible: the #AtspiAccessible corresponding to the window to select.

 *              should be a top-level window with a role of

 *              ATSPI_ROLE_APPLICATION.

 *

 * Deprecated. This function no longer does anything and should not be used.

 */

void

{

AtspiKeyDefinition *

{

  AtspiKeyDefinition *dst;

}

void

{

void

{

  GList *l;

  DeviceListenerEntry *e;

    {

    }