Exemplo n.º 1
0
    def parse_output(self, data):
        groups = self.GROUP_RE.split(data)
        devs = []

        for g in groups:
            m = self.DEVICE_RE.search(g)
            if not m or not self.FROM_ALSA.has_key(m.group(1)):
                continue

            dev = self.FROM_ALSA[m.group(1)]

            mono = None
            left = None
            right = None

            for channel, volume in self.VOLUME_RE.findall(g):
                if channel == 'Mono':
                    mono = int(volume)
                elif channel == 'Front Left':
                    left = int(volume)
                elif channel == 'Front Right':
                    right = int(volume)

            wmanager.debug('mixer', 'dev %s: %s,%s or %s', dev, left, right,
                           mono)

            if left is not None and right is not None:
                devs.append((dev, (left, right)))
            elif mono is not None:
                devs.append((dev, mono))

        return devs
Exemplo n.º 2
0
 def M5_n(self, evt):
     wmanager.debug('keys', 'Moving window to new view')
     if self.wm.current_client:
         c = self.wm.current_client
         c.iconify()
         self.wm.current_screen.view_new()
         c.deiconify()
Exemplo n.º 3
0
    def S_Pause(self, evt):
        wmanager.debug('keys', 'dropping keygrabs temporarily')

        # First release all our grabs.  They will be reinstalled
        # by BypassHandler when it exits
        self._ungrab()
        BypassHandler(self)
Exemplo n.º 4
0
    def __wm_init__(self):
        for ifclass in INTERFACE_CLASSES:
            interface = ifclass()
            status = self.system(interface.probe_cmd(), fg=1)

            # Probe OK?
            if os.WIFEXITED(status) and os.WEXITSTATUS(status) == 0:
                wmanager.debug('mixer', 'using interface %s', ifclass.__name__)
                self.mixer_interface = interface
                break
        else:
            wmanager.debug('mixer', 'could not find any interface to use')
            self.mixer_interface = None
            return

        self.dispatch.add_handler(MixerIOEventType, self.mixer_io_event)
        self.dispatch.add_handler(MixerTimeoutEventType, self.mixer_timout)

        self.mixer_devs = {}

        self.mixer_mute_devs = {}

        self.mixer_status_msg = None
        self.mixer_timer_event = None

        self.mixer_cmd_out = None
        self.mixer_update_settings()
Exemplo n.º 5
0
    def __client_init__(self):
        self.traceim_message = None

        filters = None
        for f in self.traceim_filters:
            if f.enable(self):
                if filters is None:
                    wmanager.debug(
                        'traceim',
                        'Enabling IM tracing for %s' % self.get_title())
                    self.dispatch.add_handler(X.PropertyNotify,
                                              self.traceim_handle_property)
                    self.dispatch.add_handler(wmevents.ClientIconified,
                                              self.traceim_handle_iconified)
                    self.dispatch.add_handler(wmevents.ClientDeiconified,
                                              self.traceim_handle_iconified)
                    self.dispatch.add_handler(wmevents.RemoveClient,
                                              self.traceim_handle_removed)
                    filters = [f]
                else:
                    filters.append(f)

        if filters:
            self.traceim_filters = filters
            self.traceim_message = None
            self.traceim_update()
Exemplo n.º 6
0
    def mixer_set(self, dev, val1, val2=None):
        if self.mixer_interface is None:
            wmanager.debug('mixer', 'no mixer interface')
            return

        try:
            values = self.mixer_devs[dev]
        except KeyError:
            return

        assert val1 >= 0 and val1 <= 100
        assert val2 is None or (val2 >= 0 and val2 <= 100)

        if type(values) is types.TupleType:
            if val2 is None:
                val2 = val1

            self.mixer_devs[dev] = (val1, val2)
            cmd = self.mixer_interface.set_cmd(dev, val1, val2)
        else:
            self.mixer_devs[dev] = val1
            cmd = self.mixer_interface.set_cmd(dev, val1, None)

        if cmd:
            self.system(cmd, fg=1)

            try:
                del self.mixer_mute_devs[dev]
            except KeyError:
                pass
Exemplo n.º 7
0
    def __screen_client_init__(self):
        "Create the initial pane object for this screen."

        wmanager.debug('panesScreen', 'Initializing screen %d', self.number)
        self.dispatch.add_handler(X.ConfigureRequest, self.panes_configure)
        pane = Pane(self, 0, 0, self.root_width, self.root_height)
        self.panes_fullscreen(pane)
        self.wm.panes_add(pane)
