unexist.dev

# Mpd sublet file

# Created with sur-0.1

require "socket"

require "subtle/subtlext"

# Class Pointer {{{

class Pointer

  attr_accessor :value

  def initialize(value = nil)

    @value = value

  end

  def to_s

    value.to_s

  end

end # }}}

# Class Mpd {{{

class Mpd

  # Mpd state

  attr_accessor :state

  # Mpd options

  attr_accessor :repeat

  attr_accessor :random

  attr_accessor :database

  # Mpd socket

  attr_accessor :socket

  # Mpd current song

  attr_accessor :current_song

  ## initialize {{{

  # Create a new mpd object

  # @param [String]  host      Hostname

  # @param [Fixnum]  port      Port

  # @param [String]  password  Password

  ##

  def initialize(host, port, password = nil)

    @host         = host

    @port         = port

    @password     = password

    @socket       = nil

    @state        = :off

    @repeat       = false

    @random       = false

    @database     = false

    @current_song = {}

  end # }}}

  ## connect {{{

  # Open connection to mpd

  # @return [Bool] Whether connection succeed

  ##

  def connect

    begin

      @socket = TCPSocket.new(@host, @port)

      # Handle SIGPIPE

      trap "PIPE" do

        @socket = nil

        disconnect

      end

      # Wait for mpd header

      safe_read(1)

      # Send password if any

      unless(@password.nil?)

        safe_write("password #{@password}")

        return false unless(get_ok(1))

      end

      parse_status

      parse_current

      idle

    rescue Errno::ECONNREFUSED

      puts "mpd not running"

    rescue

    end

    !@socket.nil?

  end # }}}

  ## disconnect {{{

  # Send close and shutdown

  ###

  def disconnect

    safe_write("close") unless(@socket.nil?)

    @socket = nil

    @state  = :off

  end # }}}

  ## action # {{{

  # Send action to mpd

  # @param [String]  command  Mpd action

  ##

  def action(command)

    noidle

    safe_write(command)

  end # }}}

  ## update {{{

  # Update mpd

  # @return [Bool] Whether update was successful

  ##

  def update

    get_ok(1)

    parse_status

    parse_current

    idle

    !@socket.nil?

  end # }}}

  private

  ## safe_read {{{

  # Read data from socket

  # @param [Fixnum]  timeout  Timeout in seconds

  # @return [String] Read data

  ##

  def safe_read(timeout = 0)

    line = ""

    unless(@socket.nil?)

      begin

        sets = select([ @socket ], nil, nil, timeout)

        line = @socket.readline unless(sets.nil?) #< No nil is a socket hit

      rescue EOFError

        puts "mpd read: EOF"

        @socket = nil

        disconnect

      rescue

        disconnect

      end

    end

    line

  end # }}}

  ## safe_write {{{

  # Write dats to socket

  # @param [String]  str  String to write

  ##

  def safe_write(str)

    return if(str.nil? or str.empty?)

    unless(@socket.nil?)

      begin

        @socket.write("%s\n" % [ str ])

      rescue

        disconnect

      end

    end

  end # }}}

  ## idle {{{

  # Send idle command

  ##

  def idle

    safe_write("idle player options update") unless(@socket.nil?)

  end # }}}

  ## noidle {{{

  # Send noidle command

  ###

  def noidle

    safe_write("noidle")

    get_ok(1)

  end # }}}

  ## get_ok {{{

  # Get ok or error

  # @param [Fixnum]  timeout  Timeout in seconds

  # @return [Bool] Whether mpd return ok

  ##

  def get_ok(timeout = 0)

    unless(@socket.nil?)

      line = safe_read(timeout)

      line = safe_read(timeout) if(line.match(/^changed/)) #< Skip changed message

      # Check result

      if(line.match(/^OK/))

        true

      elsif((match = line.match(/^ACK \[(.*)\] \{(.*)\} (.*)/)))

        disconnect

        # Probably non-recoverable

        puts "mpd %s error: %s" % [ match[2], match[3] ]

        false

      end

    end

  end # }}}

  ## get_reply {{{

  # Send command and return reply as hash

  # @oaran [String]  command  Command to send

  # return [Hash] Data hash

  ###

  def get_reply(command)

    hash = {}

    unless(@socket.nil?)

      begin

        safe_write(command)

        while

          line = safe_read(1)

          # Check response

          if(line.match(/^OK/))

            break

          elsif((match = line.match(/^ACK \[(.*)\] \{(.*)\} (.*)/)))

            disconnect

            # Probably non-recoverable

            puts "mpd %s error: %s" % [ match[2], match[3] ]

            raise #< Exit loop

          elsif((match = line.match(/^(\w+): (.+)$/)))

            hash[match[1].downcase] = match[2]

          end

        end

      rescue

        hash = {}

      end

    end

    hash

  end # }}}

  ## parse_status {{{

  # Parse mpd status

  ###

  def parse_status

    unless(@socket.nil?)

      status = get_reply("status")

      # Convert state

      @state = case status["state"]

        when "play"  then :play

        when "pause" then :pause

        when "stop"  then :stop

        else :off

      end

      # Set modes

      @repeat   = (0 == status["repeat"].to_i) ? false : true

      @random   = (0 == status["random"].to_i) ? false : true

      @database = !status["updating_db"].nil?

    end

  end # }}}

  ## parse_current {{{

  # Parse mpd current song

  ##

  def parse_current

    unless(@socket.nil?)

      @current_song = get_reply("currentsong")

    else

      @current_song = {}

    end

  end # }}}

