Atalho no Windows 7 para alternar entre as janelas do mesmo aplicativo, como Cmd + `no OS X

Existe um atalho no Windows 7 para alternar entre janelas em um determinado aplicativo? Eu gosto muito desse recurso no OS X; qual é o seu equivalente no Windows?

Se for um dos dez primeiros aplicativos na barra de tarefas, (Win)+ n, onde n é o número da sua posição, irá selecioná-lo e percorrer as janelas. (Use 0(zero) para o décimo aplicativo.) Por exemplo, eu tenho o Windows Explorer e o Internet Explorer fixados como as duas primeiras coisas na minha barra de tarefas, para que eu possa usar + 1para percorrer meus diretórios e + 2para percorrer meus navegadores.

Algumas notas estranhas:

• Se você pressionar e segurar e tipo (e solte) um dígito n, o Windows irá abrir o  n º aplicativo na barra de tarefas. Tocar repetidamente n percorrerá as janelas desse programa, conforme discutido acima. Conforme  declarado pelo TranslucentCloud , se você digitar Shift+ n, ele passará por eles na ordem inversa, como Alt+ Tab e  Ctrl+ Tab, etc.

  Se o n º aplicativo na barra de tarefas é preso, mas não em execução, em seguida, + nvai iniciá-lo. 

• Mas, se você pressionar e segurar eShift, desde o início, e digitarn, o Windows iniciará uma nova instância (ou pelo menos uma nova janela) desse aplicativo, mesmo se ele já estiver em execução.   (Isso falhará em alguns aplicativos, como o Windows Media Player, que não permitem a execução de várias janelas simultaneamente.)
• + nparece não funcionar com o teclado numérico.

No Windows 7 e 8, embora não exista nenhum atalho disponível apenas no teclado, você pode segurar Ctrlenquanto clica no ícone da barra de tarefas do aplicativo em que está interessado. Cada vez que você fizer isso, uma janela diferente pertencente a esse aplicativo será exibida. venha para a frente.

Além disso, o programa VistaSwitcher configura Win+ F11e Alt+ `para alternar entre as janelas do aplicativo atual. (BTW, seu site diz que o Windows 8 não é suportado, mas tive sorte com o 8.1); o único problema que vi até agora é que às vezes lista coisas como a barra lateral de pesquisa como janelas abertas. Eu simplesmente ignoro isso, mas YMMV.)

Você pode usar o AutoHotkey: www.autohotkey.com

E coloque esse script lá:

!`:: ; Next window
WinGetClass, ActiveClass, A
WinGet, WinClassCount, Count, ahk_class %ActiveClass%
IF WinClassCount = 1
    Return
Else
WinGet, List, List, % "ahk_class " ActiveClass
Loop, % List
{
    index := List - A_Index + 1
    WinGet, State, MinMax, % "ahk_id " List%index%
    if (State <> -1)
    {
        WinID := List%index%
        break
    }
}
WinActivate, % "ahk_id " WinID
return

!^`:: ; Last window
WinGetClass, ActiveClass, A
WinGet, WinClassCount, Count, ahk_class %ActiveClass%
IF WinClassCount = 1
    Return
Else
WinGet, List, List, % "ahk_class " ActiveClass
Loop, % List
{
    index := List - A_Index + 1
    WinGet, State, MinMax, % "ahk_id " List%index%
    if (State <> -1)
    {
        WinID := List%index%
        break
    }
}
WinActivate, % "ahk_id " WinID
return

Funciona muito bem para mim. Usando a Autohotkey, também fiz minhas teclas de copiar / colar / desfazer ... como o Mac. Funciona bem!

Eras

Obrigado, Erasmose, mas sua versão do script autohotkey minimizará uma janela se não houver outras janelas desse tipo. Às vezes você não sabe, e minimizar é uma maneira irritante de descobrir, então modifiquei seu script da seguinte maneira:

!`::    ; Next window
WinGetClass, ActiveClass, A
WinGet, WinClassCount, Count, ahk_class %ActiveClass%
IF WinClassCount = 1
    Return
Else
WinSet, Bottom,, A
WinActivate, ahk_class %ActiveClass%
return

!+`::    ; Last window
WinGetClass, ActiveClass, A
WinActivateBottom, ahk_class %ActiveClass%
return

ah, e também mudei a última classe para usar shift em vez de ctrl, já que eu sou o modificador para retroceder com vários outros atalhos de teclado. Eu amo a chave automática.

Alguns aplicativos que implementam o MDI fornecem Ctrl + Tab para alternar entre "Documentos" na mesma instância do aplicativo. por exemplo, MS Office. Mas esse não é um recurso do Windows e depende do aplicativo. Para outros softwares, existem diferentes atalhos. por exemplo, o Firefox não fornece esse recurso, mas há um complemento que adiciona a funcionalidade.

Além disso, aqui está uma lista de atalhos de teclado fornecidos no Windows.