Exemplo n.º 8
0
 def KP_Begin(self, event):
     wmanager.debug('keys', 'Entering move-resize mode')
     if self.wm.focus_client:
         try:
             mv = MoveResizeKeys(self.wm, self.dispatch,
                                 self.wm.focus_client, event.time)
         except keys.error, status:
             wmanager.debug('keys', 'Grabbing keyboard failed: %d', status)
Exemplo n.º 9
0
    def next_window(self):
        "Move to the next window in this pane."

        wmanager.debug('Pane', 'next window')
        clients = self.screen.query_clients(panefilter(self), 1)
        if len(clients) > 1:
            self.deactivate()
            self.window = clients[0]
            self.activate()
Exemplo n.º 10
0
 def add_units(self, cls):
     for unit, path in self.find_units(cls.PROC_DIR):
         try:
             b = cls(unit, path)
             self.infos.append(b)
             self.units[(cls.EVENT, unit)] = b
         except (IOError, BadInfo), e:
             wmanager.debug('acpi', 'could not add %s %s: %s', cls.__name__,
                            unit, e)
Exemplo n.º 11
0
    def panes_prev(self):
        "Move to the previous pane."

        if len(self.panes_list) > 1:
            wmanager.debug('panesManager', 'previous pane')
            self.panes_list[self.panes_current].deactivate()
            self.panes_current = self.panes_current - 1
            if self.panes_current < 0:
                self.panes_current = len(self.panes_list) - 1
            self.panes_list[self.panes_current].activate()
Exemplo n.º 12
0
    def panes_next(self):
        "Move to the next pane."

        if len(self.panes_list) > 1:
            wmanager.debug('panesManager', 'next pane')
            self.panes_list[self.panes_current].deactivate()
            self.panes_current = self.panes_current + 1
            if self.panes_current == len(self.panes_list):
                self.panes_current = 0
            self.panes_list[self.panes_current].activate()
Exemplo n.º 13
0
    def mw_clock_update(self):
        t = time.localtime(time.time())
        s = time.strftime(self.mw_clock_format, t)
        self.mw_clock_message.set_text(s)

        wmanager.debug('clock', 'updated to "%s", rescheduling in %d seconds',
                       s, 61 - t[5])

        # Trig a timer when minute change
        self.events.add_timer(event.TimerEvent(ClockEventType,
                                               after=61 - t[5]))
Exemplo n.º 14
0
    def prev_window(self):
        "Move to the previous window in this pane."

        wmanager.debug('Pane', 'previous window')
        clients = self.screen.query_clients(panefilter(self), 1)
        if len(clients) > 1:
            self.deactivate()
            # Lower the old window to make it the "next" window.
            self.window.lowerwindow()
            self.window = clients[len(clients) - 2]
            self.activate()
Exemplo n.º 15
0
    def __wm_screen_init__(self):
        "Create the list of panes with no current pane."
        global WM_TRANSIENT_FOR

        wmanager.debug('panesManager', 'inited')

        # Warning - if we manage more than one display, this breaks!
        if not WM_TRANSIENT_FOR:
            WM_TRANSIENT_FOR = self.display.intern_atom("WM_TRANSIENT_FOR")

        self.panes_list = []
        self.panes_current = None
Exemplo n.º 16
0
    def Pause(self, evt):
        wmanager.debug('keys', 'reinstalling keygrabs')

        self._screen.modewindow_remove_message(self._message)

        # Delete ourself, and reinstall the callee grabs
        self._cleanup()
        self._keyhandler._buildmap()

        # Remove it, just to be sure there are no circular references
        del self._keyhandler
        del self._screen
Exemplo n.º 17
0
    def S_Pause(self, evt):
        """Drop all keygrabs until Scroll_Lock is pressed again.

        Allows clients to recieve keys used by plwm.

        """
        wmanager.debug('keys', 'dropping keygrabs temporarily')

        # First release all our grabs.  They will be reinstalled
        # when BypassHandler exits

        self._ungrab()
        BypassHandler(self)
Exemplo n.º 18
0
    def add_window(self, window):
        "Add a window to this pane."

        wmanager.debug('Pane', 'Adding window %s to pane %s', window, self)
        if window == self.window: return
        old = window.panes_pane
        if old != self:
            if old: old.remove_window(window)
            self.place_window(window)
        window.panes_pane = self
        if self.window: self.deactivate()
        self.window = window
        self.activate()