end # }}}

configure :mpd do |s| # {{{

  # Icons

  s.icons = {

    :play     => Subtlext::Icon.new("play.xbm"),

    :pause    => Subtlext::Icon.new("pause.xbm"),

    :stop     => Subtlext::Icon.new("stop.xbm"),

    :prev     => Subtlext::Icon.new("prev.xbm"),

    :next     => Subtlext::Icon.new("next.xbm"),

    :note     => Subtlext::Icon.new("note.xbm"),

    :repeat   => Subtlext::Icon.new("repeat.xbm"),

    :random   => Subtlext::Icon.new("shuffle.xbm"),

    :database => Subtlext::Icon.new("diskette.xbm")

  }

  # Options

  s.def_action       = s.config[:def_action]

  s.wheel_up         = s.config[:wheel_up]

  s.wheel_down       = s.config[:wheel_down]

  s.format_string    = s.config[:format_string] || "%note%%artist% - %title%"

  s.stop_text        = s.config[:stop_text] || "mpd stopped"

  s.not_running_text = s.config[:not_running_text] || "mpd not running"

  s.blank_text       = s.config[:blank_text] || "n/a"

  s.draw_icons       = s.config[:draw_icons].nil? ? true : s.config[:draw_icons]

  s.pause_label      = s.config[:pause_label] || '*'

  s.show_pause       = s.config[:show_pause] || true

  ## Colors

  s.use_colors = s.config[:use_colors]

  colors = %w[artist album title track id pause stop note]

  if s.use_colors

    s.colors = {

      'artist'  => Subtlext::Color.new(s.config[:artist_color] || '#757575'),

      'album'   => Subtlext::Color.new(s.config[:album_color] || '#757575'),

      'title'   => Subtlext::Color.new(s.config[:title_color] || '#B8B8B8'),

      'track'   => Subtlext::Color.new(s.config[:track_color] || '#757575'),

      'id'      => Subtlext::Color.new(s.config[:id_color] || '#757575'),

      'pause'   => Subtlext::Color.new(s.config[:pause_color] || '#FECF35'),

      'stop'    => Subtlext::Color.new(s.config[:stop_color] || '#757575'),

      'note'    => Subtlext::Color.new(s.config[:note_color] || '#ffffff'),

    }

  else

    s.colors = Hash[colors.zip [""] * colors.size]

  end

  # Sanitize actions

  valid = [ "play", "pause 0", "pause 1", "stop", "previous", "next" ]

  s.def_action = "next"     unless(valid.include?(s.def_action))

  s.wheel_up   = "next"     unless(valid.include?(s.wheel_up))

  s.wheel_down = "previous" unless(valid.include?(s.wheel_down))

  # Parse format string once

  fields = [ "%note%", "%artist%", "%album%", "%title%", "%track%", "%id%" ]

  s.format_values = {}

  s.format_string.gsub!(/%[^%]+%/) do |f|

    if(fields.include?(f))

      name = f.delete("%")

      # Note: the _color format has to come before the other one

      format_values[name + '_color'] = Pointer.new

      if("%note%" == f)

        format_values[name] = self.icons[:note]

      else

        format_values[name] = Pointer.new

      end

      "%s%s"

    else

      ""

    end

  end

  # Create mpd object

  host, password = (s.config[:host] || ENV["MPD_HOST"] || "localhost").split("@")

  port           = s.config[:port]  || ENV["MPD_PORT"] || 6600

  s.mpd = Mpd.new(host, port, password)

  watch(s.mpd.socket) if(s.mpd.connect)

  update_status

