¿Algún administrador de ventanas me permite ajustar ventanas a los lados de la pantalla?

¿Me puede recomendar un Administrador de ventanas para Mac? Me gustaría tener un método abreviado de teclado que ajustara una ventana a la mitad izquierda o derecha de mi pantalla.

SizeUp es exactamente lo que necesitas:

SizeUp le permite colocar rápidamente una ventana para llenar exactamente la mitad de la pantalla (pantalla dividida), un cuarto de la pantalla (cuadrante), pantalla completa o centrada a través de la barra de menú o accesos directos configurables en todo el sistema (teclas de acceso rápido). Funcionalidad similar a "ventanas en mosaico" disponible en otros sistemas operativos.

Pagar

Divvy es una pequeña aplicación de barra de menú que te permite cambiar automáticamente el tamaño de cualquier ventana activa. Divviy prácticamente divide su pantalla en una cuadrícula de 6x6. Cuando se invoca, Divvy muestra un pequeño HUD en el centro de la pantalla con esta cuadrícula de 6x6. Dependiendo de qué parte de su pantalla desea cambiar el tamaño de su ventana activa, simplemente arrastre y seleccione esos cuadrados en el HUD y la ventana hará el resto. Es así de simple.

Después de probar SizeUp y Breeze, he decidido que Breeze se adapta mejor a mis necesidades. Ambos le permiten colocar ventanas a la izquierda, derecha o pantalla completa. La característica que me lo vendió fue establecer un tamaño y posición predeterminados para una aplicación y asignarle una tecla de acceso directo.

ShiftIt (versión original en el enlace descontinuado) hace esto, y es gratuito y de código abierto.

Editar: El proyecto ahora está en GitHub , sin embargo, el último lanzamiento fue en noviembre de 2010.

Moom

He escuchado a algunas personas hablar sobre esto también:

¿Pasa mucho tiempo moviendo y ampliando ventanas para poder ver y trabajar mejor con todo el contenido de su Mac? En lugar de hacer ese trabajo usted mismo, deje que Moom se encargue de la tarea por usted.

Si tiene un mouse mágico o un trackpad mágico, BetterTouchTool es mejor ya que puede configurar gestos específicos para administrar las ventanas. Al igual que un deslizamiento hacia la izquierda con cuatro dedos puede cambiar el tamaño de la ventana al 50% de la pantalla.

Moom es genial. Puede ajustar ventanas a: pantalla completa, media pantalla, cuarto de pantalla. También puede cambiar el tamaño con una cuadrícula. También admite métodos abreviados de teclado personalizados.

Yo personalmente uso SizeUp y Divvy a diario. Si hubiera sabido sobre ShiftIt anteriormente, probablemente no habría pagado por SizeUp. Otro de los que hay que ver que aún no se ha mencionado es BetterTouchTool , que tiene muchas otras características, pero oculto en las opciones avanzadas hay una característica agradable que llaman "Ajuste de ventana" que ajusta la ventana a la izquierda o derecha del pantalla cuando lo arrastra hacia un lado. No tiene la funcionalidad de atajo de teclado incluida, pero es un buen complemento para SizeUp y Divvy.

Encontré aquí una pregunta fuera de tema sobre Stack Overflow :

Había dos administradores de código abierto mencionados allí que no aparecían en esta lista:

• Espectáculo -> http://spectacleapp.com/
• Pizarra -> https://github.com/jigish/slate (la configuración requiere trabajo en la línea de comando)

Otro de la tienda de aplicaciones

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

También puedes probar Slate, que es gratuito y de código abierto.

También es posible que desee leer este artículo al respecto.

Aquí hay un Applescript que enlosará todas las ventanas abiertas en la aplicación principal. Agregue ~/Library/Scriptsy llame desde el menú Applescript en la barra de menú. Agregue sal al gusto (y gratis).

--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

Fuente: MacScripter a través de Google

Por lo que he visto y oído, Cinch es una gran aplicación para llevar la administración de ventanas de Windows 7 a Mac OS X.

En primer lugar, si lo gratuito es importante para usted, obtenga ShiftIt.

Si la conveniencia de un mouse es importante para usted, obtenga Cinch. Está en la Mac App Store.

Finalmente, si tienes un Macbook o un Magic Trackpad, obtén JiTouch. Le permitirá asignar un gesto a muchas, muchas cosas; uno de los cuales es pantalla completa, mitad izquierda, mitad derecha. Compruébalo seriamente si te gustan los gestos aunque sea un poco. Es como tener un mouse con más de 100 botones. JiTouch

MercuryMover

También puede consultar MercuryMover, que le ofrece una variedad de herramientas para mover ventanas en una serie de asignaciones de teclado. Solía ​​usar esto mucho cuando luchaba con una pequeña pantalla de computadora portátil, y puede hacer que voltee una ventana al borde de una pantalla, etc. ventanas '.

Estoy usando Magnet, está disponible en la AppStore

http://magnet.crowdcafe.com

Hasta donde entiendo su pregunta, desea pegar la ventana al borde de la pantalla, de modo que el lado de la ventana esté directamente en el borde de la pantalla. Esto ahora es posible en macOS Sierra (10.12) de forma nativa.

Todo lo que necesita hacer es mover la ventana que desea colocar (haciendo clic y arrastrando la parte superior de la ventana) al lado en el que desea que se adhiera. Necesita hacer esto lentamente, de lo contrario no funcionará. Después de arrastrar la ventana hacia el borde, se quedará un rato y ahí es cuando debe detenerse.