wmctile 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 16b4da5f2f8892f738465972730909f76079953b
-  data.tar.gz: 3d729136ffae9de4207c4c98bf22535520c43ca3
+  metadata.gz: cedbd5d2774446b458abd0a2606c1febd81115f4
+  data.tar.gz: d5749f69feaa8bff5410816fc0901fce8f52aad5
 SHA512:
-  metadata.gz: 5058b584b245cc4723496cb5169804e051b99a67dd7b5086c3769b388ac521b11237d7c933c22d40d353f1d25c1be7aff7d84492481673eb771b841f73f408b6
-  data.tar.gz: e70823a836615baabb513342a5804f904309c1c337876962f143ddd5dae239a8703f6e2be6cd245018fdc1f201c058a9bdc1e31aed39bf55468e7946f8589e72
+  metadata.gz: 586d18fa5307b49a679b5eef6700e634ee28d8e3f882a35542aff38339df9fce9f62cc153a94dddfb91bcaf18a9a866b52e234d62b7ba5c60f404ddfb8a57e60
+  data.tar.gz: d1800abad113bfb9e94786e289487b561adae921f8661235436065dce190aabc2d71d5706708697156de571bee78d9832e80e9043ff8ae421efdfabb0468e296

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require 'pry'
+require_relative '../lib/wmctile'
+
+windows = []
+
+`wmctrl -lx | grep -v ' -1 ' | awk '{ print $1 }'`.chomp.split("\n").map do |id|
+  windows << Wmctile::Window.new({}, id)
+end
+
+binding.pry
+
+# Need for pry to work (see https://github.com/deivid-rodriguez/pry-byebug/issues/45)
+puts 'Returning from console.'

data/bin/wmctile

@@ -1,5 +1,23 @@
 #!/usr/bin/env ruby
+require 'optparse'
 require_relative '../lib/wmctile'
 
-router = Wmctile::Router.new
-router.dispatch ARGV
+options = {}
+OptionParser.new do |opts|
+  opts.banner = 'Usage: wmctile [options] [window_strings]...'
+
+  opts.on('--switch-to', 'Switch to target window\'s workspace and focus it.') { |o| options[:switch_to] = o }
+  opts.on('--summon', 'Summon target window to current workspace and focus it.') { |o| options[:summon] = o }
+  opts.on('--shade', 'Shade (minimize) a window.') { |o| options[:shade] = o }
+  opts.on('--unshade', 'Unshade a window.') { |o| options[:unshade] = o }
+
+  opts.on('-a', '--active-window', 'Use the active window instead of [window_strings].') { |o| options[:use_active_window] = o }
+  opts.on('-c', '--current-workspace', 'Search for windows only in the current workspace.') { |o| options[:current_workspace] = o }
+  opts.on('-x [CMD]', '--exec [CMD]', 'Run a command when no window matching window_strings is found.') { |o| options[:exec] = o }
+end.parse!
+
+begin
+  Wmctile::Router.new options, ARGV
+rescue StandardError => e
+  `if which notify-send; then notify-send -i 'error' 'wmctile' '#{e}'; else echo '#{e}'; fi`
+end

data/lib/wmctile.rb

@@ -1,11 +1,40 @@
+#
+# @author Petr Marek <contact@petrmarek.eu>
+#
 module Wmctile
+  #
+  # Fetches windows from wcmtrl.
+  #
+  # @return [Array] Array of windows.
+  #
+  def self.window_list
+    @window_list ||= `wmctrl -lx`.chomp.split(/\n/)
+    @window_list
+  end
+
+  #
+  # Fetches the current workspace number from wmctrl.
+  #
+  #
+  # @return [String] Current workspace number.
+  #
+  def self.current_workspace
+    @current_workspace ||= `wmctrl -d | grep '\*' | cut -d' ' -f 1`.chomp
+    @current_workspace
+  end
+
+  #
+  # Fetches the current window id.
+  #
+  #
+  # @return [String] Current window id.
+  #
+  def self.current_window_id
+    @current_window_id ||= `wmctrl -a :ACTIVE: -v 2>&1`.chomp.split('Using window: ')[1]
+    @current_window_id
+  end
 end
 