Exemplo n.º 19
0
    def mixer_mute(self, dev):
        """Toggle muteness of DEV."""

        if self.mixer_interface is None:
            wmanager.debug('mixer', 'no mixer interface')
            return

        if self.mixer_mute_devs.has_key(dev):
            old = self.mixer_mute_devs[dev]
            self.mixer_set(dev, old)
        else:
            old = self.mixer_get(dev)
            self.mixer_set(dev, 0)
            self.mixer_mute_devs[dev] = old
Exemplo n.º 20
0
    def mixer_get(self, dev, stereo=0):
        if self.mixer_interface is None:
            wmanager.debug('mixer', 'no mixer interface')
            return None

        try:
            values = self.mixer_devs[dev]

            if type(values) is types.TupleType:
                return values[0]
            else:
                return values
        except KeyError:
            return None
Exemplo n.º 21
0
    def remove_window(self, window):
        "Tag a window as not belonging to me."

        wmanager.debug('Pane',
                       'Removing window %s from pane %s' % (window, self))
        window.panes_pane = None
        if self.window == window:
            self.deactivate()
            clients = self.screen.query_clients(panefilter(self), 1)
            if not clients: self.window = None
            else:
                self.window = clients[len(clients) - 1]
                if self.wm.panes_list[self.wm.panes_current] == self:
                    self.activate()
Exemplo n.º 22
0
    def do_activate(self):
        "Activate whatever is currently my window."

        self.wm.current_screen = self.screen
        if self.window and not self.window.withdrawn:
            wmanager.debug(
                'Pane',
                'Activating window %s in pane %s' % (self.window, self))

            # Will raise window and give focus
            self.window.activate()
            pos = self.window.panes_pointer_pos
            if pos:
                self.window.warppointer(pos[0], pos[1])
Exemplo n.º 23
0
	def __screen_client_init__(self):
		"Create the initial pane object for this screen."
		global WM_TRANSIENT_FOR
		# Warning - if we manage more than one display, this breaks!
		if not WM_TRANSIENT_FOR:
			WM_TRANSIENT_FOR = self.wm.display.intern_atom("WM_TRANSIENT_FOR")

		self.panes_list = []
		self.current_pane = None

		wmanager.debug('panesScreen', 'Initializing screen %d', self.number)
		self.dispatch.add_handler(X.ConfigureRequest, self.panes_configure)
		pane = Pane(self, 0, 0, self.root_width, self.root_height)
		self.panes_fullscreen(pane)
		self.panes_add(pane)
Exemplo n.º 24
0
	def activate(self):
		"Activate whatever is currently my window."

		self.wm.current_screen = self.screen
		if self.screen.current_pane != self:
			self.screen.current_pane.deactivate()
			self.screen.current_pane = self
		if self.window and not self.window.withdrawn:
			wmanager.debug('Pane', 'Activating window %s in pane %s' %
							(self.window, self))
			self.window.activate()
			self.window.warppointer()
		event = paneFocus()
		event.pane = self
		self.wm.misc_dispatch.dispatch_event(event)
Exemplo n.º 25
0
	def add_window(self, window):
		"Add a window to this pane."

		if window in self.window_list:
			return
		wmanager.debug('Pane', 'Adding window %s to pane %s', window, self)

		self.window_list.append(window)
		prev_pane = window.pane
		if prev_pane != self:
			if prev_pane:
				prev_pane.remove_window(window)
			self.place_window(window)
			window.pane = self
		self.window = window
		self.activate()
Exemplo n.º 26
0
class UnixLoad:
    loadcmd = "/usr/bin/uptime"
    load_re = re.compile(r'(\d+.\d\d)[, ]+(\d+.\d\d)[, ]+(\d+.\d\d)')

    def probe(self):
        return os.path.isfile(self.loadcmd)

    def get(self, wm):
        pipes = wm.system(self.loadcmd, redirect = 1)
        out = pipes[1]

        try:
            s = out.readline()
        except IOError, err:
            if err.errno == errno.EINTR:
                s = out.readline()
        out.close()

        wmanager.debug('mw_load', 'output: %s', s)

        m = self.load_re.search(s)
        if m:
            return string.join(m.groups(), ' ')
        else:
            return ''
Exemplo n.º 27
0
    def mw_acpi_handle_socket_event(self, evt):
        if evt.state & event.FileEvent.READ:
            try:
                data = self.mw_acpi_socket.recv(200)
            except socket.error, e:
                wmanager.debug('acpi',
                               'failed to receive from event socket: %s', e)
                data = ''

            if data:
                newstatus = self.mw_acpi_interface.handle_event_socket(data)
                self.mw_acpi_update(newstatus)
            else:
                wmanager.debug('acpi', 'event socket closed')
                self.mw_acpi_socket.close()
                self.mw_acpi_socket = None
                self.mw_acpi_socket_event.cancel()
