¿Puedo tener una ventana que muestre una pequeña vista previa en vivo de otro espacio de trabajo?

¿Es posible reflejar una sección activa de un espacio de trabajo para que sea visible en el espacio de trabajo actual como una ventana que se puede mover?

El otro día tuve una máquina virtual Windows 10 ejecutándose en mi host Ubuntu 16.04 que tardó mucho tiempo en completar la actualización. Seguí comprobando su progreso a través de Expo ( Super+ S) en Ubuntu. Eso me hizo pensar que este problema probablemente ya se haya resuelto ya que herramientas como el simple screenrecorder se pueden configurar para grabar solo una parte de la pantalla. Sin embargo, no sé la terminología adecuada para usar en mi búsqueda de Google.

Me gustaría ver la captura de pantalla de 300x150 a continuación en forma de una ventana flotante (con actualizaciones en vivo) en la esquina superior derecha de cualquier espacio de trabajo que esté actual.

EDITAR

(Nueva respuesta)

HECHO.
La respuesta a continuación ahora está disponible en forma pulida, como indicador, como ppa para Trusty, Xenial, Yakkety y Zesty:

sudo apt-add-repository ppa:vlijm/windowspy
sudo apt-get update
sudo apt-get install windowspy

El indicador Th (incluida la ventana de vista previa) ahora tiene poco jugo. Las opciones incluyen una ventana de configuración, configuración de tamaño / color del borde de la ventana, tamaño de la ventana.

Mientras tanto, me pareció útil vigilar la ventana de AU; ver si hay algún mensaje :)

ANTIGUA RESPUESTA

( primer segundo concepto aproximado)

Tener una representación minimizada de una ventana en otro espacio de trabajo

Para mi propia sorpresa (grande), se puede hacer de manera efectiva , ya sea con engaño y engaño; tener una representación actualizada de una ventana en otro espacio de trabajo. No apto para ver una película, definitivamente lo suficientemente bueno como para vigilar una ventana en otro lugar (ejemplo: la ventana de mi tarjeta de TV):

Cómo funciona en la práctica

1. Con la ventana al frente, presione una tecla de acceso directo:

   

   (la ventana se minimizará)

2. Vaya a otro espacio de trabajo, presione la tecla de acceso directo nuevamente, aparecerá una pequeña representación de la ventana, actualizada cada 4 segundos:

   

   La ventana siempre se muestra encima de otras ventanas. Tal como está, la ventana es de 300 px (ancho), pero se puede configurar en cualquier tamaño.

3. Para finalizar, presione (nuevamente) la tecla de acceso directo. La pequeña ventana se cerrará, se moverá a la ventana gráfica de la ventana original, que aparecerá de nuevo, sin minimizar.

Los guiones

1. El script de control

   #!/usr/bin/env python3
   import subprocess
   import os
   import sys
   import time
   
   # paths
   imagepath = os.path.join(os.environ["HOME"], ".showcase")
   wfile = os.path.join(imagepath, "currentwindow")
   vpfile = os.path.join(imagepath, "last_vp")
   # setup path
   if not os.path.exists(imagepath):
       os.mkdir(imagepath)
   
   def get(command):
       try:
           return subprocess.check_output(command).decode("utf-8").strip()
       except subprocess.CalledProcessError:
           pass
   
   def get_vp():
       open(vpfile, "wt").write(get(["wmctrl", "-d"]).split()[5])
   
   def run(command):
       subprocess.Popen(command)
   
   def convert_tohex(widxd):
       return widxd[:2]+((10-len(widxd))*"0")+widxd[2:]
   
   def check_windowtype(wid):
       check = get(["xprop", "-id", wid])
       return not any([s in check for s in [
           "_NET_WM_WINDOW_TYPE_DOCK",
           "_NET_WM_WINDOW_TYPE_DESKTOP"]])
   
   def edit_winprops(wid, convert=True):
       run(["xdotool", "windowminimize", wid])
       if convert:
           widxd = convert_tohex(hex(int(wid)))
       else:
           widxd = wid
       run(["wmctrl", "-i", "-r", widxd, "-b", "add,sticky"])
       get_vp()
       open(os.path.join(imagepath, "currentwindow"), "wt").write(widxd)
   
   def initiate_min():
       # if not, minmize window, write the file
       wid = get(["xdotool", "getactivewindow"])
       if check_windowtype(wid):
           edit_winprops(wid)
       else:
           pidinfo = [l.split() for l in wlist.splitlines()]
           match = [l for l in pidinfo if all([
               get(["ps", "-p", l[2], "-o", "comm="]) == "VirtualBox",
               not "Manager" in l])]
           if match:
               edit_winprops(match[0][0], convert=False)
   
   # windowlist
   wlist = get(["wmctrl", "-lp"])
   
   if "Window preview" in wlist:
       # kill the miniwindow
       pid = get(["pgrep", "-f", "showmin"])
       run(["kill", pid])
       window = open(wfile).read().strip()
       viewport = open(vpfile).read().strip()
       run(["wmctrl", "-o", viewport])
       time.sleep(0.3)
       run(["wmctrl", "-i", "-r", window, "-b", "remove,sticky"])
       run(["wmctrl", "-ia", window])
       os.remove(wfile)
   
   else:
       # check if windowfile exists
       wfileexists = os.path.exists(wfile)
       if wfileexists:
           # if file exists, try to run miniwindow
           window = open(wfile).read().strip()
           if window in wlist:
               # if the window exists, run!
               run(["showmin", window])
           else:
               # if not, minmize window, write the file
               initiate_min()
       else:
           # if not, minmize window, write the file
           initiate_min()

