Algum gerenciador de janelas me permite encaixar janelas nas laterais da tela?

Você pode recomendar um Gerenciador de Janelas para Mac? Gostaria de ter um atalho de teclado que encaixe uma janela na metade esquerda ou direita da minha tela.

SizeUp é exatamente o que você precisa:

O SizeUp permite que você posicione rapidamente uma janela para preencher exatamente metade da tela (tela dividida), um quarto da tela (quadrante), tela cheia ou centralizada através da barra de menus ou atalhos configuráveis ​​em todo o sistema (teclas de atalho). Semelhante à funcionalidade "janelas lado a lado" disponível em outros sistemas operacionais.

Dividir

Divvy é um pequeno aplicativo da barra de menus que permite redimensionar automaticamente qualquer janela ativa. Divviy virtualmente divide sua tela em uma grade 6x6. Quando invocado, o Divvy exibe um pouco de HUD no meio da tela com essa grade 6x6. Dependendo da parte da tela que você deseja redimensionar sua janela ativa, basta arrastar e selecionar os quadrados no HUD e a janela fará o resto. É simples assim.

Após testar o SizeUp e o Breeze, decidi que o Breeze atende às minhas necessidades da melhor maneira. Ambos permitem que você posicione as janelas à esquerda, direita ou Tela cheia. O recurso que o vendeu para mim foi definir um tamanho e posição padrão para um aplicativo e atribuir uma tecla de atalho.

ShiftIt (versão original no link descontinuado) faz isso e é gratuito e de código aberto.

Edit: O projeto está agora no GitHub , no entanto, a última versão foi em novembro de 2010.

Moom

Ouvi algumas pessoas falarem sobre isso também:

Você gasta muito tempo movendo e ampliando janelas, para poder ver e trabalhar melhor com todo o conteúdo do seu Mac? Em vez de fazer esse trabalho você mesmo, deixe o Moom cuidar da tarefa para você.

Se você possui um mouse mágico ou um trackpad mágico, o BetterTouchTool é melhor, pois você pode definir gestos específicos para gerenciar as janelas. Como um toque de quatro dedos para a esquerda, você pode redimensionar a janela para a esquerda, 50% da tela.

Moom é ótimo. Você pode encaixar as janelas em: tela cheia, meia tela, quarto de tela. Você também pode redimensionar com uma grade. Também suporta atalhos de teclado personalizados.

Eu pessoalmente uso SizeUp e Divvy diariamente. Se eu soubesse do ShiftIt antes, provavelmente não teria pago pelo SizeUp. Outro item que ainda não foi mencionado é o BetterTouchTool , que possui muitos outros recursos, mas oculto nas opções avançadas, há um recurso interessante chamado "Snap à janela", que encaixa a janela à esquerda ou direita do tela quando você a arrasta para o lado. Não possui a funcionalidade de atalho de teclado incluída, mas é um bom complemento para SizeUp e Divvy.

Encontrei aqui uma questão fora do tópico no Stack Overflow :

Havia dois gerenciadores de código aberto mencionados lá que não apareciam nessa lista:

• Espetáculo -> http://spectacleapp.com/
• Slate -> https://github.com/jigish/slate (a instalação requer trabalho na linha de comando)

Outro da App Store

• Slicer -> https://itunes.apple.com/us/app/slicer/id487999732?mt=12

Você também pode experimentar o Slate, que é gratuito e de código aberto.

Você também pode ler este artigo sobre isso.

Aqui está um Applescript que agrupará todas as janelas abertas no aplicativo mais à frente. Adicione ~/Library/Scriptse ligue no menu Applescript na barra de menus. Adicione sal a gosto (e grátis).

--tile windows of frontmost applications in a grid
--this script is useful for
--multiple window chatting
--working side by side of several windows of the same app

--make need to make it as a stay open application later
--for now assume that it is opened and closed per invokation

property horizontalSpacing : 10 -- sets the horizontal spacing between windows
property verticalSpacing : 10 -- sets the vertical spacing between windows
property maxRows : 2
property maxCols : 2

on run {}
    local a
    set userscreen to my getUserScreen()

    --display dialog (getFrntApp() as string)
    try
        set applist to getFrntApp()
        if length of applist = 0 then
            return
        end if
        set a to item 1 of getFrntApp()
    on error the error_message number the error_number
        display dialog "Error: " & the error_number & ". " & the error_message buttons {"OK"} default button 1
    end try

    try
        tileScriptable(a, userscreen)
    on error the error_message number the error_number
        --display dialog "Error: " & the error_number & ". " & the error_message buttons {"OK"} default button 1
        try
            tileUnscriptable(a, userscreen)
        on error the error_message number the error_number
            display dialog "Error: " & the error_number & ". " & the error_message buttons {"OK"} default button 1
        end try
    end try