Exemplo n.º 28
0
	def place_window(self, window = None):
		"Figure out where the window should be put."

		if window is None:
			window = self.window
		if window is None:
			return
		wmanager.debug('Pane', 'Placing window %s for pane %s' % (window, self))

		# Bypassing size hints/gravity, they seem useless for tiles.
		width = self.width - 2 * window.border_width
		height = self.height - 2 * window.border_width
		x, y = self.x, self.y
		x, y, width, height = window.keep_on_screen(x, y, width, height)

		wmanager.debug('Pane-configure', 'Resizing window from %d, %d to %d, %d' %
						(window.width, window.height, width, height))
		window.moveresize(x, y, width, height)
Exemplo n.º 29
0
    def mixer_update_settings(self):
        if self.mixer_interface is None:
            wmanager.debug('mixer', 'no mixer interface')
            return

        if self.mixer_cmd_out is not None:
            wmanager.debug('mixer',
                           'previous update command has not finished yet')
            return

        pipes = self.system(self.mixer_interface.get_cmd(), redirect=1)

        self.mixer_cmd_out = pipes[1]
        self.mixer_cmd_data = ''
        self.mixer_cmd_event = event.FileEvent(MixerIOEventType,
                                               self.mixer_cmd_out,
                                               event.FileEvent.READ)
        self.events.add_file(self.mixer_cmd_event)
Exemplo n.º 30
0
    def handle_event(self, eventstr):
        m = self.event_re.match(eventstr)
        if not m:
            wmanager.debug('acpi', 'could parse event, closing socket:',
                           eventstr)
            self.socket.close()
            return

        event = m.group(1).replace('/', '_')
        arg = m.group(2)

        try:
            unit = self.units[(event, arg)]
        except KeyError:
            wmanager.debug('acpi', 'unknown event: %s', eventstr)
            return

        if unit.update():
            self.status_changed = 1
Exemplo n.º 31
0
    def traceim_update(self):
        m = []
        for f in self.traceim_filters:
            if f.unseen(self):
                m.append(f.message)

        if m:
            m = ' '.join(m)
            if m != self.traceim_message:
                wmanager.debug('traceim', 'Unseen IM for %s: %s',
                               self.get_title(), m)
                self.traceim_message = m
                self.wm.traceim_add_message(self, m)
        else:
            if self.traceim_message:
                wmanager.debug('traceim', 'No longer unseen IM for %s',
                               self.get_title())
                self.traceim_message = None
                self.wm.traceim_remove_message(self)
Exemplo n.º 32
0
	def __client_init__(self):
		"Arrange to open in the current pane."

		wmanager.debug('Pane', 'Initing client %s', self)
		# Set this clients gravity
		if self.window.get_property(WM_TRANSIENT_FOR, Xatom.WINDOW, 0, 1) is not None:
			self.panes_gravity = self.screen.panes_transient_gravity
		elif self.sizehints and self.sizehints.flags & Xutil.PMaxSize:
			self.panes_gravity = self.screen.panes_maxsize_gravity
		else:
			self.panes_gravity = self.screen.panes_window_gravity

		self.pane = None
		pane = self.screen.current_pane
		if pane.screen != self.screen:
			pane = filter(lambda p, m=self.screen: p.screen == m, self.screen.panes_list)[0]
		pane.add_window(self)
		self.dispatch.add_handler(X.UnmapNotify, self.panes_unmap)
		self.dispatch.add_handler(X.DestroyNotify, self.panes_unmap)
Exemplo n.º 33
0
    def __client_init__(self):
        "Arrange to open in the current pane."

        wmanager.debug('Pane', 'Initing client %s', self)
        # Set this clients gravity
        if self.window.get_property(WM_TRANSIENT_FOR, Xatom.WINDOW, 0,
                                    1) is not None:
            self.panes_gravity = self.wm.panes_transient_gravity
        elif self.sizehints and self.sizehints.flags & Xutil.PMaxSize:
            self.panes_gravity = self.wm.panes_maxsize_gravity
        else:
            self.panes_gravity = self.wm.panes_window_gravity

        self.panes_pointer_pos = self.panes_pane = None
        pane = self.wm.panes_list[self.wm.panes_current]
        if pane.screen != self.screen:
            pane = filter(lambda p, m=self.screen: p.screen == m,
                          self.wm.panes_list)[0]
        pane.add_window(self)
        self.dispatch.add_handler(X.UnmapNotify, self.panes_unmap)
        self.dispatch.add_handler(X.DestroyNotify, self.panes_unmap)
