dtk wmii config

#
# High-level wmii configuration.
#
# Ruby code in this file has access
# to a CONFIG constant which contains
# the data in this configuration file.
#
#--
# Copyright protects this work.
# See LICENSE file for details.
#++


##
# Program preferences.
#
program:
  #terminal: gnome-terminal
  terminal: urxvt
  browser: firefox
  editor: gvim
  filer: nautilus --no-desktop
  lock: gnome-screensaver-command --activate


##
# Appearance settings.
#
display:

  ##
  # Where to display the horizontal status bar?
  #
  # Possible choices are "top" and "bottom".
  #
  bar: bottom

  ##
  # The font to use in all text drawn by wmii.
  #
  font: -*-fixed-medium-r-*-*-13-*-*-*-*-*-*-*

  ##
  # Thickness of client border (measured in pixels).
  #
  border: 1

  ##
  # Number of seconds a notice should be displayed.
  #
  notice: 5

  ##
  # Color schemes for everything drawn by wmii.
  #
  #   <scheme>: "<text> <background> <border>"
  #
  # You can find more color schemes here:
  #
  #   http://wmii.suckless.org/scripts_n_snips/themes
  #
  color:
    normal:   "#000000 #eeeee6 #81654f"
    #focus:    "#000000 #d1d1d1 #000000"
    #focus:    "#ffffff #5e5e5e #000000"
    focus:    "#a0ff00 #686363 #000000"
    error:    "#000000 #81654f #000000"
    notice:   "#000000 #a1956d #413328"
    success:  "#000000 #c1c48b #81654f"

  ##
  # Color of desktop background.
  #
  background: "#eeeee6"

  ##
  # Settings for columns drawn by wmii.
  #
  #   mode: <the wmii "colmode" setting>
  #   rule: <the wmii "colrules" setting>
  #
  column:
    mode: stack
    rule: |
      /gimp/ -> 17+83+41
      /.*/ -> 62+38 # Golden Ratio

  ##
  # Mapping of clients to views they must appear on.
  #
  #   - <client props regular expression> : <tags to apply>
  #
  # These mappings are processed in top-to-bottom order.
  # Processing stops after the first matching mapping is applied.
  #
  client:
    - /MPlayer|VLC/ : ~

  ##
  # Self-refreshing buttons on the status bar.
  #
  #   - <button name>:
  #       refresh:  <number of seconds to wait before refreshing the content>
  #       content:  <Ruby code whose result is displayed as the content>
  #       click:    <Ruby code to handle mouse clicks on the status button.
  #                  This code has access to a "mouse_button" variable which is
  #                  an integer representing the mouse button that was clicked.>
  #
  # You can refresh a particular status button in Ruby using:
  #
  #   status "your button name"
  #
  # The horizontal order in which these buttons appear on the status
  # bar reflects the vertical order in which they are defined below.
  #
  status:
    #- system_load:
    #    refresh: 10
    #    content: |
    #      load_averages = File.read('/proc/loadavg').split.first(3)
    #      current_load  = load_averages.first.to_f
    #
    #      # visually indicate the intensity of system load
    #      color = case
    #        when current_load > 3.0 then CONFIG['display']['color']['error']
    #        when current_load > 1.5 then CONFIG['display']['color']['notice']
    #      end
    #
    #      [color, *load_averages]

    - clock:
        refresh: 30
        content: Time.now.strftime '%d.%m.%Y|%H:%M'


