ubuntuusers.de

#!/bin/bash
###############################INFORMATION######################################
# This script provides additional functionality for window placement with
# EWMH/NetWM compatible X Window Managers such as metacity, xfwm4, kwin, icewm,
# window maker or openbox. Possibly newer versions of those window managers
# might already support these features innately.
# The functions influences the active window only and it is recommended to use 
# the script with "focus follows mouse" for best user experience.      
# 
# Although generally a command line utility with fully working switches this
# script is meant to be a backend wrapper to bind keyboard shortcuts to.
# Best working with a combination of mod keys and the numpad keys.
#
# Dependencies:
# wmctrl, xdotool, xwit, EWMH/NetWM compatible X Window Manager
#
###############################CONFIGURATION####################################
# You have to change the following values (unit: pixels) to ensure the script 
# will work properly with your screen resolution and theme. 

# Resolution, screen width (sw) and height (sh)
sw="1440"
sh="900"
# Top panel height
tp="0"
# Bottom panel height
bp="32"
# Left panel width
lp="0"
# Right panel width
rp="0"
# Titlebar height
tb="25"
# Left border width
lb="3"
# Right border width
rb="3"
# Bottom border width
bb="3"
# Additional window margins
wm="1"
################################################################################

# Define remaining variables
# Get window ID for all windows on current desktop
# Still kinda instable, FIX ME!
win_id_all=$(wmctrl -l | grep "  $(xdotool get_desktop)" | cut -d " " -f1)
# Store in array for further processing
win_array=( $win_id_all )
# Get window ID of currently active window
win_active=$(xdotool getactivewindow)

# Display usage information
function usage () {
	cat <<USAGE
window-fu - This script provides additional functionality for window placement 
with EWMH/NetWM compatible X Window Managers accessible via keyboard shortcuts.
Please apply according shortcuts in your desktop environment manually to
window-fu and one(!) parameter.
To ensure the script is working properly edit the variables at the top of the
script file according to your screen and theme settings.
	
Dependencies:
	wmctrl, xdotool, xwit
	
Usage:
	window-fu [PARAMETER] (applied to keyboard shortcut)
		
Example:
	window-fu -l (applied to SHIFT+ALT+KP_LEFT)
		
Parameters:	
	-h -? Display this usage information.
	-l    Dock window at left screen edge maximized vertically
	-r    Dock window at right screen edge maximized vertically
	-t    Dock window at top screen edge maximized horizontally
	-b    Dock window at bottom screen edge maximized horizontally
	-pt   Set window height to screen height half docked at top edge
	-pb   Set window height to screen height half docked at bottom edge
	-tl   Set window height to screen height half docked at top left corner
	-bl   Set window height to screen height half docked at bottom left corner
	-tr   Set window height to screen height half docked at top right corner
	-br   Set window height to screen height half docked at top left corner
	-f    Toggle window fullscreen (maximize window)
	-m    Minimize all windows except active one on current desktop
	-u    Unminimize all windows on current desktop
USAGE
}

# Functions
function snap_left ()
{
	w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
	h=$(($sh - $tb - $bb - -$tp - $bp))
	x=$((0 + $lp))
	y=$((0 + $tp))
	wmctrl -r :ACTIVE: -e 0,$x,$y,$w,$h
	# Function win_maximize will overwrite the properties
	# Use absolute values for placement and size instead
	#wmctrl -r :ACTIVE: -b add,maximized_vert
}

function snap_right ()
{
	w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
	h=$(($sh - $tb - $bb - -$tp - $bp))
	x=$(($sw/2 - $rp/2 + $lp/2 + $wm))
	y=$((0 + $tp))
	wmctrl -r :ACTIVE: -e 0,$x,$y,$w,$h
	# See comment in function snap_left
	#wmctrl -r :ACTIVE: -b add,maximized_vert
}

function snap_top ()
{
	w=$(($sw - $lb - $rb - $lp - $rp))
	h=$(($sh/2 - $tb - $bb - $tp/2 - $bp/2 - $wm))
	x=$((0 + $lp))
	y=$((0 + $tp))
	wmctrl -r :ACTIVE: -e 0,$x,$y,$w,$h
	# See comment in function snap_left
	#wmctrl -r :ACTIVE: -b add,maximized_horz
}
	
function snap_bottom ()
{
	w=$(($sw - $lb - $rb - $lp - $rp))
	h=$(($sh/2 - $tb - $bb - $tp/2 - $bp/2 - $wm))
	x=$((0 + $lp))
	y=$(($sh/2 - $bp/2 + $tp/2))
	wmctrl -r :ACTIVE: -e 0,$x,$y,$w,$h
	# See comment in function snap_left
	#wmctrl -r :ACTIVE: -b add,maximized_horz	
}

function pos_top ()
{
	h=$(($sh/2 - $tb - $bb - $tp/2 - $bp/2 - $wm))
	y=$((0 + $tp))
	wmctrl -r :ACTIVE: -e 0,-1,$y,-1,$h
}

