rumai 3.2.4 → 3.3.0

data/CREDITS

@@ -9,17 +9,12 @@ Suraj N. Kurapati
 %#----------------------------------------------------------------------------
 
 Christoph Blank,
-Simon Hafner,
+Kenneth De Winter,
+Mattia Gheda,
 Michael Andrus,
 Nathan Neff,
-[Gigamo],
-[ghedamat],
-[skirge]
-
-%# XXX: only link to these contributors because they do not have real names
-[Gigamo]: http://github.com/gigamo
-[ghedamat]: http://github.com/ghedamat
-[skirge]: http://github.com/skirge
+Sebastian Chmielewski,
+Simon Hafner
 
 %#----------------------------------------------------------------------------
 ## LICENSE

data/lib/rumai/fs.rb

@@ -15,12 +15,11 @@ module Rumai
     IXP_AGENT = IXP::Agent.new(UNIXSocket.new(IXP_SOCK_ADDR))
 
   rescue => error
-    error.message << %{
-      Ensure that (1) the WMII_ADDRESS environment variable is set and that (2)
-      it correctly specifies the filesystem path of wmii's IXP socket file,
-      which is typically located at "/tmp/ns.$USER.:$DISPLAY/wmii".
-    }.gsub(/^ +/, '').gsub(/\A|\z/, "\n")
-
+    error.message <<EOF
+Ensure that (1) the WMII_ADDRESS environment variable is set and that (2) it
+correctly specifies the absolute filesystem path to wmii's IXP socket file,
+which is typically located at "/tmp/ns.$USER.:$DISPLAY/wmii".
+EOF
     raise error
   end
 
@@ -28,8 +27,6 @@ module Rumai
   # An entry in the IXP file system.
   #
   class Node
-    @@cache = Hash.new {|h,k| h[k] = Node.new(k) }
-
     attr_reader :path
 
     def initialize path
@@ -59,6 +56,8 @@ module Rumai
     ##
     # Tests if this node is a directory.
     #
+    # @see Rumai::IXP::Agent#stat
+    #
     def directory?
       exist? and stat.directory?
     end
@@ -66,6 +65,8 @@ module Rumai
     ##
     # Returns the names of all files in this directory.
     #
+    # @see Rumai::IXP::Agent#entries
+    #
     def entries
       begin
         IXP_AGENT.entries @path
@@ -98,6 +99,7 @@ module Rumai
     # @yieldparam [String] line
     #
     def each_line &block
+      raise ArgumentError unless block_given?
       open do |file|
         until (chunk = file.read(true)).empty?
           chunk.each_line(&block)
@@ -108,6 +110,8 @@ module Rumai
     ##
     # Writes the given content to this node.
     #
+    # @see Rumai::IXP::Agent#write
+    #
     def write content
       IXP_AGENT.write @path, content
     end
@@ -124,10 +128,14 @@ module Rumai
     ##
     # Deletes the file corresponding to this node on the IXP server.
     #
+    # @see Rumai::IXP::Agent#remove
+    #
     def remove
       IXP_AGENT.remove @path
     end
 
+    @@cache = Hash.new {|h,k| h[k] = Node.new(k) }
+
     ##
     # Returns the given sub-path as a Node object.
     #

data/lib/rumai/inochi.rb

@@ -3,27 +3,27 @@ module Rumai
   ##
   # Official name of this project.
   #
-  PROJECT = "Rumai"
+  PROJECT = 'Rumai'
 
   ##
   # Short single-line description of this project.
   #
-  TAGLINE = "Ruby interface to the wmii window manager"
+  TAGLINE = 'Ruby interface to the wmii window manager'
 
   ##
   # Address of this project's official home page.
   #
-  WEBSITE = "http://snk.tuxfamily.org/lib/rumai/"
+  WEBSITE = 'http://snk.tuxfamily.org/lib/rumai/'
 
   ##
   # Number of this release of this project.
   #
-  VERSION = "3.2.4"
+  VERSION = '3.3.0'
 
   ##
   # Date of this release of this project.
   #
-  RELDATE = "2010-06-06"
+  RELDATE = '2010-07-16'
 
   ##
   # Description of this release of this project.
@@ -74,8 +74,8 @@ module Rumai
   #   }
   #
   DEVTIME = {
-    "inochi" => [ ">= 3.0.0", "< 4" ],
-    "dfect"  => [ "~> 2" ], # for unit testing
+    'inochi' => [ '>= 3.0.0', '< 4' ],
+    'dfect'  => [ '~> 2' ], # for unit testing
   }
 
   # establish gem version dependencies

data/lib/rumai/ixp/transport.rb

@@ -76,8 +76,8 @@ module Rumai
           rescue ThreadError
             # pool is empty, so fill it
             FILL_RATE.times do
-              if @pos != @lim
-                @pool << @pos
+              if @pos != @lim then
+                @pool.enq @pos
                 @pos = @pos.succ
               else
                 # range is exhausted, so give other threads
@@ -96,7 +96,7 @@ module Rumai
         # that it may be occupied again in the future.
         #
         def release member
-          @pool << member
+          @pool.enq member
         end
       end
 
@@ -192,7 +192,7 @@ module Rumai
       #
       def MODES.parse mode
         if mode.respond_to? :split