2. La ventana representatiom

   #!/usr/bin/env python3
   import gi
   gi.require_version('Gtk', '3.0')
   from gi.repository import Gtk, GObject
   from PIL import Image
   import os
   import subprocess
   import time
   from threading import Thread
   import sys
   
   wid = sys.argv[1]
   xsize = 300
   
   imagepath = os.path.join(os.environ["HOME"], ".showcase")
   if not os.path.exists(imagepath):
       os.mkdir(imagepath)
   img_in = os.path.join(imagepath, "image.png")
   resized = os.path.join(imagepath, "resized.png")
   
   def get_img():
       subprocess.Popen([
           "import", "-window", wid, "-resize", str(xsize),  resized
           ])
   
   get_img()
   
   class Splash(Gtk.Window):
   
       def __init__(self):
           Gtk.Window.__init__(self, title="Window preview")
           maingrid = Gtk.Grid()
           self.add(maingrid)
           self.image = Gtk.Image()
           # set the path to the image below
           self.resized = resized
           self.image.set_from_file(self.resized)
           maingrid.attach(self.image, 0, 0, 1, 1)
           maingrid.set_border_width(3)
           self.update = Thread(target=self.update_preview)
           self.update.setDaemon(True)
           self.update.start()
   
       def update_preview(self):
           while True:
               get_img()
               time.sleep(3)
               GObject.idle_add(
                   self.image.set_from_file, self.resized,
                   priority=GObject.PRIORITY_DEFAULT
                   )
   
   def miniwindow():
       window = Splash()
       window.set_decorated(False)
       window.set_resizable(False)
       window.set_keep_above(True)
       window.set_wmclass("ShowCase", "showcase")
       window.connect("destroy", Gtk.main_quit)
       GObject.threads_init()
       window.show_all()
       window.move(70, 50)
       Gtk.main()
   
   miniwindow()

Cómo utilizar

1. Instalar python3-pil, xdotoolywmctrl

   sudo apt-get install xdotool wmctrl python3-pil
   

2. Cree, si aún no existe, el directorio ~/bin.

3. Copie la secuencia de comandos 1, controle la secuencia de comandos, como (exactamente) showcase_control(sin extensión) ~/bin, y hágalo ejecutable .
4. Copie el script 2, el script de mini ventana, como (exactamente) showmin(sin extensión) en ~/bin, y hágalo ejecutable .

5. Cierre sesión y vuelva a iniciarla, y agregue el siguiente comando al acceso directo que elija:

   showcase_control
   

   Elija: Configuración del sistema> "Teclado"> "Atajos"> "Atajos personalizados". Haga clic en "+" y agregue el comando:

   showcase_control
   

   y debería funcionar!

   • Presione la tecla una vez para tomar la ventana actual
   • muévase al otro espacio de trabajo donde desea la mini ventana
   • Presione nuevamente para mostrar la mini ventana
   • Presione nuevamente para regresar al espacio de trabajo original, (automáticamente) minimice la ventana original y cierre el mini-uno.

Desventajas?