end run

on tileScriptable(a, screen)
    local i, c
    set i to 1
    tell application named a
        set theWindows to every window of application a whose visible is true and floating is false and ¬
            modal is false -- and miniaturized is false
        set c to count theWindows
        if c = 0 then
            return
        end if
        set tiles to calTileBounds(c, screen, 1)
        repeat with theWindow in theWindows
            my tileScriptableWindow(a, theWindow, item i of tiles)
            set i to i + 1
        end repeat
    end tell
end tileScriptable

on tileUnscriptable(a, screeninfo)
    -- unscriptable app
    local i, c
    set i to 1
    tell application "System Events"
        set theWindows to (every window of application process a)
        --set theWindows to my filterUnscriptableInvisible(theWindows)

        set c to count theWindows

        if c = 0 then
            return
        end if

        --display dialog screeninfo as string giving up after 5
        set tiles to my calTileBounds(c, screeninfo, 1)
        repeat with theWindow in theWindows
            --display dialog (class of visible of theWindow)
            my tileUnScriptableWindow(a, theWindow, item i of tiles)
            set i to i + 1
        end repeat

    end tell
end tileUnscriptable

on filterUnscriptableInvisible(ws)
    -- filter out from ws windows that are docked    
    set newws to {}
    set docklist to getNamesDocked()
    --display dialog (docklist as string)
    repeat with theWindow in ws
        if name of theWindow is not in docklist then
            set end of newws to theWindow
        end if
    end repeat

    --display dialog (count newws)
    return newws
end filterUnscriptableInvisible

on getNamesDocked()
    tell application "System Events" to tell process "Dock"'s list 1
        set l to name of UI elements whose subrole is "AXMinimizedWindowDockItem"
    end tell

    return l
end getNamesDocked

on tileScriptableWindow(a, w, bound)
    tell application a
        set bounds of w to bound
    end tell
end tileScriptableWindow

on tileUnScriptableWindow(a, w, bound)
    tell application "System Events"
        --display dialog (count position of w)
        set AppleScript's text item delimiters to " "

        set position of w to {(item 1 of bound), (item 2 of bound)}

        -- why the -5?
        set size of w to {(item 3 of bound) - (item 1 of bound) - 5, ¬
            (item 4 of bound) - (item 2 of bound) - 5}
        --display dialog (count properties of w)
    end tell
end tileUnScriptableWindow

on calTileBounds(nWindows, screen, direction)
    -- return a list of lists of window bounds
    -- a simple tile algo that tiles along direction (current only 1=horizontal)

    local nrows, nColumns, irow, icolumn, nSpacingWidth, nSpacingHeight, nWindowWidth, nWindowHeight
    set {x0, y0, availScreenWidth, availScreenHeight} to screen
    set ret to {}

    set nrows to (nWindows div maxCols)
    if (nWindows mod maxCols) ≠ 0 then
        set nrows to nrows + 1
    end if

    if nrows < maxRows then
        set nSpacingHeight to (nrows - 1) * verticalSpacing
        set nWindowHeight to (availScreenHeight - nSpacingHeight) / nrows
    else
        set nSpacingHeight to (maxRows - 1) * verticalSpacing
        set nWindowHeight to (availScreenHeight - nSpacingHeight) / maxRows
    end if

    repeat with irow from 0 to nrows - 1
        if nrows ≤ maxRows and irow = nrows - 1 then
            set nColumns to nWindows - irow * maxCols
        else
            set nColumns to maxCols
        end if
        set nSpacingWidth to (nColumns - 1) * horizontalSpacing
        set nWindowWidth to (availScreenWidth - nSpacingWidth) / nColumns
        set nTop to y0 + (irow mod maxRows) * (verticalSpacing + nWindowHeight)
        --display dialog "Top: " & nTop buttons {"OK"} default button 1
        repeat with icolumn from 0 to nColumns - 1
            set nLeft to x0 + (icolumn) * (horizontalSpacing + nWindowWidth)
            set itile to {¬
                nLeft, ¬
                nTop, ¬
                nLeft + nWindowWidth, ¬
                nTop + nWindowHeight}
            set end of ret to itile
            --display dialog item 3 of itile as string
            --set itile to {x0 + (icolumn - 1) * wgrid, y0, wgrid, hgrid}
            --set item 3 of itile to ((item 1 of itile) + (item 3 of itile))
            --set item 4 of itile to ((item 2 of itile) + (item 4 of itile))
        end repeat
    end repeat

    return ret