-require_relative 'wmctile/class'
-require_relative 'wmctile/class_with_dmenu'
-require_relative 'wmctile/settings'
-require_relative 'wmctile/memory'
-require_relative 'wmctile/window'
-require_relative 'wmctile/window_manager'
-require_relative 'wmctile/window_tiler'
+require_relative 'wmctile/errors'
 require_relative 'wmctile/router'
+require_relative 'wmctile/window'

data/lib/wmctile/errors.rb

@@ -0,0 +1,12 @@
+module Wmctile
+  module Errors
+    #
+    # Class WindowNotFound provides an error class for Window
+    #
+    class WindowNotFound < StandardError
+      def initialize(window_string)
+        super(%(No matching window found for: "#{window_string}".))
+      end
+    end
+  end
+end

data/lib/wmctile/router.rb

@@ -1,187 +1,53 @@
-class Wmctile::Router < Wmctile::Class
-	##################################
-	## init ##########################
-	##################################
-	def initialize
-		@settings = Wmctile::Settings.new
-		@all_workspaces = false
-	end
-	##################################
-	## main dispatch method ##########
-	##################################
-	def dispatch args = []
-		if args.length
-			main_arg = args[0]
-			if ['--all-workspaces', '-a'].include? main_arg 
-				@all_workspaces = true
-				drop = 2
-				main_arg = args[1]
-			else
-				@all_workspaces = false
-				drop = 1
-			end
-			if main_arg and !['dispatch', 'initialize', 'wm', 'wt', 'memory'].include? main_arg and self.respond_to? main_arg
-				self.send main_arg, *args.drop(drop)
-			else
-				self.help
-			end
-		else
-			self.help
-		end
-	end
-	##################################
-	## object getter methods #########
-	##################################
-	def wm
-		@wm || @wm = Wmctile::WindowManager.new(@settings)
-	end
-	def wt
-		# @wm might be nil
-		@wt || @wt = Wmctile::WindowTiler.new(@settings, self.memory, @wm)
-	end
-	def memory
-		@memory || @memory = Wmctile::Memory.new
-	end
-	##################################
-	## actual command-line methods ###
-	##################################
-	def help args = nil
-		puts <<-eos
-wmctile version 0.1.2
-
-usage:
-   wmctile [--option1, --option2, ...] <command> ['argument1', 'argument2', ...]
-
-examples:
-   wmctile snap 'left' 'terminator'
-   wmctile summon --all-workspaces ':ACTIVE:'
-
-options:
-   --all-workspaces, -a
-      Use all workspaces when searching for windows. 
-
-commands:
-   summon 'window_string'
-      Summons a window matching 'window_str'.
-
-   summon_or_run 'window_string' 'command_to_run'
-      Summons a window matching 'window_string'. If no window is found, the 'command_to_run' is run.
-
-   switch_to 'window_string'
-      Switches to a window matching 'window_string'.
-
-   switch_to_or_run 'window_string' 'command_to_run'
-      Switches to a window matching 'window_string'. If no window is found, the 'command_to_run' is run.
-
-   maximize 'window_string'
-      Maximizes a window matching 'window_string'.
-
-   unmaximize 'window_string'
-      Unmaximizes a window matching 'window_string'.
-
-   shade 'window_string'
-      Shades a window matching 'window_string'.
-
-   unshade 'window_string'
-      Unshades a window matching 'window_string'.
-
-   unshade_last_shaded
-      Unshades the last shaded window on active workspace.
-
-   snap 'where' 'window_string' ['portion']
-      Snaps a window matching 'window_string' to occupy the 'where' 'portion' of the screen.
-         'where' can be one of 'left', 'right', 'top', 'bottom'
-         'portion' is a float number with the default of 0.5
-
-   resize 'where' ['portion']
-      Resizes the last performed action (snap/tile etc.) on active workspace.
-         'where' can be one of 'left', 'right', 'top', 'bottom'
-             The action depends on the previously performed action. When you resize 'left' a previous snap 'left', you're shrinking the  window. When you resize 'left' a previous snap 'right', you're increasing the size of the window.
-         'portion' is a float number with the default of 0.01 by which to edit the previous portion of the screen
-
-   resize_snap 'where' ['portion']
-      Resizes the last performed snap on active workspace. Arguments are the same as in resize command.
-
-additional information:
-   To use the active window, pass ':ACTIVE:' as the 'window_string' argument.
-		eos
-	end
-	def summon window_str
-		window = self.wm.find_in_windows window_str, @all_workspaces
-		if window
-			window.summon
-			return true
-		else
-			return false
-		end
-	end
-	def summon_or_run window_str, cmd_to_run
-		unless self.summon window_str
-			self.cmd "#{ cmd_to_run } > /dev/null &"
-		end
-	end
-	def switch_to window_str
-		window = self.wm.find_in_windows window_str, @all_workspaces
-		if window
-			window.switch_to
-			return true
-		else
-			return false
-		end
-	end
-	def switch_to_or_run window_str, cmd_to_run
-		unless self.switch_to window_str
-			self.cmd "#{ cmd_to_run } > /dev/null &"
-		end
-	end
-	def maximize window_str
-		window = self.wm.get_window window_str
-		if window
-			window.maximize
-		end
-	end
-	def unmaximize window_str
-		window = self.wm.get_window window_str
-		if window
-			window.unmaximize
-		end
-	end
-	def shade window_str
-		window = self.wm.get_window window_str
-		if window
-			window.shade
-			self.memory.set self.wm.workspace, 'shade', {
-				'window_id' => window.id
-			}
-		end
-	end
-	def unshade window_str
-		window = self.wm.get_window window_str
-		if window
-			window.unshade
-			self.memory.set self.wm.workspace, 'unshade', {
-				'window_id' => window.id
-			}
-		end
-	end
-	def unshade_last_shaded
-		win_id = self.memory.get self.wm.workspace, 'shade', 'window_id'
-		window = Wmctile::Window.new win_id, @settings
-		if window
-			window.unshade
-			self.memory.set self.wm.workspace, 'unshade', {
-				'window_id' => window.id
-			}
-		end
-	end
-	def snap where = 'left', window_str = nil, portion = 0.5
-		self.wt.snap where, window_str, portion
-	end
-	def resize where = 'left', portion = 0.01
-		self.wt.resize where, portion
-	end
-	def resize_snap where = 'left', portion = 0.01
-		self.wt.resize_snap where, portion
-	end
-
-end
+module Wmctile
+  #
+  # Router is the backbone of wmctile.
+  # It dispatches relevant methods based on the command-line arguments.
+  #
+  class Router
+    #
+    # Starts wmctile, runs the required methods.
+    #
+    # @param [Hash] command line options
+    # @param [Array] window_strings ARGV array
+    #
+    def initialize(arguments, window_strings)
+      return unless window_strings.count
+
+      @arguments = arguments
+      @window_strings = window_strings
+
+      if arguments[:switch_to]
+        window.switch_to
+      elsif arguments[:summon]
+        window.summon
+      elsif arguments[:shade]
+        window.toggle_shaded(true)
+      elsif arguments[:unshade]
+        window.toggle_shaded(false)
+      end
+    end
+
+    #
+    # Creates a new window based on @arguments and @window_strings.
+    # If no window is found, checks for the -x/--exec argument. If present, executes it.
+    #
+    # @param [Integer] index index of the window from matching windows array
+    #
+    # @return [Window] window instance
+    #
+    def window(index = 0)
+      if @arguments[:use_active_window]
+        Window.new(@arguments, Wmctile.current_window_id)
+      else
+        Window.new(@arguments, @window_strings[index])
+      end
+    rescue Errors::WindowNotFound
+      if @arguments[:exec]
+        # Exec the command
+        puts "Executing command: #{@arguments[:exec]}"
+        `#{@arguments[:exec]} &`
+      end
+      raise Errors::WindowNotFound, @window_strings[index]
+    end
+  end
+end