function pos_bottom ()
{
	h=$(($sh/2 - $tb - $bb - $tp/2 - $bp/2 - $wm))
	y=$(($sh/2 - $bp/2 + $tp/2))
	wmctrl -r :ACTIVE: -e 0,-1,$y,-1,$h
}

function snap_top_left ()
{
	w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
	h=$(($sh/2 - $tb - $bb - $tp/2 - $bp/2 - $wm))
	x=$((0 + $lp))
	y=$((0 + $tp))
	wmctrl -r :ACTIVE: -e 0,$x,$y,$w,$h

}

function snap_bottom_left ()
{
	w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
	h=$(($sh/2 - $tb - $bb - $tp/2 - $bp/2 - $wm))
	x=$((0 + $lp/2 + $rp/2 + $wm))
	y=$(($sh/2 - $bp/2 + $tp/2))
	wmctrl -r :ACTIVE: -e 0,$x,$y,$w,$h
}

function snap_top_right ()
{
	w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
	h=$(($sh/2 - $tb - $bb - $tp/2 - $bp/2 - $wm))
	x=$(($sw/2 - $rp/2 + $lp/2 + $wm))
	y=$((0 + $tp))
	wmctrl -r :ACTIVE: -e 0,$x,$y,$w,$h
}

function snap_bottom_right ()
{
	w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
	h=$(($sh/2 - $tb - $bb - $tp/2 - $bp/2 - $wm))
	x=$(($sw/2 - $rp/2 + $lp/2 + $wm))
	y=$(($sh/2 - $bp/2 + $tp/2))
	wmctrl -r :ACTIVE: -e 0,$x,$y,$w,$h
}

function win_maximize ()
{
	wmctrl -r :ACTIVE: -b toggle,maximized_vert,maximized_horz
}

function win_minimize ()
{
	for i in ${win_array[@]}
	do
	# wmctrl outputs hex, xdotool and xwit use decimal values for window IDs
	# let converts those hex to decimal values
		let win_id=$i
		if [ "$win_active" != "$win_id" ]
		then
		xwit -iconify -id $win_id
		fi
	done
}

function win_unminimize ()
{
	for i in ${win_array[@]}
	do
	# See function win_minimize for explaination
		let win_id=$i
	if [ "$win_active" != "$win_id" ]
	then
	# Give focus to each unhidden window to avoid pager blinking
		xwit -pop -focus -id $win_id
	fi
	done
	# Give focus to formerly active window again
	xwit -focus -id $win_active	
}

# Bring together parameters and functions
function win_fu ()
{
	case $1 in
		-h)
			usage
			;;
		-\?)
			usage
			;;
		-l)
			snap_left
			;;
		-r)
			snap_right
			;;
		-t)
			snap_top
			;;
		-b)
			snap_bottom
			;;
		-pt)
			pos_top
			;;
		-pb)
			pos_bottom
			;;
		-tl)
			snap_top_left
			;;
		-bl)
			snap_bottom_left
			;;
		-tr)
			snap_top_right
			;;
		-br)
			snap_bottom_right
			;;
		-f)
			win_maximize
			;;
		-m)
			win_minimize
			;;
		-u)
			win_unminimize
			;;
		*)
			exit 1
			;;
	esac
}

# Let it happen
win_fu $1
Code

#!/bin/bash

# Resolution, screen width (sw) and height (sh)
sw="1440"
sh="900"
# Top panel height
tp="0"
# Bottom panel height
bp="32"
# Left panel width
lp="0"
# Right panel width
rp="0"
# Titlebar height
tb="25"
# Left border width
lb="3"
# Right border width
rb="3"
# Bottom border width
bb="3"
# Additional window margins
wm="1"
# Get active desktop and window ids from this desktop
desk_active=$(wmctrl -d | grep "*" | cut -d " " -f1)
win_id_all=$(wmctrl -l | grep "  $desk_active" | cut -d " " -f1)
win_array=( $win_id_all )