Exemplo n.º 34
0
    def mixer_status_view(self, devs=None, stereo=0, timeout=5):
        if self.mixer_interface is None:
            wmanager.debug('mixer', 'no mixer interface')
            return

        if devs is None:
            devs = self.mixer_devs.keys()

        msg = ''
        for dev in devs:
            try:
                val = self.mixer_mute_devs[dev]
                valstr = 'MUTE:%s' % val
            except KeyError:
                try:
                    values = self.mixer_devs[dev]

                    if type(values) is types.TupleType:
                        if stereo:
                            valstr = '%s:%s' % values
                        else:
                            valstr = str(values[0])
                    else:
                        valstr = str(values)
                except KeyError:
                    valstr = 'N/A'

            msg = '%s  [%s %s]' % (msg, dev, valstr)

        if self.mixer_status_msg is None:
            self.mixer_status_msg = self.current_screen.modestatus_new(msg)
        else:
            self.mixer_status_msg.set(msg)

        if self.mixer_timer_event is not None:
            self.mixer_timer_event.cancel()

        self.mixer_timer_event = event.TimerEvent(MixerTimeoutEventType,
                                                  after=timeout)
        self.events.add_timer(self.mixer_timer_event)
Exemplo n.º 35
0
    def place_window(self, window=None):
        "Figure out where the window should be put."

        if not window: window = self.window
        wmanager.debug('Pane',
                       'Placing window %s for pane %s' % (window, self))
        width, height = window.follow_size_hints(
            self.width - 2 * window.border_width,
            self.height - 2 * window.border_width)

        # If it doesn't fit, just force it.
        if width > self.width - 2 * window.border_width:
            width = self.width - 2 * window.border_width
        if height > self.height - 2 * window.border_width:
            height = self.height - 2 * window.border_width

        if window.panes_gravity in (X.NorthEastGravity, X.EastGravity,
                                    X.SouthEastGravity):
            x = self.x
        elif window.panes_gravity in (X.NorthGravity, X.CenterGravity,
                                      X.SouthGravity):
            x = self.x + (self.width - width) / 2 - window.border_width
        else:
            x = self.x + self.width - width - (2 * window.border_width)

        if window.panes_gravity in (X.NorthEastGravity, X.NorthGravity,
                                    X.NorthWestGravity):
            y = self.y
        elif window.panes_gravity in (X.EastGravity, X.CenterGravity,
                                      X.WestGravity):
            y = self.y + (self.height - height) / 2 - window.border_width
        else:
            y = self.y + self.height - height - (2 * window.border_width)

        x, y, width, height = window.keep_on_screen(x, y, width, height)

        wmanager.debug(
            'Pane-configure', 'Resizing window from %d, %d to %d, %d' %
            (window.width, window.height, width, height))
        window.moveresize(x, y, width, height)
Exemplo n.º 36
0
	def remove_window(self, window):
		"Disown a window and cycle a new one into focus."

		if window.pane != self or window not in self.window_list:
			return
		wmanager.debug('Pane', 'Removing window %s from pane %s' % (window, self))
		window.pane = None
		windex = self.window_list.index(window)
		self.window_list.remove(window)
		if self.window == window:
			# Jump back towards the beginning of the window list.
			if windex > 0:
				windex -= 1
			elif self.window_list != []:
				windex = 0
			else:
				self.window = None
				if self.screen.current_pane == self:
					self.wm.set_current_client(None)
				return

			self.window = self.window_list[windex]
			if self.screen.current_pane == self:
				self.activate()
Exemplo n.º 37
0
	def panes_add(self, pane):
		"Add the given pane to the list of all panes."

		wmanager.debug('panesManager', 'added pane %s', `pane`)
		self.panes_list.append(pane)
		if self.current_pane is None: self.current_pane = self.panes_list[0]
Exemplo n.º 38
0
 def  __screen_client_init__( self ):
     log.debug( "tritiumScreen. __screen_client_init__" )
     "Create the initial pane object for this screen."
     wmanager.debug( 'panesScreen', 'Initializing screen %d', self.number )
     self.dispatch.add_handler( X.ConfigureRequest, self.configure_frame )