ubuntuusers.de

(x, y, width, height) = $window->get_client_window_geometry
(xp, yp, widthp, heightp) = $window->get_geometry 

#!/usr/bin/env python

import wnck

screen = wnck.screen_get_default()
screen.force_update()

for win in screen.get_windows():
    if not 'Panel' in win.get_name():
        print win.get_name()
        win.unmaximize()
        win.set_geometry('current', 'width', 0, 0, 320, 280)

#!/usr/bin/env python

from optparse import OptionParser
import sys

from Xlib.display import Display
from Xlib.protocol.event import ClientMessage
from Xlib.X import (
    AnyPropertyType,
    SubstructureNotifyMask,
    SubstructureRedirectMask)


class WinControl(object):

    def __init__(self):
        self.display = Display()
        self.screen = self.display.screen()
        self.root = self.screen.root
        self.CLIENTLIST = self.display.intern_atom('_NET_CLIENT_LIST')
        self.MOVERESIZE = self.display.intern_atom('_NET_MOVERESIZE_WINDOW')
        self.NETNAME = self.display.intern_atom('_NET_WM_NAME')
        self.NORMAL = self.display.intern_atom('_NET_WM_WINDOW_TYPE_NORMAL')
        self.WINTYPE = self.display.intern_atom('_NET_WM_WINDOW_TYPE')

    def get_xids(self, only_xids=False, wins=False, max=-1):
        """ Return all xids from clientlist
        
            xids : return only xids (no names)
            wins : Return only window xids
            max  :  Number of maximal returned xids, -1 means no maximum
        """ 
        xids = self.root.get_full_property(
            self.CLIENTLIST,
            AnyPropertyType).value
        if wins:
            xids = [xid for xid in xids if self.iswindow(xid)]
        if max == -1:
            max = len(xids)
        for i in xrange(max):
            xid = xids[i]
            if only_xids:
                yield int(xid)
            else:
                yield int(xid), self.get_name(xid)
                
    def iswindow(self, xid):
        window = self.get_window(xid)
        wintype = window.get_full_property(self.WINTYPE, AnyPropertyType).value
        return self.NORMAL in wintype

    def get_name(self, xid):
        window = self.get_window(xid)
        netname = window.get_full_property(self.NETNAME, AnyPropertyType).value
        return window.get_wm_name() or netname

    def get_window(self, xid):
        return self.display.create_resource_object('window', xid)

    def tile(self, left, right):
        """ Tile two windows verticale using their xids
        """
        w, h = self.screen.width_in_pixels, self.screen.height_in_pixels
        win_left, win_right = self.get_window(left), self.get_window(right)
        self.moveresize(win_left, x=0, y=0, width=w/2, height=h)
        self.moveresize(win_right, x=w/2, y=0, width=w/2, height=h)
        #self.display.flush()

    def moveresize(self, window, gravity=0, x=-1, y=-1, width=-1, height=-1):
        """ This is mostly adapted from the pywmctrl project
            See: http://hg.lophus.org/pywmctrl/file/tip/pywmctrl.py
            
            Negative values mean zero
        """
        flags = gravity
        if x > -1:
            flags |= 1 << 8
        else:
            x = 0
        if y > -1:
            flags |= 1 << 9
        else:
            y = 0
        if width > 0:
            flags |= 1 << 10
        else:
            width = 0
        if height > 0:
            flags |= 1 << 11
        else:
            height = 0
        data = [flags, x, y, width, height]
        fillup = [0] * (5 - len(data))
        moveresize = ClientMessage(
            window=window,
            client_type=self.MOVERESIZE,
            data=(32, data + fillup))
        mask = (SubstructureRedirectMask|SubstructureNotifyMask)
        self.root.send_event(moveresize, event_mask=mask)
        self.display.sync()