end calTileBounds



on getFrntApp()
    tell application "System Events" to set frntProc to ¬
        name of every process whose frontmost is true and visible ≠ false
    return frntProc
end getFrntApp

on getUserScreen()
    -- size of the menubar
    tell application "System Events"
        set {menuBarWidth, menuBarHeight} to size of UI element 1 of application process "SystemUIServer"
        --display dialog "Menubar width: " & menubarWidth & ", height: " & menubarHeight
        set dockApp to (application process "Dock")
        set {dockWidth, dockHeight} to size of UI element 1 of dockApp
        --display dialog "Dock width: " & dockWidth & ", height: " & dockHeight
        set dockPos to position of UI element 1 of dockApp
        --display dialog "Dock x: " & (item 1 of dockPos) & ", y: " & (item 2 of dockPos)
    end tell

    -- size of the full screen
    (*
   {word 3 of (do shell script "defaults read /Library/Preferences/com.apple.windowserver | grep -w Width") as number, ¬
       word 3 of (do shell script "defaults read /Library/Preferences/com.apple.windowserver | grep -w Height") as number}
   *)
    tell application "Finder"
        set screenSize to bounds of window of desktop
        set screenWidth to item 3 of screenSize
        set screenHeight to item 4 of screenSize
    end tell
    --display dialog "Screen width: " & screenWidth & ", height: " & screenHeight

    -- by default, set the available screen size to the full screen size
    set availableWidth to screenWidth
    set availableHeight to screenHeight - menuBarHeight
    set availableX to 0
    set availableY to menuBarHeight

    --determine the userscreen origin and size

    -- case 0: hidden dock
    -- if (item 1 of dockPos < 0 or item 1 of dockPos ≥ screenHeight) then
    -- no need to change anything
    -- end if

    -- case 1: bottom dock
    if ((item 2 of dockPos) + dockHeight = screenHeight) then
        set availableHeight to availableHeight - dockHeight
    end if

    -- case 2: left dock
    if (item 1 of dockPos = 0) then
        set availableWidth to availableWidth - dockWidth
        set availableX to dockWidth
    end if

    -- case 3: right dock
    if ((item 1 of dockPos) + dockWidth = screenWidth) then
        set availableWidth to availableWidth - dockWidth
    end if

    return {availableX, availableY, availableWidth, availableHeight}
end getUserScreen

Fonte: MacScripter via Google

Pelo que vi e ouvi, o Cinch é um ótimo aplicativo para trazer o gerenciamento de janelas do Windows 7 para o Mac OS X.

Primeiro de tudo, se o gratuito é importante para você, obtenha o ShiftIt.

Se a conveniência de um mouse é importante para você, obtenha o Cinch. Está na Mac App Store.

Finalmente, se você possui um Macbook ou um Magic Trackpad, obtenha o JiTouch. Isso permitirá que você atribua um gesto a muitas, muitas coisas; uma delas é tela cheia, meia esquerda, meia direita. Sério, confira se você gosta de gestos, mesmo que um pouco. É como ter um mouse com mais de 100 botões. JiTouch

MercuryMover

Você também pode olhar para o MercuryMover, que oferece uma variedade de ferramentas para mover janelas sob uma série de mapeamentos de teclado. Eu costumava usar isso muito quando lutava com uma pequena tela de laptop, e você pode fazer com que ela vire uma janela até a borda da tela, etc. Ele mapeia mais de perto a funcionalidade do menu do sistema 'mover' que você encontra no Windows normal ' janelas'.

Estou usando o Magnet, está disponível na AppStore

http://magnet.crowdcafe.com

Tanto quanto eu entendo a sua pergunta, você deseja colar a janela na borda da tela, para que o lado da janela fique diretamente na borda da tela. Agora isso é possível no macOS Sierra (10.12) nativamente.

Tudo o que você precisa fazer é mover a janela que deseja posicionar (clicando e arrastando a parte superior da janela) para o lado em que deseja que ela fique. Você precisa fazer isso lentamente, caso contrário não funcionará. Depois de arrastar a janela até a borda, ela ficará um tempo e é aí que você deve parar.