• La configuración, como es actualmente, agrega algo de trabajo para su procesador. Sin embargo, en mi sistema (muy) antiguo, agrega (en promedio) appr. 4-5%, creo, que no noté de ninguna manera.

  Actualización: Resulta que importpuede cambiar el tamaño de la imagen en un solo paso, junto con la obtención de la imagen de la ventana. Esto significa una reducción sustancial en la carga del procesador. Al mismo tiempo, el tiempo de actualización es más corto (3 segundos ahora), aún a "costos" más bajos.

Explicación

• Mi punto de partida fue la forma en que OP mencionó que quería usar la opción para vigilar una ventana en otro espacio de trabajo, esperando que algo terminara.
• Mientras que , literalmente, tener una exacta (mini) copia de una ventana en otro espacio de trabajo parece imposible, nos podemos hacer una imagen de una ventana existente con el import-command, una vez que tenemos la ventana Identificación. Si bien esto funciona en ventanas minimizadas o ventanas sin foco, sin embargo, hay un problema: la ventana debe estar en el espacio de trabajo actual .
• El truco es entonces temporalmente (mientras se usa la mini ventana) hacer que la ventana sea "pegajosa" (estar prácticamente disponible en todos los espacios de trabajo) con wmctrl, pero minimizada al mismo tiempo.
• Dado que todo se hace automáticamente, la diferencia efectivamente es nula, ya que al volver a la ventana de visualización inicial, "despegar" la ventana original y minimizarla, se hace automáticamente.

En breve:

1. Al presionar el acceso directo una vez: la ventana objetivo se vuelve pegajosa, pero minimizada
2. Presionándolo nuevamente (presumiblemente en otro espacio de trabajo): aparece una pequeña mini versión de la ventana en la esquina superior izquierda, actualizada una vez cada cuatro segundos.
3. Al presionarlo nuevamente: la mini ventana está cerrada, el escritorio se mueve al espacio de trabajo inicial de la ventana, la ventana se restaura sin pegar y minimizada.

Específicamente para VirtualBox

Cuando la ventana VBox está al frente, resulta que las teclas de acceso directo de Ubuntu están deshabilitadas (!), Por lo que el script de control debe iniciarse de otra manera. A continuación algunos breves.

Opción 1

Edité el script de control. Ahora solo en el caso de VirtualBox:

• Haga clic en cualquier lugar del escritorio, luego presione la tecla de acceso directo. Después de eso, simplemente use la tecla de acceso directo para mostrar la ventana y salir.

  Explicación: La secuencia de comandos de control se hizo para salir si la ventana era del tipo "escritorio", ya que no querría minimizar el escritorio. Ahora el script primero busca posibles ventanas de VirtualBox existentes, para apuntar, si la ventana actualmente activa es el escritorio.

opcion 2

• Copie el icono a continuación (haga clic con el botón derecho -> guardar como), guárdelo como minwinicon.png

  

• Copie las líneas a continuación en un archivo vacío, guárdelo como minwin.desktopen ~/.local/share/applications:

  [Desktop Entry]
  Type=Application
  Name=Window Spy
  Exec=showcase_control 
  Icon=/path/to/minwinicon.png
  StartupNotify=false
  

  ¡Debería cerrar sesión y volver a iniciarla para que el iniciador "encuentre" la ~/binruta local !
  Arrastre el icono al iniciador para usarlo.

La segunda solución tiene una desventaja importante: después de usarla desde el iniciador, seguirá parpadeando durante unos segundos, esperando que aparezca una ventana. Durante eso, hacer clic nuevamente no tendrá ningún efecto. Eso se puede resolver, como se describe aquí , pero incluir eso en esta respuesta realmente lo haría demasiado largo. Si desea utilizar la opción dos, consulte el enlace.

Algo que parece excesivo pero que funciona totalmente para este propósito es Open Broadcaster . En el cuadro de lista "Fuentes", haga clic en el signo más, seleccione "Captura de ventana", luego siga las indicaciones para seleccionar la ventana que le interesa. No tiene sentido presionar el registro; solo usa la vista previa. Está disponible para casi cualquier sistema operativo , con instrucciones para Ubuntu aquí , que he copiado a continuación.

sudo apt-get install ffmpeg
sudo add-apt-repository ppa:obsproject/obs-studio
sudo apt-get update
sudo apt-get install obs-studio

Si lo desea, puede ir al menú "Ver" y ocultar todos los elementos de la interfaz de usuario.