def main():
    """Get all open window names and their ids in xprop style (hexadecimal)
    
    Option '-t' / '--tile':
    Tile first two windows of clientlist instead of showing id's
    """
    parser = OptionParser(
        'Usage: %prog [-t|--tile] [-h|--help]\n' \
        'Get all open window names and their ids in xprop style (hexadecimal)')

    parser.add_option(
        '-t',
        '--tile',
        dest='tile',
        action='store_true',
        help="tile first two windows of clientlist instead of showing id's")

    (options, args) = parser.parse_args()

    wc = WinControl()

    if options.tile:
        try:
            left, right = wc.get_xids(only_xids=True, wins=True, max=2)
        except IndexError:
            print >> sys.stderr, 'Could not tile: Found less than two windows'
            sys.exit(1)
        wc.tile(left, right)

    else:
        for xid, name in wc.get_xids(wins=True):
            print hex(xid), name


if __name__ == '__main__':
    main()

#!/usr/bin/env python

""" Tile your open windows

    Based on python-wnck. To download the module visit:
    http://rox4debian.berlios.de/0install/Python-Wnck.xml
"""

from optparse import OptionParser
import sys

import wnck


class Screen(object):
    """ Provide access to open windows and screen size
    """
    def __init__(self):
        self.screen = wnck.screen_get_default()
        self.screen.force_update()

    def get_windows(self, max=-1):
        """ Check client list for 'real' windows

            Yield ALL windows as tuples (name, winobj)
            Setting max will limit that 

            NOTE: winobj is a wnck.Window object. See perl-doc for details:
            http://gtk2-perl.sourceforge.net/doc/pod/Gnome2/Wnck/Window.html
        """
        windows = [win for win in self.screen.get_windows()
                   if self.iswindow(win)]
        if max == -1:
            max = len(windows)
        for i in xrange(max):
            win = windows[i]
            if self.iswindow(win):
                yield win.get_name(), win

    def iswindow(self, win):
        return win.get_window_type() == wnck.WindowType(0)

    def get_screen_size(self):
        return self.screen.get_width(), self.screen.get_height()


def tile():
    """ TODO: Tile window objects according to specified settings
        Current status only tiles first two windows from client list verticale
    """
    screen = Screen()
    left, right = screen.get_windows(max=2)
    width, height = screen.get_screen_size()
    left[1].set_geometry('current', 'width', 0, 0, width/2, height)
    right[1].set_geometry('current', 'width', width/2, 0, width/2, height)
    return "Tiled '%s' and '%s'" % (left[0], right[0]) 


def main():
    """ Get all open window names and their ids in xprop style (hexadecimal)
    
        Option '-t' / '--tile':
        Tile first two windows of clientlist instead of showing id's
    """
    parser = OptionParser(
        'Usage: %prog [-t|--tile] [-h|--help]\n' \
        'Get all open window names and their ids in xprop style (hexadecimal)')

    parser.add_option(
        '-t',
        '--tile',
        dest='tile',
        action='store_true',
        help="tile first two windows of clientlist instead of showing id's")

    (options, args) = parser.parse_args()

    if options.tile:
        try:
            print tile()
        except IndexError:
            print >> sys.stderr, 'Could not tile: Found less than two windows'
            sys.exit(1)

    else:
        screen = Screen()
        for name, winobj in screen.get_windows():
            print hex(int(winobj.get_xid())), name


if __name__ == '__main__':
    main()

from subprocess import PIPE, Popen

def get_windows():
    """ Return a list of all open windows

        Use 9-tuples for each window 
        (id, desktop, pid, x, y, width, height, client, title)

        id      : window identity (hexadecimal)
        desktop : desktop number (-1 means sticky window, e.g. panels)
        pid     : window pid
        x       : x-offset
        y       : y-offset
        width   : window width
        height  : window height
        client  : client machine name
        title   : window title

        NOTE: All values are strings # TODO
    """
    return [tuple(line.split(None, 8)) for line in _wclines('-lpG') if line]


def get_workarea():
    """ Return workarea geometry of current desktop
        (this means the area without panels)

        Use 2-tuple (x, y)
    """
    for line in _wclines('-d'):
        if '*' in line: # '*' marks current desktop
            break
    geometry = line.split(None, 9)[8]
    return tuple(map(int, geometry.split('x')))


def _wclines(arg):
    """ Run wmctrl with specified arg and return output lines in a list
    """ 
    return Popen(['wmctrl', arg], stdout=PIPE).communicate()[0].split('\n')