aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/programs/Xserver/Xext
diff options
context:
space:
mode:
authorMike Gabriel <mike.gabriel@das-netzwerkteam.de>2019-05-11 09:41:15 +0200
committerMike Gabriel <mike.gabriel@das-netzwerkteam.de>2019-05-11 09:41:15 +0200
commit22649369085dfaa351003ba76b7838160089f7cc (patch)
tree1c83284c7be0c038601cfc41ad53ce9351b2e70a /nx-X11/programs/Xserver/Xext
parentf6177d2adb9540134bf7e760fd7df4599e98a713 (diff)
parentfac36b24f55b02040bd6950d8de0385fdbb33703 (diff)
downloadnx-libs-22649369085dfaa351003ba76b7838160089f7cc.tar.gz
nx-libs-22649369085dfaa351003ba76b7838160089f7cc.tar.bz2
nx-libs-22649369085dfaa351003ba76b7838160089f7cc.zip
Merge branch 'uli42-pr/small_fixes' into 3.6.x
Attributes GH PR #797: https://github.com/ArcticaProject/nx-libs/pull/797
Diffstat (limited to 'nx-X11/programs/Xserver/Xext')
-rw-r--r--nx-X11/programs/Xserver/Xext/Imakefile6
-rw-r--r--nx-X11/programs/Xserver/Xext/xtest1dd.c1612
-rw-r--r--nx-X11/programs/Xserver/Xext/xtest1dd.h126
-rw-r--r--nx-X11/programs/Xserver/Xext/xtest1di.c915
4 files changed, 3 insertions, 2656 deletions
diff --git a/nx-X11/programs/Xserver/Xext/Imakefile b/nx-X11/programs/Xserver/Xext/Imakefile
index becc7b66e..8262f667d 100644
--- a/nx-X11/programs/Xserver/Xext/Imakefile
+++ b/nx-X11/programs/Xserver/Xext/Imakefile
@@ -73,21 +73,21 @@ XF86BIGFOBJS = xf86bigfont.o
#endif
SRCS = shape.c $(SHMSRCS) xcmisc.c\
- xtest.c xtest1di.c xtest1dd.c sleepuntil.c \
+ xtest.c sleepuntil.c \
bigreq.c sync.c $(SCRNSAVSRC) \
$(XF86BIGFSRCS) $(SECURITYSRCS) \
$(PNRXSRCS) $(DPMSSRCS) \
$(XVSRCS) $(XRESSRCS) $(DMXSRCS)
OBJS = shape.o $(SHMOBJS) xcmisc.o \
- xtest.o xtest1di.o xtest1dd.o sleepuntil.o \
+ xtest.o sleepuntil.o \
bigreq.o sync.o $(SCRNSAVOBJ) \
$(XF86BIGFOBJS) $(SECURITYOBJS) \
$(PNRXOBJS) $(DPMSOBJS) \
$(XVOBJS) $(XRESOBJS) $(DMXOBJS)
SOBJS = $(SHMOBJS) $(SECURITYOBJS) \
- shape.o xtest.o xtest1di.o xtest1dd.o sleepuntil.o $(PNRXOBJS) \
+ shape.o xtest.o sleepuntil.o $(PNRXOBJS) \
$(XF86BIGFOBJS)
#if defined(NXAgentServer) && NXAgentServer
diff --git a/nx-X11/programs/Xserver/Xext/xtest1dd.c b/nx-X11/programs/Xserver/Xext/xtest1dd.c
deleted file mode 100644
index e3a7aa07e..000000000
--- a/nx-X11/programs/Xserver/Xext/xtest1dd.c
+++ /dev/null
@@ -1,1612 +0,0 @@
-/*
- * File: xtest1dd.c
- *
- * This file contains the device dependent parts of the input
- * synthesis extension.
- */
-
-/*
-
-
-Copyright 1986, 1987, 1988, 1998 The Open Group
-
-Permission to use, copy, modify, distribute, and sell this software and its
-documentation for any purpose is hereby granted without fee, provided that
-the above copyright notice appear in all copies and that both that
-copyright notice and this permission notice appear in supporting
-documentation.
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-Except as contained in this notice, the name of The Open Group shall not be
-used in advertising or otherwise to promote the sale, use or other dealings
-in this Software without prior written authorization from The Open Group.
-
-
-Copyright 1986, 1987, 1988 by Hewlett-Packard Corporation
-
-Permission to use, copy, modify, and distribute this
-software and its documentation for any purpose and without
-fee is hereby granted, provided that the above copyright
-notice appear in all copies and that both that copyright
-notice and this permission notice appear in supporting
-documentation, and that the name of Hewlett-Packard not be used in
-advertising or publicity pertaining to distribution of the
-software without specific, written prior permission.
-
-Hewlett-Packard makes no representations about the
-suitability of this software for any purpose. It is provided
-"as is" without express or implied warranty.
-
-This software is not subject to any license of the American
-Telephone and Telegraph Company or of the Regents of the
-University of California.
-
-*/
-
-/***************************************************************
- * include files
- ***************************************************************/
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include <stdio.h>
-#include <nx-X11/Xos.h>
-#include <nx-X11/X.h>
-#include <nx-X11/Xmd.h>
-#include <nx-X11/Xproto.h>
-#include "misc.h"
-#include "dixstruct.h"
-#define XTestSERVER_SIDE
-#include <nx-X11/extensions/xtestext1.h>
-
-#include "xtest1dd.h"
-
-/***************************************************************
- * defines
- ***************************************************************/
-
-/*
- * the size of the fake input action array
- */
-#define ACTION_ARRAY_SIZE 100
-
-/***************************************************************
- * externals
- ***************************************************************/
-
-/*
- * Holds the xTestInputAction event type code.
- * This is defined in xtestext1di.c.
- */
-extern int XTestInputActionType;
-/*
- * Holds the xTestFakeAck event type code.
- * This is defined in xtestext1di.c.
- */
-extern int XTestFakeAckType;
-/*
- * used in the WriteReplyToClient macro
- */
-extern int exclusive_steal;
-
-/***************************************************************
- * variables
- ***************************************************************/
-
-/*
- * array to hold fake input actions
- */
-struct {
- /*
- * holds the action type, one of: XTestDELAY_ACTION,
- * XTestKEY_ACTION, XTestMOTION_ACTION, XTestJUMP_ACTION
- */
- CARD8 type;
- /*
- * holds the device type, in the range 0 to 15
- */
- CARD8 device;
- /*
- * for XTestKEY_ACTION type, holds the keycode
- */
- CARD8 keycode;
- /*
- * for XTestKEY_ACTION type, holds the key up/down state
- */
- CARD8 keystate;
- /*
- * for XTestMOTION_ACTION and XTestJUMP_ACTION types,
- * holds the x and y coordinates to move the mouse to
- */
- int x;
- int y;
- /*
- * holds the time to delay (in milliseconds) before performing
- * the action
- */
- CARD32 delay_time;
-}action_array[ACTION_ARRAY_SIZE];
-
-/*
- * write index for input action array
- */
-static int write_index = 0;
-/*
- * read index for input action array
- */
-static int read_index = 0;
-/*
- * this is where the input actions are accumulated until they are sent
- * to a client (in a wire event)
- */
-static xTestInputActionEvent input_action_packet;
-/*
- * holds the index (in bytes) into the input actions buffer in the
- * current input action event
- */
-static int packet_index;
-/*
- * logical x position of the mouse during input action gathering
- */
-short xtest_mousex;
-/*
- * logical y position of the mouse during input action gathering
- */
-short xtest_mousey;
-/*
- * logical x position of the mouse while we are reading fake input actions
- * from the client and putting them into the fake input action array
- */
-static short pmousex;
-/*
- * logical y position of the mouse while we are reading fake input actions
- * from the client and putting them into the fake input action array
- */
-static short pmousey;
-/*
- * The playback_on flag is set to 1 while there are input actions in the
- * input action array. It is set to 0 when the server has received all of
- * the user actions.
- */
-int playback_on = 0;
-/*
- * identity of the client using XTestGetInput to get user input actions
- */
-ClientPtr current_xtest_client;
-/*
- * if 1 send multiple input actions per XTestInputAction event;
- * if 0 send one input action per XTestInputAction event
- */
-static char packed_mode;
-/*
- * identity of the client using the XTestFakeInput function to send some
- * fake input actions to the server
- */
-ClientPtr playback_client = NULL;
-/*
- * Set to 1 when the XTestFAKE_ACK_REQUEST flag is set in a XTestFakeInput
- * request. Set back to 0 when all of the input actions have been sent
- * to the server.
- */
-static int acknowledge = 0;
-/*
- * The server's idea of the current time is saved in these variables when
- * a XTestFakeInput request is received. It is restored when all fake input
- * actions are sent to the server or when the playback client disconnects.
- */
-static int saved_sec;
-static int saved_usec;
-/*
- * Set to 1 when there is a valid time in saved_sec and saved_usec.
- */
-static int time_saved = 0;
-/*
- * holds the extension's notion of what the current time is while it is
- * sending input actions to a client
- */
-static struct timeval current_time;
-/*
- * holds the time when the extension should place the next fake input action
- * into the server's normal events queue
- */
-static struct timeval play_time;
-/*
- * set to 1 when play_time is first set, cleared to 0 when the
- * client using the extension disconnects, or when XTestReset is called
- */
-static char play_clock = 0;
-/*
- * holds the amount of time left until the next input action from the
- * input action array can be sent to the server
- */
-static struct timeval rtime;
-/*
- * Set to 1 after the extension is done waiting for the correct time delay
- * for an input action to be sent to the server. Remains a 1 until the time
- * delay for the next input action is computed. Then set to 0 if the
- * extension has to wait for the correct time delay.
- */
-static int go_for_next = 1;
-/*
- * needed to restore waitime if playback is to be aborted
- */
-static struct timeval *restorewait;
-/*
- * tmon special command key
- *
- * To use the test monitor program (called tmon) efficiently, it is
- * desirable to have the extension be able to recognize a special "trigger"
- * key. If the extension did not do this, tmon would have to have the
- * extension send all keyboard user input actions exclusively to tmon,
- * only to have tmon send them right back if they were not the command key.
- *
- * If the extension can recognize the command key, then tmon can let the
- * extension handle keyboard user input actions normally until the command
- * key is pressed (and released), and only then have the extension start
- * sending keyboard user input actions exclusively to tmon.
- *
- * Any key on the keyboard can be used for this command key. It is most
- * convenient if it is a low-frequency key. If you want to generate a
- * normal occurrance of this key to a client, just hit it twice. Tmon
- * will recognize the first occurrance of the key, take control of the input
- * actions, and wait for certain keys. If it sees another occurrance of the
- * command key, it will send one occurrance of the command key to the
- * extension, and go back to waiting.
- *
- * set and also referenced in device layer
- * XXX there should be a way to set this through the protocol
- */
-KeyCode xtest_command_key = 0;
-
-/***************************************************************
- * function declarations
- ***************************************************************/
-
-static void parse_key_fake(
- XTestKeyInfo * /* fkey */
- );
-static void parse_motion_fake(
- XTestMotionInfo * /* fmotion */
- );
-static void parse_jump_fake(
- XTestJumpInfo * /* fjump */
- );
-static void parse_delay_fake(
- XTestDelayInfo * /* tevent */
- );
-static void send_ack(
- ClientPtr /* client */
- );
-static void start_play_clock(
- void
- );
-static void compute_action_time(
- struct timeval * /* rtime */
- );
-static int find_residual_time(
- struct timeval * /* rtime */
- );
-
-static CARD16 check_time_event(
- void
- );
-static CARD32 current_ms(
- struct timeval * /* otime */
- );
-static int there_is_room(
- int /* actsize */
- );
-
-/******************************************************************************
- *
- * stop_stealing_input
- *
- * Stop stealing input actions.
- */
-void
-stop_stealing_input()
-{
-/*
- * put any code that you might need to stop stealing input actions here
- */
- if (packet_index != 0)
- {
- /*
- * if there is a partially full input action event waiting
- * when this function is called, send it to the client
- */
- flush_input_actions();
- }
-}
-
-/******************************************************************************
- *
- * steal_input
- *
- * Start stealing input actions and sending them to the passed-in client.
- */
-void
-steal_input(client, mode)
-/*
- * which client is to receive the input action events
- */
-ClientPtr client;
-/*
- * what input action packing mode to use. one of 0, XTestPACKED_MOTION,
- * or XTestPACKED_ACTIONS; optionally 'or'ed with XTestEXCLUSIVE,
- */
-CARD32 mode;
-{
- if (packet_index != 0)
- {
- /*
- * if there is a partially full input action event waiting
- * when this function is called, send it to the client
- */
- flush_input_actions();
- }
- else
- {
- /*
- * otherwise, set up a new input action event
- */
- input_action_packet.type = XTestInputActionType;
- packet_index = 0;
- }
- /*
- * set up the new input action packing mode
- */
- packed_mode = mode & ~(XTestEXCLUSIVE);
- /*
- * keep track of where the mouse is
- */
- XTestGetPointerPos(&xtest_mousex, &xtest_mousey);
- /*
- * keep track of which client is getting input actions
- */
- current_xtest_client = client;
- /*
- * find out what time it is
- */
- X_GETTIMEOFDAY(&current_time);
- /*
- * jump to the initial position of the mouse, using a device type of 0.
- */
- XTestStealJumpData(xtest_mousex, xtest_mousey, 0);
-}
-
-/******************************************************************************
- *
- * flush_input_actions
- *
- * Write the input actions event to the current requesting client
- * and re-initialize the input action event.
- */
-void
-flush_input_actions()
-{
- /*
- * pointer to the input action event
- */
- char *rep;
- /*
- * loop index
- */
- int i;
-
- if (packet_index == 0)
- {
- /*
- * empty input actions event
- */
- return;
- }
- else if (packet_index < XTestACTIONS_SIZE)
- {
- /*
- * fill to the end of the input actions event with 0's
- */
- for (i = packet_index; i <XTestACTIONS_SIZE; i++)
- {
- input_action_packet.actions[i] = 0;
- }
- }
- rep = (char *) (&input_action_packet);
-
- /*
- * set the serial number of the input action event
- */
- input_action_packet.sequenceNumber = current_xtest_client->sequence;
- /*
- * send the input action event to the client
- */
- WriteEventsToClient(current_xtest_client, 1, (xEvent *) rep);
- /*
- * re-initialize the input action event
- */
- input_action_packet.type = XTestInputActionType;
- packet_index = 0;
-}
-
-/******************************************************************************
- *
- * XTestStealJumpData
- *
- * Create one or more input actions and put them in the input action
- * event. The input actions will be an (maybe) XTestDELAY_ACTION
- * and an XTestJUMP_ACTION.
- */
-void
-XTestStealJumpData(jx, jy, dev_type)
-/*
- * the x and y coordinates to jump to
- */
-int jx;
-int jy;
-/*
- * which device caused the jump
- */
-int dev_type;
-{
- XTestJumpInfo *jmp_ptr;
- /*
- * time delta (in ms) from previous event
- */
- CARD16 tchar;
-
- /*
- * Get the time delta from the previous event. If needed,
- * the check_time_event routine will put an XTestDELAY_ACTION
- * type action in the input action event.
- */
- tchar = check_time_event();
- if (!there_is_room(sizeof(XTestJumpInfo)))
- {
- /*
- * If there isn't room in the input action event for
- * an XTestJUMP_ACTION, then send that event to the
- * client and start filling an empty one.
- */
- flush_input_actions();
- }
- /*
- * update the logical mouse position
- */
- xtest_mousex = jx;
- xtest_mousey = jy;
- /*
- * point jmp_ptr to the correct place in the input action event
- */
- jmp_ptr = (XTestJumpInfo *)
- &(input_action_packet.actions[packet_index]);
- /*
- * compute the input action header
- */
- jmp_ptr->header = (XTestPackDeviceID(dev_type) | XTestJUMP_ACTION);
- /*
- * set the x and y coordinates to jump to in the input action
- */
- jmp_ptr->jumpx = jx;
- jmp_ptr->jumpy = jy;
- /*
- * set the delay time in the input action
- */
- jmp_ptr->delay_time = tchar;
- /*
- * increment the packet index by the size of the input action
- */
- packet_index = packet_index + sizeof(XTestJumpInfo);
- if (packed_mode == 0)
- {
- /*
- * if input actions are not packed, send the input
- * action event to the client
- */
- flush_input_actions();
- }
-}
-
-/******************************************************************************
- *
- * current_ms
- *
- * Returns the number of milliseconds from the passed-in time to the
- * current time, and then updates the passed-in time to the current time.
- */
-static CARD32
-current_ms(otime)
-struct timeval *otime;
-{
- struct timeval tval;
- unsigned long the_ms;
- unsigned long sec;
- unsigned long usec;
-
- /*
- * get the current time
- */
- X_GETTIMEOFDAY(&tval);
- if (tval.tv_usec < otime->tv_usec)
- {
- /*
- * borrow a second's worth of microseconds if needed
- */
- usec = tval.tv_usec - otime->tv_usec + 1000000;
- sec = tval.tv_sec - 1 - otime->tv_sec;
- }
- else
- {
- usec = tval.tv_usec - otime->tv_usec;
- sec = tval.tv_sec - otime->tv_sec;
- }
- /*
- * update the passed-in time to the new time
- */
- *otime = tval;
- /*
- * compute the number of milliseconds contained in
- * 'sec' seconds and 'usec' microseconds
- */
- the_ms = (sec * 1000000L + usec) / 1000L;
- return (the_ms);
-}
-
-/******************************************************************************
- *
- * check_time_event
- *
- * If time delta is > XTestSHORT_DELAY_TIME then insert a time event
- * and return 0; else return the delay time.
- */
-static CARD16
-check_time_event()
-{
- CARD32 tstamp;
- CARD16 tchar;
- XTestDelayInfo *tptr;
-
- /*
- * get the number of milliseconds between input actions
- */
- tstamp = current_ms(&current_time);
- /*
- * if the number of milliseconds is too large to fit in a CARD16,
- * then add a XTestDELAY_ACTION to the input action event.
- */
- if (tstamp > XTestSHORT_DELAY_TIME)
- {
- /*
- * If there isn't room in the input action event for
- * an XTestDELAY_ACTION, then send that event to the
- * client and start filling an empty one.
- */
- if (!there_is_room(sizeof(XTestDelayInfo)))
- {
- flush_input_actions();
- }
- /*
- * point tptr to the correct place in the input action event
- */
- tptr = (XTestDelayInfo *)
- (&(input_action_packet.actions[packet_index]));
- /*
- * compute the input action header
- */
- tptr->header = XTestPackDeviceID(XTestDELAY_DEVICE_ID) |
- XTestDELAY_ACTION;
- /*
- * set the delay time in the input action
- */
- tptr->delay_time = tstamp;
- /*
- * increment the packet index by the size of the input action
- */
- packet_index = packet_index + (sizeof(XTestDelayInfo));
- if (packed_mode != XTestPACKED_ACTIONS)
- {
- /*
- * if input actions are not packed, send the input
- * action event to the client
- */
- flush_input_actions();
- }
- /*
- * set the returned delay time to 0
- */
- tchar = 0;
- }
- else
- {
- /*
- * set the returned delay time to the computed delay time
- */
- tchar = tstamp;
- }
- return(tchar);
-}
-
-/******************************************************************************
- *
- * there_is_room
- *
- * Checks if there is room in the input_action_packet for an input action
- * of the size actsize bytes. Returns 1 if there is space, 0 otherwise.
- *
- */
-static int
-there_is_room(actsize)
-/*
- * the number of bytes of space needed
- */
-int actsize;
-{
- if ((packet_index + actsize) > XTestACTIONS_SIZE)
- {
- return(0);
- }
- else
- {
- return(1);
- }
-}
-
-/******************************************************************************
- *
- * XTestStealMotionData
- *
- * Put motion information from the locator into an input action.
- *
- * called from x_hil.c
- */
-void
-XTestStealMotionData(dx, dy, dev_type, mx, my)
-/*
- * the x and y delta motion of the locator
- */
-int dx;
-int dy;
-/*
- * which locator did the moving
- */
-int dev_type;
-/*
- * the x and y position of the locator before the delta motion
- */
-int mx;
-int my;
-{
- /*
- * pointer to a XTestMOTION_ACTION input action
- */
- XTestMotionInfo *fm;
- /*
- * time delta from previous event
- */
- CARD16 tchar;
-
- /*
- * if the current position of the locator is not the same as
- * the logical position, then update the logical position
- */
- if ((mx != xtest_mousex) || (my != xtest_mousey))
- {
- XTestStealJumpData(mx, my, dev_type);
- }
- /*
- * if the delta motion is outside the range that can
- * be held in a motion input action, use a jump input action
- */
- if ((dx > XTestMOTION_MAX) || (dx < XTestMOTION_MIN) ||
- (dy > XTestMOTION_MAX) || (dy < XTestMOTION_MIN))
- {
- XTestStealJumpData((xtest_mousex + dx),
- (xtest_mousey + dy), dev_type);
- }
- else
- {
- /*
- * compute the new logical position of the mouse
- */
- xtest_mousex += dx;
- xtest_mousey += dy;
- /*
- * Get the time delta from the previous event. If needed,
- * the check_time_event routine will put an XTestDELAY_ACTION
- * type action in the input action event.
- */
- tchar = check_time_event();
- /*
- * If there isn't room in the input action event for
- * an XTestDELAY_ACTION, then send that event to the
- * client and start filling an empty one.
- */
- if (!there_is_room(sizeof(XTestMotionInfo)))
- {
- flush_input_actions();
- /*
- * point fm to the correct place in the input action event
- */
- }
- fm = (XTestMotionInfo *)
- &(input_action_packet.actions[packet_index]);
- /*
- * compute the input action header
- */
- fm->header = XTestMOTION_ACTION;
- if (dx < 0)
- {
- fm->header |= XTestX_NEGATIVE;
- dx = abs(dx);
- }
- if (dy < 0)
- {
- fm->header |= XTestY_NEGATIVE;
- dy = abs(dy);
- }
- fm->header |= XTestPackDeviceID(dev_type);
- /*
- * compute the motion data byte
- */
- fm->motion_data = XTestPackYMotionValue(dy);
- fm->motion_data |= XTestPackXMotionValue(dx);
- /*
- * set the delay time in the input action
- */
- fm->delay_time = tchar;
- /*
- * increment the packet index by the size of the input action
- */
- packet_index = packet_index + sizeof(XTestMotionInfo);
- if (packed_mode == 0)
- {
- /*
- * if input actions are not packed, send the input
- * action event to the client
- */
- flush_input_actions();
- }
-
- }
-}
-
-/******************************************************************************
- *
- * XTestStealKeyData
- *
- * Place this key data in the input_action_packet.
- *
- */
-Bool
-XTestStealKeyData(keycode, keystate, dev_type, locx, locy)
-/*
- * which key/button moved
- */
-unsigned keycode;
-/*
- * whether the key/button was pressed or released
- */
-int keystate;
-/*
- * which device caused the input action
- */
-int dev_type;
-/*
- * the x and y coordinates of the locator when the action happenned
- */
-int locx;
-int locy;
-{
- /*
- * pointer to key/button motion input action
- */
- XTestKeyInfo *kp;
- /*
- * time delta from previous event
- */
- CARD16 tchar;
- char keytrans = 0;
-
- /*
- * update the logical position of the locator if the physical position
- * of the locator is not the same as the logical position.
- */
- if ((locx != xtest_mousex) || (locy != xtest_mousey))
- {
- XTestStealJumpData(locx, locy, dev_type);
- }
- /*
- * Get the time delta from the previous event. If needed,
- * the check_time_event routine will put an XTestDELAY_ACTION
- * type action in the input action event.
- */
- tchar = check_time_event();
- if (!there_is_room(sizeof(XTestKeyInfo)))
- {
- /*
- * If there isn't room in the input action event for
- * an XTestDELAY_ACTION, then send that event to the
- * client and start filling an empty one.
- */
- flush_input_actions();
- }
- /*
- * point kp to the correct place in the input action event
- */
- kp = (XTestKeyInfo *)
- (&(input_action_packet.actions[packet_index]));
- /*
- * compute the input action header
- */
- kp->header = XTestPackDeviceID(dev_type);
- if ((keystate == KeyRelease) || (keystate == ButtonRelease))
- {
- keytrans = XTestKEY_UP;
- }
- else if ((keystate == KeyPress) || (keystate == ButtonPress))
- {
- keytrans = XTestKEY_DOWN;
- }
- else
- {
- printf("%s: invalid key/button state %d.\n",
- XTestEXTENSION_NAME,
- keystate);
- }
- kp->header = kp->header | keytrans | XTestKEY_ACTION;
- /*
- * set the keycode in the input action
- */
- kp->keycode = keycode;
- /*
- * set the delay time in the input action
- */
- kp->delay_time = tchar;
- /*
- * increment the packet index by the size of the input action
- */
- packet_index = packet_index + sizeof(XTestKeyInfo);
- /*
- * if the command key has been released or input actions are not
- * packed, send the input action event to the client
- */
- if(((keycode == xtest_command_key) && (keystate == KeyRelease)) ||
- (packed_mode != XTestPACKED_ACTIONS))
- {
- flush_input_actions();
- }
- /* return TRUE if the event should be passed on to DIX */
- if (exclusive_steal)
- return ((keystate == KeyRelease) &&
- (keycode == xtest_command_key));
- else
- return ((keystate != KeyRelease) ||
- (keycode != xtest_command_key));
-}
-
-/******************************************************************************
- *
- * parse_fake_input
- *
- * Parsing routine for a XTestFakeInput request. It will take a request
- * and parse its contents into the input action array. Eventually the
- * XTestProcessInputAction routine will be called to take input actions
- * from the input action array and send them to the server to be handled.
- */
-void
-parse_fake_input(client, req)
-/*
- * which client did the XTestFakeInput request
- */
-ClientPtr client;
-/*
- * a pointer to the xTestFakeInputReq structure sent by the client
- */
-char *req;
-{
- /*
- * if set to 1, done processing input actions from the request
- */
- int done = 0;
- /*
- * type of input action
- */
- CARD8 action_type;
- /*
- * device type
- */
- CARD8 dev_type;
- /*
- * pointer to an xTestFakeInputReq structure
- */
- xTestFakeInputReq *request;
- /*
- * holds the index into the action list in the request
- */
- int parse_index;
-
- /*
- * get a correct-type pointer to the client-supplied request data
- */
- request = (xTestFakeInputReq *) req;
- /*
- * save the acknowledge requested state for use in
- * XTestProcessInputAction
- */
- acknowledge = request->ack;
- /*
- * set up an index into the action list in the request
- */
- parse_index = 0;
- if (write_index >= ACTION_ARRAY_SIZE)
- {
- /*
- * if the input action array is full, don't add any more
- */
- done = 1;
- }
- while (!done)
- {
- /*
- * get the type of input action in the list
- */
- action_type = (request->action_list[parse_index])
- & XTestACTION_TYPE_MASK;
- /*
- * get the type of device in the list
- */
- dev_type = XTestUnpackDeviceID(request->action_list[parse_index]);
- /*
- * process the input action appropriately
- */
- switch (action_type)
- {
- case XTestKEY_ACTION:
- parse_key_fake((XTestKeyInfo *)
- &(request->action_list[parse_index]));
- parse_index = parse_index + sizeof(XTestKeyInfo);
- break;
- case XTestMOTION_ACTION:
- parse_motion_fake((XTestMotionInfo *)
- &(request->action_list[parse_index]));
- parse_index = parse_index + sizeof(XTestMotionInfo);
- break;
- case XTestJUMP_ACTION:
- parse_jump_fake((XTestJumpInfo *)
- &(request->action_list[parse_index]));
- parse_index = parse_index + sizeof(XTestJumpInfo);
- break;
- case XTestDELAY_ACTION:
- if (dev_type == XTestDELAY_DEVICE_ID)
- {
- parse_delay_fake((XTestDelayInfo *)
- &(request->action_list[parse_index]));
- parse_index = parse_index +
- sizeof(XTestDelayInfo);
- }
- else
- {
- /*
- * An invalid input action header byte has
- * been detected, so there are no more
- * input actions in this request.
- * The intended invalid action header byte
- * for this case should have a value of 0.
- */
- done = 1;
- }
- break;
- }
- if (parse_index >= XTestMAX_ACTION_LIST_SIZE)
- {
- /*
- * entire XTestFakeInput request has been processed
- */
- done = 1;
- }
- if (write_index >= ACTION_ARRAY_SIZE)
- {
- /*
- * no room in the input actions array
- */
- done = 1;
- }
- }
- if (write_index > read_index)
- {
- /*
- * there are fake input actions in the input action array
- * to be given to the server
- */
- playback_on = 1;
- playback_client = client;
- }
-}
-
-/******************************************************************************
- *
- * parse_key_fake
- *
- * Called from parse_fake_input.
- *
- * Copy the fake key input action from its packed form into the array of
- * pending input events.
- */
-static void
-parse_key_fake(fkey)
-XTestKeyInfo *fkey;
-{
- action_array[write_index].type = XTestKEY_ACTION;
- action_array[write_index].device = XTestUnpackDeviceID(fkey->header);
- action_array[write_index].keycode = fkey->keycode;
- action_array[write_index].keystate = fkey->header & XTestKEY_STATE_MASK;
- action_array[write_index].delay_time = fkey->delay_time;
- write_index++;
-}
-
-/******************************************************************************
- *
- * parse_motion_fake
- *
- * Called from parse_fake_input.
- *
- * Copy the fake motion input action from its packed form into the array of
- * pending input events.
- */
-static void
-parse_motion_fake(fmotion)
-XTestMotionInfo *fmotion;
-{
- int dx;
- int dy;
-
- dx = (XTestUnpackXMotionValue(fmotion->motion_data));
- dy = (XTestUnpackYMotionValue(fmotion->motion_data));
- if (((fmotion->header) & XTestX_SIGN_BIT_MASK) == XTestX_NEGATIVE)
- {
- pmousex -= dx;
- }
- else
- {
- pmousex += dx;
- }
- if (((fmotion->header) & XTestY_SIGN_BIT_MASK) == XTestY_NEGATIVE)
- {
- pmousey -= dy;
- }
- else
- {
- pmousey += dy;
- }
- action_array[write_index].type = XTestJUMP_ACTION;
- action_array[write_index].device = XTestUnpackDeviceID(fmotion->header);
- action_array[write_index].x = pmousex;
- action_array[write_index].y = pmousey;
- action_array[write_index].delay_time = fmotion->delay_time;
- write_index++;
-}
-
-/******************************************************************************
- *
- * parse_jump_fake
- *
- * Called from parse_fake_input.
- *
- * Copy the fake jump input action from its packed form into the array of
- * pending input events.
- */
-static void
-parse_jump_fake(fjump)
-XTestJumpInfo *fjump;
-{
- pmousex = fjump->jumpx;
- pmousey = fjump->jumpy;
- action_array[write_index].type = XTestJUMP_ACTION;
- action_array[write_index].device = XTestUnpackDeviceID(fjump->header);
- action_array[write_index].x = pmousex;
- action_array[write_index].y = pmousey;
- action_array[write_index].delay_time = fjump->delay_time;
- write_index++;
-}
-
-/******************************************************************************
- *
- * parse_delay_fake
- *
- * Called from parse_fake_input.
- *
- * Copy the fake delay input action from its packed form into the array of
- * pending input events.
- */
-static void
-parse_delay_fake(tevent)
-XTestDelayInfo *tevent;
-{
- action_array[write_index].type = XTestDELAY_ACTION;
- action_array[write_index].delay_time = tevent->delay_time;
- write_index++;
-}
-
-/******************************************************************************
- *
- * XTestComputeWaitTime
- *
- * Compute the amount of time the server should wait before sending the
- * next monitor event in playback mode.
- */
-void
-XTestComputeWaitTime(waittime)
-struct timeval *waittime;
-{
- /*
- * The playback_on flag is set to 1 in parse_fake_input. It is set to
- * 0 in XTestProcessInputAction if the server has replayed all input
- * actions.
- */
- if (playback_on)
- {
- if (!play_clock)
- {
- /*
- * if the playback clock has never been set,
- * then do it now
- */
- start_play_clock();
- }
- /*
- * We need to save the waittime the first time through. This
- * is a value the server uses, and we have to restore it when
- * all of the input actions are processed by the server.
- */
- if (!time_saved)
- {
- saved_sec = waittime->tv_sec;
- saved_usec = waittime->tv_usec;
- time_saved = 1;
- }
- if (go_for_next)
- {
- /*
- * if we just processed an input action, figure out
- * how long to wait for the next input action
- */
- compute_action_time(&rtime);
- }
- else
- {
- /*
- * else just find out how much more time to wait
- * on the current input action
- */
- (void)find_residual_time(&rtime);
- }
- waittime->tv_sec = rtime.tv_sec;
- waittime->tv_usec = rtime.tv_usec;
- }
-}
-
-/******************************************************************************
- *
- * XTestProcessInputAction
- *
- * If there are any input actions in the input action array,
- * then take one out and process it.
- *
- */
-int
-XTestProcessInputAction(readable, waittime)
-/*
- * This is the value that a 'select' function returned just before this
- * routine was called. If the select timed out, this value will be 0.
- *
- * This extension modifies the select call's timeout value to cause the
- * select to time out when the next input action is ready to given to
- * the server. This routine is called immediately after the select, to
- * give it a chance to process an input action. If we have an input action
- * to process and the only reason that the select returned was because it
- * timed out, then we change the select value to 1 and return 1 instead of 0.
- */
-int readable;
-/*
- * this is the timeout value that the select was called with
- */
-struct timeval *waittime;
-{
-int mousex, mousey;
- /*
- * if playback_on is 0, then the input action array is empty
- */
- if (playback_on)
- {
- restorewait = waittime;
- /*
- * figure out if we need to wait for the next input action
- */
- if (find_residual_time(&rtime) > 0)
- {
- /*
- * still have to wait before processing the current
- * input action
- */
- go_for_next = 0;
- }
- else
- {
- /*
- * don't have to wait any longer before processing
- * the current input action
- */
- go_for_next = 1;
- }
- /*
- * if we have an input action to process and the only reason
- * that the select returned was because it timed out, then we
- * change the select value to 1 and return 1 instead of 0
- */
- if (readable == 0)
- {
- readable++;
- }
- /*
- * if we don't need to wait, then get an input action from
- * the input action array and process it
- */
- if (go_for_next)
- {
- /*
- * There are three possible types of input actions in
- * the input action array (motion input actions are
- * converted to jump input actions before being put
- * into the input action array). Delay input actions
- * are processed by the compute_action_time function
- * which is called from XTestComputeWaitTime. The
- * other two types of input actions are processed here.
- */
- if (action_array[read_index].type == XTestJUMP_ACTION)
- {
- XTestJumpPointer(
- action_array[read_index].x,
- action_array[read_index].y,
- action_array[read_index].device);
- }
- if (action_array[read_index].type == XTestKEY_ACTION)
- {
- GetSpritePosition(&mousex, &mousey);
- XTestGenerateEvent(
- action_array[read_index].device,
- action_array[read_index].keycode,
- action_array[read_index].keystate,
- mousex,
- mousey);
- }
- read_index++;
- /*
- * if all input actions are processed, then restore
- * the server state
- */
- if (read_index >= write_index)
- {
- waittime->tv_sec = saved_sec;
- waittime->tv_usec = saved_usec;
- time_saved = 0;
- playback_on = 0;
- if (acknowledge)
- {
- /*
- * if the playback client is waiting
- * for an xTestFakeAck event, send
- * it to him
- */
- send_ack(playback_client);
- acknowledge = 0;
- }
- write_index = 0;
- read_index = 0;
- playback_client = (ClientPtr) NULL;
- play_clock = 0;
- }
- }
- }
- return(readable);
-}
-
-/******************************************************************************
- *
- * send_ack
- *
- * send an xTestFakeAck event to the client
- */
-static void
-send_ack(client)
-ClientPtr client;
-{
- xTestFakeAckEvent rep;
-
- /*
- * set the serial number of the xTestFakeAck event
- */
- rep.sequenceNumber = client->sequence;
- rep.type = XTestFakeAckType;
- WriteEventsToClient(client, 1, (xEvent *) &rep);
-}
-
-/******************************************************************************
- *
- * start_play_clock
- *
- * start the clock for play back.
- */
-static void
-start_play_clock()
-{
- X_GETTIMEOFDAY(&play_time);
- /*
- * flag that play_time is valid
- */
- play_clock = 1;
-}
-
-/******************************************************************************
- *
- * compute_action_time
- *
- * Set the play clock to the time when the next input action should be put
- * into the server's input queue. Fill the rtime structure with values
- * for the delta until the time for the next input action.
- */
-static void
-compute_action_time(rtime)
-struct timeval *rtime;
-{
- /*
- * holds the delay time in milliseconds
- */
- unsigned long dtime;
- /*
- * holds the number of microseconds in the sum of the dtime value
- * and the play_time value
- */
- unsigned long tot_usec;
- /*
- * holds the number of seconds and microseconds in the
- * dtime value
- */
- unsigned long sec;
- unsigned long usec;
- /*
- * holds the current time
- */
- struct timeval btime;
-
- /*
- * Put the time from the current input action in dtime
- */
- dtime = action_array[read_index].delay_time;
- /*
- * If the current input action is a delay input action,
- * add in the time from the following input action.
- */
- if ((action_array[read_index].type == XTestDELAY_ACTION) &&
- ((read_index + 1) < write_index))
- {
- read_index++;
- dtime = dtime + action_array[read_index].delay_time;
- }
- /*
- * compute the number of seconds and microseconds in the
- * dtime value
- */
- sec = dtime / 1000;
- usec = (dtime % 1000) * 1000;
- /*
- * get the current time in btime
- */
- X_GETTIMEOFDAY(&btime);
- /*
- * compute the number of microseconds in the sum of the dtime value
- * and the current usec value
- */
- tot_usec = btime.tv_usec + usec;
- /*
- * if it is greater than one second's worth, adjust the seconds
- */
- if (tot_usec >= 1000000)
- {
- tot_usec -= 1000000;
- sec++;
- }
- play_time.tv_usec = tot_usec;
- play_time.tv_sec = btime.tv_sec + sec;
- /*
- * put the time until the next input action in rtime
- */
- rtime->tv_sec = sec;
- rtime->tv_usec = usec;
-}
-
-/******************************************************************************
- *
- * find_residual_time
- *
- * Find the time interval from the current time to the value in play_time.
- * This is the time to wait till putting the next input action into the
- * server's input queue. If the time is already up, reset play_time to
- * the current time.
- */
-static int
-find_residual_time(the_residual)
-struct timeval *the_residual;
-{
- /*
- * if > 0, there is time to wait. If < 0, then don't wait
- */
- int wait = 1;
- /*
- * holds the current time
- */
- struct timeval btime;
- /*
- * holds the current time in seconds and microseconds
- */
- unsigned long bsec;
- unsigned long busec;
- /*
- * holds the playback time in seconds and microseconds
- */
- unsigned long psec;
- unsigned long pusec;
-
- /*
- * get the current time in btime
- */
- X_GETTIMEOFDAY(&btime);
- /*
- * get the current time in seconds and microseconds
- */
- bsec = btime.tv_sec;
- busec = btime.tv_usec;
- /*
- * get the playback time in seconds and microseconds
- */
- psec = play_time.tv_sec;
- pusec = play_time.tv_usec;
- /*
- * if the current time is already later than the playback time,
- * we don't need to wait
- */
- if (bsec > psec)
- {
- wait = -1;
- }
- else
- {
- if (bsec == psec)
- {
- /*
- * if the current and playback times have the same
- * second value, then compare the microsecond values
- */
- if ( busec >= pusec)
- {
- /*
- * if the current time is already later than
- * the playback time, we don't need to wait
- */
- wait = -1;
- }
- else
- {
- the_residual->tv_usec = pusec - busec;
- the_residual->tv_sec = 0;
- }
- }
- else
- {
- if (busec > pusec)
- {
- /*
- * 'borrow' a second's worth of microseconds
- * from the seconds left to wait
- */
- the_residual->tv_usec = 1000000 - busec + pusec;
- psec--;
- the_residual->tv_sec = psec - bsec;
- }
- else
- {
- the_residual->tv_sec = psec - bsec;
- the_residual->tv_usec = pusec - busec;
- }
- }
- }
- if (wait < 0)
- {
- /*
- * if don't need to wait, set the playback time
- * to the current time
- */
- X_GETTIMEOFDAY(&play_time);
- /*
- * set the time to wait to 0
- */
- the_residual->tv_sec = 0;
- the_residual->tv_usec = 0;
- }
- return(wait);
-}
-
-/******************************************************************************
- *
- * abort_play_back
- */
-void
-abort_play_back()
-{
- /*
- * If we were playing back input actions at the time of the abort,
- * restore the original wait time for the select in the main wait
- * loop of the server
- */
- if (playback_on)
- {
- restorewait->tv_sec = saved_sec;
- restorewait->tv_usec = saved_usec;
- }
- /*
- * make the input action array empty
- */
- read_index = 0;
- write_index = 0;
- /*
- * we are no longer playing back anything
- */
- playback_on = 0;
- play_clock = 0;
- go_for_next = 1;
- /*
- * there is no valid wait time saved any more
- */
- time_saved = 0;
- /*
- * there are no valid clients using this extension
- */
- playback_client = (ClientPtr) NULL;
- current_xtest_client = (ClientPtr) NULL;
-}
-
-/******************************************************************************
- *
- * return_input_array_size
- *
- * Return the number of input actions in the input action array.
- */
-void
-return_input_array_size(client)
-/*
- * which client to send the reply to
- */
-ClientPtr client;
-{
- xTestQueryInputSizeReply rep;
-
- rep.type = X_Reply;
- /*
- * set the serial number of the reply
- */
- rep.sequenceNumber = client->sequence;
- rep.length = 0;
- rep.size_return = ACTION_ARRAY_SIZE;
- WriteReplyToClient(client,
- sizeof(xTestQueryInputSizeReply),
- (void *) &rep);
-}
diff --git a/nx-X11/programs/Xserver/Xext/xtest1dd.h b/nx-X11/programs/Xserver/Xext/xtest1dd.h
deleted file mode 100644
index 5a3ee1781..000000000
--- a/nx-X11/programs/Xserver/Xext/xtest1dd.h
+++ /dev/null
@@ -1,126 +0,0 @@
-/************************************************************
-
-Copyright 1996 by Thomas E. Dickey <dickey@clark.net>
-
- All Rights Reserved
-
-Permission to use, copy, modify, and distribute this software and its
-documentation for any purpose and without fee is hereby granted,
-provided that the above copyright notice appear in all copies and that
-both that copyright notice and this permission notice appear in
-supporting documentation, and that the name of the above listed
-copyright holder(s) not be used in advertising or publicity pertaining
-to distribution of the software without specific, written prior
-permission.
-
-THE ABOVE LISTED COPYRIGHT HOLDER(S) DISCLAIM ALL WARRANTIES WITH REGARD
-TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS, IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDER(S) BE
-LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-********************************************************/
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#ifndef XTEST1DD_H
-#define XTEST1DD_H 1
-
-extern short xtest_mousex;
-extern short xtest_mousey;
-extern int playback_on;
-extern ClientPtr current_xtest_client;
-extern ClientPtr playback_client;
-extern KeyCode xtest_command_key;
-
-extern void stop_stealing_input(
- void
-);
-
-extern void
-steal_input(
- ClientPtr /* client */,
- CARD32 /* mode */
-);
-
-extern void
-flush_input_actions(
- void
-);
-
-extern void
-XTestStealJumpData(
- int /* jx */,
- int /* jy */,
- int /* dev_type */
-);
-
-extern void
-XTestStealMotionData(
- int /* dx */,
- int /* dy */,
- int /* dev_type */,
- int /* mx */,
- int /* my */
-);
-
-extern Bool
-XTestStealKeyData(
- unsigned /* keycode */,
- int /* keystate */,
- int /* dev_type */,
- int /* locx */,
- int /* locy */
-);
-
-extern void
-parse_fake_input(
- ClientPtr /* client */,
- char * /* req */
-);
-
-extern void
-XTestComputeWaitTime(
- struct timeval * /* waittime */
-);
-
-extern int
-XTestProcessInputAction(
- int /* readable */,
- struct timeval * /* waittime */
-);
-
-extern void
-abort_play_back(
- void
-);
-
-extern void
-return_input_array_size(
- ClientPtr /* client */
-);
-
-extern void XTestGenerateEvent(
- int /* dev_type */,
- int /* keycode */,
- int /* keystate */,
- int /* mousex */,
- int /* mousey */
-);
-
-extern void XTestGetPointerPos(
- short * /* fmousex */,
- short * /* fmousey */
-);
-
-extern void XTestJumpPointer(
- int /* jx */,
- int /* jy */,
- int /* dev_type */
-);
-
-#endif /* XTEST1DD_H */
diff --git a/nx-X11/programs/Xserver/Xext/xtest1di.c b/nx-X11/programs/Xserver/Xext/xtest1di.c
deleted file mode 100644
index b1d69ef47..000000000
--- a/nx-X11/programs/Xserver/Xext/xtest1di.c
+++ /dev/null
@@ -1,915 +0,0 @@
-/*
- * File: xtest1di.c
- *
- * This file contains the device independent parts of the input
- * synthesis extension.
- */
-
-/*
-
-
-Copyright 1986, 1987, 1988, 1998 The Open Group
-
-Permission to use, copy, modify, distribute, and sell this software and its
-documentation for any purpose is hereby granted without fee, provided that
-the above copyright notice appear in all copies and that both that
-copyright notice and this permission notice appear in supporting
-documentation.
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-Except as contained in this notice, the name of The Open Group shall not be
-used in advertising or otherwise to promote the sale, use or other dealings
-in this Software without prior written authorization from The Open Group.
-
-
-Copyright 1986, 1987, 1988 by Hewlett-Packard Corporation
-
-Permission to use, copy, modify, and distribute this
-software and its documentation for any purpose and without
-fee is hereby granted, provided that the above copyright
-notice appear in all copies and that both that copyright
-notice and this permission notice appear in supporting
-documentation, and that the name of Hewlett-Packard not be used in
-advertising or publicity pertaining to distribution of the
-software without specific, written prior permission.
-
-Hewlett-Packard makes no representations about the
-suitability of this software for any purpose. It is provided
-"as is" without express or implied warranty.
-
-This software is not subject to any license of the American
-Telephone and Telegraph Company or of the Regents of the
-University of California.
-
-*/
-
-/*****************************************************************************
- * include files
- ****************************************************************************/
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include <stdio.h>
-#include <nx-X11/X.h>
-#include <nx-X11/Xproto.h>
-#include "misc.h"
-#include "os.h"
-#include "gcstruct.h"
-#include "extnsionst.h"
-#include "dixstruct.h"
-#include "opaque.h"
-#define XTestSERVER_SIDE
-#include <nx-X11/extensions/xtestext1.h>
-
-#include "xtest1dd.h"
-
-/*****************************************************************************
- * defines
- ****************************************************************************/
-
-/*****************************************************************************
- * variables
- ****************************************************************************/
-
-/*
- * Holds the request type code for this extension. The request type code
- * for this extension may vary depending on how many extensions are installed
- * already, so the initial value given below will be added to the base request
- * code that is aquired when this extension is installed.
- */
-static int XTestReqCode = 0;
-/*
- * Holds the two event type codes for this extension. The event type codes
- * for this extension may vary depending on how many extensions are installed
- * already, so the initial values given below will be added to the base event
- * code that is aquired when this extension is installed.
- */
-int XTestInputActionType = 0;
-int XTestFakeAckType = 1;
-/*
- * true => monitor stealing input
- */
-int on_steal_input = FALSE;
-/*
- * true => monitor alone getting input
- */
-int exclusive_steal = FALSE;
-/*
- * holds the resource type assigned to this extension
- */
-static RESTYPE XTestType;
-/*
- * holds the resource ID for the client currently using XTestGetInput
- */
-static XID current_client_id;
-
-/*****************************************************************************
- * function declarations
- ****************************************************************************/
-
-static DISPATCH_PROC(ProcXTestDispatch);
-static DISPATCH_PROC(SProcXTestDispatch);
-static DISPATCH_PROC(ProcTestFakeInput);
-static DISPATCH_PROC(SProcTestFakeInput);
-static DISPATCH_PROC(ProcTestGetInput);
-static DISPATCH_PROC(SProcTestGetInput);
-static DISPATCH_PROC(ProcTestStopInput);
-static DISPATCH_PROC(SProcTestStopInput);
-static DISPATCH_PROC(ProcTestReset);
-static DISPATCH_PROC(SProcTestReset);
-static DISPATCH_PROC(ProcTestQueryInputSize);
-static DISPATCH_PROC(SProcTestQueryInputSize);
-
-static void XTestResetProc(
- ExtensionEntry * /* unused */
- );
-static void SReplyXTestDispatch(
- ClientPtr /* client_ptr */,
- int /* size */,
- char * /* reply_ptr */
- );
-static void SEventXTestDispatch(
- xEvent * /* from */,
- xEvent * /* to */
- );
-
-static int XTestCurrentClientGone(
- void * /* value */,
- XID /* id */
- );
-
-/*****************************************************************************
- *
- * XTestExtension1Init
- *
- * Called from InitExtensions in main() or from QueryExtension() if the
- * extension is dynamically loaded.
- *
- * XTestExtension1Init has no events or errors
- * (other than the core errors).
- */
-void
-XTestExtension1Init(void)
-{
- /*
- * holds the pointer to the extension entry structure
- */
- ExtensionEntry *extEntry;
-
- extEntry = AddExtension(XTestEXTENSION_NAME,
- XTestEVENT_COUNT,
- 0,
- ProcXTestDispatch,
- SProcXTestDispatch,
- XTestResetProc,
- StandardMinorOpcode);
- if (extEntry)
- {
- /*
- * remember the request code assigned to this extension
- */
- XTestReqCode = extEntry->base;
- /*
- * make an atom saying that this extension is present
- */
- (void) MakeAtom(XTestEXTENSION_NAME,
- strlen(XTestEXTENSION_NAME),
- TRUE);
- /*
- * remember the event codes assigned to this extension
- */
- XTestInputActionType += extEntry->eventBase;
- XTestFakeAckType += extEntry->eventBase;
- /*
- * install the routine to handle byte-swapping the replies
- * for this extension in the ReplySwapVector table
- */
- ReplySwapVector[XTestReqCode] = (ReplySwapPtr) SReplyXTestDispatch;
- /*
- * install the routine to handle byte-swapping the events
- * for this extension in the EventSwapVector table
- */
- EventSwapVector[XTestInputActionType] = SEventXTestDispatch;
- EventSwapVector[XTestFakeAckType] = SEventXTestDispatch;
- /*
- * get the resource type for this extension
- */
- XTestType = CreateNewResourceType(XTestCurrentClientGone);
- if (XTestType == 0)
- {
- FatalError("XTestExtension1Init: CreateNewResourceType failed\n");
- }
- }
- else
- {
- FatalError("XTestExtension1Init: AddExtensions failed\n");
- }
-}
-
-/*****************************************************************************
- *
- * ProcXTestDispatch
- *
- *
- */
-static int
-ProcXTestDispatch(client)
- register ClientPtr client;
-{
- REQUEST(xReq);
- if (stuff->data == X_TestFakeInput)
- {
- return(ProcTestFakeInput(client));
- }
- else if (stuff->data == X_TestGetInput)
- {
- return(ProcTestGetInput(client));
- }
- else if (stuff->data == X_TestStopInput)
- {
- return(ProcTestStopInput(client));
- }
- else if (stuff->data == X_TestReset)
- {
- return(ProcTestReset(client));
- }
- else if (stuff->data == X_TestQueryInputSize)
- {
- return(ProcTestQueryInputSize(client));
- }
- else
- {
- SendErrorToClient(client,
- XTestReqCode,
- stuff->data,
- None,
- BadRequest);
- return(BadRequest);
- }
-}
-
-/*****************************************************************************
- *
- * SProcXTestDispatch
- *
- *
- */
-static int
-SProcXTestDispatch(client)
- register ClientPtr client;
-{
- REQUEST(xReq);
- if (stuff->data == X_TestFakeInput)
- {
- return(SProcTestFakeInput(client));
- }
- else if (stuff->data == X_TestGetInput)
- {
- return(SProcTestGetInput(client));
- }
- else if (stuff->data == X_TestStopInput)
- {
- return(SProcTestStopInput(client));
- }
- else if (stuff->data == X_TestReset)
- {
- return(SProcTestReset(client));
- }
- else if (stuff->data == X_TestQueryInputSize)
- {
- return(SProcTestQueryInputSize(client));
- }
- else
- {
- SendErrorToClient(client,
- XTestReqCode,
- stuff->data,
- None,
- BadRequest);
- return(BadRequest);
- }
-}
-
-/*****************************************************************************
- *
- * SProcTestFakeInput
- *
- *
- */
-static int
-SProcTestFakeInput(client)
- register ClientPtr client;
-{
- /*
- * index counter
- */
- int i;
- /*
- * pointer to the next input action in the request
- */
- CARD8 *input_action_ptr;
- /*
- * holds the type of the next input action in the request
- */
- int input_action_type;
-
- REQUEST(xTestFakeInputReq);
- /*
- * byte-swap the fields in the request
- */
- swaps(&stuff->length);
- swapl(&stuff->ack);
- /*
- * have to parse and then byte-swap the input action list here
- */
- for (i = 0; i < XTestMAX_ACTION_LIST_SIZE;)
- {
- /*
- * point to the next input action in the request
- */
- input_action_ptr = &(((xTestFakeInputReq *) stuff)->action_list[i]);
- /*
- * figure out what type of input action it is
- */
- input_action_type = (*input_action_ptr) & XTestACTION_TYPE_MASK;
- /*
- * byte-swap the input action according to it's type
- */
- switch (input_action_type)
- {
- case XTestKEY_ACTION:
- /*
- * byte-swap the delay_time field
- */
- swaps(&(((XTestKeyInfo *) input_action_ptr)->delay_time));
- /*
- * advance to the next input action
- */
- i += sizeof(XTestKeyInfo);
- break;
- case XTestMOTION_ACTION:
- /*
- * byte-swap the delay_time field
- */
- swaps(&(((XTestMotionInfo *) input_action_ptr)->delay_time));
- /*
- * advance to the next input action
- */
- i += sizeof(XTestMotionInfo);
- break;
- case XTestJUMP_ACTION:
- /*
- * byte-swap the jumpx field
- */
- swaps(&(((XTestJumpInfo *) input_action_ptr)->jumpx));
- /*
- * byte-swap the jumpy field
- */
- swaps(&(((XTestJumpInfo *) input_action_ptr)->jumpy));
- /*
- * byte-swap the delay_time field
- */
- swaps(&(((XTestJumpInfo *) input_action_ptr)->delay_time));
- /*
- * advance to the next input action
- */
- i += sizeof(XTestJumpInfo);
- break;
- default:
- /*
- * if this is a delay input action, then byte-swap it,
- * otherwise we have reached the end of the input
- * actions in this request
- */
- if (XTestUnpackDeviceID(*input_action_ptr) ==
- XTestDELAY_DEVICE_ID)
- {
- /*
- * byte-swap the delay_time field
- */
- swapl(&(((XTestDelayInfo *) input_action_ptr)->delay_time));
- /*
- * advance to the next input action
- */
- i += sizeof(XTestDelayInfo);
- }
- else
- {
- /*
- * if the input action header byte is 0 or
- * ill-formed, then there are no more input
- * actions in this request
- */
- i = XTestMAX_ACTION_LIST_SIZE;
- }
- break;
- }
- }
- return(ProcTestFakeInput(client));
-}
-
-/*****************************************************************************
- *
- * SProcTestGetInput
- *
- *
- */
-static int
-SProcTestGetInput(client)
- register ClientPtr client;
-{
- REQUEST(xTestGetInputReq);
- /*
- * byte-swap the fields in the request
- */
- swaps(&stuff->length);
- swapl(&stuff->mode);
- return(ProcTestGetInput(client));
-}
-
-/*****************************************************************************
- *
- * SProcTestStopInput
- *
- *
- */
-static int
-SProcTestStopInput(client)
- register ClientPtr client;
-{
- REQUEST(xTestStopInputReq);
- /*
- * byte-swap the length field in the request
- */
- swaps(&stuff->length);
- return(ProcTestStopInput(client));
-}
-
-/*****************************************************************************
- *
- * SProcTestReset
- *
- *
- */
-static int
-SProcTestReset(client)
- register ClientPtr client;
-{
- REQUEST(xTestResetReq);
- /*
- * byte-swap the length field in the request
- */
- swaps(&stuff->length);
- return(ProcTestReset(client));
-}
-
-/*****************************************************************************
- *
- * SProcTestQueryInputSize
- *
- *
- */
-static int
-SProcTestQueryInputSize(client)
- register ClientPtr client;
-{
- REQUEST(xTestQueryInputSizeReq);
- /*
- * byte-swap the length field in the request
- */
- swaps(&stuff->length);
- return(ProcTestQueryInputSize(client));
-}
-
-/*****************************************************************************
- *
- * ProcTestFakeInput
- *
- *
- */
-static int
-ProcTestFakeInput(client)
- register ClientPtr client;
-{
- REQUEST(xTestFakeInputReq);
- REQUEST_SIZE_MATCH(xTestFakeInputReq);
-
- if (playback_client == NULL)
- {
- playback_client = client;
- current_client_id = FakeClientID(client->index);
- AddResource(current_client_id,
- XTestType,
- 0);
- MakeClientGrabImpervious(client);
- }
- if (playback_client == client)
- {
- /*
- * This extension does not need to clean up any
- * server state when a client using this function
- * "goes away". The server will just process any
- * input actions that have already been sent to it,
- * and will then reset its association with a client.
- */
- parse_fake_input(client, (char *)stuff);
- return(Success);
- }
- else
- {
- /*
- * this is a request by another client to send fake
- * input while the server is still being used
- */
- SendErrorToClient(client,
- XTestReqCode,
- X_TestFakeInput,
- None,
- BadAccess);
- return(BadAccess);
- }
-}
-
-/*****************************************************************************
- *
- * ProcTestGetInput
- *
- *
- */
-static int
-ProcTestGetInput(client)
- register ClientPtr client;
-{
- REQUEST(xTestGetInputReq);
- REQUEST_SIZE_MATCH(xTestGetInputReq);
- if (on_steal_input)
- {
- /*
- * this is a request by another client to get fake input
- * while the server is still sending input to the first client
- */
- SendErrorToClient(client,
- XTestReqCode,
- X_TestGetInput,
- None,
- BadAccess);
- return(BadAccess);
- }
- else
- {
- /*
- * Set up a resource associated with the client using this
- * function so that this extension gets called when the
- * client "goes away". This allows this extension to
- * clean up the server state.
- */
- current_client_id = FakeClientID(client->index);
- AddResource(current_client_id,
- XTestType,
- 0);
- /*
- * indicate that a client is stealing input
- */
- on_steal_input = TRUE;
- if ((stuff->mode & XTestEXCLUSIVE) == 0)
- {
- exclusive_steal = FALSE;
- }
- else
- {
- exclusive_steal = TRUE;
- }
- steal_input(client, stuff->mode);
- return(Success);
- }
-}
-
-/*****************************************************************************
- *
- * ProcTestStopInput
- *
- *
- */
-static int
-ProcTestStopInput(client)
- register ClientPtr client;
-{
- REQUEST_SIZE_MATCH(xTestStopInputReq);
- if (on_steal_input && (current_xtest_client == client))
- {
- on_steal_input = FALSE;
- exclusive_steal = FALSE;
- stop_stealing_input();
- /*
- * remove the resource associated with this client
- */
- FreeResource(current_client_id, RT_NONE);
- return(Success);
- }
- else
- {
- /*
- * this is a request to stop fake input when fake input has
- * never been started or from a client that hasn't started
- * fake input
- */
- SendErrorToClient(client,
- XTestReqCode,
- X_TestStopInput,
- None,
- BadAccess);
- return(BadAccess);
- }
-}
-
-/*****************************************************************************
- *
- * ProcTestReset
- *
- *
- */
-static int
-ProcTestReset(client)
- register ClientPtr client;
-{
- REQUEST_SIZE_MATCH(xTestResetReq);
- on_steal_input = FALSE;
- exclusive_steal = FALSE;
- /*
- * defined in xtest1dd.c
- */
- stop_stealing_input();
- /*
- * defined in xtest1dd.c
- */
- abort_play_back();
- return(Success);
-}
-
-/*****************************************************************************
- *
- * ProcTestQueryInputSize
- *
- *
- */
-static int
-ProcTestQueryInputSize(client)
- register ClientPtr client;
-{
- REQUEST_SIZE_MATCH(xTestQueryInputSizeReq);
- /*
- * defined in xtest1dd.c
- */
- return_input_array_size(client);
- return(Success);
-}
-
-/*****************************************************************************
- *
- * XTestResetProc
- *
- * This function is called by the server when the server has no clients
- * connected to it. It must put eveything back the way it was before
- * this extension was installed.
- */
-/*ARGSUSED*/
-static void
-XTestResetProc(unused)
- ExtensionEntry * unused;
-{
- /*
- * remove the routine to handle byte-swapping the replies
- * for this extension in the ReplySwapVector table
- */
- ReplySwapVector[XTestReqCode] = ReplyNotSwappd;
- /*
- * remove the routine to handle byte-swapping the events
- * for this extension in the EventSwapVector table
- */
- EventSwapVector[XTestInputActionType] = NotImplemented;
- EventSwapVector[XTestFakeAckType] = NotImplemented;
- /*
- * reset the variables initialized just once at load time
- */
- XTestReqCode = 0;
- XTestInputActionType = 0;
- XTestFakeAckType = 1;
- on_steal_input = FALSE;
- exclusive_steal = FALSE;
- playback_client = 0; /* Don't really need this but it looks nice */
-}
-
-/*****************************************************************************
- *
- * PXTestCurrentClientGone
- *
- * This routine is called when a client that has asked for input actions
- * to be sent to it "goes away". This routine must clean up the
- * server state.
- */
-/*ARGSUSED*/
-static int
-XTestCurrentClientGone(value, id)
- void * value;
- XID id;
-{
- /*
- * defined in xtest1dd.c
- */
- on_steal_input = FALSE;
- exclusive_steal = FALSE;
- /*
- * defined in xtestdd.c
- */
- playback_client = 0;
- abort_play_back();
- return TRUE;
-}
-
-/*****************************************************************************
- *
- * SReplyXTestDispatch
- *
- * Swap any replies defined in this extension.
- */
-static void
-SReplyXTestDispatch(client_ptr, size, reply_ptr)
- ClientPtr client_ptr;
- int size;
- char *reply_ptr;
-{
- /*
- * pointer to xTestQueryInputSizeReply
- */
- xTestQueryInputSizeReply *rep_ptr;
-
- /*
- * there is only one reply in this extension, so byte-swap it
- */
- rep_ptr = (xTestQueryInputSizeReply *) reply_ptr;
- swaps(&(rep_ptr->sequenceNumber));
- swapl(&(rep_ptr->length));
- swapl(&(rep_ptr->size_return));
- /*
- * now write the swapped reply to the client
- */
- WriteToClient(client_ptr, size, reply_ptr);
-}
-
-/*****************************************************************************
- *
- * SEventXTestDispatch
- *
- * Swap any events defined in this extension.
- */
-static void
-SEventXTestDispatch(from, to)
- xEvent *from;
- xEvent *to;
-{
- /*
- * index counter
- */
- int i;
- /*
- * pointer to the next input action in the event
- */
- CARD8 *input_action_ptr;
- /*
- * holds the type of the next input action in the event
- */
- int input_action_type;
-
-
- /*
- * copy the type information from the "from" event to the "to" event
- */
- ((xTestInputActionEvent *) to)->type =
- ((xTestInputActionEvent *) from)->type;
- /*
- * copy the sequence number information from the "from" event to the
- * "to" event
- */
- ((xTestInputActionEvent *) to)->sequenceNumber =
- ((xTestInputActionEvent *) from)->sequenceNumber;
- /*
- * byte-swap the sequence number in the "to" event
- */
- swaps(&(((xTestInputActionEvent *) to)->sequenceNumber));
- /*
- * If the event is an xTestInputActionEvent, then it needs more
- * processing. Otherwise, it is an xTestFakeAckEvent, which
- * has no other information in it.
- */
- if ((((xTestInputActionEvent *) to)->type & 0x7f) ==
- XTestInputActionType)
- {
- /*
- * copy the input actions from the "from" event
- * to the "to" event
- */
- for (i = 0; i < XTestACTIONS_SIZE; i++)
- {
- ((xTestInputActionEvent *) to)->actions[i] =
- ((xTestInputActionEvent *) from)->actions[i];
- }
- /*
- * byte-swap the input actions in the "to" event
- */
- for (i = 0; i < XTestACTIONS_SIZE; i++)
- {
- /*
- * point to the next input action in the event
- */
- input_action_ptr = &(((xTestInputActionEvent *) to)->actions[i]);
- /*
- * figure out what type of input action it is
- */
- input_action_type = (*input_action_ptr) &
- XTestACTION_TYPE_MASK;
- /*
- * byte-swap the input action according to it's type
- */
- switch (input_action_type)
- {
- case XTestKEY_ACTION:
- /*
- * byte-swap the delay_time field
- */
- swaps(&(((XTestKeyInfo *) input_action_ptr)->delay_time));
- /*
- * advance to the next input action
- */
- i += sizeof(XTestKeyInfo);
- break;
- case XTestMOTION_ACTION:
- /*
- * byte-swap the delay_time field
- */
- swaps(&(((XTestMotionInfo *) input_action_ptr)->delay_time));
- /*
- * advance to the next input action
- */
- i += sizeof(XTestMotionInfo);
- break;
- case XTestJUMP_ACTION:
- /*
- * byte-swap the jumpx field
- */
- swaps(&(((XTestJumpInfo *) input_action_ptr)->jumpx));
- /*
- * byte-swap the jumpy field
- */
- swaps(&(((XTestJumpInfo *) input_action_ptr)->jumpy));
- /*
- * byte-swap the delay_time field
- */
- swaps(&(((XTestJumpInfo *) input_action_ptr)->delay_time));
- /*
- * advance to the next input action
- */
- i += sizeof(XTestJumpInfo);
- break;
- default:
- /*
- * if this is a delay input action, then
- * byte-swap it, otherwise we have reached the
- * end of the input actions in this event
- */
- if (XTestUnpackDeviceID(*input_action_ptr) ==
- XTestDELAY_DEVICE_ID)
- {
- /*
- * byte-swap the delay_time field
- */
- swapl(&(((XTestDelayInfo *) input_action_ptr)->delay_time));
- /*
- * advance to the next input action
- */
- i += sizeof(XTestDelayInfo);
- }
- else
- {
- /*
- * if the input action header byte is 0
- * or ill-formed, then there are no
- * more input actions in this event
- */
- i = XTestACTIONS_SIZE;
- }
- break;
- }
- }
- }
-}