Do any kind of window supervisors permit me to break windows sideways of the display screen?

Can you advise a Window Manager for the Mac? I would love to have a keyboard faster way that would certainly break a windows to the left or appropriate fifty percent of my screen.

2019-05-07 11:51:09
Source Share
Answers: 9

If you have a magic mouse or magic trackpad, BetterTouchTool is much better as you can set details motions to take care of the home windows. Like a 4 finger left swipe can be to resize the window to the left 50% of the screen.

2019-05-19 18:55:17

First of all, if free is necessary to you, get ShiftIt.

If ease from a computer mouse is necessary to you, get Cinch. It remains in the Mac App Store.

Ultimately if you have a Macbook or a Magic Trackpad, get JiTouch. It will certainly permit you to assign a motion to several, several points ; among which is complete screen, fifty percent - left, fifty percent - right. Seriously examine it out if you like motions also a little. It resembles having a computer mouse with 100+switches. JiTouch

2019-05-19 17:39:51


Divvy is a little menubar application that permits you to instantly resize any kind of energetic window. Divviy basically separates your screen right into a 6x6 grid. When conjured up, Divvy raises a little HUD in the center of the screen with this 6x6 grid. Relying on what component of your screen you intend to resize your energetic window, simply drag and also select those squares on the HUD and also the window does the remainder. It's that straightforward.

2019-05-09 07:07:15

After examining SizeUp and also Breeze, I've determined that Breeze fits my demands the most effective. Both permit you to place home windows left wing, right, or Fullscreen. The attribute that marketed it for me was establishing a default dimension & placement for an application and also appointing it a faster way key.

2019-05-09 05:45:17

SizeUp is specifically what you require:

SizeUp permits you to promptly place a window to load specifically half the screen (splitscreen), a quarter of the screen (quadrant), complete screen, or focused using the food selection bar or configurable system - vast faster ways (hotkeys). Comparable to "tiled home windows" capability readily available on various other running systems.

2019-05-09 04:51:33

Here is an Applescript that will certainly floor tile every one of the open windows in the frontmost application. Include in ~/Library/Scripts and also call from the Applescript menu in the menu bar. Add salt to preference (and also free).

--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)
        set applist to getFrntApp()
        if length of applist = 0 then
        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

        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
            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
        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
        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
        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
            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/ | grep -w Width") as number, ¬
       word 3 of (do shell script "defaults read /Library/Preferences/ | 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

Source : MacScripter via Google

2019-05-09 04:41:17


You could additionally consider MercuryMover, which offers you a series of window relocating devices under a collection of keyboard mappings. I made use of to utilize this a whole lot when having problem with a tiny laptop computer screen, and also you can get it to turn a window to the side of a screen and so on. It most very closely maps the 'action' system food selection capability that you enter regular Windows 'home windows'.

2019-05-07 20:46:43

I directly make use of SizeUp and also Divvy each day. If I had actually found out about ShiftIt previously, I possibly would not have actually spent for SizeUp. An additional one to look into that hasn't been stated yet is BetterTouchTool, which has a great deal of various other attributes, yet concealed in the innovative alternatives is a wonderful attribute they call "Window Snapping" which breaks the window to the left or right of the screen when you drag it sideways. Does not have keyboard faster way capability consisted of, yet it is a wonderful supplement to SizeUp and also Divvy.

2019-05-07 20:14:01

ShiftIt (initial variation at link stopped ) does this, and also is free and also open resource.

Modify : The task is currently on GitHub, nonetheless the last release remained in November 2010.

2019-05-07 18:21:16