-          mode.split(//).inject(0) {|m,c| m | self[c].to_i }
+          mode.split(//).inject(0) {|acc,chr| acc | self[chr].to_i }
         else
           mode.to_i
         end
@@ -206,16 +206,12 @@ module Rumai
       # @see File::open
       #
       def open path, mode = 'r'
-        mode = MODES.parse(mode)
-
         # open the file
         path_fid = walk(path)
-
         talk Topen.new(
           :fid  => path_fid,
-          :mode => mode
+          :mode => MODES.parse(mode)
         )
-
         stream = FidStream.new(self, path_fid, @msize)
 
         # return the file stream
@@ -355,9 +351,7 @@ module Rumai
       # Returns the content of the file/directory at the given path.
       #
       def read path, *args
-        open path do |f|
-          f.read(*args)
-        end
+        open(path) {|f| f.read(*args) }
       end
 
       ##
@@ -371,7 +365,7 @@ module Rumai
           raise ArgumentError, "#{path.inspect} is not a directory"
         end
 
-        read(path).map! {|t| t.name}
+        read(path).map! {|t| t.name }
       end
 
       ##
@@ -379,9 +373,7 @@ module Rumai
       # the file at the given path.
       #
       def write path, content
-        open path, 'w' do |f|
-          f << content
-        end
+        open(path, 'w') {|f| f.write content }
       end
 
       ##
@@ -392,8 +384,6 @@ module Rumai
         prefix = File.dirname(path)
         target = File.basename(path)
 
-        mode = MODES.parse(mode)
-
         with_fid do |prefix_fid|
           walk_fid prefix_fid, prefix
 
@@ -402,7 +392,7 @@ module Rumai
             :fid => prefix_fid,
             :name => target,
             :perm => perm,
-            :mode => mode
+            :mode => MODES.parse(mode)
           )
         end
       end

data/lib/rumai/wm.rb

@@ -21,1079 +21,1179 @@ module Rumai
   # abstraction of WM components
   #---------------------------------------------------------------------------
 
+  ##
+  # @note Inheritors must override the {Chain#chain} method.
+  #
+  module Chain
     ##
-    # @note Inheritors must override the {Chain#chain} method.
+    # Returns an array of objects related to this one.
     #
-    module Chain
-      ##
-      # Returns an array of objects related to this one.
-      #
-      def chain
-        [self]
-      end
+    def chain
+      [self]
+    end
 
-      ##
-      # Returns the object after this one in the chain.
-      #
-      def next
-        sibling(+1)
-      end
+    ##
+    # Returns the object after this one in the chain.
+    #
+    def next
+      sibling(+1)
+    end
 
-      ##
-      # Returns the object before this one in the chain.
-      #
-      def prev
-        sibling(-1)
-      end
+    ##
+    # Returns the object before this one in the chain.
+    #
+    def prev
+      sibling(-1)
+    end
 
-      private
+    private
 
-      def sibling offset
-        arr = chain
+    def sibling offset
+      arr = chain
 
-        if pos = arr.index(self)
-          arr[(pos + offset) % arr.length]
-        end
+      if pos = arr.index(self)
+        arr[(pos + offset) % arr.length]
       end
     end
+  end
+
+  ##
+  # The basic building block of the WM hierarchy.
+  #
+  # @note Inheritors must define a {curr} class method.
+  # @note Inheritors must override the {focus} method.
+  #
+  module WidgetImpl
+    attr_reader :id
+
+    def == other
+      @id == other.id
+    end
 
     ##
-    # The basic building block of the WM hierarchy.
-    #
-    # @note Inheritors must define a {curr} class method.
-    # @note Inheritors must override the {focus} method.
+    # Checks if this widget currently has focus.
     #
-    module WidgetImpl
-      attr_reader :id
+    def current?
+      self == self.class.curr
+    end
 
-      def == other
-        @id == other.id
-      end
+    alias focus? current?
+  end
 
-      ##
-      # Checks if this widget currently has focus.
-      #
-      def current?
-        self == self.class.curr
+  ##
+  # A widget that has a corresponding representation in the IXP file system.
+  #
+  class WidgetNode < Node
+    include WidgetImpl
+
+    def initialize id, path_prefix
+      super "#{path_prefix}/#{id}"
+
+      if id == FOCUSED_WIDGET_ID and ctl.exist?
+        @id = ctl.read.split.first
+        super "#{path_prefix}/#{@id}"
+      else
+        @id = id.to_s
       end
+    end
+  end
+
+  ##
+  # A graphical program that is running in your current X Windows session.
+  #
+  class Client < WidgetNode
+    def initialize client_id
+      super client_id, '/client'
+    end
 
-      alias focus? current?
+    ##
+    # Returns the currently focused client.
+    #
+    def self.curr
+      new FOCUSED_WIDGET_ID
     end
 
+    #-------------------------------------------------------------------------
+    include Chain
+    #-------------------------------------------------------------------------
+
     ##
-    # A widget that has a corresponding representation in the IXP file system.
+    # Returns a list of all clients in the current view.
     #
-    class WidgetNode < Node
-      include WidgetImpl
+    def chain
+      View.curr.clients
+    end
 
-      def initialize id, path_prefix
-        super "#{path_prefix}/#{id}"
+    #-------------------------------------------------------------------------
+    # WM operations
+    #-------------------------------------------------------------------------
 
-        if id == FOCUSED_WIDGET_ID and ctl.exist?
-          @id = ctl.read.split.first
-          super "#{path_prefix}/#{@id}"
-        else
-          @id = id.to_s
+    ##
+    # Focuses this client within the given view.
+    #
+    def focus view = nil
+      if exist? and not focus?
+        (view ? [view] : self.views).each do |v|
+          if a = self.area(v) and a.exist?
+            v.focus
+            a.focus
+
+            # slide focus from the current client onto this client
+            arr = a.client_ids
+            src = arr.index Client.curr.id
+            dst = arr.index @id
+
+            distance = (src - dst).abs
+            direction = src < dst ? :down : :up
+
+            distance.times { v.select direction }
+            break
+          end
         end
       end
     end
 
     ##
-    # A graphical program that is running in your current X Windows session.
+    # Sends this client to the given destination within the given view.
     #
-    class Client < WidgetNode
-      def initialize client_id
-        super client_id, '/client'
-      end
-
-      ##
-      # Returns the currently focused client.
-      #
-      def self.curr
-        new FOCUSED_WIDGET_ID
-      end
-
-      include Chain
+    def send area_or_id, view = View.curr
+      dst = area_to_id(area_or_id)
+      view.ctl.write "send #{@id} #{dst}"
+    end
 
-        ##
-        # Returns a list of all clients in the current view.
-        #
-        def chain
-          View.curr.clients
-        end
+    alias move send
 
-      #-----------------------------------------------------------------------
-      # WM operations
-      #-----------------------------------------------------------------------
-
-        ##
-        # Focuses this client within the given view.
-        #
-        def focus view = nil
-          if exist? and not focus?
-            (view ? [view] : self.views).each do |v|
-              if a = self.area(v) and a.exist?
-                v.focus
-                a.focus
-
-                # slide focus from the current client onto this client
-                arr = a.client_ids
-                src = arr.index Client.curr.id
-                dst = arr.index @id
-
-                distance = (src - dst).abs
-                direction = src < dst ? :down : :up
-
-                distance.times { v.select direction }
-                break
-              end
-            end
-          end
-        end
+    ##
+    # Swaps this client with the given destination within the given view.
+    #
+    def swap area_or_id, view = View.curr
+      dst = area_to_id(area_or_id)
+      view.ctl.write "swap #{@id} #{dst}"
+    end
 
-        ##
-        # Sends this client to the given destination within the given view.
-        #
-        def send area_or_id, view = View.curr
-          dst = area_to_id(area_or_id)
-          view.ctl.write "send #{@id} #{dst}"
-        end
+    ##
+    # Moves this client in the given direction on the given view.
+    #
+    def nudge direction, view = View.curr
+      reshape :nudge, direction, view
+    end
 
-        alias move send
+    ##
+    # Grows this client in the given direction on the given view.
+    #
+    def grow direction, view = View.curr
+      reshape :grow, direction, view
+    end
 
-        ##
-        # Swaps this client with the given destination within the given view.
-        #
-        def swap area_or_id, view = View.curr
-          dst = area_to_id(area_or_id)
-          view.ctl.write "swap #{@id} #{dst}"
-        end
+    ##
+    # Terminates this client nicely (requests this window to be closed).
+    #
+    def kill
+      ctl.write :kill
+    end
 
-        ##
-        # Terminates this client nicely (requests this window to be closed).
-        #
-        def kill
-          ctl.write :kill
-        end
+    ##
+    # Terminates this client forcefully.
+    #
+    def slay
+      ctl.write :slay
+    end
 
-        ##
-        # Terminates this client forcefully.
-        #
-        def slay
-          ctl.write :slay
-        end
+    ##
+    # Maximizes this client to occupy the
+    # entire screen on the current view.
+    #
+    def fullscreen
+      ctl.write 'Fullscreen on'
+    end
 
-        ##
-        # Maximizes this client to occupy the
-        # entire screen on the current view.
-        #
-        def fullscreen
-          ctl.write 'Fullscreen on'
-        end
+    ##
+    # Restores this client back to its original size on the current view.
+    #
+    def unfullscreen
+      ctl.write 'Fullscreen off'
+    end
 
-        ##
-        # Restores this client back to its original size on the current view.
-        #
-        def unfullscreen
-          ctl.write 'Fullscreen off'
-        end
+    ##
+    # Toggles the fullscreen status of this client on the current view.
+    #
+    def fullscreen!
+      ctl.write 'Fullscreen toggle'
+    end
 
-        ##
-        # Toggles the fullscreen status of this client on the current view.
-        #
-        def fullscreen!
-          ctl.write 'Fullscreen toggle'
-        end
+    ##
+    # Checks if this client is currently fullscreen on the current view.
+    #
+    def fullscreen?
+      #
+      # If the client's dimensions match those of the
+      # floating area, then we know it is fullscreen.
+      #
+      View.curr.manifest =~ /^# #{FLOATING_AREA_ID} (\d+) (\d+)\n.*^#{FLOATING_AREA_ID} #{@id} \d+ \d+ \1 \2 /m
+    end
 
-        ##
-        # Checks if this client is currently fullscreen on the current view.
-        #
-        def fullscreen?
-          #
-          # If the client's dimensions match those of the
-          # floating area, then we know it is fullscreen.
-          #
-          View.curr.manifest =~ /^# #{FLOATING_AREA_ID} (\d+) (\d+)\n.*^#{FLOATING_AREA_ID} #{@id} \d+ \d+ \1 \2 /m
-        end
+    ##
+    # Checks if this client is sticky (appears in all views).
+    #
+    def stick?
+      tags.include? CLIENT_STICKY_TAG
+    end
 
-        ##
-        # Checks if this client is sticky (appears in all views).
-        #
-        def stick?
-          tags.include? CLIENT_STICKY_TAG
-        end
+    ##
+    # Makes this client sticky (appears in all views).
+    #
+    def stick
+      tag CLIENT_STICKY_TAG
+    end
 
-        ##
-        # Makes this client sticky (appears in all views).
-        #
-        def stick
-          tag CLIENT_STICKY_TAG
-        end
+    ##
+    # Makes this client unsticky (does not appear in all views).
+    #
+    def unstick
+      untag CLIENT_STICKY_TAG
+    end
 
-        ##
-        # Makes this client unsticky (does not appear in all views).
-        #
-        def unstick
-          untag CLIENT_STICKY_TAG
-        end
+    ##
+    # Toggles the stickyness of this client.
+    #
+    def stick!
+      if stick?
+        unstick
+      else
+        stick
+      end
+    end
 
-        ##
-        # Toggles the stickyness of this client.
-        #
-        def stick!
-          if stick?
-            unstick
-          else
-            stick
-          end
-        end
+    ##
+    # Checks if this client is in the floating area of the given view.
+    #
+    def float? view = View.curr
+      area(view).floating?
+    end
 
-        ##
-        # Checks if this client is in the floating area of the given view.
-        #
-        def float? view = View.curr
-          area(view).floating?
-        end
+    ##
+    # Puts this client into the floating area of the given view.
+    #
+    def float view = View.curr
+      send :toggle, view unless float? view
+    end
 
-        ##
-        # Puts this client into the floating area of the given view.
-        #
-        def float view = View.curr
-          send :toggle, view unless float? view
-        end
+    ##
+    # Puts this client into the managed area of the given view.
+    #
+    def unfloat view = View.curr
+      send :toggle, view if float? view
+    end
 
-        ##
-        # Puts this client into the managed area of the given view.
-        #
-        def unfloat view = View.curr
-          send :toggle, view if float? view
-        end
+    ##
+    # Toggles the floating status of this client in the given view.
+    #
+    def float! view = View.curr
+      send :toggle, view
+    end
 
-        ##
-        # Toggles the floating status of this client in the given view.
-        #
-        def float! view = View.curr
-          send :toggle, view
-        end
+    ##
+    # Checks if this client is in the managed area of the given view.
+    def manage? view = View.curr
+      not float? view
+    end
 
-        ##
-        # Checks if this client is in the managed area of the given view.
-        def manage? view = View.curr
-          not float? view
-        end
+    alias manage unfloat
 
-        alias manage unfloat
+    alias unmanage float
 
-        alias unmanage float
+    alias manage! float!
 
-        alias manage! float!
+    #-------------------------------------------------------------------------
+    # WM hierarchy
+    #-------------------------------------------------------------------------
 
-      #-----------------------------------------------------------------------
-      # WM hierarchy
-      #-----------------------------------------------------------------------
+    ##
+    # Returns the area that contains this client within the given view.
+    #
+    def area view = View.curr
+      view.area_of_client self
+    end
 
-        ##
-        # Returns the area that contains this client within the given view.
-        #
-        def area view = View.curr
-          view.area_of_client self
-        end
+    ##
+    # Returns the views that contain this client.
+    #
+    def views
+      tags.map! {|t| View.new t }
+    end
 
-        ##
-        # Returns the views that contain this client.
-        #
-        def views
-          tags.map! {|t| View.new t }
-        end
+    #-------------------------------------------------------------------------
+    # tag manipulations
+    #-------------------------------------------------------------------------
 
-      #-----------------------------------------------------------------------
-      # tag manipulations
-      #-----------------------------------------------------------------------
+    TAG_DELIMITER = '+'.freeze
 
-        TAG_DELIMITER = '+'.freeze
+    ##
+    # Returns the tags associated with this client.
+    #
+    def tags
+      self[:tags].read.split TAG_DELIMITER
+    end
 
-        ##
-        # Returns the tags associated with this client.
-        #
-        def tags
-          self[:tags].read.split TAG_DELIMITER
+    ##
+    # Modifies the tags associated with this client.
+    #
+    # If a tag name is '~', this client is placed
+    # into the floating layer of the current view.
+    #
+    # If a tag name begins with '~', then this
+    # client is placed into the floating layer
+    # of the view corresponding to that tag.
+    #
+    # If a tag name is '!', this client is placed
+    # into the managed layer of the current view.
+    #
+    # If a tag name begins with '!', then this
+    # client is placed into the managed layer
+    # of the view corresponding to that tag.
+    #
+    def tags= *tags
+      float = []
+      manage = []
+      inherit = []
+
+      tags.join(TAG_DELIMITER).split(TAG_DELIMITER).each do |tag|
+        case tag
+        when '~'  then float   << Rumai.curr_tag
+        when /^~/ then float   << $'
+        when '!'  then manage  << Rumai.curr_tag
+        when /^!/ then manage  << $'
+        else           inherit << tag
         end
+      end
 
-        ##
-        # Modifies the tags associated with this client.
-        #
-        # If a tag name is '~', this client is placed
-        # into the floating layer of the current view.
-        #
-        # If a tag name begins with '~', then this
-        # client is placed into the floating layer
-        # of the view corresponding to that tag.
-        #
-        # If a tag name is '!', this client is placed
-        # into the managed layer of the current view.
-        #
-        # If a tag name begins with '!', then this
-        # client is placed into the managed layer
-        # of the view corresponding to that tag.
-        #
-        def tags= *tags
-          float = []
-          manage = []
-          inherit = []
-
-          tags.join(TAG_DELIMITER).split(TAG_DELIMITER).each do |tag|
-            case tag
-            when '~'  then float   << Rumai.curr_tag
-            when /^~/ then float   << $'
-            when '!'  then manage  << Rumai.curr_tag
-            when /^!/ then manage  << $'
-            else           inherit << tag
-            end
-          end
+      self[:tags].write((float + manage + inherit).uniq.join(TAG_DELIMITER))
 
-          self[:tags].write((float + manage + inherit).uniq.join(TAG_DELIMITER))
+      float.each do |tag|
+        self.float View.new(tag)
+      end
 
-          float.each do |tag|
-            self.float View.new(tag)
-          end
+      manage.each do |tag|
+        self.manage View.new(tag)
+      end
+    end
 
-          manage.each do |tag|
-            self.manage View.new(tag)
-          end
-        end
+    ##
+    # Evaluates the given block within the
+    # context of this client's list of tags.
+    #
+    def with_tags &block
+      arr = self.tags
+      arr.instance_eval(&block)
+      self.tags = arr
+    end
 
-        ##
-        # Evaluates the given block within the
-        # context of this client's list of tags.
-        #
-        def with_tags &block
-          arr = self.tags
-          arr.instance_eval(&block)
-          self.tags = arr
-        end
+    ##
+    # Adds the given tags to this client.
+    #
+    def tag *tags
+      with_tags do
+        concat tags
+      end
+    end
 
-        ##
-        # Adds the given tags to this client.
-        #
-        def tag *tags
-          with_tags do
-            concat tags
-          end
+    ##
+    # Removes the given tags from this client.
+    #
+    def untag *tags
+      with_tags do
+        tags.flatten.each do |tag|
+          delete tag.to_s
         end
+      end
+    end
 
-        ##
-        # Removes the given tags from this client.
-        #
-        def untag *tags
-          with_tags do
-            tags.flatten.each do |tag|
-              delete tag.to_s
-            end
-          end
-        end
+    #-------------------------------------------------------------------------
+    # multiple client grouping
+    #-------------------------------------------------------------------------
 
-      #-----------------------------------------------------------------------
-      # multiple client grouping
-      #-----------------------------------------------------------------------
+    ##
+    # Checks if this client is included in the current grouping.
+    #
+    def group?
+      tags.include? CLIENT_GROUPING_TAG
+    end
 
-        ##
-        # Checks if this client is included in the current grouping.
-        #
-        def group?
-          tags.include? CLIENT_GROUPING_TAG
-        end
+    ##
+    # Adds this client to the current grouping.
+    #
+    def group
+      with_tags do
+        push CLIENT_GROUPING_TAG
+      end
+    end
 
-        ##
-        # Adds this client to the current grouping.
-        #
-        def group
-          with_tags do
-            push CLIENT_GROUPING_TAG
-          end
-        end
+    ##
+    # Removes this client to the current grouping.
+    #
+    def ungroup
+      untag CLIENT_GROUPING_TAG
+    end
 
-        ##
-        # Removes this client to the current grouping.
-        #
-        def ungroup
-          untag CLIENT_GROUPING_TAG
-        end
+    ##
+    # Toggles the presence of this client in the current grouping.
+    #
+    def group!
+      if group?
+        ungroup
+      else
+        group
+      end
+    end
 
-        ##
-        # Toggles the presence of this client in the current grouping.
-        #
-        def group!
-          if group?
-            ungroup
-          else
-            group
-          end
-        end
+    private
 
-      private
+    def reshape method, direction, view
+      area = self.area(view)
+      index = area.client_ids.index(@id) + 1 # numbered as 1..N
+      view.ctl.write "#{method} #{area.id} #{index} #{direction}"
+    end
 
-      ##
-      # Returns the wmii ID of the given area.
-      #
-      def area_to_id area_or_id
-        if area_or_id.respond_to? :id
-          id = area_or_id.id
-          id == FLOATING_AREA_ID ? :toggle : id
-        else
-          area_or_id
-        end
+    ##
+    # Returns the wmii ID of the given area.
+    #
+    def area_to_id area_or_id
+      if area_or_id.respond_to? :id
+        id = area_or_id.id
+        id == FLOATING_AREA_ID ? :toggle : id
+      else
+        area_or_id
       end
     end
+  end
 
+  ##
+  # @note Inheritors should override the {client_ids} method.
+  #
+  module ClientContainer
     ##
-    # @note Inheritors should override the {ClientContainer#client_ids} method.
+    # Returns the IDs of the clients in this container.
     #
-    module ClientContainer
-      ##
-      # Returns the IDs of the clients in this container.
-      #
-      def client_ids
-        []
-      end
+    def client_ids
+      []
+    end
 
-      ##
-      # Returns the clients contained in this container.
-      #
-      def clients
-        client_ids.map! {|i| Client.new i }
-      end
+    ##
+    # Returns the clients contained in this container.
+    #
+    def clients
+      client_ids.map! {|i| Client.new i }
+    end
 
-      # multiple client grouping
-      %w[group ungroup group!].each do |meth|
-        define_method meth do
-          clients.each do |c|
-            c.__send__ meth
-          end
+    # multiple client grouping
+    %w[group ungroup group!].each do |meth|
+      define_method meth do
+        clients.each do |c|
+          c.__send__ meth
         end
       end
+    end
 
-      ##
-      # Returns all grouped clients in this container.
-      #
-      def grouping
-        clients.select {|c| c.group? }
-      end
+    ##
+    # Returns all grouped clients in this container.
+    #
+    def grouping
+      clients.select {|c| c.group? }
     end
+  end
+
+  ##
+  # A region that contains clients. This can be either
+  # the floating area or a column in the managed area.
+  #
+  class Area
+    attr_reader :view
 
     ##
-    # A region that contains clients. This can be either
-    # the floating area or a column in the managed area.
+    # @param [Rumai::View] view
+    #   the view object which contains this area
     #
-    class Area
-      attr_reader :view
+    def initialize area_id, view = View.curr
+      @id = Integer(area_id) rescue area_id
+      @view = view
+    end
 
-      ##
-      # @param [Rumai::View] view
-      #   the view object which contains this area
-      #
-      def initialize area_id, view = View.curr
-        @id = Integer(area_id) rescue area_id
-        @view = view
-      end
+    ##
+    # Checks if this area is the floating area.
+    #
+    def floating?
+      @id == FLOATING_AREA_ID
+    end
 
-      ##
-      # Checks if this area is the floating area.
-      #
-      def floating?
-        @id == FLOATING_AREA_ID
-      end
+    ##
+    # Checks if this is a managed area (a column).
+    #
+    def column?
+      not floating?
+    end
 
-      ##
-      # Checks if this is a managed area (a column).
-      #
-      def column?
-        not floating?
-      end
+    alias managed? column?
 
-      alias managed? column?
+    #-------------------------------------------------------------------------
+    include WidgetImpl
+    #-------------------------------------------------------------------------
 
-      include WidgetImpl
+    ##
+    # Returns the currently focused area.
+    #
+    def self.curr
+      View.curr.area_of_client Client.curr
+    end
 
-        ##
-        # Returns the currently focused area.
-        #
-        def self.curr
-          View.curr.area_of_client Client.curr
-        end
+    ##
+    # Returns the floating area in the given view.
+    #
+    def self.floating view = View.curr
+      new FLOATING_AREA_ID, view
+    end
 
-        ##
-        # Returns the floating area in the given view.
-        #
-        def self.floating view = View.curr
-          new FLOATING_AREA_ID, view
-        end
+    #-------------------------------------------------------------------------
+    include Chain
+    #-------------------------------------------------------------------------
 
-      include Chain
+    ##
+    # Returns a list of all areas in the current view.
+    #
+    def chain
+      @view.areas
+    end
 
-        ##
-        # Returns a list of all areas in the current view.
-        #
-        def chain
-          @view.areas
-        end
+    ##
+    # Checks if this object exists in the chain.
+    #
+    def exist?
+      chain.include? self
+    end
 
-        ##
-        # Checks if this object exists in the chain.
-        #
-        def exist?
-          chain.include? self
-        end
+    #-------------------------------------------------------------------------
+    include ClientContainer
+    #-------------------------------------------------------------------------
 
-      include ClientContainer
+    ##
+    # Returns the IDs of the clients in this area.
+    #
+    def client_ids
+      @view.client_ids @id
+    end
 
-        ##
-        # Returns the IDs of the clients in this area.
-        #
-        def client_ids
-          @view.client_ids @id
-        end
+    #-------------------------------------------------------------------------
+    include Enumerable
+    #-------------------------------------------------------------------------
 
-      include Enumerable
+    ##
+    # Iterates through each client in this container.
+    #
+    def each &block
+      clients.each(&block)
+    end
 
-        ##
-        # Iterates through each client in this container.
-        #
-        def each &block
-          clients.each(&block)
-        end
+    #-------------------------------------------------------------------------
+    # WM operations
+    #-------------------------------------------------------------------------
 
-      ##
-      # Sets the layout of clients in this column.
-      #
-      def layout= mode
-        case mode
-        when :stack then mode = 'stack-max'
-        when :max   then mode = 'stack+max'
-        end
+    ##
+    # Puts focus on this area.
+    #
+    def focus
+      @view.ctl.write "select #{@id}"
+    end
 
-        @view.ctl.write "colmode #{@id} #{mode}"
+    ##
+    # Sets the layout of clients in this column.
+    #
+    def layout= mode
+      case mode
+      when :stack then mode = 'stack-max'
+      when :max   then mode = 'stack+max'
       end
 
-      #-----------------------------------------------------------------------
-      # WM operations
-      #-----------------------------------------------------------------------
+      @view.ctl.write "colmode #{@id} #{mode}"
+    end
 
-        ##
-        # Puts focus on this area.
-        #
-        def focus
-          @view.ctl.write "select #{@id}"
-        end
+    #-------------------------------------------------------------------------
+    # array abstraction: area is an array of clients
+    #-------------------------------------------------------------------------
+
+    ##
+    # Returns the number of clients in this area.
+    #
+    def length
+      client_ids.length
+    end
 
-      #-----------------------------------------------------------------------
-      # array abstraction: area is an array of clients
-      #-----------------------------------------------------------------------
+    ##
+    # Inserts the given clients at the bottom of this area.
+    #
+    def push *clients
+      clients.flatten!
+      return if clients.empty?
 
-        ##
-        # Returns the number of clients in this area.
-        #
-        def length
-          client_ids.length
+      insert clients
+
+      # move inserted clients to bottom
+      clients.reverse.each_with_index do |c, i|
+        until c.id == self.client_ids[-i.succ]
+          c.send :down
         end
+      end
+    end
 
-        ##
-        # Inserts the given clients at the bottom of this area.
-        #
-        def push *clients
-          clients.flatten!
-          return if clients.empty?
+    alias << push
 
-          insert clients
+    ##
+    # Inserts the given clients after the
+    # currently focused client in this area.
+    #
+    def insert *clients
+      clients.flatten!
+      return if clients.empty?
 
-          # move inserted clients to bottom
-          clients.reverse.each_with_index do |c, i|
-            until c.id == self.client_ids[-i.succ]
-              c.send :down
-            end
-          end
-        end
+      clients.each do |c|
+        import_client c
+      end
+    end
 
-        alias << push
+    ##
+    # Inserts the given clients at the top of this area.
+    #
+    def unshift *clients
+      clients.flatten!
+      return if clients.empty?
 
-        ##
-        # Inserts the given clients after the
-        # currently focused client in this area.
-        #
-        def insert *clients
-          clients.flatten!
-          return if clients.empty?
+      insert clients
 
-          clients.each do |c|
-            import_client c
-          end
+      # move inserted clients to top
+      clients.each_with_index do |c, i|
+        until c.id == self.client_ids[i]
+          c.send :up
         end
+      end
+    end
 
-        ##
-        # Inserts the given clients at the top of this area.
-        #
-        def unshift *clients
-          clients.flatten!
-          return if clients.empty?
+    ##
+    # Concatenates the given area to the bottom of this area.
+    #
+    def concat area
+      push area.clients
+    end
 
-          insert clients
+    ##
+    # Ensures that this area has at most the given number of clients.
+    #
+    # Areas to the right of this one serve as a buffer into which excess
+    # clients are evicted and from which deficit clients are imported.
+    #
+    def length= max_clients
+      return unless max_clients > 0
+      len, out = length, fringe
 
-          # move inserted clients to top
-          clients.each_with_index do |c, i|
-            until c.id == self.client_ids[i]
-              c.send :up
-            end
-          end
-        end
+      if len > max_clients
+        out.unshift clients[max_clients..-1]
 
-        ##
-        # Concatenates the given area to the bottom of this area.
-        #
-        def concat area
-          push area.clients
-        end
+      elsif len < max_clients
+        until (diff = max_clients - length) == 0
+          importable = out.clients[0, diff]
+          break if importable.empty?
 
-        ##
-        # Ensures that this area has at most the given number of clients.
-        #
-        # Areas to the right of this one serve as a buffer into which excess
-        # clients are evicted and from which deficit clients are imported.
-        #
-        def length= max_clients
-          return unless max_clients > 0
-          len, out = length, fringe
-
-          if len > max_clients
-            out.unshift clients[max_clients..-1]
-
-          elsif len < max_clients
-            until (diff = max_clients - length) == 0
-              importable = out.clients[0, diff]
-              break if importable.empty?
-
-              push importable
-            end
-          end
+          push importable
         end
+      end
+    end
 
-      private
+    private
 
-      ##
-      # Moves the given client into this area.
-      #
-      def import_client c
-        if exist?
-          c.send self
-
-        else
-          # move the client to the nearest existing column
-          src = c.area
-          dst = chain.last
+    ##
+    # Moves the given client into this area.
+    #
+    def import_client c
+      if exist?
+        c.send self
 
-          c.send dst unless src == dst
+      else
+        # move the client to the nearest existing column
+        src = c.area
+        dst = chain.last
 
-          # slide the client over to this column
-          c.send :right
-          @id = dst.id.next
+        c.send dst unless src == dst
 
-          raise 'column should exist now' unless exist?
-        end
-      end
+        # slide the client over to this column
+        c.send :right
+        @id = dst.id.next
 
-      ##
-      # Returns the next area, which may or may not exist.
-      #
-      def fringe
-        Area.new @id.next, @view
+        raise 'column should exist now' unless exist?
       end
     end
 
     ##
-    # The visualization of a tag.
+    # Returns the next area, which may or may not exist.
     #
-    class View < WidgetNode
-      include WidgetImpl
+    def fringe
+      Area.new @id.next, @view
+    end
+  end
+
+  ##
+  # The visualization of a tag.
+  #
+  class View < WidgetNode
+    def initialize view_id
+      super view_id, '/tag'
+    end
 
-        ##
-        # Returns the currently focused view.
-        #
-        def self.curr
-          new FOCUSED_WIDGET_ID
-        end
+    #-------------------------------------------------------------------------
+    include WidgetImpl
+    #-------------------------------------------------------------------------
 
-        ##
-        # Focuses this view.
-        #
-        def focus
-          IXP_FS_ROOT.ctl.write "view #{@id}"
-        end
+    ##
+    # Returns the currently focused view.
+    #
+    def self.curr
+      new FOCUSED_WIDGET_ID
+    end
 
-      include Chain
+    ##
+    # Focuses this view.
+    #
+    def focus
+      IXP_FS_ROOT.ctl.write "view #{@id}"
+    end
 
-        ##
-        # Returns a list of all views.
-        #
-        def chain
-          Rumai.views
-        end
+    #-------------------------------------------------------------------------
+    include Chain
+    #-------------------------------------------------------------------------
 
-      include ClientContainer
+    ##
+    # Returns a list of all views.
+    #
+    def chain
+      Rumai.views
+    end
 
-        ##
-        # Returns the IDs of the clients contained
-        # in the given area within this view.
-        #
-        def client_ids area_id = '\S+'
-          manifest.scan(/^#{area_id} (0x\S+)/).flatten
-        end
+    #-------------------------------------------------------------------------
+    include ClientContainer
+    #-------------------------------------------------------------------------
 
-      include Enumerable
+    ##
+    # Returns the IDs of the clients contained
+    # in the given area within this view.
+    #
+    def client_ids area_id = '\S+'
+      manifest.scan(/^#{area_id} (0x\S+)/).flatten
+    end
 
-        ##
-        # Iterates through each area in this view.
-        #
-        def each &block
-          areas.each(&block)
-        end
+    #-------------------------------------------------------------------------
+    include Enumerable
+    #-------------------------------------------------------------------------
 
-      def initialize view_id
-        super view_id, '/tag'
-      end
+    ##
+    # Iterates through each area in this view.
+    #
+    def each &block
+      areas.each(&block)
+    end
 
-      #-----------------------------------------------------------------------
-      # WM operations
-      #-----------------------------------------------------------------------
+    #-----------------------------------------------------------------------
+    # WM operations
+    #-----------------------------------------------------------------------
 
-        ##
-        # Returns the manifest of all areas and clients in this view.
-        #
-        def manifest
-          index.read || ''
-        end
+    ##
+    # Returns the manifest of all areas and clients in this view.
+    #
+    def manifest
+      index.read || ''
+    end
 
-        ##
-        # Moves the focus from the current client in the given direction.
-        #
-        def select direction
-          ctl.write "select #{direction}"
-        end
+    ##
+    # Moves the focus from the current client in the given direction.
+    #
+    def select direction
+      ctl.write "select #{direction}"
+    end
 
-      #-----------------------------------------------------------------------
-      # WM hierarchy
-      #-----------------------------------------------------------------------
-
-        ##
-        # Returns the area which contains the given client in this view.
-        #
-        def area_of_client client_or_id
-          arg =
-            if client_or_id.respond_to? :id
-              client_or_id.id
-            else
-              client_or_id
-            end
-
-          manifest =~ /^(\S+) #{arg}/
-          if area_id = $1
-            Area.new area_id, self
-          end
-        end
+    #-----------------------------------------------------------------------
+    # WM hierarchy
+    #-----------------------------------------------------------------------
 
-        ##
-        # Returns the IDs of all areas in this view.
-        #
-        def area_ids
-          manifest.scan(/^# (\d+)/).flatten.unshift(FLOATING_AREA_ID)
+    ##
+    # Returns the area which contains the given client in this view.
+    #
+    def area_of_client client_or_id
+      arg =
+        if client_or_id.respond_to? :id
+          client_or_id.id
+        else
+          client_or_id
         end
 
-        ##
-        # Returns all areas in this view.
-        #
-        def areas
-          area_ids.map! {|i| Area.new i, self }
-        end
+      manifest =~ /^(\S+) #{arg}/
+      if area_id = $1
+        Area.new area_id, self
+      end
+    end
 
-        ##
-        # Returns the floating area of this view.
-        #
-        def floating_area
-          Area.floating self
-        end
+    ##
+    # Returns the IDs of all areas in this view.
+    #
+    def area_ids
+      manifest.scan(/^# (\d+)/).flatten.unshift(FLOATING_AREA_ID)
+    end
 
-        ##
-        # Returns all columns (managed areas) in this view.
-        #
-        def columns
-          areas[1..-1]
-        end
+    ##
+    # Returns all areas in this view.
+    #
+    def areas
+      area_ids.map! {|i| Area.new i, self }
+    end
 
-        alias managed_areas columns
-
-        ##
-        # Resiliently iterates through possibly destructive changes to
-        # each column.  That is, if the given block creates new
-        # columns, then those will also be processed in the iteration.
-        #
-        def each_column starting_column_id = 1
-          i = starting_column_id
-          loop do
-            a = Area.new i, self
-
-            if a.exist?
-              yield a
-            else
-              break
-            end
-
-            i += 1
-          end
-        end
+    ##
+    # Returns the floating area of this view.
+    #
+    def floating_area
+      Area.floating self
+    end
 
-        alias each_managed_area each_column
-
-      #-----------------------------------------------------------------------
-      # visual arrangement of clients
-      #-----------------------------------------------------------------------
-
-        ##
-        # Arranges the clients in this view, while maintaining
-        # their relative order, in the tiling fashion of LarsWM.
-        #
-        # Only the first client in the primary column is kept; all others
-        # are evicted to the *top* of the secondary column.  Any subsequent
-        # columns are squeezed into the *bottom* of the secondary column.
-        #
-        def arrange_as_larswm
-          maintain_focus do
-            # keep only one client in the primary column
-            main = Area.new(1, self)
-            main.length = 1
-            main.layout = :default
-
-            # collapse remaining areas into secondary column
-            extra = squeeze_columns(1..-1)
-
-            if dock = extra.first
-              dock.layout = :default
-            end
-          end
-        end
+    ##
+    # Returns all columns (managed areas) in this view.
+    #
+    def columns
+      areas[1..-1]
+    end
 
-        ##
-        # Arranges the clients in this view, while maintaining
-        # their relative order, in a (at best) square grid.
-        #
-        def arrange_in_grid max_clients_per_column = nil
-          # compute client distribution
-          unless max_clients_per_column
-            num_clients = num_managed_clients
-            return unless num_clients > 0
-
-            num_columns = Math.sqrt(num_clients)
-            max_clients_per_column = (num_clients / num_columns).round
-          end
+    alias managed_areas columns
 
-          return if max_clients_per_column < 1
+    ##
+    # Resiliently iterates through possibly destructive changes to
+    # each column.  That is, if the given block creates new
+    # columns, then those will also be processed in the iteration.
+    #
+    def each_column starting_column_id = 1
+      i = starting_column_id
+      loop do
+        a = Area.new i, self
 
-          # apply the distribution
-          maintain_focus do
-            each_column do |a|
-              a.length = max_clients_per_column
-              a.layout = :default
-            end
-          end
+        if a.exist?
+          yield a
+        else
+          break
         end
 
-        ##
-        # Arranges the clients in this view, while maintaining
-        # their relative order, in the given number of columns.
-        #
-        def arrange_in_stacks num_stacks
-          return if num_stacks < 1
-
-          # compute client distribution
-          num_clients = num_managed_clients
-          return unless num_clients > 0
+        i += 1
+      end
+    end
 
-          stack_length = num_clients / num_stacks
-          return if stack_length < 1
+    alias each_managed_area each_column
 
-          # apply the distribution
-          maintain_focus do
-            each_column do |a|
-              a.length = stack_length
-              a.layout = :stack
-            end
+    #-------------------------------------------------------------------------
+    # visual arrangement of clients
+    #-----------------------------------------------------------------------
 
-            squeeze_columns num_stacks-1..-1
-          end
-        end
+    ##
+    # Arranges the clients in this view, while maintaining
+    # their relative order, in the tiling fashion of LarsWM.
+    #
+    # Only the first client in the primary column is kept; all others
+    # are evicted to the *top* of the secondary column.  Any subsequent
+    # columns are squeezed into the *bottom* of the secondary column.
+    #
+    def arrange_as_larswm
+      maintain_focus do
+        # keep only one client in the primary column
+        main = Area.new(1, self)
+        main.length = 1
+        main.layout = :default
 
-        ##
-        # Arranges the clients in this view, while
-        # maintaining their relative order, in a (at
-        # best) equilateral triangle.  However, the
-        # resulting arrangement appears like a diamond
-        # because wmii does not waste screen space.
-        #
-        def arrange_in_diamond
-          num_clients = num_managed_clients
-          return unless num_clients > 1
-
-          # determine dimensions of the rising sub-triangle
-          rise = num_clients / 2
-
-          span = sum = 0
-          1.upto rise do |h|
-            if sum + h > rise
-              break
-            else
-              sum += h
-              span += 1
-            end
-          end
+        # collapse remaining areas into secondary column
+        extra = squeeze_columns(1..-1)
 
-          peak = num_clients - (sum * 2)
+        if dock = extra.first
+          dock.layout = :default
+        end
+      end
+    end
 
-          # describe the overall triangle as a sequence of heights
-          rise_seq = (1..span).to_a
-          fall_seq = rise_seq.reverse
+    ##
+    # Arranges the clients in this view, while maintaining
+    # their relative order, in a (at best) square grid.
+    #
+    def arrange_in_grid max_clients_per_column = nil
+      # compute client distribution
+      unless max_clients_per_column
+        num_clients = num_managed_clients
+        return unless num_clients > 0
+
+        num_columns = Math.sqrt(num_clients)
+        max_clients_per_column = (num_clients / num_columns).round
+      end
 
-          heights = rise_seq
-          heights << peak if peak > 0
-          heights.concat fall_seq
+      return if max_clients_per_column < 1
 
-          # apply the heights
-          maintain_focus do
-            each_column do |col|
-              if h = heights.shift
-                col.length = h
-                col.layout = :default
-              end
-            end
-          end
+      # apply the distribution
+      maintain_focus do
+        each_column do |a|
+          a.length = max_clients_per_column
+          a.layout = :default
         end
+      end
+    end
 
-      private
+    ##
+    # Arranges the clients in this view, while maintaining
+    # their relative order, in the given number of columns.
+    #
+    def arrange_in_stacks num_stacks
+      return if num_stacks < 1
 
-      ##
-      # Squeezes all columns in the given index range into a single one.
-      #
-      def squeeze_columns range
-        extra = columns[range]
+      # compute client distribution
+      num_clients = num_managed_clients
+      return unless num_clients > 0
 
-        if extra.length > 1
-          extra.reverse.each_cons(2) do |src, dst|
-            dst.concat src
-          end
+      stack_length = num_clients / num_stacks
+      return if stack_length < 1
+
+      # apply the distribution
+      maintain_focus do
+        each_column do |a|
+          a.length = stack_length
+          a.layout = :stack
         end
 
-        extra
+        squeeze_columns num_stacks-1..-1
       end
+    end
 
-      ##
-      # Executes the given block and restores
-      # focus to the client that had focus
-      # before the given block was executed.
-      #
-      def maintain_focus
-        c, v = Client.curr, View.curr
-        yield
-        c.focus v
+    ##
+    # Arranges the clients in this view, while
+    # maintaining their relative order, in a (at
+    # best) equilateral triangle.  However, the
+    # resulting arrangement appears like a diamond
+    # because wmii does not waste screen space.
+    #
+    def arrange_in_diamond
+      num_clients = num_managed_clients
+      return unless num_clients > 1
+
+      # determine dimensions of the rising sub-triangle
+      rise = num_clients / 2
+
+      span = sum = 0
+      1.upto rise do |h|
+        if sum + h > rise
+          break
+        else
+          sum += h
+          span += 1
+        end
       end
 
-      ##
-      # Returns the number of clients in the non-floating areas of this view.
-      #
-      def num_managed_clients
-        manifest.scan(/^\d+ 0x/).length
+      peak = num_clients - (sum * 2)
+
+      # quantify overall triangle as a sequence of heights
+      rise_seq = (1..span).to_a
+      fall_seq = rise_seq.reverse
+
+      heights = rise_seq
+      heights << peak if peak > 0
+      heights.concat fall_seq
+
+      # apply the heights
+      maintain_focus do
+        each_column do |col|
+          if h = heights.shift
+            col.length = h
+            col.layout = :default
+          end
+        end
       end
     end
 
-  #---------------------------------------------------------------------------
-  # access to global WM state
-  #---------------------------------------------------------------------------
+    private
 
     ##
-    # Returns the root of IXP file system hierarchy.
+    # Squeezes all columns in the given index range into a single one.
     #
-    def fs
-      IXP_FS_ROOT
+    def squeeze_columns range
+      extra = columns[range]
+
+      if extra.length > 1
+        extra.reverse.each_cons(2) do |src, dst|
+          dst.concat src
+        end
+      end
+
+      extra
     end
 
     ##
-    # Returns the current set of tags.
+    # Executes the given block and restores
+    # focus to the client that had focus
+    # before the given block was executed.
     #
-    def tags
-      ary = IXP_FS_ROOT.tag.entries.sort
-      ary.delete FOCUSED_WIDGET_ID
-      ary
+    def maintain_focus
+      c, v = Client.curr, View.curr
+      yield
+      c.focus v
     end
 
     ##
-    # Returns the current set of views.
+    # Returns the number of clients in the non-floating areas of this view.
     #
-    def views
-      tags.map! {|t| View.new t }
+    def num_managed_clients
+      manifest.scan(/^\d+ 0x/).length
     end
+  end
 
-    include ClientContainer
+  ##
+  # Subdivision of the bar---the thing that spans the width of the
+  # screen---useful for displaying information and system controls.
+  #
+  class Barlet < Node
+    attr_reader :side
 
-      ##
-      # Returns the IDs of the current set of clients.
-      #
-      def client_ids
-        ary = IXP_FS_ROOT.client.entries
-        ary.delete FOCUSED_WIDGET_ID
-        ary
+    def initialize file_name, side
+      prefix =
+        case @side = side
+        when :left then '/lbar'
+        when :right then '/rbar'
+        else raise ArgumentError, side
+        end
+
+      super "#{prefix}/#{file_name}"
+    end
+
+    COLORS_REGEXP = /^\S+ \S+ \S+/
+
+    def label
+      case read
+      when /^label (.*)$/ then $1
+      when /#{COLORS_REGEXP} (.*)$/o then $1
       end
+    end
 
-    ##
-    # Returns a list of all grouped clients in
-    # the currently focused view. If there are
-    # no grouped clients, then the currently
-    # focused client is returned in the list.
-    #
-    def grouping
-      list = curr_view.clients.select {|c| c.group? }
-      list << curr_client if list.empty? and curr_client.exist?
-      list
+    def colors
+      case read
+      when /^colors (.*)$/ then $1
+      when COLORS_REGEXP then $&
+      end
+    end
+
+    # detect the new bar file format introduced in wmii-hg2743
+    temp_barlet = IXP_FS_ROOT.rbar["temp_barlet_#{object_id}"]
+    begin
+      temp_barlet.create
+      SPLIT_FILE_FORMAT = temp_barlet.read =~ /\Acolors/
+    ensure
+      temp_barlet.remove
+    end
+
+    def label= label
+      if SPLIT_FILE_FORMAT
+        write "label #{label}"
+      else
+        write "#{colors} #{label}"
+      end
+    end
+
+    def colors= colors
+      if SPLIT_FILE_FORMAT
+        write "colors #{colors}"
+      else
+        write "#{colors} #{label}"
+      end
     end
+  end
+
+  #---------------------------------------------------------------------------
+  # access to global WM state
+  #---------------------------------------------------------------------------
+
+  ##
+  # Returns the root of IXP file system hierarchy.
+  #
+  def fs
+    IXP_FS_ROOT
+  end
+
+  ##
+  # Returns the current set of tags.
+  #
+  def tags
+    ary = IXP_FS_ROOT.tag.entries.sort
+    ary.delete FOCUSED_WIDGET_ID
+    ary
+  end
+
+  ##
+  # Returns the current set of views.
+  #
+  def views
+    tags.map! {|t| View.new t }
+  end
+
+  ##
+  # Returns a list of all grouped clients in
+  # the currently focused view. If there are
+  # no grouped clients, then the currently
+  # focused client is returned in the list.
+  #
+  def grouping
+    list = curr_view.clients.select {|c| c.group? }
+    list << curr_client if list.empty? and curr_client.exist?
+    list
+  end
+
+  #---------------------------------------------------------------------------
+  include ClientContainer
+  #---------------------------------------------------------------------------
+
+  ##
+  # Returns the IDs of the current set of clients.
+  #
+  def client_ids
+    ary = IXP_FS_ROOT.client.entries
+    ary.delete FOCUSED_WIDGET_ID
+    ary
+  end
 
   #---------------------------------------------------------------------------
   # shortcuts for interactive WM manipulation (via IRB)
   #---------------------------------------------------------------------------
 
-    def curr_client ; Client.curr       ; end
-    def next_client ; curr_client.next  ; end
-    def prev_client ; curr_client.prev  ; end
+  def curr_client ; Client.curr       ; end
+  def next_client ; curr_client.next  ; end
+  def prev_client ; curr_client.prev  ; end
 
-    def curr_area   ; Area.curr         ; end
-    def next_area   ; curr_area.next    ; end
-    def prev_area   ; curr_area.prev    ; end
+  def curr_area   ; Area.curr         ; end
+  def next_area   ; curr_area.next    ; end
+  def prev_area   ; curr_area.prev    ; end
 
-    def curr_view   ; View.curr         ; end
-    def next_view   ; curr_view.next    ; end
-    def prev_view   ; curr_view.prev    ; end
+  def curr_view   ; View.curr         ; end
+  def next_view   ; curr_view.next    ; end
+  def prev_view   ; curr_view.prev    ; end
 
-    def curr_tag    ; curr_view.id      ; end
-    def next_tag    ; next_view.id      ; end
-    def prev_tag    ; prev_view.id      ; end
+  def curr_tag    ; curr_view.id      ; end
+  def next_tag    ; next_view.id      ; end
+  def prev_tag    ; prev_view.id      ; end
 
-    # provide easy access to container state information
-    [Client, Area, View].each {|c| c.extend ExportInstanceMethods }
+  # provide easy access to container state information
+  [Client, Area, View].each {|c| c.extend ExportInstanceMethods }
 
-    def focus_client id
-      Client.focus id
-    end
+  def focus_client id
+    Client.focus id
+  end
 
-    def focus_area id
-      Area.focus id
-    end
+  def focus_area id
+    Area.focus id
+  end
 
-    def focus_view id
-      View.focus id
-    end
+  def focus_view id
+    View.focus id
+  end
 
-    # provide easy access to this module's instance methods
-    module_function(*instance_methods(false))
+  # provide easy access to this module's instance methods
+  extend self
 end