##
# Interaction settings.
#
control:

  ##
  # The wmii "grabmod" setting.
  #
  grab: Mod4

  ##
  # Key sequence prefixes.
  #
  mod:    Mod4
  move:   Mod4-Shift
  swap:   Mod4-w
  view:   Mod4-v
  group:  Mod4-g
  prog:   Mod1

  ##
  # Direction keys.
  #
  up:    k
  down:  j
  left:  h
  right: l

  ##
  # Sequence keys.
  #
  prev: b
  next: n

  ##
  # Key bindings.
  #
  #   <key sequence>: <Ruby code to execute>
  #
  # A key sequence may contain ${...} expressions which
  # are replaced with the value corresponding to '...'
  # in the 'control' section of this configuration file.
  #
  # For example, if the 'control' section of
  # this configuration file appeared like this:
  #
  #   control:
  #     foo: Mod4
  #     bar: y
  #
  # and the following key sequence was used:
  #
  #   ${foo}-${bar},${bar}
  #
  # then after ${...} expression replacement,
  # that key sequence would appear like this:
  #
  #   Mod4-y,y
  #
  key:
    #---------------------------------------------------------------------------
    # focus
    #---------------------------------------------------------------------------

    ${mod}-${up}: | # focus above client
      curr_view.select(:up) rescue nil

    ${mod}-${down}: | # focus below client
      curr_view.select(:down) rescue nil

    ${mod}-${left}: | # focus left client
      curr_view.select(:left) rescue nil

    ${mod}-${right}: | # focus right client
      curr_view.select(:right) rescue nil

    ${mod}-space: | # focus floating area (toggle)
      curr_view.select(:toggle)

    ${mod}-${prev}: | # focus previous view
      prev_view.focus

    ${mod}-${next}: | # focus next view
      next_view.focus

    ${mod}-Escape: | # focus most recently focused view
      $last_view.focus if $last_view

    # focus the view whose index or name equals the pressed number
    #${mod}-1: focus_view tags[0] || 1
    ${mod}-1: switch_to_numeric_tag(1)
    ${mod}-2: switch_to_numeric_tag(2)
    ${mod}-3: switch_to_numeric_tag(3)
    ${mod}-4: switch_to_numeric_tag(4)
    ${mod}-5: switch_to_numeric_tag(5)
    ${mod}-6: switch_to_numeric_tag(6)
    ${mod}-7: switch_to_numeric_tag(7)
    ${mod}-8: switch_to_numeric_tag(8)
    ${mod}-9: switch_to_numeric_tag(9)
    ${mod}-0: switch_to_numeric_tag(0)
    #${mod}-8: focus_view '8:mail'
    #${mod}-9: focus_view '9:im'
    #${mod}-0: focus_view tags[9] || 10

    # focus the view whose name begins with the pressed alphabet
    ${view},a: t = tags.grep(/^a/i).first and focus_view(t)
    ${view},b: t = tags.grep(/^b/i).first and focus_view(t)
    ${view},c: t = tags.grep(/^c/i).first and focus_view(t)
    ${view},d: t = tags.grep(/^d/i).first and focus_view(t)
    ${view},e: t = tags.grep(/^e/i).first and focus_view(t)
    ${view},f: t = tags.grep(/^f/i).first and focus_view(t)
    ${view},g: t = tags.grep(/^g/i).first and focus_view(t)
    ${view},h: t = tags.grep(/^h/i).first and focus_view(t)
    ${view},i: t = tags.grep(/^i/i).first and focus_view(t)
    ${view},j: t = tags.grep(/^j/i).first and focus_view(t)
    ${view},k: t = tags.grep(/^k/i).first and focus_view(t)
    ${view},l: t = tags.grep(/^l/i).first and focus_view(t)
    ${view},m: t = tags.grep(/^m/i).first and focus_view(t)
    ${view},n: t = tags.grep(/^n/i).first and focus_view(t)
    ${view},o: t = tags.grep(/^o/i).first and focus_view(t)
    ${view},p: t = tags.grep(/^p/i).first and focus_view(t)
    ${view},q: t = tags.grep(/^q/i).first and focus_view(t)
    ${view},r: t = tags.grep(/^r/i).first and focus_view(t)
    ${view},s: t = tags.grep(/^s/i).first and focus_view(t)
    ${view},t: t = tags.grep(/^t/i).first and focus_view(t)
    ${view},u: t = tags.grep(/^u/i).first and focus_view(t)
    ${view},v: t = tags.grep(/^v/i).first and focus_view(t)
    ${view},w: t = tags.grep(/^w/i).first and focus_view(t)
    ${view},x: t = tags.grep(/^x/i).first and focus_view(t)
    ${view},y: t = tags.grep(/^y/i).first and focus_view(t)
    ${view},z: t = tags.grep(/^z/i).first and focus_view(t)

    #---------------------------------------------------------------------------
    # move
    #---------------------------------------------------------------------------

    ${move}-${up}: | # move grouping toward the top
      grouping.each {|c| c.send(:up) rescue nil }

    ${move}-${down}: | # move grouping toward the bottom
      grouping.each {|c| c.send(:down) rescue nil }

    ${move}-${left}: | # move grouping toward the left
      grouping.each {|c| c.send(:left) rescue nil }

    ${move}-${right}: | # move grouping toward the right
      grouping.each {|c| c.send(:right) rescue nil }

    ${move}-space: | # move grouping to floating area (toggle)
      grouping.each {|c| c.send(:toggle) rescue nil }

    ${move}-t: | # move grouping to chosen view
      #
      # Changes the tag (according to a menu choice) of
      # each grouped client and returns the chosen tag.
      #
      # The +tag -tag idea is from Jonas Pfenniger:
      #
      #   http://zimbatm.oree.ch/articles/2006/06/15/wmii-3-and-ruby
      #
      #choices = tags.map {|t| [t, "+#{t}", "-#{t}"] }.flatten
      choices = default_tags.merge(resolve_namespaces(tags)).to_a.map {|t| [t, "+#{t}", "-#{t}"] }.flatten

      if target = key_menu(choices, 'tag as:')
        grouping.each {|c| c.tags = target }
      end

    # move grouping to the view whose index or name equals the pressed number
    ${move}-1: grouping.each {|c| c.tags = tags[0] || 1  }
    ${move}-2: grouping.each {|c| c.tags = tags[1] || 2  }
    ${move}-3: grouping.each {|c| c.tags = tags[2] || 3  }
    ${move}-4: grouping.each {|c| c.tags = tags[3] || 4  }
    ${move}-5: grouping.each {|c| c.tags = tags[4] || 5  }
    ${move}-6: grouping.each {|c| c.tags = tags[5] || 6  }
    ${move}-7: grouping.each {|c| c.tags = tags[6] || 7  }
    ${move}-8: grouping.each {|c| c.tags = tags[7] || 8  }
    ${move}-9: grouping.each {|c| c.tags = tags[8] || 9  }
    ${move}-0: grouping.each {|c| c.tags = tags[9] || 10 }

    #---------------------------------------------------------------------------
    # group
    #---------------------------------------------------------------------------

    ${group},g: | # toggle current client from grouping
      curr_client.group!

    ${group},c: | # add clients in current area to grouping
      curr_area.group

    ${group},Shift-c: | # remove clients in current area from grouping
      curr_area.ungroup

    ${group},f: | # add clients in floating area to grouping
      Area.floating.group

    ${group},Shift-f: | # remove clients in floating area from grouping
      Area.floating.ungroup

    ${group},m: | # add clients in managed areas to grouping
      curr_view.managed_areas.each {|a| a.group }

    ${group},Shift-m: | # remove clients in managed areas from grouping
      curr_view.managed_areas.each {|a| a.ungroup }

    ${group},v: | # add clients in current view to grouping
      curr_view.group

    ${group},Shift-v: | # remove clients in current view from grouping
      curr_view.ungroup

    ${group},i: | # invert the grouping in the current view
      curr_view.group!

    ${group},Shift-i: | # invert the grouping in all views
      Rumai.group!

    ${group},n: | # remove all clients everywhere from grouping
      Rumai.ungroup

    #---------------------------------------------------------------------------
    # swap
    #---------------------------------------------------------------------------

    ${swap},${up}: | # swap with above client
      curr_client.swap(:up) rescue nil

    ${swap},${down}: | # swap with below client
      curr_client.swap(:down) rescue nil

    ${swap},${left}: | # swap with left client
      curr_client.swap(:left) rescue nil

    ${swap},${right}: | # swap with right client
      curr_client.swap(:right) rescue nil

    # swap current client with the column whose index equals the pressed number
    ${swap},1: curr_client.swap 1
    ${swap},2: curr_client.swap 2
    ${swap},3: curr_client.swap 3
    ${swap},4: curr_client.swap 4
    ${swap},5: curr_client.swap 5
    ${swap},6: curr_client.swap 6
    ${swap},7: curr_client.swap 7
    ${swap},8: curr_client.swap 8
    ${swap},9: curr_client.swap 9
    ${swap},0: curr_client.swap 10

    #---------------------------------------------------------------------------
    # client
    #---------------------------------------------------------------------------

    ${mod}-f: | # zoom client to fullscreen (toggle)
      curr_client.fullscreen!

    ${mod}-q: | # kill the current client
      curr_client.kill

    #---------------------------------------------------------------------------
    # column
    #---------------------------------------------------------------------------

    ${mod}-d: | # apply equal-spacing layout to current column
      curr_area.layout = 'default-max'

    ${mod}-s: | # apply stacked layout to current column
      curr_area.layout = 'stack-max'

    ${mod}-m: | # apply maximized layout to current column
      curr_area.layout = 'stack+max'

    #---------------------------------------------------------------------------
    # menu
    #---------------------------------------------------------------------------

    ${mod}-a: | # run internal action chosen from a menu
      if choice = key_menu(actions, 'run action:')
        action choice
      end

    ${mod}-p: | # run external program chosen from a menu
      if choice = key_menu(@programs, 'run program:')
        launch choice
      end

    ${mod}-t: | # focus view chosen from a menu
      if choice = key_menu(default_tags.merge(existing_tags).to_a, 'show view:')
        focus_view choice
      end

    #---------------------------------------------------------------------------
    # launcher
    #---------------------------------------------------------------------------

    #${mod}-Return: | # launch a terminal
    ${prog}-s: | # launch a terminal
      #
      # Launch a new terminal and set its
      # working directory to be the same
      # as the currently focused terminal.
      #
      work = ENV['HOME']

      label = curr_client.label.read rescue ''

      # iterate in reverse order because
      # paths are usually at end of label
      label.split(' ').reverse_each do |s|
        path = File.expand_path(s)

        if File.exist? path
          unless File.directory? path
            path = File.dirname(path)
          end

          work = path
          break
        end
      end

      require 'fileutils'
      FileUtils.cd work do
        launch CONFIG['program']['terminal']
      end

    ${prog}-w: |
        launch CONFIG['program']['browser']

    ${prog}-e: |
        launch CONFIG['program']['filer']

    ${prog}-l: |
        launch CONFIG['program']['lock']

  ##
  # Event handlers.
  #
  #   <event name>: <Ruby code to execute>
  #
  # The Ruby code has access to an "argv" variable which
  # is a list of arguments that were passed to the event.
  #
  event:
    CreateTag: |
      tag = argv[0]
      but = fs.lbar[tag]
      but.create unless but.exist?
      but.write "#{CONFIG['display']['color']['normal']} #{tag}"
      existing_tags.merge(resolve_namespaces([tag]))
      LOG.debug "existing tags: #{existing_tags.to_a}"

    DestroyTag: |
      tag = argv[0]
      but = fs.lbar[tag]
      but.remove if but.exist?
      existing_tags.replace(resolve_namespaces(tags))
      LOG.debug "existing tags: #{existing_tags.to_a}"

    FocusTag: |
      tag = argv[0]
      but = fs.lbar[tag]
      but.write "#{CONFIG['display']['color']['focus']} #{tag}" if but.exist?

    UnfocusTag: |
      tag = argv[0]
      but = fs.lbar[tag]
      but.write "#{CONFIG['display']['color']['normal']} #{tag}" if but.exist?

    UrgentTag: |
      tag = argv[1]
      but = fs.lbar[tag]
      but.write "#{CONFIG['display']['color']['notice']} #{tag}" if but.exist?

    NotUrgentTag: |
      tag = argv[1]
      but = fs.lbar[tag]
      color = curr_view.id == tag ? 'focus' : 'normal'
      but.write "#{CONFIG['display']['color'][color]} #{tag}" if but.exist?

    LeftBarClick: &LeftBarClick |
      mouse_button, view_id = argv

      if mouse_button == '1' # primary button
        focus_view view_id
      end

    ##
    # allows the user to drag a file over a
    # view button and activate that view while
    # still holding on to their dragged file!
    #
    LeftBarDND: *LeftBarClick

    RightBarClick: |
      status_click *argv.reverse

    ClientMouseDown: |
      client_id, mouse_button = argv

      if mouse_button == '3' # secondary button
        client = Client.new(client_id)

        case click_menu %w[stick group fullscreen kill slay], 'client'
        when 'stick'      then client.stick!
        when 'group'      then client.group!
        when 'fullscreen' then client.fullscreen!
        when 'kill'       then client.kill
        when 'slay'       then client.slay
        end
      end

  ##
  # Internal scripts.
  #
  #   <action name>: <Ruby code to execute>
  #
  action:


##
# Arbitrary logic.
#
#   script:
#     before: <Ruby code to execute before processing this file>
#     after:  <Ruby code to execute after processing this file>
#
script:
  before: |
    # handle namespaces
    require 'set'

    default_tags = SortedSet.new(['comm:', 'comm:im', 'comm:mail', 'devel:', 'sys:', 'uni:', 'web'])
    existing_tags = SortedSet.new

    def resolve_namespaces(tags)
        LOG.debug "resolving namespaces from #{tags}:"
        namespaces = Set.new
        tags.each do |tag_name|
            subtags = tag_name.split(':')
            last_subtag = 0
            #namespaces
            while last_subtag < (subtags.length - 1)
                namespaces.add(subtags[0..last_subtag].join(':') + ':')
                last_subtag += 1
            end
            ###FIXME: last splitted element does not have to be bare tag!
            ###      may be namespace if tag_name ends on ':'!!
            #bare tag
            namespaces.add(subtags[0..last_subtag].join(':'))
        end
        LOG.debug "resolved namespaces: #{namespaces.to_a}"
        #return namespaces.to_a
        return namespaces
    end

    def switch_to_numeric_tag(digit)
      if t = tags.grep(/^#{digit}/).first
        LOG.debug "tag #{digit} exists: #{t}"
        focus_view(t)
      elsif choice = key_menu(["#{digit}:"], 'show view:')
        focus_view choice
      end
    end

    DETACHED_TAG = '|'
    ZOOMED_SUFFIX = /~(\d+)$/

    # keep track of most recently focused view
    $last_view = nil

    class Rumai::View
      alias __focus__ focus

      def focus
        $last_view = View.curr
        __focus__
      end
    end

  after: |
    # background image
    system 'wmsetbg --back-color gray --center /home/dtk/.wmii/background.png'

    # clean up
    system 'pkill -u dtk -f /etc/X11/wmii/wmiirc'
    system 'pkill -u dtk trayer'

    # autostart
    system 'trayer --edge bottom --align right --widthtype pixel --width 130 --height 17 --SetPartialStrut true &'
    system 'nm-applet &'
    system 'gnome-power-manager &'
    system 'gnome-volume-control-applet &'
    system 'bluetooth-applet &'
    system 'update-notifier &'

    # make systray sticky
    sleep 0.5
    trayer_pattern = /panel:trayer:panel/
    curr_view.manifest.split("\n").each do |client_descriptor|
        if client_descriptor.match(trayer_pattern)
            trayer = Client.new(client_descriptor.split()[1])
            trayer.stick
        end
    end