# For each serial number of each element of array do...
for n in $(seq 0 $((${#win_array[@]} - 1)) )
do
	# For each win_id with serial number $n do...
	for i in ${win_array[$n]}
	do
	# Check wether serial number $n is even (0) or odd (1)
	if [ "$(( $n % 2 ))" -eq "0" ]
	# If even snap window left
	then
		w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
		h=$(($sh - $tb - $bb -$tp - $bp))
		x=$((0 + $lp))
		y=$((0 + $tp))
		wmctrl -i -r $i -e 0,$x,$y,$w,$h
	# If odd snap window right
	else
		w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
		h=$(($sh - $tb - $bb - -$tp - $bp))
		x=$(($sw/2 - $rp/2 + $lp/2 + $wm))
		y=$((0 + $tp))
		wmctrl -i -r $i -e 0,$x,$y,$w,$h
	fi
	done
done

#!/bin/bash

# Resolution, screen width (sw) and height (sh)
sw="1440"
sh="900"
# Top panel height
tp="0"
# Bottom panel height
bp="32"
# Left panel width
lp="0"
# Right panel width
rp="0"
# Titlebar height
tb="25"
# Left border width
lb="3"
# Right border width
rb="3"
# Bottom border width
bb="3"
# Additional window margins
wm="1"
# Get active desktop and window ids from this desktop
desk_active=$(wmctrl -d | grep "*" | cut -d " " -f1)
win_id_all=$(wmctrl -l | grep "  $desk_active" | cut -d " " -f1)
win_array=( $win_id_all )
win_count=${#win_array[@]}

function left ()
{
	w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
	h=$(($sh - $tb - $bb -$tp - $bp))
	x=$((0 + $lp))
	y=$((0 + $tp))
}

function right ()
{
	w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
	h=$(($sh - $tb - $bb - -$tp - $bp))
	x=$(($sw/2 - $rp/2 + $lp/2 + $wm))
	y=$((0 + $tp))
}

function top_left ()
{
	w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
	h=$(($sh/2 - $tb - $bb - $tp/2 - $bp/2 - $wm))
	x=$((0 + $lp))
	y=$((0 + $tp))
}

function bottom_left ()
{
	w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
	h=$(($sh/2 - $tb - $bb - $tp/2 - $bp/2 - $wm))
	x=$((0 + $lp/2 + $rp/2 + $wm))
	y=$(($sh/2 - $bp/2 + $tp/2))
}

function top_right ()
{
	w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
	h=$(($sh/2 - $tb - $bb - $tp/2 - $bp/2 - $wm))
	x=$(($sw/2 - $rp/2 + $lp/2 + $wm))
	y=$((0 + $tp))
}

function bottom_right ()
{
	w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
	h=$(($sh/2 - $tb - $bb - $tp/2 - $bp/2 - $wm))
	x=$(($sw/2 - $rp/2 + $lp/2 + $wm))
	y=$(($sh/2 - $bp/2 + $tp/2))
}

function place ()
{
	wmctrl -i -r $i -e 0,$x,$y,$w,$h
}

# If 2 or less open windows 1 left and 1 right
if [ "$win_count" -le "2" ]
then
# For each serial number of each element of array do...
for (( n=0 ; n <= $((win_count - 1)) ; n++))
do
	# For each win_id with serial number $n do...
	for i in ${win_array[$n]}
	do
	# Check wether serial number $n is even (0) or odd (1)
	if [ "$(( $n % 2 ))" -eq "0" ]
	# If even snap window left
	then
		left && place
	# If odd snap window right
	else
		right && place
	fi
	done
done
# If 3 open windows 1 left and 2 right
elif [ "$win_count" -eq "3" ]
then
	for i in ${win_array[0]}
	do
	top_left && place
	done
	for i in ${win_array[1]}
	do
	bottom_left && place
	done
	for i in ${win_array[2]}
	do
	right && place
	done	
# If 4 or more open windows 2 left and 2 right
else
	for ((n=0 ; n <= $(($win_count - 1)) ; n++))
	do
		# Set $i for function place ()
		i=${win_array[$n]}
		if [ "$(( $n % 4 ))" -eq "0" ]
		then
		top_left && place
		elif [ "$(( $n % 4 ))" -eq "1" ]
		then
		bottom_left && place
		elif [ "$(( $n % 4 ))" -eq "2" ]
		then
		top_right && place
		elif [ "$(( $n % 4 ))" -eq "3" ]
		then
		bottom_right && place
		fi
	done	
fi

wmctrl -l | grep "  $(wmctrl -d | grep "*" | cut -d " " -f1)" | cut -d " " -f1
= 0x04400003

xdpyinfo | grep focus | grep -E -o 0x[0-9a-f]+
= 0x4400004

xdotool getactivewindow
= 71303171

hex_id=0x04400003
let hex_id=$dec_id
echo $dec_id
= 71303171

#!/bin/bash

# Dependencies:
# wmctrl, xdotool

# Resolution, screen width (sw) and height (sh)
sw="1440"
sh="900"
# Top panel height
tp="0"
# Bottom panel height
bp="32"
# Left panel width
lp="0"
# Right panel width
rp="0"
# Titlebar height
tb="25"
# Left border width
lb="3"
# Right border width
rb="3"
# Bottom border width
bb="3"
# Additional window margins
wm="1"
# Get active desktop and window ids from this desktop
desk_active=$(wmctrl -d | grep "*" | cut -d " " -f1)
win_id_all=$(wmctrl -l | grep "  $desk_active" | cut -d " " -f1)
win_array=( $win_id_all )
win_count=${#win_array[@]}

# Functions to declare variables for window geometry
function left ()
{
	w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
	h=$(($sh - $tb - $bb -$tp - $bp))
	x=$((0 + $lp))
	y=$((0 + $tp))
}

function right ()
{
	w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
	h=$(($sh - $tb - $bb - -$tp - $bp))
	x=$(($sw/2 - $rp/2 + $lp/2 + $wm))
	y=$((0 + $tp))
}

function top ()
{
	h=$(($sh/2 - $tb - $bb - $tp/2 - $bp/2 - $wm))
	w=$(($sw - $lb - $rb - $lp - $rp))
	x=$((0 + $lp))
	y=$((0 + $tp))
}

function bottom ()
{
	w=$(($sw - $lb - $rb - $lp - $rp))
	h=$(($sh/2 - $tb - $bb - $tp/2 - $bp/2 - $wm))
	x=$((0 + $lp))
	y=$(($sh/2 - $bp/2 + $tp/2))
}

function top_left ()
{
	w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
	h=$(($sh/2 - $tb - $bb - $tp/2 - $bp/2 - $wm))
	x=$((0 + $lp))
	y=$((0 + $tp))
}

function bottom_left ()
{
	w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
	h=$(($sh/2 - $tb - $bb - $tp/2 - $bp/2 - $wm))
	x=$((0 + $lp/2 + $rp/2 + $wm))
	y=$(($sh/2 - $bp/2 + $tp/2))
}

function top_right ()
{
	w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
	h=$(($sh/2 - $tb - $bb - $tp/2 - $bp/2 - $wm))
	x=$(($sw/2 - $rp/2 + $lp/2 + $wm))
	y=$((0 + $tp))
}

function bottom_right ()
{
	w=$(($sw/2 - $lb - $rb - $lp/2 - $rp/2 - $wm))
	h=$(($sh/2 - $tb - $bb - $tp/2 - $bp/2 - $wm))
	x=$(($sw/2 - $rp/2 + $lp/2 + $wm))
	y=$(($sh/2 - $bp/2 + $tp/2))
}

# wmctrl command for window placement
function place ()
{
	wmctrl -i -r $win_id -e 0,$x,$y,$w,$h
}

# The functions for each type of placement grid
function left_right () 
{
	for (( n=0 ; n <= $((win_count - 1)) ; n++ ))
	do
		win_id=${win_array[$n]}
		if [ "$(( $n % 2 ))" -eq "0" ]
		then
		left && place
		else
		right && place
		fi
	done
}

function top_bottom () 
{
	for (( n=0 ; n <= $((win_count - 1)) ; n++ ))
	do
		win_id=${win_array[$n]}
		if [ "$(( $n % 2 ))" -eq "0" ]
		then 
			top && place
		else 
			bottom && place 
		fi
	done
}
	
function left_right_right () 
{
	for (( n=0 ; n <= $((win_count - 1)) ; n++ ))
	do
		win_id=${win_array[$n]}
		win_active=$(xdotool getactivewindow)
		let win_current=$win_id
		if [ "$(( $n % 3 ))" -eq "0" ]
		then 
			if [ $win_active = $win_current ] 
			then 
				left && place 
			else
				top_right && place
			fi
		elif [ "$(( $n % 3 ))" -eq "1" ]
		then 
			if [ $win_active = $win_current ] 
			then
				left && place
			else
				bottom_right && place
			fi
		elif [ "$(( $n % 3 ))" -eq "2" ] 
		then
			if [ $win_active = $win_current ] 
			then
				left && place
			else
				top_right && place
			fi
		fi
	done
}

function right_left_left () 
{
	for (( n=0 ; n <= $((win_count - 1)) ; n++ ))
	do
		win_id=${win_array[$n]}
		win_active=$(xdotool getactivewindow)
		let win_current=$win_id
		if [ "$(( $n % 3 ))" -eq "0" ]
		then 
			if [ $win_active = $win_current ] 
			then 
				right && place 
			else
				top_left && place
			fi
		elif [ "$(( $n % 3 ))" -eq "1" ]
		then 
			if [ $win_active = $win_current ] 
			then
				right && place
			else
				bottom_left && place
			fi
		elif [ "$(( $n % 3 ))" -eq "2" ] 
		then 
			if [ $win_active = $win_current ] 
			then
				right && place
			else
				top_left && place
			fi
		fi
	done
}

function top_bottom_bottom () 
{
	for (( n=0 ; n <= $((win_count - 1)) ; n++ ))
	do
		win_id=${win_array[$n]}
		win_active=$(xdotool getactivewindow)
		let win_current=$win_id
		if [ "$(( $n % 3 ))" -eq "0" ]
		then 
			if [ $win_active = $win_current ] 
			then 
				top && place 
			else
				bottom_left && place
			fi
		elif [ "$(( $n % 3 ))" -eq "1" ]
		then 
			if [ $win_active = $win_current ] 
			then
				top && place
			else
				bottom_right && place
			fi
		elif [ "$(( $n % 3 ))" -eq "2" ] 
		then 
			if [ $win_active = $win_current ] 
			then
				top && place
			else
				bottom_left && place
			fi
		fi
	done
}

function bottom_top_top () 
{
	for (( n=0 ; n <= $((win_count - 1)) ; n++ ))
	do
		win_id=${win_array[$n]}
		win_active=$(xdotool getactivewindow)
		let win_current=$win_id
		if [ "$(( $n % 3 ))" -eq "0" ]
		then 
			if [ $win_active = $win_current ] 
			then 
				bottom && place 
			else
				top_left && place
			fi
		elif [ "$(( $n % 3 ))" -eq "1" ]
		then 
			if [ $win_active = $win_current ] 
			then
				bottom && place
			else
				top_right && place
			fi
		elif [ "$(( $n % 3 ))" -eq "2" ] 
		then 
			if [ $win_active = $win_current ] 
			then
				bottom && place
			else
				top_left && place
			fi
		fi
	done
}

function top_bottom_left_right () 
{
	for (( n=0 ; n <= $(($win_count - 1)) ; n++ ))
	do
		win_id=${win_array[$n]}
		if [ "$(( $n % 4 ))" -eq "0" ]
		then
		top_left && place
		elif [ "$(( $n % 4 ))" -eq "1" ]
		then
		bottom_left && place
		elif [ "$(( $n % 4 ))" -eq "2" ]
		then
		top_right && place
		elif [ "$(( $n % 4 ))" -eq "3" ]
		then
		bottom_right && place
		fi
	done
}

# Bring together parameters and according functions
function win_place () 
{
	case $1 in
		-lr)
			left_right
			;;
		-tb)
			top_bottom
			;;
		-lrr)
			left_right_right
			;;
		-rll)
			right_left_left
			;;
		-tbb)
			top_bottom_bottom
			;;
		-btt)
			bottom_top_top
			;;
		-f)
			top_bottom_left_right
			;;
		*)
			exit 1
			;;
	esac
}

