• xdotool的manual


    XDOTOOL(1)                            XDOTOOL(1)



    NAME
           xdotool - command-line X11 automation
           tool

    SYNOPSIS
           xdotool cmd args...

           Notation: Some documentation uses
           [window] to denote an optional window
           argument. This case means that the
           argument, if not present, will default to
           "%1". See "WINDOW STACK" for what "%1"
           means.

    DESCRIPTION
           xdotool lets you programatically (or
           manually) simulate keyboard input and
           mouse activity, move and resize windows,
           etc. It does this using X11's XTEST
           extension and other Xlib functions.

           There is some support for Extended Window
           Manager Hints (aka EWMH or NetWM).  See
           the "EXTENDED WINDOW MANAGER HINTS"
           section for more information.

    KEYBOARD COMMANDS
           key [options] keystroke [keystroke ...]
               Options:

               --window window
                   Send keystrokes to a specific
                   window id. You can use "WINDOW
                   STACK" references like "%1" and
                   "%@" here. If there is a window
                   stack, then "%1" is the default,
                   otherwise the current window is
                   used.

                   See also: "SENDEVENT NOTES" and
                   "WINDOW STACK"

               --clearmodifiers
                   Clear modifiers before sending
                   keystrokes. See CLEARMODIFIERS
                   below.

               --delay milliseconds
                   Delay between keystrokes. Default
                   is 12ms.

               Type a given keystroke. Examples
               being "alt+r", "Control_L+J",
               "ctrl+alt+n", "BackSpace".

               Generally, any valid X Keysym string
               will work. Multiple keys are
               separated by '+'. Aliases exist for
               "alt", "ctrl", "shift", "super", and
               "meta" which all map to Foo_L, such
               as Alt_L and Control_L, etc.

               In cases where your keyboard doesn't
               actually have the key you want to
               type, xdotool will automatically find
               an unused keycode and use that to
               type the key.

               With respect to "COMMAND CHAINING",
               this command consumes the remainder
               of the arguments or until a new
               xdotool command is seen, because no
               xdotool commands are valid
               keystrokes.

               Example: Send the keystroke "F2"
                xdotool key F2

               Example: Send 'a' with an accent over
               it (not on english keyboards, but
               still works with xdotool)
                xdotool key Aacute

               Example: Send ctrl+l and then
               BackSpace as separate keystrokes:
                xdotool key ctrl+l BackSpace

               Example: Send ctrl+c to all windows
               matching title 'gdb' (See "COMMAND
               CHAINING")
                xdotool search --name gdb key ctrl+c

           keydown [options] keystroke
               Same as above, except only keydown
               (press) events are sent.

           keyup keystroke
               Same as above, except only keyup
               (release) events are sent.

           type [options] something to type
               Options:

               --window windowid
                   Send keystrokes to a specific
                   window id. See "SENDEVENT NOTES"
                   below. The default, if no window
                   is given, depends on the window
                   stack. If the window stack is
                   empty the current window is typed
                   at using XTEST. Otherwise, the
                   default is "%1" (see "WINDOW
                   STACK").

               --delay milliseconds
                   Delay between keystrokes. Default
                   is 12ms.

               --clearmodifiers
                   Clear modifiers before sending
                   keystrokes. See CLEARMODIFIERS
                   below.

               Types as if you had typed it.
               Supports newlines and tabs (ASCII
               newline and tab). Each keystroke is
               separated by a delay given by the
               --delay option.

               With respect to "COMMAND CHAINING",
               this command consumes the remainder
               of the arguments and types them. That
               is, no commands can chain after
               'type'.

               Example: to type 'Hello world!' you
               would do:
                xdotool type 'Hello world!'

    MOUSE COMMANDS
           mousemove [options] x y OR 'restore'
               Move the mouse to the specific X and
               Y coordinates on the screen.

               You can move the mouse to the
               previous location if you specify
               'restore' instead of an X and Y
               coordinate. Restoring only works if
               you have moved previously in this
               same command invocation. Further, it
               does not work with the --window
               option.

               For example, to click the top-left
               corner of the screen and move the
               mouse to the original position before
               you moved it, use this:
                xdotool mousemove 0 0 click 1
               mousemove xdorestore

               --window WINDOW
                   Specify a window to move relative
                   to. Coordinates 0,0 are at the
                   top left of the window you
                   choose.

                   "WINDOW STACK" references are
                   valid here, such as %1 and %@.
                   Though, using %@ probably doesn't
                   make sense.

               --screen SCREEN
                   Move the mouse to the specified
                   screen to move to. This is only
                   useful if you have multiple
                   screens and ARE NOT using
                   Xinerama.

                   The default is the current
                   screen. If you specify --window,
                   the --screen flag is ignored.

               --polar
                   Use polar coordinates. This makes
                   'x' an angle (in degrees, 0-360,
                   etc) and 'y' the distance.

                   Rotation starts at 'up' (0
                   degrees) and rotates clockwise:
                   90 = right, 180 = down, 270 =
                   left.

                   The origin defaults to the center
                   of the current screen. If you
                   specify a --window, then the
                   origin is the center of that
                   window.

               --clearmodifiers
                   See CLEARMODIFIERS

               --sync
                   After sending the mouse move
                   request, wait until the mouse is
                   actually moved. If no movement is
                   necessary, we will not wait. This
                   is useful for scripts that depend
                   on actions being completed before
                   moving on.

                   Note: We wait until the mouse
                   moves at all, not necessarily
                   that it actually reaches your
                   intended destination. Some
                   applications lock the mouse
                   cursor to certain regions of the
                   screen, so waiting for any
                   movement is better in the general
                   case than waiting for a specific
                   target.

           mousemove_relative [options] x y
               Move the mouse x,y pixels relative to
               the current position of the mouse
               cursor.

               --polar
                   Use polar coordinates. This makes
                   'x' an angle (in degrees, 0-360,
                   etc) and 'y' the distance.

                   Rotation starts at 'up' (0
                   degrees) and rotates clockwise:
                   90 = right, 180 = down, 270 =
                   left.

               --sync
                   After sending the mouse move
                   request, wait until the mouse is
                   actually moved. If no movement is
                   necessary, we will not wait. This
                   is useful for scripts that depend
                   on actions being completed before
                   moving on.

                   Note that we wait until the mouse
                   moves at all, not necessarily
                   that it actually reaches your
                   intended destination. Some
                   applications lock the mouse
                   cursor to certain regions of the
                   screen, so waiting for any
                   movement is better in the general
                   case than waiting for a specific
                   target.

               --clearmodifiers
                   See CLEARMODIFIERS

           click [options] button
               Send a click, that is, a mousedown
               followed by mouseup for the given
               button with a short delay between the
               two (currently 12ms).

               Buttons generally map this way: Left
               mouse is 1, middle is 2, right is 3,
               wheel up is 4, wheel down is 5.

               --clearmodifiers
                   Clear modifiers before clicking.
                   See CLEARMODIFIERS below.

               --repeat REPEAT
                   Specify how many times to click.
                   Default is 1. For a double-click,
                   use '--repeat 2'

               --delay MILLISECONDS
                   Specify how long, in
                   milliseconds, to delay between
                   clicks. This option is not used
                   if the --repeat flag is set to 1
                   (default).

               --window WINDOW
                   Specify a window to send a click
                   to. See "SENDEVENT NOTES" below
                   for caveats. Uses the current
                   mouse position when generating
                   the event.

                   The default, if no window is
                   given, depends on the window
                   stack. If the window stack is
                   empty the current window is typed
                   at using XTEST. Otherwise, the
                   default is "%1" (see "WINDOW
                   STACK").

           mousedown [options] button
               Same as click, except only a mouse
               down is sent.

           mouseup [options] button
               Same as click, except only a mouse up
               is sent.

           getmouselocation [--shell]
               Outputs the x, y, screen, and window
               id of the mouse cursor. Screen
               numbers will be nonzero if you have
               multiple monitors and are not using
               Xinerama.

               --shell
                   This makes getmouselocation
                   output shell data you can eval.
                   Example:

                    % xdotool getmouselocation --shell
                    X=880
                    Y=443
                    SCREEN=0
                    WINDOW=16777250

                    % eval $(xdotool getmouselocation --shell)
                    % echo $X,$Y
                    714,324

           behave_screxdoen_edge [options] where
           command ...
               Bind an action to events when the
               mouse hits the screen edge or corner.

               Options are:

               --delay MILLISECONDS
                   Delay in milliseconds before
                   running the command. This allows
                   you to require a given edge or
                   corner to be held for a short
                   period before your command will
                   run. If you leave the edge or
                   corner before the delay expires
                   then the time will reset.

               --quiesce MILLISECONDS
                   Delay in milliseconds before the
                   next command will run. This helps
                   prevent accidentally running your
                   command extra times; especially
                   useful if you have a very short
                   --delay (like the default of 0).

               Event timeline

                * Mouse hits an edge or corner.
                * If delay is nonzero, the mouse must stay in this edge or corner until delay time expires.
                * If still in the edge/corner, trigger.
                * If quiesce is nonzero, then there is a cool-down period where the next
                  trigger cannot occur

               Valid 'where' values are:

               left
               top-left
               top
               top-right
               right
               bottom-left
               bottom
               bottom-right

               Examples:
                # Activate google-chrome when you
               move the mouse to the bottom-left
               corner:
                xdotool behave_screen_edge bottom-
               left
                  search --class google-chrome
               windowactivate

                # Go to the next workspace (right). Known to work in GNOME (metacity and compiz)
                xdotool behave_screen_edge --delay 500 bottom-right key XF86Forward

                # Activate firefox and do a web search in a new tab for text in your clipboard
                xdotool behave_screen_edge --delay 1000 top-left
                    search --classname Navigator
                    windowactivate --sync key --delay 250 ctrl+t ctrl+k ctrl+v Return

    WINDOW COMMANDS
           search [options] pattern
               Search for windows with titles,
               names, or classes with a regular
               expression pattern. The output is
               line-delimited list of X window
               identifiers. If you are using
               "COMMAND CHAINING", the search
               command will only write window ids to
               stdout if it is the last (or only)
               command in the chain; otherwise, it
               is silent.

               The result is saved to the window
               stack for future chained commands.
               See "WINDOW STACK" and "COMMAND
               CHAINING" for details.

               The default options are "--name
               --class --classname" (unless you
               specify one one or more of --name
               --class or --classname).

               The options available are:

               --class
                   Match against the window class.

               --classname
                   Match against the window
                   classname.

               --maxdepth N
                   Set recursion/child search depth.
                   Default is -1, meaning infinite.
                   0 means no depth, only root
                   windows will be searched. If you
                   only want toplevel windows, set
                   maxdepth of 1 (or 2, depending on
                   how your window manager does
                   decorations).

               --name
                   Match against the window name.
                   This is the same string that is
                   displayed in the window titlebar.

               --onlyvisible
                   Show only visible windows in the
                   results. This means ones with map
                   state IsViewable.

               --pid PID
                   Match windows that belong to a
                   specific process id. This may not
                   work for some X applications that
                   do not set this metadata on its
                   windows.

               --screen N
                   Select windows only on a specific
                   screen. Default is to search all
                   screens. Only meaningful if you
                   have multiple displays and are
                   not using Xinerama.

               --desktop N
                   Only match windows on a certain
                   desktop. 'N' is a number. The
                   default is to search all
                   desktops.

               --limit N
                   Stop searching after finding N
                   matching windows. Specifying a
                   limit will help speed up your
                   search if you only want a few
                   results.

                   The default is no search limit
                   (which is equivalent to '--limit
                   0')

               --title
                   DEPRECATED. See --name.

               --all
                   Require that all conditions be
                   met. For example:

                    xdotool search --all --pid 1424 --name "Hello World"

                   This will match only windows that
                   have "Hello World" as a name and
                   are owned by pid 1424.

               --any
                   Match windows that match any
                   condition (logically, 'or'). This
                   is on by default. For example:

                    xdotool search --any --pid 1424 --name "Hello World"

                   This will match any windows owned
                   by pid 1424 or windows with name
                   "Hello World"

               --sync
                   Block until there are results.
                   This is useful when you are
                   launching an application want
                   want to wait until the
                   application window is visible.
                   For example:

                    google-chrome &
                    xdotool search --sync --onlyvisible --class "google-chrome"

           selectwindow
               Get the window id (for a client) by
               clicking on it. Useful for having
               scripts query you humans for what
               window to act on. For example,
               killing a window by clicking on it:

                xdotool selectwindow windowkill

           behave window action command ...
               Bind an action to an event on a
               window. This lets you run additional
               xdotool commands whenever a matched
               event occurs.

               The command run as a result of the
               behavior is run with %1 being the
               window that was acted upon. Examples
               follow after the event list.

               The following are valid events:

               mouse-enter
                   Fires when the mouse enters a
                   window. This is similar to 'mouse
                   over' events in javascript, if
                   that helps.

               mouse-leave
                   Fires when the mouse leaves a
                   window. This is the opposite of
                   'mouse-enter'

               mouse-click
                   Fires when the mouse is clicked.
                   Specifically, when the mouse
                   button is released.

               focus
                   Fires when the window gets input
                   focus.

               blur
                   Fires when the window loses
                   focus.

               Examples:

                # Print the cursor location whenever the mouse enters a currently-visible
                # window:
                xdotool search --onlyvisible . behave %@ mouse-enter getmouselocation

                # Print the window title and pid whenever an xterm gets focus
                xdotool search --class xterm behave %@ focus getwindowname getwindowpid

                # Emulate focus-follows-mouse
                xdotool search . behave %@ mouse-enter windowfocus

           getwindowpid [window]
               Output the PID owning a given window.
               This requires effort from the
               application owning a window and may
               not work for all windows. This uses
               _NET_WM_PID property of the window.
               See "EXTENDED WINDOW MANAGER HINTS"
               below for more information.

               If no window is given, the default is
               '%1'. If no windows are on the stack,
               then this is an error. See "WINDOW
               STACK" for more details.

               Example: Find the PID for all xterms:
                xdotool search --class xterm
               getwindowpid %@

           getwindowname [window]
               Output the name of a given window,
               also known as the title. This is the
               text displayed in the window's
               titlebar by your window manager.

               If no window is given, the default is
               '%1'. If no windows are on the stack,
               then this is an error. See "WINDOW
               STACK" for more details.

           getwindowgeometry [options] [window]
               Output the geometry (location and
               position) of a window. The values
               include: x, y, width, height, and
               screen number.

               --shell
                   Output values suitable for 'eval'
                   in a shell.

           getwindowfocus [-f]
               Prints the window id of the currently
               focused window. Saves the result to
               the window stack. See "WINDOW STACK"
               for more details.

               If the current window has no WM_CLASS
               property, we assume it is not a
               normal top-level window and traverse
               up the parents until we find a window
               with a WM_CLASS set and return that
               window id.

               If you really want the window
               currently having focus and don't care
               if it has a WM_CLASS setting, then
               use 'getwindowfocus -f'

           windowsize [options] [window] width
           height
               Set the window size of the given
               window. If no window is given, %1 is
               the default.  See "WINDOW STACK" and
               "COMMAND CHAINING" for more details.

               Percentages are valid for width and
               height. They are relative to the
               geometry of the screen the window is
               on. For example, to make a window the
               full width of the screen, but half
               height:

                xdotool windowsize I<window> 100% 50%

               Percentages are valid with --usehints
               and still mean pixel-width relative
               to the screen size.

               The options available are:

               --usehints
                   Use window sizing hints (when
                   available) to set width and
                   height.  This is useful on
                   terminals for setting the size
                   based on row/column of text
                   rather than pixels.

               --sync
                   After sending the window size
                   request, wait until the window is
                   actually resized. If no change is
                   necessary, we will not wait. This
                   is useful for scripts that depend
                   on actions being completed before
                   moving on.

                   Note: Because many window
                   managers may ignore or alter the
                   original resize request, we will
                   wait until the size changes from
                   its original size, not necessary
                   to the requested size.

               Example: To set a terminal to be
               80x24 characters, you would use:
                xdotool windowsize --usehints
               some_windowid 80 24

           windowmove [options] [window] x y
               Move the window to the given
               position. If no window is given, %1
               is the default. See "WINDOW STACK"
               and "COMMAND CHAINING" for more
               details.

               If the given x coordinate is
               literally 'x', then the window's
               current x position will be unchanged.
               The same applies for 'y'.

               Examples:

                xdotool getactivewindow windowmove 100 100    # Moves to 100,100
                xdotool getactivewindow windowmove x 100      # Moves to x,100
                xdotool getactivewindow windowmove 100 y      # Moves to 100,y
                xdotool getactivewindow windowmove 100 y      # Moves to 100,y

               --sync
                   After sending the window move
                   request, wait until the window is
                   actually moved. If no movement is
                   necessary, we will not wait. This
                   is useful for scripts that depend
                   on actions being completed before
                   moving on.

               --relative
                   Make movement relative to the
                   current window position.

           windowfocus [options] [window]
               Focus a window. If no window is
               given, %1 is the default. See "WINDOW
               STACK" and "COMMAND CHAINING" for
               more details.

               Uses XSetInputFocus which may be
               ignored by some window managers or
               programs.

               --sync
                   After sending the window focus
                   request, wait until the window is
                   actually focused. This is useful
                   for scripts that depend on
                   actions being completed before
                   moving on.

           windowmap [options] [window]
               Map a window. In X11 terminology,
               mapping a window means making it
               visible on the screen. If no window
               is given, %1 is the default. See
               "WINDOW STACK" and "COMMAND CHAINING"
               for more details.

               --sync
                   After requesting the window map,
                   wait until the window is actually
                   mapped (visible). This is useful
                   for scripts that depend on
                   actions being completed before
                   moving on.

           windowminimize [options] [window]
               Minimize a window. In X11
               terminology, this is called
               'iconify.'  If no window is given, %1
               is the default. See "WINDOW STACK"
               and "COMMAND CHAINING" for more
               details.

               --sync
                   After requesting the window
                   minimize, wait until the window
                   is actually minimized. This is
                   useful for scripts that depend on
                   actions being completed before
                   moving on.

           windowraise [window_id=%1]
               Raise the window to the top of the
               stack. This may not work on all
               window managers. If no window is
               given, %1 is the default. See "WINDOW
               STACK" and "COMMAND CHAINING" for
               more details.

           windowreparent [source_window]
           destination_window
               Reparent a window. This moves the
               source_window to be a child window of
               destination_window. If no source is
               given, %1 is the default.  "WINDOW
               STACK" window references (like %1)
               are valid for both source_window and
               destination_window See "WINDOW STACK"
               and "COMMAND CHAINING" for more
               details.

           windowkill [window]
               Kill a window. This action will
               destroy the window and kill the
               client controlling it. If no window
               is given, %1 is the default. See
               WINDOW STACK and "COMMAND CHAINING"
               for more details.

           windowunmap [options] [window_id=%1]
               Unmap a window, making it no longer
               appear on your screen. If no window
               is given, %1 is the default. See
               "WINDOW STACK" and "COMMAND CHAINING"
               for more details.

               --sync
                   After requesting the window
                   unmap, wait until the window is
                   actually unmapped (hidden). This
                   is useful for scripts that depend
                   on actions being completed before
                   moving on.

           set_window [options] [windowid=%1]
               Set properties about a window. If no
               window is given, %1 is the default.
               See "WINDOW STACK" and "COMMAND
               CHAINING" for more details.

               Options:

               --name newname
                   Set window WM_NAME (the window
                   title, usually)

               --icon-name newiconname
                   Set window WM_ICON_NAME (the
                   window title when minimized,
                   usually)

               --role newrole
                   Set window WM_WINDOW_ROLE

               --classname newclassname
                   Set window class name (not to be
                   confused with window class)

               --class newclass
                   Set window class (not to be
                   confused with window class name)

               --overrideredirect value
                   Set window's override_redirect
                   value. This value is a hint to
                   the window manager for whether or
                   not it should be managed. If the
                   redirect value is 0, then the
                   window manager will draw borders
                   and treat this window normally.
                   If the value is 1, the window
                   manager will ignore this window.

                   If you change this value, your
                   window manager may not notice the
                   change until the window is mapped
                   again, so you may want to issue
                   'windowunmap' and 'windowmap' to
                   make the window manager take
                   note.

    DESKTOP AND WINDOW COMMANDS
           These commands follow the EWMH standard.
           See the section "EXTENDED WINDOW MANAGER
           HINTS" for more information.

           windowactivate [options] [window]
               Activate the window. This command is
               different from windowfocus: if the
               window is on another desktop, we will
               switch to that desktop. It also uses
               a different method for bringing the
               window up. I recommend trying this
               command before using windowfocus, as
               it will work on more window managers.

               If no window is given, %1 is the
               default. See "WINDOW STACK" and
               "COMMAND CHAINING" for more details.

               --sync
                   After sending the window
                   activation, wait until the window
                   is actually activated. This is
                   useful for scripts that depend on
                   actions being completed before
                   moving on.

           getactivewindow
               Output the current active window.
               This command is often more reliable
               than getwindowfocus. The result is
               saved to the window stack. See
               "WINDOW STACK" for more details.

           set_num_desktops number
               Changes the number of desktops or
               workspaces.

           get_num_desktops
               Output the current number of
               desktops.

           get_desktop_viewport [--shell]
               Report the current viewport's
               position. If --shell is given, the
               output is friendly to shell eval.

               Viewports are sometimes used instead
               of 'virtual desktops' on some window
               managers. A viewport is simply a view
               on a very large desktop area.

           set_desktop_viewport x y
               Move the viewport to the given
               position. Not all requests will be
               obeyed - some windowmangers only obey
               requests that align to workspace
               boundaries, such as the screen size.

               For example, if your screen is
               1280x800, you can move to the 2nd
               workspace by doing:
                xdotool set_desktop_viewport 1280 0

           set_desktop [options] desktop_number
               Change the current view to the
               specified desktop.

               --relative
                   Use relative movements instead of
                   absolute. This lets you move
                   relative to the current desktop.

           get_desktop
               Output the current desktop in view.

           set_desktop_for_window [window]
           desktop_number
               Move a window to a different desktop.
               If no window is given, %1 is the
               default. See "WINDOW STACK" and
               "COMMAND CHAINING" for more details.

           get_desktop_for_window [window]
               Output the desktop currently
               containing the given window. Move a
               window to a different desktop. If no
               window is given, %1 is the default.
               See WINDOW STACK and "COMMAND
               CHAINING" for more details.

    MISCELLANEOUS COMMANDS
           exec [options] command [...]
               Execute a program. This is often
               useful when combined with
               behave_screen_edge to do things like
               locking your screen.

               Options:

               --sync
                   Block until the child process
                   exits. The child process exit
                   status is then passed to the
                   parent process (xdotool) which
                   copies it.

               Examples:
                # Lock the screen when the mouse
               sits in the top-right corner
                xdotool behave_screen_edge --delay
               1000 top-right
                  exec gnome-screensaver-command
               --lock
                # Substitute 'xscreensaver-command
               -lock' if you use that program.

                # The following will fail to move the mouse because we use '--sync' and
                # /bin/false exits nonzero:
                xdotool exec --sync /bin/false mousemove 0 0

                # This succeeds, though, since we do not use --sync on the exec command.
                xdotool exec /bin/false mousemove 0 0

           sleep seconds
               Sleep for a specified period.
               Fractions of seconds (like 1.3, or
               0.4) are valid, here.

    SCRIPTS
           xdotool can read a list of commands via
           stdin or a file if you want. A script
           will fail when any command fails.

           Truthfully, 'script' mode isn't fully
           fleshed out and may fall below your
           expectations. If you have suggestions,
           please email the list or file a bug (See
           CONTACT).

           Scripts can use positional arguments
           (Represented by $1, $2, ...) and
           environment variables (like $HOME or
           $WINDOWID). Quoting arguments should work
           as expected.

           Scripts are processed for parameter and
           environment variable expansion and then
           run as if you had invoked xdotool with
           the entire script on one line (using
           COMMAND CHAINING).

           ·   Read commands from a file:

                xdotool filename

           ·   Read commands from stdin:

                xdotool -

           ·   Read commands from a redirected file

                xdotool - < myfile

           You can also write scripts that only
           execute xdotool. Example:

            #!/usr/local/bin/xdotool
            search --onlyvisible --classname $1

            windowsize %@ $2 $3
            windowraise %@

            windowmove %1 0 0
            windowmove %2 $2 0
            windowmove %3 0 $3
            windowmove %4 $2 $3

           This script will take all windows matched
           by the classname query given by arg1 ($1)
           and sizes/moves them into a 2x2 grid with
           windows sized by the 2nd and 3rd
           parameters.

           Here's an example usage:

            % ./myscript xterm 600 400

           Running it like this will take 4 visible
           xterms, raise them, and move them into a
           2x2 tile grid with each window 600x400
           pixels in size.

    CLEARMODIFIERS
           Any command taking the --clearmodifiers
           flag will attempt to clear any active
           input modifiers during the command and
           restore them afterwards.

           For example, if you were to run this
           command:
            xdotool key a

           The result would be 'a' or 'A' depending
           on whether or not you were holding the
           shift key on your keyboard. Often it is
           undesirable to have any modifiers active,
           so you can tell xdotool to clear any
           active modifiers.

           The order of operations if you hold shift
           while running 'xdotool key
           --clearmodifiers a' is this:

           1. Query for all active modifiers (finds
           shift, in this case)
           2. Try to clear shift by sending 'key up'
           for the shift key
           3. Runs normal 'xdotool key a'
           4. Restore shift key by sending 'key
           down' for shift

           The --clearmodifiers flag can currently
           clear of the following:

           ·   any key in your active keymap that
               has a modifier associated with it.
               (See xmodmap(1)'s 'xmodmap -pm'
               output)

           ·   mouse buttons (1, 2, 3, 4, and 5)

           ·   caps lock

    SENDEVENT NOTES
           If you are trying to send key input to a
           specific window, and it does not appear
           to be working, then it's likely your
           application is ignoring the events
           xdotool is generating. This is fairly
           common.

           Sending keystrokes to a specific window
           uses a different API than simply typing
           to the active window. If you specify
           'xdotool type --window 12345 hello'
           xdotool will generate key events and send
           them directly to window 12345.  However,
           X11 servers will set a special flag on
           all events generated in this way (see
           XEvent.xany.send_event in X11's manual).
           Many programs observe this flag and
           reject these events.

           It is important to note that for key and
           mouse events, we only use XSendEvent when
           a specific window is targeted. Otherwise,
           we use XTEST.

           Some programs can be configured to accept
           events even if they are generated by
           xdotool. Seek the documentation of your
           application for help.

           Specific application notes (from the
           author's testing): * Firefox 3 seems to
           ignore all input when it does not have
           focus.  * xterm can be configured while
           running with ctrl+leftclick, 'Allow
           SendEvents' * gnome-terminal appears to
           accept generated input by default.

    WINDOW STACK
           Certain commands (search,
           getactivewindow, getwindowfocus) will
           find windows for you. These results
           generally printed to stdout, but they are
           also saved to memory for future use
           during the lifetime of the xdotool
           process. See "COMMAND CHAINING" for more
           information.

           The only modifications support for the
           window stack are to replace it. That is,
           two of two sequential searches, only the
           last one's results will be the window
           stack.

    COMMAND CHAINING
           xdotool supports running multiple
           commands on a single invocation.
           Generally, you'll start with a search
           command (see "WINDOW STACK") and then
           perform a set of actions on those
           results.

           To query the window stack, you can use
           special notation "%N" where N is a number
           or the '@' symbol. If %N is given, the
           Nth window will be selected from the
           window stack. Generally you will only
           want the first window or all windows.
           Note that the order of windows in the
           window stack corresponds to the window
           stacking order, i.e. the bottom-most
           window will be reported first (see
           XQueryTree(3)). Thus the order of the
           windows in the window stack may not be
           consistent across invocations.

           The notation described above is used as
           the "window" argument for any given
           command.

           For example, to resize all xterms to
           80x24:

            xdotool search --class xterm -- windowsize --usehints %@ 80 24

           Resize move the current window:

            xdotool getactivewindow windowmove 0 0

           In all cases, the default window
           argument, if omitted, will default to
           "%1". It is obviously an error if you
           omit the window argument and the window
           stack is empty. If you try to use the
           window stack and it is empty, it is also
           an error.

           To activate the first firefox window
           found:

            xdotool search --class firefox windowactivate

           These would error:

            xdotool windowactivate
            xdotool windowactivate %1
            xdotool windowactivate %@

           When xdotool exits, the current window
           stack is lost.

           Additinally, commands that modify the
           "WINDOW STACK" will not print the results
           if they are not the last command. For
           example:

            # Output the active window:
            % xdotool getactivewindow
            20971533

            # Output the pid of the active window, but not the active window id:
            % xdotool getactivewindow getwindowpid
            4686

    EXTENDED WINDOW MANAGER HINTS
           The following pieces of the EWMH standard
           are supported:

           _NET_SUPPORTED
               Asks the window manager what is
               supported

           _NET_CURRENT_DESKTOP
               Query and set the current desktop.
               Support for this enables these
               commands: "set_desktop",
               "get_desktop".

           _NET_WM_DESKTOP
               Query and set what desktop a window
               is living in. Support for this
               enables these commands:
               "set_desktop_for_window",
               "get_desktop_for_window".

           _NET_ACTIVE_WINDOW
               Allows you to query and set the
               active window by asking the window
               manager to bring it forward. Support
               for this enables these commands:
               "windowactivate", "getactivewindow".

           _NET_WM_PID
               This feature is application
               dependent, not window-manager
               dependent. Query the PID owning a
               given window. Support for this
               enables these commands:
               "getwindowpid".

    SUPPORTED FEATURES
           xdotool (and libxdo) will try to function
           under all circumstances. However, there
           may be some cases where functionality is
           not provided by your X server or by your
           window manager. In these cases, xdotool
           will try to detect and tell you if an
           action requires a feature not currently
           supported by your system.

           For window-manager specific features, see
           "EXTENDED WINDOW MANAGER HINTS".

           XTEST
               If your X server does not support
               XTEST, then some typing and mouse
               movement features may not work.
               Specifically, typing and mouse
               actions that act on the "current
               window" (window 0 in libxdo) are
               unlikely to work.

               In most cases, XTEST is a feature you
               can enable on your X server if it is
               not enabled by default.

               You can see the list of supported X
               extensions by typing 'xdpyinfo' and
               looking the text 'number of
               extensions: ...'

    BUGS
           Typing unusual symbols under non-us
           keybindings is known to occasionally send
           the wrong character.

    SEE ALSO
           xprop(1), xwininfo(1),

           Project site:
           <http://www.semicomplete.com/projects/xdotool>

           Google Code:
           <http://semicomplete.googlecode.com/>

           EWMH specification:
           <http://standards.freedesktop.org/wm-spec/wm-spec-1.3.html>

    CONTACT
           Please send questions to
           xdotool-users@googlegroups.com. File bugs
           and feature requests at the following
           URL:

           <http://code.google.com/p/semicomplete/issues/list>

           Alternately, if you prefer email, feel
           free to file bugs by emailing the list.
           What works for you :)

    AUTHOR
           xdotool was written by Jordan Sissel.

           This manual page was written originally
           by Daniel Kahn Gillmor
           <dkg@fifthhorseman.net> for the Debian
           project (but may be used by others). It
           is maintained by Jordan Sissel.

           Patches, ideas, and other contributions
           by many, nice folks. See the CHANGELIST
           file for who provided what.



                       2013-01-10         XDOTOOL(1)

    还需要再琢磨琢磨。。。。,不会用

  • 相关阅读:
    动漫评书
    Mycat高可用解决方案二(主从复制)
    Mycat高可用解决方案一(mysql安装)
    基于开源博客系统(mblog)搭建网站
    七、Docker启动tocmat 8
    Kotlin开发springboot项目(三)
    Kotlin开发springboot项目(二)
    Kotlin开发springboot项目(一)
    mybatis总结
    VUE学习总结
  • 原文地址:https://www.cnblogs.com/gaocan/p/5386644.html
Copyright © 2020-2023  润新知