data/lib/wmctile/window.rb

@@ -1,69 +1,121 @@
-class Wmctile::Window < Wmctile::Class
-	attr_accessor :id, :name, :title
+module Wmctile
+  #
+  # Window is the core element of wmctile. It is described by an id, which has to be fetched from a window_string.
+  #
+  class Window
+    #
+    # Window init function. Tries to find an id.
+    #
+    #
+    # @param [Hash] arguments command line options
+    # @param [String] window_string command line string given
+    #
+    def initialize(arguments, window_string)
+      @window_string = window_string
+      @regexp_string = Regexp.new(window_string)
+      find_window(arguments[:current_workspace])
+    end
 
-	def initialize win_string, settings
-		@default_movement = { :x => 0, :y => 0, :width => '-1', :height => '-1' }
-		@settings = settings
-		@id = win_string[/0x[\d\w]{8}/]
-		self.get_name_and_title win_string
-	end
-	def get_name_and_title win_string
-		if win_string == @id
-			@name = ''
-			@title = ''
-		else
-			after_id_and_workspace = win_string[14..-1].split(/\s+#{ @settings.hostname }\s+/, 2)
-			@name = after_id_and_workspace[0]
-			@title = after_id_and_workspace[1]
-		end
-	end
-	def dmenu_item
-		unless @dmenu_item
-			str = "#{ @id } #{ @name } #{ @title }"
-			@dmenu_item = Dmenu::Item.new str, self
-		end
-		@dmenu_item
-	end
-	def get_name
-		if @name == ''
-			self.get_name_and_title self.cmd('wmctrl -lx | grep ' + @id)
-		end
-		@name
-	end
-	def get_name_length
-		@name.length
-	end
-	def set_name_length name_length
-		@name += ' '*(name_length - @name.length)
-	end
-	def wmctrl wm_cmd = '', summon = false
-		self.cmd "wmctrl -i#{ summon ? 'R' : 'r' } #{ @id } #{ wm_cmd }"
-		return self # return self so that commands can be chained
-	end
-	def move how_to_move = {}
-		how_to_move = @default_movement.merge! how_to_move
-		cmd = "-e 0,#{ how_to_move[:x].to_i },#{ how_to_move[:y].to_i },#{ how_to_move[:width].to_i },#{ how_to_move[:height].to_i }"
-		self.unshade
-		self.unmaximize
-		self.wmctrl cmd
-	end
-	def shade
-		self.wmctrl '-b add,shaded'
-	end
-	def unshade
-		self.wmctrl '-b remove,shaded'
-	end
-	def summon
-		self.wmctrl '', true
-	end
-	def switch_to
-		self.cmd "wmctrl -ia #{ @id }"
-		return self
-	end
-	def maximize
-		self.wmctrl '-b add,maximized_vert,maximized_horz'
-	end
-	def unmaximize
-		self.wmctrl '-b remove,maximized_vert,maximized_horz'
-	end
-end
+    #
+    # Filters down the window_list to @matching_windows.
+    #
+    # @param [Boolean] current_workspace_only Should only the current workspace be used?
+    #
+    # @return [void]
+    #
+    def find_window(current_workspace_only = false)
+      @matching_windows = Wmctile.window_list.grep(@regexp_string)
+      filter_out_workspaces if current_workspace_only
+      if @matching_windows.count > 1
+        filter_more_matching_windows
+      elsif @matching_windows.count == 1
+        @matching_line = @matching_windows[0]
+      else
+        fail Errors::WindowNotFound, @window_string
+      end
+      extract_matching_line_information
+    end
+
+    #
+    # Filters out @matching_windows so that only the ones on current_workspace remain.
+    #
+    #
+    # @return [Array] @matching_windows
+    #
+    def filter_out_workspaces
+      @matching_windows = @matching_windows.grep(/^\w+\s+#{Wmctile.current_workspace}\s+/)
+    end
+
+    #
+    # Takes the @matching_line and extracts @id, @workspace and @wm_class
+    #
+    #
+    # @return [void]
+    #
+    def extract_matching_line_information
+      parts = @matching_line.split(/\s+/)
+      @id = parts[0]
+      @workspace = parts[1]
+      @wm_class = parts[2]
+    end
+
+    def filter_more_matching_windows
+      ids = @matching_windows.map { |matching_window| matching_window.match(/^(\w+)\s/)[1] }
+      target_index = 0
+      if ids.include? Wmctile.current_window_id
+        # Hold on to your hat, we're gonna loop!
+        i = ids.index(Wmctile.current_window_id)
+        if i + 1 < ids.count
+          # Current window is not the last
+          target_index = i + 1
+        end
+      end
+      print(target_index)
+      @matching_line = @matching_windows[target_index]
+    end
+
+    #
+    # Switch to window's workspace and focus it.
+    #
+    #
+    # @return [void]
+    #
+    def switch_to
+      return unless @id
+      `wmctrl -ia #{@id}`
+    end
+
+    #
+    # Summon a window to current workspace and focus it.
+    #
+    #
+    # @return [void]
+    #
+    def summon
+      return unless @id
+      `wmctrl -iR #{@id}`
+    end
+
+    #
+    # Shade (minimize) or unshade a window.
+    #
+    # @param [Boolean] should_shade
+    #
+    # @return [void]
+    #
+    def toggle_shaded(should_shade = true)
+      return unless @id
+
+      if should_shade
+        begin
+          # Use xdotool if possible
+          `xdotool windowminimize #{@id}`
+        rescue
+          `wmctrl -ir #{@id} -b add,shaded`
+        end
+      else
+        `wmctrl -ir #{@id} -b remove,shaded`
+      end
+    end
+  end
+end

metadata

@@ -1,66 +1,173 @@
 --- !ruby/object:Gem::Specification
 name: wmctile
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - mreq
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-09 00:00:00.000000000 Z
+date: 2016-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: dmenu
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.0'
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.0'
-description: Window manager's best friend in a gem.
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Window manager's best friend. In a gem.
 email: contact@petrmarek.eu
 executables:
 - wmctile
 extensions: []
 extra_rdoc_files: []
 files:
+- bin/console
 - bin/wmctile
 - lib/wmctile.rb
-- lib/wmctile/class.rb
-- lib/wmctile/class_with_dmenu.rb
-- lib/wmctile/memory.rb
+- lib/wmctile/errors.rb
 - lib/wmctile/router.rb
-- lib/wmctile/settings.rb
 - lib/wmctile/window.rb
-- lib/wmctile/window_manager.rb
-- lib/wmctile/window_tiler.rb
 homepage: http://mreq.github.io/wmctile
 licenses:
-- GPL-2
+- GPL-3
 metadata: {}
 post_install_message: |
   Thanks for installing wmctile. Make sure, you have the following dependencies installed on your system:
 
   wmctrl
-  xrandr
-  dmenu
+  xdotool
 
   On Ubuntu it's as easy as running:
 
-  sudo apt-get install wmctrl, xrandr, dmenu
+  sudo apt-get install wmctrl xdotool
 
   If you have that, run:
 
-  wmctile help
+  wmctile --help
 
-  to show the available commands. Also be sure to check the detailed docs at http://mreq.github.io/wmctile/build/docs.
+  to show the available commands.
 rdoc_options: []
 require_paths:
 - lib
@@ -81,3 +188,4 @@ signing_key:
 specification_version: 4
 summary: wmctile
 test_files: []
+has_rdoc: 

data/lib/wmctile/class.rb

@@ -1,13 +0,0 @@
-class Wmctile::Class
-	def cmd cmd
-		# [0..-2] to strip the last \n
-		`#{ cmd }`[0..-2]
-	end
-	def notify title, string, icon = nil
-		if icon
-			system "notify-send -i '#{ icon }' '#{title}' '#{string}'"
-		else	
-			system "notify-send '#{title}' '#{string}'"
-		end
-	end
-end

data/lib/wmctile/class_with_dmenu.rb

@@ -1,24 +0,0 @@
-require 'dmenu'
-
-class Wmctile::ClassWithDmenu < Wmctile::Class
-	def dmenu items
-		a = Dmenu.new
-		# override defaults
-		a.background = '#242424'
-		a.case_insensitive = true
-		a.font = 'Ubuntu Mono-12'
-		a.foreground = 'white'
-		a.lines = 10
-		a.position = :bottom
-		a.selected_background = '#2e557e'
-		# set items
-		a.items = items
-		# run
-		b = a.run()
-		if b.is_a? Dmenu::Item
-			return b.value
-		else
-			return b
-		end
-	end
-end

data/lib/wmctile/memory.rb

@@ -1,64 +0,0 @@
-require 'yaml'
-
-class Wmctile::Memory < Wmctile::Class
-	##################################
-	## init ##########################
-	##################################
-	def initialize
-		@path = File.expand_path '~/.config/wmctile/wmctile-memory.yml'
-		if not File.exist? @path
-			raw_memory = self.create_new_memory
-		end
-		raw_memory ||= File.read @path
-		@memory = YAML.load(raw_memory)
-	end
-	def create_new_memory
-		dir_path = @path[/(.*)\/wmctile-memory.yml/, 1]
-		if not Dir.exists? dir_path
-			Dir.mkdir dir_path
-		end
-		out_file = File.new @path, 'w'
-		# 20 workspaces should suffice
-		20.times do |i|
-			out_file.puts "#{i}:"
-		end
-		out_file.close
-	end
-	def write_memory
-		out_file = File.new @path, 'w'
-		out_file.puts @memory.to_yaml
-		out_file.close
-	end
-	##################################
-	## getters/setters ###############
-	##################################
-	def get workspace = 0, key = nil, key_sub = nil
-		begin
-			a = @memory[workspace]
-			if key.nil?
-				return nil
-			else
-				a = a[key]
-				if key_sub.nil?
-					return a
-				else
-					return a[key_sub]
-				end
-			end
-		rescue Exception => e
-			return nil			
-		end
-	end
-	def set workspace = 0, key, hash
-		hash.merge! 'time' => Time.now.to_i
-		if @memory[workspace].nil?
-			@memory[workspace] = {}
-		end
-		if @memory[workspace][key]
-			@memory[workspace][key] = hash
-		else
-			@memory[workspace].merge! key => hash
-		end
-		self.write_memory
-	end
-end

data/lib/wmctile/settings.rb

@@ -1,56 +0,0 @@
-require 'yaml'
-
-class Wmctile::Settings < Wmctile::Class
-	def method_missing sym, *args, &block
-		return false
-	end
-
-	def initialize
-		path = File.expand_path '~/.config/wmctile/wmctile-settings.yml'
-		if not File.exist? path
-			raw_settings = self.create_new_settings path
-		end
-		raw_settings ||= File.read path
-		settings = YAML.load(raw_settings)
-		if settings
-			settings.each { |name, value|
-				instance_variable_set("@#{name}", value)
-				self.class.class_eval { attr_reader name.intern }
-			}
-		end
-	end
-
-	def test_requirements
-		req = ['xrandr', 'wmctrl', 'dmenu']
-		ret = req.reject { |r| self.cmd("which #{ r }").length > 0 }
-		return ret
-	end
-	def create_new_settings path
-		req = self.test_requirements
-		unless req.nil? or req.length == 0
-			puts <<-eos
-You don't have #{ req.join(', ') } installed. Wmctile can't run without that.
-
-To fix this on Ubuntu, run:
-
-sudo apt-get install #{ req.join(' ') }
-			eos
-			exit
-		end
-		dir_path = path[/(.*)\/wmctile-settings.yml/, 1]
-		if not Dir.exists? dir_path
-			Dir.mkdir dir_path
-		end
-		out_file = File.new path, 'w'
-		out_file.puts self.default_settings.to_yaml
-		out_file.close
-	end
-	def default_settings
-		{
-			:window_border => 1,
-			:panel_height => 24,
-			:panel_width => 0,
-			:hostname => self.cmd('hostname')
-		}
-	end
-end

data/lib/wmctile/window_manager.rb

@@ -1,174 +0,0 @@
-class Wmctile::WindowManager < Wmctile::ClassWithDmenu
-	attr_accessor :w, :h, :workspace, :windows
-	##################################
-	## init ##########################
-	##################################
-	def initialize settings
-		@settings = settings
-		self.init_dimensions
-	end
-	def init_dimensions
-		# legacy (but fast) method via wmctrl
-		# dimensions = cmd("wmctrl -d | awk '{ print $9 }' | head -n1").split('x')
-		# xrandr is slower, but offers more information
-		dimensions = cmd("xrandr | grep -E '\sconnected\s[0-9]+x[0-9]+\+0' | awk '{print $3}' | awk -F'+' '{print $1}'").split('x')
-		@w = dimensions[0].to_i - 2*@settings.window_border
-		@h = dimensions[1].to_i - 2*@settings.window_border - @settings.panel_height
-		@workspace = cmd("wmctrl -d | grep '\*' | awk '{ print $1 }'").to_i
-	end
-	##################################
-	## dimension getters #############
-	##################################
-	def width portion = 1
-		@w * portion
-	end
-	def height portion = 1
-		@h * portion
-	end
-	##################################
-	## window getters ################
-	##################################
-	def get_window window_str = nil, all_workspaces = false
-		if window_str.nil?
-			window = self.ask_for_window all_workspaces
-		else
-			if window_str == ':ACTIVE:'
-				window = self.get_active_window
-			else
-				window = self.find_window window_str, all_workspaces
-				unless window
-					# does window_str have an icon bundle in it? (aka evince.Evince)
-					if window_str =~ /[a-z0-9]+\.[a-z0-9]+/i
-						icon = window_str.split('.').first
-					else
-						icon = nil
-					end
-					self.notify 'No window found', "#{ window_str }", icon
-				end
-			end
-		end
-		window
-	end
-	def get_active_window
-		win_id = self.cmd('wmctrl -a :ACTIVE: -v 2>&1').split('Using window: ').last
-		Wmctile::Window.new win_id, @settings
-	end
-	def find_window window_string, all_workspaces = false
-		cmd = "wmctrl -lx | grep -F #{ window_string }"
-		cmd += ' | grep -E \'0x\w+\s+' + @workspace.to_s + '\s+\''  unless all_workspaces
-		window_string = self.cmd cmd
-		window_string = window_string.split("\n").first
-		if window_string.nil?
-			return nil
-		else
-			return Wmctile::Window.new window_string, @settings
-		end
-	end
-	def find_windows window_string, all_workspaces = false
-		cmd = "wmctrl -lx | grep -F #{ window_string }"
-		cmd += ' | grep -E \'0x\w+\s+' + @workspace.to_s + '\s+\''  unless all_workspaces
-		window_strings = self.cmd cmd
-		window_strings = window_strings.split("\n")
-		if window_string.nil?
-			return nil
-		else
-			return window_strings.map { |w| Wmctile::Window.new w, @settings }
-		end
-	end
-	def find_in_windows window_string, all_workspaces = false
-		if window_string.nil?
-			self.ask_for_window all_workspaces
-		else
-			windows = self.find_windows window_string, all_workspaces
-			if windows
-				ids = windows.collect(&:id)
-				active_win = self.get_active_window
-				if ids.include? active_win.id
-					# cycle through the windows
-					i = ids.index active_win.id
-					# try the next one
-					if ids[i+1]
-						window = windows[i+1]
-					# fallback to the first one
-					else
-						window = windows.first
-					end
-				else
-					# switch to the first one
-					window = windows.first
-				end
-				return window
-			end
-			return nil
-		end
-	end
-	def ask_for_window all_workspaces = false
-		self.dmenu self.windows.map(&:dmenu_item)
-	end
-	##################################
-	## window lists ##################
-	##################################
-	def build_win_list all_workspaces = false
-		unless all_workspaces
-			variable_name = '@windows_on_workspace'
-		else
-			variable_name = '@windows_all'
-		end
-		unless instance_variable_get(variable_name)
-			unless all_workspaces
-				cmd = "wmctrl -lx | grep \" #{ @workspace } \""
-			else
-				cmd = "wmctrl -lx"
-			end
-			arr = cmd(cmd).split("\n")
-
-			new_list = arr.map { |w| Wmctile::Window.new(w, @settings) }
-			name_length = new_list.map(&:get_name_length).max
-			new_list.each { |w| w.set_name_length(name_length) }
-
-			instance_variable_set(variable_name, new_list)
-		end
-		instance_variable_get(variable_name)
-	end
-	def windows all_workspaces = false
-		unless all_workspaces
-			variable_name = '@windows_on_workspace'
-		else
-			variable_name = '@windows_all'
-		end
-		unless instance_variable_get(variable_name)
-			self.build_win_list all_workspaces
-		else
-			instance_variable_get(variable_name)
-		end
-	end
-	##################################
-	## window size calculators #######
-	##################################
-	def calculate_snap where, portion = 0.5
-		return case where
-		when 'left'
-			{
-				:x => @settings.panel_width, :y => @settings.panel_height,
-				:height => self.height, :width => self.width(portion)
-			}
-		when 'right'
-			{
-				:x => self.width(portion), :y => @settings.panel_height,
-				:height => self.height, :width => self.width(1-portion)
-			}
-		when 'top'
-			{
-				:x => @settings.panel_width, :y => @settings.panel_height,
-				:height => self.height(portion), :width => self.width
-			}
-		when 'bottom'
-			{
-				:x => @settings.panel_width, :y => @settings.panel_height + self.height(1-portion),
-				:height => self.height(portion), :width => self.width
-			}
-		else
-			nil
-		end
-	end
-end

data/lib/wmctile/window_tiler.rb

@@ -1,95 +0,0 @@
-class Wmctile::WindowTiler < Wmctile::Class
-	##################################
-	## init ##########################
-	##################################
-	def initialize settings, memory, wm = nil
-		@settings = settings
-		@memory = memory
-		@wm = wm
-	end
-	##################################
-	## object getter methods #########
-	##################################
-	def wm
-		@wm || @wm = Wmctile::WindowManager.new(@settings)
-	end
-	def memory
-		@memory || @memory = Wmctile::Memory.new
-	end
-	##################################
-	## actual snapping methods #######
-	##################################
-	def snap where = 'left', window_str = nil, portion = 0.5
-		window = self.wm.get_window window_str
-		if window
-			how_to_move = self.wm.calculate_snap where, portion.to_f
-			if how_to_move
-				window.move how_to_move
-				self.memory.set self.wm.workspace, 'snap', {
-					'where' => where, 'portion' => portion, 'window_id' => window.id
-				}
-			end
-		end
-	end
-	def resize where = 'left', portion = 0.01
-		portion = portion.to_f
-		# what are we moving? the last one used from these:
-		methods = ['snap']
-		freshest_meth = nil
-		freshest_time = 0
-		methods.each do |meth|
-			time = self.memory.get self.wm.workspace, meth, 'time'
-			if time > freshest_time
-				freshest_time = time
-				freshest_meth = meth
-			end
-		end
-		# ok, got it, it's freshest_meth
-		self.send "resize_#{ freshest_meth }", where, portion
-	end
-	def resize_snap where = 'left', portion = 0.01
-		portion = portion.to_f
-		info = self.memory.get self.wm.workspace, 'snap'
-		if info.nil?
-			return nil
-		end
-		negative = case info['where']
-		when 'left'
-			if where == 'left'	
-				true
-			elsif where == 'right'
-				false
-			else
-				nil
-			end
-		when 'right'
-			if where == 'left'	
-				false
-			elsif where == 'right'
-				true
-			else
-				nil
-			end
-		when 'top'
-			if where == 'bottom'	
-				false
-			elsif where == 'top'
-				true
-			else
-				nil
-			end
-		when 'bottom'
-			if where == 'top'	
-				false
-			elsif where == 'bottom'
-				true
-			else
-				nil
-			end
-		end
-		unless negative.nil?
-			portion = -portion  if negative
-			self.snap info['where'], info['window_id'], info['portion']+portion
-		end
-	end
-end