# Let it happen
win_place $1

#!/bin/bash
##WINDOW-FOO####################################################################
# By Andreas Lis <dauerflucher@googlemail.com>
# Released under GNU General Public License 3.0
# Copyright (c) 2011
#
# Last updated on Jan /25/2011
#
##GNU GENERAL PUBLIC LICENSE 3.0################################################
# This program is free software: you can redistribute it and/or modify it under 
# the terms of the GNU General Public License as published by the Free Software 
# Foundation, either version 3 of the License, or (at your option) any later 
# version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT 
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with 
# this program.  If not, see <http://www.gnu.org/licenses/> or write to the 
# Free Software Foundation, Inc., 
# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
##GENERAL INFORMATION###########################################################
# This script provides additional functionality for window operations with
# EWMH/NetWM compatible X Window Managers such as metacity, xfwm4, kwin, icewm, 
# window maker or openbox. Possibly newer versions of some of those window
# managers might already support all or some of the features innately.
# 
# Dependencies:
# wmctrl, xdotool, xwit, EWMH/NetWM compatible X Window Manager
#
##END OF HEAD###################################################################
# Uncomment for debugging
#set -x

# Define global variables
# Remaining global variables are defined in configuration file - see line 339
if [ "$1" != "-h" ] && [ "$1" != "-?" ] && [ "$1" != "-s" ] && [ "$1" != "-V" ]
then
# Get active desktop
#desk_active=$(xdotool get_desktop)
#desk_active=$(wmctrl -d | grep "*" | cut -d " " -f1)
desk_active=$(wmctrl -d | awk '/\*/{print $1}')

