cycle_dimensions()

Complexity

Conditions

9

Size

Total Lines

81

Duplication

Lines	0
Ratio	0 %

Importance

Changes	8
Bugs	1	Features	1

"""Available window-management commands"""
           the same function with different arguments.

           @param command_map: A dict mapping command names to argument lists.
           @type command_map: C{dict}
           """
        # TODO: Refactor and redesign for better maintainability
        def decorate(func):
            """Closure used to allow decorator to take arguments"""
            for cmd, arglist in command_map.items():
                self.add(cmd, *arglist)(func)
            return func
        return decorate

    def call(self, command, winman, *args, **kwargs):
        # type: (str, WindowManager, *Any, **Any) -> Any
        # TODO: Decide what to do about return values
        """Resolve a textual positioning command and execute it."""
        cmd = self.commands.get(command, None)

        if cmd:
            logging.debug("Executing command '%s' with arguments %r, %r",
                          command, args, kwargs)
            cmd(winman, *args, **kwargs)
        else:
            logging.error("Unrecognized command: %s", command)


#: The instance of L{CommandRegistry} to be used in 99.9% of use cases.
commands = CommandRegistry()

The name commands does not conform to the constant naming conventions ((([A-Z_][A-Z0-9_]*)|(__.*__))$).

def cycle_dimensions(winman,      # type: WindowManager
                     win,         # type: Any  # TODO: Consistent Window type
                     state,       # type: Dict[str, Any]
                     *dimensions  # type: Any
                     ):  # type: (...) -> Optional[gtk.gdk.Rectangle]
    # type: (WindowManager, Any, Dict[str, Any], *Tuple[...]) ->
    # TODO: Standardize on what kind of window object to pass around
    """Cycle the active window through a list of positions and shapes.

    Takes one step each time this function is called.

    If the window's dimensions are not within 100px (by euclidean distance)
    of an entry in the list, set them to the first list entry.

    @param dimensions: A list of tuples representing window geometries as
        floating-point values between 0 and 1, inclusive.
    @type dimensions: C{[(x, y, w, h), ...]}
    @type win: C{gtk.gdk.Window}

    @returns: The new window dimensions.
    @rtype: C{gtk.gdk.Rectangle}
    """
    win_geom = winman.get_geometry_rel(win, state['monitor_geom'])
    usable_region = state['usable_region']

    # Get the bounding box for the usable region (overlaps panels which
    # don't fill 100% of their edge of the screen)
    clip_box = usable_region.get_clipbox()

    logging.debug("Selected preset sequence:\n\t%r", dimensions)

    # Resolve proportional (eg. 0.5) and preserved (None) coordinates
    dims = []
    for tup in dimensions:
        current_dim = []
        for pos, val in enumerate(tup):
            if val is None:
                current_dim.append(tuple(win_geom)[pos])
            else:
                # FIXME: This is a bit of an ugly way to get (w, h, w, h)
                # from clip_box.
                current_dim.append(int(val * tuple(clip_box)[2 + pos % 2]))

        dims.append(current_dim)

    if not dims:
        return None

    logging.debug("Selected preset sequence resolves to these monitor-relative"
                  " pixel dimensions:\n\t%r", dims)

    # Calculate euclidean distances between the window's current geometry