# [X11] Zoom à l'aide d'une commande (résolu)

## LostControl

Salut,

Je viens d'acquérir un Thinkpad X32. La combinaison de touches <Fn>+<Space> permet de zoomer sous Windaube. J'aimerais obtenir le même effet sous X11. Très simple, il s'agit de la combinaison de touche bien connue <Ctrl>+<Alt>+<->/<+>.

Mais existe-t'il un moyen de faire la même chose en ligne de commande ?

Il y a xrandr mais celui-ci change aussi la résolution du bureau ce que je ne souhaite pas  :Confused:  Je désire le même comportement que <Ctrl>+<Alt>+<->/<+>.

Merci

----------

## geekounet

Heu, Ctrl-Alt-+/- change la résolution aussi il me semble.

----------

## bosozoku

Je dois dire que ça m'interesse beaucoup ! En fait je recherche plutot quelque chose qui me permette de zoomer sur une fenêtre en particulier mais sans l'effet de rechargement de X. Quelque chose de fluide. Ça existe au moins ?

----------

## truc

j'vais sans doute dire un truc qui n'a rienà voir mais

```
xmag
```

Peut servir apparement à zoomer sur une zone de l'écran, mais autant vous l'avouer tout de suite, je ne sais pas vraiment m'en servir.. j'ia juste vue que...

----------

## bosozoku

Oué je sais m'en servir et c'est pas exactement ce que je veux, mais je te remercie quand même  :Wink: 

----------

## LostControl

Salut,

Merci pour les réponses. Mais xmag ne correspond pas à ce que je souhaite faire.

Personne n'a d'autres idées ?

A+

----------

## geekounet

Je ne sais pas si c'est ce que vous voulez, mais si c'est juste pour zoomer sans besoin d'interaction avec la fenêtre, simplement faire un screenshot de la fenêtre et l'afficher en plein écran avec un zoom ajusté à l'écran.

----------

## TGL

Je garantis rien du tout, mais un truc dans ce genre là pourrait marcher : 

```
#include <X11/extensions/XTest.h>

#include <X11/keysym.h>

int main() {

   Display* disp = XOpenDisplay(NULL);

   if (disp == NULL) return 1;

   // press Ctrl+Alt+Keypad-Add

   XTestFakeKeyEvent(disp,

      XKeysymToKeycode(disp, XK_Control_L),

      True, CurrentTime);

   XTestFakeKeyEvent(disp,

      XKeysymToKeycode(disp, XK_Alt_L),

      True, CurrentTime);

   XTestFakeKeyEvent(disp,

      XKeysymToKeycode(disp, XK_KP_Add),

      True, CurrentTime);

   // release it

   XTestFakeKeyEvent(disp,

      XKeysymToKeycode(disp, XK_KP_Add),

      False, CurrentTime);

   XTestFakeKeyEvent(disp,

      XKeysymToKeycode(disp, XK_Alt_L),

      False, CurrentTime);

   XTestFakeKeyEvent(disp,

      XKeysymToKeycode(disp, XK_Control_L),

      False, CurrentTime);

   XCloseDisplay(disp);

   return 0;

}
```

 À enregistrer en tant que xzoom.c (par exemple), puis à compiler avec : 

```
# gcc -o xzoom xzoom.c -lX11 -lXtst
```

 Perso je peux pas tester parceque de toute façon ici le Ctrl+Alt+Plus ne marche pas (mauvaise config ou je ne sais quoi, mais bref mon X il veut pas zoomer), mais j'ai essayé avec un BackSpace à la place du KP_Add, et ça tue le serveur bien comme il faut, donc bref je suppose que c'est une bonne méthode...

Idée originale pompée ici (numlockx).

----------

## LostControl

Voilà  :Very Happy: 

Merci ça marche nickel ! C'est exactement ce que je cherchais  :Cool:  Voici une version améliorée.

```
#include <stdio.h>

#include <string.h>

#include <X11/extensions/XTest.h>

#include <X11/keysym.h>

#define NBR_KEYS 3

void executeKeys(Display *disp, unsigned int *keys, int length) {

   int i;

   /* press */

   for (i=0; i<length; i++) {

      XTestFakeKeyEvent(disp, XKeysymToKeycode(disp, keys[i]), True,

                  CurrentTime);

   }

   /* release */

   for (i=length-1; i>=0; i--) {

      XTestFakeKeyEvent(disp, XKeysymToKeycode(disp, keys[i]), False,

                  CurrentTime);

   }

}

int main(int argc, char **argv) {

   Display* disp = XOpenDisplay(NULL);

   unsigned int zoom_in[NBR_KEYS] = {XK_Control_L, XK_Alt_L, XK_KP_Add};

   unsigned int zoom_out[NBR_KEYS] = {XK_Control_L, XK_Alt_L, XK_KP_Subtract};

   if (disp == NULL) return 1;

   if (argc != 2) {

      printf("Please specify a parameter: in|out\n");

      return 1;

   }

   if (strcmp(argv[1], "in") == 0) {

      executeKeys(disp, zoom_in, NBR_KEYS);

   } else if (strcmp(argv[1], "out") == 0) {

      executeKeys(disp, zoom_out, NBR_KEYS);

   } else {

      printf("Unknown parameter. Please specify a parameter: in|out\n");

   }

   XCloseDisplay(disp);

   return 0;

}
```