# Get all window IDs from windows on active desktop
#win_id_all=$(wmctrl -l | grep "  $desk_active" | cut -d " " -f1)
win_id_all=$(wmctrl -l | awk '/  '$desk_active'/{print $1}')

# Store in array for further processing
win_array=( $win_id_all )

# Get total of all windows on active dekstop
win_count=${#win_array[@]}
	
	if [ "$1" = "-lrr" ] || [ "$1" = "-rll" ] || [ "$1" = "-tbb" ] || [ "$1" = "-btt" ] || [ "$1" = "-m" ] || [ "$1" = "-u" ]
	then
# Get window ID of currently active window
		win_active=$(xdotool getactivewindow)
	fi
fi

# Path of configuration file
config_path="$HOME/.config/window-foo"
config_file="window-foo.cfg"

# Display usage information
function usage () {
	cat <<USAGE
Window-Foo - Based on several command line utilities this script provides
additional functionality for window operations with EWMH/NetWM compatible X
Window Managers. Mainly meant to be controlled via keyboard shortcuts, please
apply those in your keyboard settings manually.
To ensure the script is working properly with your screen resolution and window
manager theme please edit the configuration file accordingly.

Dependencies:
	wmctrl, xdotool, xwit, EWMH/NetWM compatible X Window Manager
	
Usage: 
	window-foo [PARAMETER] (best applied to keyboard shortcut)
	
Example:
	window-foo -l (applied to SHIFT+ALT+KP_LEFT)

Parameters:

	General:
	-h -?	Displays usage information
	
	-s		Opens window-foo configuration file with the default editor set in
			the $EDITOR environment variable or creates configuration file if 
			non-existent in $HOME/.config/window-foo/window-foo.cfg	
			This function is automatically invoked if no configuration file is
			found
	
	-V		Displays version and license information 

	Active window only:
	
	-l		Snap active window at left screen edge maximized vertically
	
			-------------
			|     |
			|  a  |
			|     |
			-------------
				
	-r		Snap active window at right screen edge maximized vertically
	
			-------------
			      |     |
			      |  a  |
			      |     |
			-------------
			
	-t		Snap active window at top screen edge maximized horizontally
	
			-------------
			|     a     |
			-------------
			
			-------------
	
	-b		Snap active window at bottom screen edge maximized horizontally
	
			-------------
			
			-------------
			|     a     |
			-------------
	
	-f		Toggle active window maximized
	
			-------------
			|           |
			|     a     |
			|           |
			-------------
	
	-pt		Set active window height to screen height half and snap to top edge
	
			-------------
			  |   a   |
			  ---------
			
			-------------
	
	-pb		Set active window height to screen height half and snap to bottom 
			edge
			
			-------------
			  |   a   |
			  ---------
			
			-------------
			
	-tl		Set active window height to screen height half and snap to top left
			screen corner
			
			-------------
			|  a  |
			-------
			
			-------------
			
	-bl		Set active window height to screen height half and snap to bottom
			left screen corner
			
			-------------
			
			-------
			|  a  |       
			-------------
			
	-tr		Set active window height to screen height half and snap to top right
			screen corner
			
			-------------
			      |  a  |
			      -------
			
			-------------
			
	-br		Set active window height to screen height half and snap to bottom
			right screen corner
			
			-------------
			
			      -------
			      |  a  |
			-------------

	All windows on active desktop:
	
	-lr		Snap all windows alternating to left and right screen edges with
			screen width half and maximized vertically
			
			-------------
			|     |     |
			|     |     |
			|     |     |
			-------------
			
	-tb		Snap all windows alternating to top and bottom screen edges with
			screen height half and maximized horizontally
			
			-------------
			|           |
			-------------
			|           |
			-------------
			
	-lrr	Snap active window to left screen edge maximized vertically, stack 
			inactive windows alternating to top and bottom right screen corners
			
			-------------
			|     |     |
			|  a  -------
			|     |     |
			-------------
	
	-rll	Snap active window to right screen edge maximized vertically, stack
			inactive windows alternating to top and bottom left screen corners
			
			-------------
			|     |     |
			-------  a  |
			|     |     |
			-------------
			
	-tbb	Snap active window to top screen edge maximized horizontally, stack
			inactive windows alternating to bottom left and right screen corners
			
			-------------
			|     a     |
			-------------
			|     |     |
			-------------
			
	-btt	Snap active window to bottom screen edge maximized horizontally,
			stack inactive windows alternating to top left and right screen
			corners
			
			-------------
			|     |     |
			-------------
			|     a     |
			-------------
			
	-tblr	Snap all windows alternating to top and bottom left and right screen
			corners
			
			-------------
			|     |     |
			-------------
			|     |     |
			-------------
			
	-m		Minimize resp. iconify all windows expect active one on current
			desktop
			
	-u		Unminimize resp. popup all windows on current desktop
USAGE
}

# Create a default config file
function config () {
	cat << CONFIG
##WINDOW-FOO CONFIGURATION FILE#################################################
# To ensure the script working properly with your screen resolution and window
# manager theme you have to change the values of the following variables 
# accordingly. Unit is pixels.
# To get the border sizes for your window manager theme have a look in the theme
# folder in /usr/share/themes/.
# The default values currently feature a 1440x900 wide screen resolution with 
# window manager theme Shiki-Colors-Easy and one 32px panel at the bottom.
################################################################################ 
# Screen resolution
screen_width="1440"
screen_height="900"

# Top panel height
top_panel="0"

# Bottom panel height
bottom_panel="32"

# Left panel width
left_panel="0"

# Right panel width
right_panel="0"

# Window title bar height
title_bar="25"

# Window left border width
left_border="3"

# Window right border width
right_border="3"

# Window bottom border width
bottom_border="3"

# Additional window margins (space between window borders)
window_margin="1"
CONFIG
}

function version () {
	cat << VERSION
Window-Foo --
By Andreas Lis <dauerflucher@googlemail.com>
Released unter GNU General Public License 3.0
Copyright (c) 2011

Last updated on Jan /25/2011
VERSION
}

# Function to create and edit configuration file
# Configuration file contains remaining global variables
function setup () {
if [ -e $config_path/$config_file ]
then
	editor $config_path/$config_file
else
	mkdir -p $config_path
	config > $config_path/$config_file
	editor $config_path/$config_file
fi
}

# Check if a configuration file is existent
if [ -e $config_path/$config_file ]
then
# Source configuration file to define remaining global variables
	if [ "$1" != "-h" ] && [ "$1" != "-?" ] && [ "$1" != "-V" ]
	then
	source $config_path/$config_file
	fi
else
# If non-existent invoke setup function except user manually executes setup
	if [ "$1" != "-s" ]
	then
	setup
	fi
fi

# Functions to define variables for window geometry
function left () {
	w=$(( $screen_width/2 - $left_border - $right_border - $left_panel/2 - $right_panel/2 - $window_margin ))
	h=$(( $screen_height - $title_bar - $bottom_border -$top_panel - $bottom_panel ))
	x=$(( 0 + $left_panel ))
	y=$(( 0 + $top_panel ))
}

function right () {
	w=$(( $screen_width/2 - $left_border - $right_border - $left_panel/2 - $right_panel/2 - $window_margin ))
	h=$(( $screen_height - $title_bar - $bottom_border -$top_panel - $bottom_panel ))
	x=$(( $screen_width/2 - $right_panel/2 + $left_panel/2 + $window_margin ))
	y=$(( 0 + $top_panel ))
}

function top () {
	h=$(( $screen_height/2 - $title_bar - $bottom_border - $top_panel/2 - $bottom_panel/2 - $window_margin ))
	w=$(( $screen_width - $left_border - $right_border - $left_panel - $right_panel ))
	x=$(( 0 + $left_panel ))
	y=$(( 0 + $top_panel ))
}

function bottom () {
	w=$(( $screen_width - $left_border - $right_border - $left_panel - $right_panel ))
	h=$(( $screen_height/2 - $title_bar - $bottom_border - $top_panel/2 - $bottom_panel/2 - $window_margin ))
	x=$(( 0 + $left_panel ))
	y=$(( $screen_height/2 - $bottom_panel/2 + $top_panel/2 ))
}

function top_left () {
	w=$(( $screen_width/2 - $left_border - $right_border - $left_panel/2 - $right_panel/2 - $window_margin ))
	h=$(( $screen_height/2 - $title_bar - $bottom_border - $top_panel/2 - $bottom_panel/2 - $window_margin ))
	x=$(( 0 + $left_panel ))
	y=$(( 0 + $top_panel ))
}

function bottom_left () {
	w=$(( $screen_width/2 - $left_border - $right_border - $left_panel/2 - $right_panel/2 - $window_margin ))
	h=$(( $screen_height/2 - $title_bar - $bottom_border - $top_panel/2 - $bottom_panel/2 - $window_margin ))
	x=$(( 0 + $left_panel/2 + $right_panel/2 + $window_margin ))
	y=$(( $screen_height/2 - $bottom_panel/2 + $top_panel/2 ))
}

function top_right () {
	w=$(( $screen_width/2 - $left_border - $right_border - $left_panel/2 - $right_panel/2 - $window_margin ))
	h=$(( $screen_height/2 - $title_bar - $bottom_border - $top_panel/2 - $bottom_panel/2 - $window_margin ))
	x=$(( $screen_width/2 - $right_panel/2 + $left_panel/2 + $window_margin ))
	y=$(( 0 + $top_panel ))
}

function bottom_right () {
	w=$(( $screen_width/2 - $left_border - $right_border - $left_panel/2 - $right_panel/2 - $window_margin ))
	h=$(( $screen_height/2 - $title_bar - $bottom_border - $top_panel/2 - $bottom_panel/2 - $window_margin ))
	x=$(( $screen_width/2 - $right_panel/2 + $left_panel/2 + $window_margin ))
	y=$(( $screen_height/2 - $bottom_panel/2 + $top_panel/2 ))
}

function pos_top () {
	w="-1"
	h=$(( $screen_height/2 - $title_bar - $bottom_border - $top_panel/2 - $bottom_panel/2 - $window_margin ))
	x="-1"
	y=$(( 0 + $top_panel ))
}

function pos_bottom () {
	w="-1"
	h=$(( $screen_height/2 - $title_bar - $bottom_border - $top_panel/2 - $bottom_panel/2 - $window_margin ))
	x="-1"
	y=$(( $screen_height/2 - $bottom_panel/2 - $top_panel/2 ))	
}

# wmctrl commands for window placement
function place () {
	wmctrl -i -r $win_id -e 0,$x,$y,$w,$h
}

function place_active () {
	wmctrl -r :ACTIVE: -e 0,$x,$y,$w,$h
}

# Functions for each type of placement grid
function left_right () {
	for (( n=0 ; n <= $((win_count - 1)) ; n++ ))
	do
		win_id=${win_array[$n]}
		if [ "$(( $n % 2 ))" -eq "0" ]
		then
		left && place
		else
		right && place
		fi
	done
}

function top_bottom () {
	for (( n=0 ; n <= $((win_count - 1)) ; n++ ))
	do
		win_id=${win_array[$n]}
		if [ "$(( $n % 2 ))" -eq "0" ]
		then 
			top && place
		else 
			bottom && place 
		fi
	done
}
	
function left_right_right () {
	for (( n=0 ; n <= $((win_count - 1)) ; n++ ))
	do
		win_id=${win_array[$n]}
		let win_current=$win_id
		if [ "$(( $n % 3 ))" -eq "0" ]
		then 
			if [ $win_active = $win_current ] 
			then 
				left && place 
			else
				top_right && place
			fi
		elif [ "$(( $n % 3 ))" -eq "1" ]
		then 
			if [ $win_active = $win_current ] 
			then
				left && place
			else
				bottom_right && place
			fi
		elif [ "$(( $n % 3 ))" -eq "2" ] 
		then
			if [ $win_active = $win_current ] 
			then
				left && place
			else
				top_right && place
			fi
		fi
	done
}

function right_left_left () {
	for (( n=0 ; n <= $((win_count - 1)) ; n++ ))
	do
		win_id=${win_array[$n]}
		let win_current=$win_id
		if [ "$(( $n % 3 ))" -eq "0" ]
		then 
			if [ $win_active = $win_current ] 
			then 
				right && place 
			else
				top_left && place
			fi
		elif [ "$(( $n % 3 ))" -eq "1" ]
		then 
			if [ $win_active = $win_current ] 
			then
				right && place
			else
				bottom_left && place
			fi
		elif [ "$(( $n % 3 ))" -eq "2" ] 
		then 
			if [ $win_active = $win_current ] 
			then
				right && place
			else
				top_left && place
			fi
		fi
	done
}

function top_bottom_bottom () {
	for (( n=0 ; n <= $((win_count - 1)) ; n++ ))
	do
		win_id=${win_array[$n]}
		let win_current=$win_id
		if [ "$(( $n % 3 ))" -eq "0" ]
		then 
			if [ $win_active = $win_current ] 
			then 
				top && place 
			else
				bottom_left && place
			fi
		elif [ "$(( $n % 3 ))" -eq "1" ]
		then 
			if [ $win_active = $win_current ] 
			then
				top && place
			else
				bottom_right && place
			fi
		elif [ "$(( $n % 3 ))" -eq "2" ] 
		then 
			if [ $win_active = $win_current ] 
			then
				top && place
			else
				bottom_left && place
			fi
		fi
	done
}

function bottom_top_top () {
	for (( n=0 ; n <= $((win_count - 1)) ; n++ ))
	do
		win_id=${win_array[$n]}
		let win_current=$win_id
		if [ "$(( $n % 3 ))" -eq "0" ]
		then 
			if [ $win_active = $win_current ] 
			then 
				bottom && place 
			else
				top_left && place
			fi
		elif [ "$(( $n % 3 ))" -eq "1" ]
		then 
			if [ $win_active = $win_current ] 
			then
				bottom && place
			else
				top_right && place
			fi
		elif [ "$(( $n % 3 ))" -eq "2" ] 
		then 
			if [ $win_active = $win_current ] 
			then
				bottom && place
			else
				top_left && place
			fi
		fi
	done
}

function top_bottom_left_right () {
	for (( n=0 ; n <= $(($win_count - 1)) ; n++ ))
	do
		win_id=${win_array[$n]}
		if [ "$(( $n % 4 ))" -eq "0" ]
		then
		top_left && place
		elif [ "$(( $n % 4 ))" -eq "1" ]
		then
		bottom_left && place
		elif [ "$(( $n % 4 ))" -eq "2" ]
		then
		top_right && place
		elif [ "$(( $n % 4 ))" -eq "3" ]
		then
		bottom_right && place
		fi
	done
}

function minimize () {
	for i in ${win_array[@]}
	do
		# wmctrl outputs hex, xdotool and xwit use decimal values for window IDs
		# let converts those hex to decimal values
		let win_id=$i
		if [ "$win_active" != "$win_id" ]
		then
		xwit -iconify -id $win_id
		fi
	done
}

function unminimize () {
	for i in ${win_array[@]}
	do
		# See function win_minimize for explaination
		let win_id=$i
		if [ "$win_active" != "$win_id" ]
		then
		# Give focus to each unhidden window to avoid pager blinking
		xwit -pop -focus -id $win_id
		fi
	done
	# Give focus to formerly active window again
	xwit -focus -id $win_active	
}

# Bring together parameters and according functions
function win_foo () {
	case $1 in
		-h)
			usage
			echo ""
			version
			;;
		-\?)
			usage
			echo ""
			version
			;;
		-s)
			setup
			;;
		-V)
			version
			;;	
		-l)
			left && place_active
			;;
		-r)
			right && place_active
			;;
		-t)
			top && place_active
			;;
		-b)
			bottom && place_active
			;;
		-f)
			wmctrl -r :ACTIVE: -b toggle,maximized_vert,maximized_horz
			;;
		-pt)
			pos_top && place_active
			;;
		-pb)
			pos_bottom && place_active
			;;
		-tl)
			top_left && place_active
			;;
		-bl)
			bottom_left && place_active
			;;
		-tr)
			top_right && place_active
			;;
		-br)
			bottom_right && place_active
			;;
		-lr)
			left_right
			;;
		-tb)
			top_bottom
			;;
		-lrr)
			left_right_right
			;;
		-rll)
			right_left_left
			;;
		-tbb)
			top_bottom_bottom
			;;
		-btt)
			bottom_top_top
			;;
		-tblr)
			top_bottom_left_right
			;;
		-m)
			minimize
			;;
		-u)
			unminimize
			;;
		*)
			exit 1
			;;
	esac
}

# Let it happen
win_foo $1