Além disso, existem discussões sobre atalhos de teclado no Windows.

Espero que ajude.

O Easy Windows Switcher da Neosmart faz exatamente o que você procura.

Aqui está a descrição do site Easy Windows Switcher

O Easy Window Switcher facilita a alternância entre janelas diferentes alt+`( como alt + backtick) como em um Mac. Esqueça a necessidade de ter alt+tabentre um milhão e um de janelas abertas diferentes para encontrar a que você está procurando, com o Easy Window Switcher, separar as janelas do mesmo programa é apenas uma alt+`distância.

O VistaSwitcher permite ou para esse recurso. É compatível com o Windows 10 (embora o nome sugira o contrário). No Windows 8 ou superior, sugiro adicionar certos aplicativos de metrô à lista de exclusões.

A resposta principal é boa, mas não funciona nas configurações de vários monitores, nas quais a barra de tarefas está configurada para mostrar apenas ícones no monitor ativo.

Além do que Scott ( https://superuser.com/users/150988/scott ) compartilhou:

ctrl+ repeatedly click sobre o ícone do aplicativo na barra de tarefas também fará o trabalho.

Com o AutoHotkey também, um comportamento mais natural:

; Switch between windows of the same application with Alt+(key above Tab)
; Icon: made by Freepik (www.freepik.com), licence CC 3.0 BY
;       from https://www.flaticon.com/free-icon/switch-window_71630
; Script Licence: CC0 (Public Domain)
; Source: https://framagit.org/dr4Ke/AutoHotkey_scripts

KeyName := GetKeyName("sc029")
Menu, Tray, Tip, Switch between windows of the same applications with 'Alt+%KeyName%'

*!SC029::
WinGetClass, ActiveClass, A
WinGet, WinClassCount, Count, ahk_class %ActiveClass%
If WinClassCount = 1
    Return
WinGet, List, List, % "ahk_class " ActiveClass

index := 0
if not GetKeyState("Shift") {
    index := 1
}
;MsgBox, Entering Loop
While GetKeyState("Alt") {
    If GetKeyState("Shift") {
        index := Mod(List + index - 2, List) + 1
    } else {
        index := Mod(List + index, List) + 1
    }
    WinGet, State, MinMax, % "ahk_id " List%index%
    if (State == -1)
    {
        continue
    }
    WinID := List%index%
    WinActivate, % "ahk_id " WinID
    ErrorLevel := 1
    sleep 50
    While (ErrorLevel != 0) and GetKeyState("Alt") {
        KeyWait, sc029, DT1
    }
}
return

Criei um script do AutoHotkey para alternar entre as janelas do mesmo aplicativo que funcionam com aplicativos comuns do Windows , atalhos do Chrome e aplicativos do Chrome .

https://github.com/JuanmaMenendez/AutoHotkey-script-Open-Show-Apps/blob/master/AutoHotkey-script-Switch-Windows-same-App.ahk

Extra

Nesse repositório do Github, há outro script do AutoHotkey que pode funcionar bem em conjunto com este, porque você poderá abrir, restaurar ou minimizar seus aplicativos usando as teclas de atalho que deseja.

Exemplo:

• F7:: OpenOrShowAppBasedOnExeName("C:\Windows\System32\SnippingTool.exe")
• F8:: OpenOrShowAppBasedOnWindowTitle("Gmail", "C:\Program Files (x86)\Google\Chrome\Application\chrome.exe --app=https://mail.google.com/mail/")

Criei um script AutoHotkey que se integra perfeitamente ao Windows Task Switcher ( Alt+ Tab), fornecendo todos os seus benefícios: visualizações de janelas de aplicativos, clique para selecionar, navegação pelas teclas de seta, apenas ative a única janela que você deseja. Invoque / navegue com Alt+ `e Alt+ Shift+ `(backtick) para alternar entre janelas com o mesmo nome de processo que a janela atual. Acho isso mais útil do que Win+ num, pois funciona para qualquer aplicativo (em vez de ter que lembrar o número do slot fixado), as visualizações da janela são maiores, o fundo não fica desfocado e combina perfeitamente com o Alt+ Tabnavigation. Testado no Windows 10.

O truque principal é ocultar temporariamente janelas de aplicativos não-alvo do Alternador de tarefas, definindo WS_EX_TOOLWINDOWe desmarcando WS_EX_APPWINDOW. Para definir esses estilos de janelas em janelas executando como administrador, o AutoHotkey precisa ser assinado ou executado como administrador . Eu segui as instruções de assinatura muito fáceis aqui .

Alguns tópicos relacionados que contribuíram:

• https://stackoverflow.com/questions/35971452/what-is-the-right-way-to-send-alt-tab-in-ahk
• https://autohotkey.com/board/topic/21657-alttab-window-list-get-a-list-of-alt-tab-windows/

!`::
{
   WS_EX_TOOLWINDOW = 0x80
   WS_EX_APPWINDOW = 0x40000
   tw := []
   aw := []

   WinGet, processName, ProcessName, A

   DetectHiddenWindows, Off
   AltTab_window_list(1)

   Loop, %AltTab_ID_List_0%
   {
      wid := AltTab_ID_List_%A_Index%
      WinGet, processName2, ProcessName, ahk_id %wid%

      if (processName2 != processName)
      {
         WinGet, exStyle2, ExStyle, ahk_id %wid%

         if (!(exStyle2 & WS_EX_TOOLWINDOW))
         {
            tw.InsertAt(0, wid)
            WinSet, ExStyle, ^0x80, ahk_id %wid%
         }

         if ((exStyle2 & WS_EX_APPWINDOW))
         {
            aw.InsertAt(0, wid)
            WinSet, ExStyle, ^0x40000, ahk_id %wid%
         }
      }
   }

   Send {Alt Down}{Tab} ; Bring up switcher immediately

   KeyWait, ``, T.25  ; Go to next window; wait .25s before looping
   if (Errorlevel == 0)
   {
      While ( GetKeyState( "Alt","P" ) )
      {
         KeyWait, ``, D T.25
         if (Errorlevel == 0)
         {
            if (GetKeyState( "Shift","P" ))
            {
               Send {Alt Down}{Shift Down}{Tab}
               Sleep, 200
            }
            else
            {
               Send {Alt Down}{Tab}
               Sleep, 200
            }
         }
      }
   }

   Send {Alt Up} ; Close switcher on hotkey release

   for index, wid in tw
   {
      WinSet, ExStyle, ^0x80, ahk_id %wid%
   }

   for index, wid in aw
   {
      WinSet, ExStyle, ^0x40000, ahk_id %wid%
   }
}
return

AltTab_window_list(excludeToolWindows)
{
   global
   WS_EX_CONTROLPARENT =0x10000
   WS_EX_APPWINDOW =0x40000
   WS_EX_TOOLWINDOW =0x80
   WS_DISABLED =0x8000000
   WS_POPUP =0x80000000
   AltTab_ID_List_ =0
   WinGet, Window_List, List,,, Program Manager ; Gather a list of running programs
   id_list =
   Loop, %Window_List%
   {
      wid := Window_List%A_Index%
      WinGetTitle, wid_Title, ahk_id %wid%
      WinGet, Style, Style, ahk_id %wid%

      If ((Style & WS_DISABLED) or ! (wid_Title)) ; skip unimportant windows
         Continue

      WinGet, es, ExStyle, ahk_id %wid%
      Parent := Decimal_to_Hex( DllCall( "GetParent", "uint", wid ) )
      WinGetClass, Win_Class, ahk_id %wid%
      WinGet, Style_parent, Style, ahk_id %Parent%

      If ((excludeToolWindows & (es & WS_EX_TOOLWINDOW))
         or ((es & ws_ex_controlparent) and ! (Style & WS_POPUP) and !(Win_Class ="#32770") and ! (es & WS_EX_APPWINDOW)) ; pspad child window excluded
         or ((Style & WS_POPUP) and (Parent) and ((Style_parent & WS_DISABLED) =0))) ; notepad find window excluded ; note - some windows result in blank value so must test for zero instead of using NOT operator!
         continue
      AltTab_ID_List_ ++
      AltTab_ID_List_%AltTab_ID_List_% :=wid
   }  
   AltTab_ID_List_0 := AltTab_ID_List_
}

Usando a Autohotkey, aqui está minha versão, que funciona com aplicativos Chrome e Electron. Foi modificado a partir da resposta de @ user332861 , de modo a distinguir corretamente os aplicativos Chrome e Electron, como Slack e Visual Studio Code. (Para fazer isso, ele usa em ahk_exevez de ahk_class)

!`::    ; Next window if using alt-backtick
    WinGet, ExeName, ProcessName , A
    WinGet, ExeCount, Count, ahk_exe %ExeName%
    If ExeCount = 1
        Return
    Else
        WinSet, Bottom,, A
        WinActivate, ahk_exe %ExeName%
return

!+`::    ; prev window, Alt+shift+backtick
    WinGet, ExeName, ProcessName , A
    WinActivateBottom, ahk_exe %ExeName%
return

!`::
#`::
WinGet, ExeName, ProcessName, A
WinActivateBottom, ahk_exe %ExeName%
return

Simplificado a partir da resposta de @ otter.pro. Isso simplesmente alterna entre as janelas atuais do aplicativo. Andar de bicicleta para a frente pode fazer aparecer breves flashes de outras janelas. Como não ver flashes é provavelmente mais importante que o ciclismo bidirecional, apenas não avance. Além disso, esta resposta permite # `como uma alternativa ao!`, Pois essa é a combinação de teclas para o atalho do Mac.