A utiliser avec "xzoom in" ou "xzoom out".

Encore merci et A+

----------

## TGL

 *LostControl wrote:*   

> Voici une version améliorée.
> 
> ...
> 
> A utiliser avec "xzoom in" ou "xzoom out".

 

Bien vu  :Wink: 

Bon bah sinon, pour la petite histoire : perso là j'étais en train de bidouiller en Python avec le module Xlib (dev-python/python-xlib) pour faire un programme qui pourrait générer n'importe quelle séquence d'évennements clavier (et donc pour pouvoir faire "xkeystroke Control_L+Alt_L+KP_Add" dans le cas qui nous intéresse ici). L'extension XTest étant en principe supportée par ce module, ça aurait dû être simple, sauf que voilà, ça marchait pas, pour une raison qui m'échappe encore... Donc je Google pour choper un peu plus de doc, et dans le tas je tombe là dessus : 

http://hoopajoo.net/projects/xautomation.html

Erf... et en plus il est dans portage (x11-misc/xautomation). Une fois la bête installée, on doit pouvoir zoomer comme ça : 

```
% xte 'keydown Control_L' 'keydown Alt_L' 'key KP_Add' 'keyup Alt_L' 'keyup Control_L' 
```

 ..ou encore faire un script de ce genre là : 

```
#!/bin/bash

prog=$(basename "${0}")

xte=$(which xte 2>/dev/null)

if [[ -z "${xte}" ]] ; then

    echo "This scripts requires \"xte\" from \"x11-misc/xautomation\"" >&2

    exit 1

fi

mod_down[0]="keydown Control_L"

mod_down[1]="keydown Alt_L"

in[0]="key KP_Add"

out[0]="key KP_Substract"

mod_up[0]="keyup Control_L"

mod_up[1]="keyup Alt_L"

if [[ "${1}" == "in" || "${1}" == "out" ]]; then

    eval ${xte} \"\${mod_down[@]}\" \"\${${1}[@]}\" \"\${mod_up[@]}\"

else

    echo "Usage: ${prog} <in|out>" >&2

    exit 2

fi
```

Bref, on a un peu réinventé la roue, mais c'est pas grave, on aura appris qlqs trucs...

----------

## TGL

 *TGL wrote:*   

> ça aurait dû être simple, sauf que voilà, ça marchait pas, pour une raison qui m'échappe encore...

 

Erf... un match de foot plus tard (0/0, c'était chiant, on ne m'y reprendra plus), je remets le nez dedans et je vois que j'avais oublié d'envoyer mes évenements (Display.sync()). Donc voilà, maintenant c'est toujours du vite-fait-crado, mais au moins ça marche :

```
#!/usr/bin/python

import sys

from Xlib import display, X, XK

def keystroke(sequence):

    global disp, valid_keys

    down_keycodes = []

    for key in sequence.split('+'):

        if key in valid_keys:

            keycode = disp.keysym_to_keycode(XK.string_to_keysym(key))

            disp.xtest_fake_input(X.KeyPress, keycode)

            down_keycodes.append(keycode)

        else: print >>sys.stderr, "%s: invalid key name" % key

    while down_keycodes:

        keycode = down_keycodes.pop()

        disp.xtest_fake_input(X.KeyRelease, keycode)

valid_keys = {}

for name in dir(XK):

    if name[:3] == 'XK_':

        valid_keys[name[3:]] = None

disp = display.Display()

for sequence in sys.argv[1:]:

    keystroke(sequence)

    disp.sync()
```

 Et ça s'utilise comme ça : 

```
% ./xkeystroke Shift_L+a b Shift_L+c

AbC
```

 ou encore pour faire un zoom-in : 

```
% ./xkeystroke Control_L+Alt_L+KP_Add
```

On en est quand même à 3 solutions, ça mérite un petit (résolu) ça, non ?  :Smile: 

----------

## TGL

J'ai résumé ce topic dans une petite doc sur le subforum tout nouveau tout beau, parceque j'avais trouvé ça intéressant...

-- 

NDM : modification du lien qui ne pointait pas sur le bon thread.

-- yoyo

----------