end # }}}

helper do |s| # {{{

  def update_status # {{{

    mesg  = self.not_running_text

    modes = ""

    icon  = :play

    unless(self.mpd.socket.nil?)

      if(:play == self.mpd.state or :pause == self.mpd.state)

        # Select icon

        icon = case self.mpd.state

               when :play  then :pause

               when :pause then :play

               end

        # Sanity?

        self.format_values.each do |k, v|

          if(self.mpd.current_song.include?(k))

            self.format_values[k].value = if self.mpd.current_song[k].nil? 

                                          then self.blank_text

                                          else self.mpd.current_song[k]

                                          end

          elsif k.end_with?('_color')

            self.format_values[k].value = self.colors[k.chomp('_color')]

          else

            self.format_values[k].value = self.blank_text

          end

        end

        # Modes

        modes << self.icons[:repeat]   if(self.mpd.repeat)

        modes << self.icons[:random]   if(self.mpd.random)

        modes << self.icons[:database] if(self.mpd.database)

        modes = " %s" % [ modes ] unless(modes.empty?)

        # Assemble format

        mesg = self.format_string % self.format_values.values

      elsif(:stop == self.mpd.state)

        mesg = self.colors['stop'] + self.stop_text

        icon = :play

      end

    end

    if self.draw_icons

      self.data = "%s%s%s%s%s %s" % [

        self.icons[icon], self.icons[:stop],

        self.icons[:prev], self.icons[:next],

        modes, mesg

      ]

    else

      if self.show_pause && self.mpd.state == :pause

        mesg = "%s%s %s" % [self.colors['pause'], self.pause_label, mesg]

      end

      self.data = mesg

    end

  end # }}}

  def smart_play_command

    case self.mpd.state

    when :stop  then "play"

    when :pause then "pause 0"

    when :play  then "pause 1"

    end

  end

end # }}}

on :mouse_down do |s, x, y, b| # {{{

  if(s.mpd.socket.nil?)

    watch(s.mpd.socket) if(s.mpd.connect)

    update_status

  else

    # Send to socket

    if s.draw_icons

      action = case b

               when 1

                 case x

                 when 0..15  then smart_play_command

                 when 16..31 then "stop"

                 when 32..47 then "previous"

                 when 48..63 then "next"

                 else

                   s.def_action == "play" ? smart_play_command : s.def_action

                 end

               when 4 then s.wheel_up

               when 5 then s.wheel_down

               end

    else

      action = case b

               when 1

                 s.def_action == "play" ? smart_play_command : s.def_action

               when 4 then s.wheel_up

               when 5 then s.wheel_down

               end

    end

    s.mpd.action(action)

  end

end # }}}

on :watch do |s| # {{{

  unwatch unless(s.mpd.update)

  update_status

end # }}}