root/lang/ruby/Amalgam/AppController.rb @ 1056

require 'osx/cocoa'
include OSX

require "pathname"

class TransparentView < NSView
        def drawRect(rect)
                super_drawRect(rect)
                NSColor.clearColor.set
                NSRectFill(bounds)
        end
end

class AmalgamWindow < NSWindow
        def canBecomeKeyWindow
                true
        end

        def canBecomeMainWindow
                true
        end

        def sendEvent(e)
                if e.oc_type == NSKeyDown
                        return if delegate.process_keyevent(e)
                end
                super_sendEvent(e)
        end
end

class History < Array
        attr_accessor :pointer

        def pointer
                @pointer ||= 0
        end

        def prev(str)
                if self.pointer == 0
                        self.unshift str
                end
                self.pointer += 1
                @pointer = length - 1 if @pointer >= length
                self[@pointer]
        end

        def next
                self.pointer -= 1
                @pointer = 0 if @pointer < 0
                ret = self[@pointer]
                if self.pointer == 0
                        self.shift
                end
                ret
        end

        def add(hist)
                self.unshift hist
                self.replace(self.first(20))
        end

        def reset
                while self.pointer > 0
                        self.next
                end
        end
end

class Candidate
        attr_accessor :name, :desc, :icon, :proc

        def initialize(name, desc, icon=nil, &block)
                @desc = desc.to_s
                @name = name.to_s
                @proc = block
                case icon
                when Symbol
                        @icon = NSWorkspace.sharedWorkspace.iconForFileType(icon.to_s)
                when Pathname
                        @icon = NSWorkspace.sharedWorkspace.iconForFile(icon.to_s)
                when NilClass
                        @icon = NSWorkspace.sharedWorkspace.iconForFileType("unknown")
                when NSData
                        @icon = NSImage.alloc.initWithData(str)
                when NSImage
                        @icon = icon
                else
                        str = NSData.objc_send :dataWithBytes, icon.to_s, :length
                        @icon = NSImage.alloc.initWithData(str)
                end
        end

        def call(*args)
                if @proc.arity.abs > 0
                        @proc.call(self, *args)
                end
        end
end

class Command < Candidate
end

require "yaml"
require "rubygems"
require "module/pluggable"
require "plugin_base"
class AmalgamConfig

        PATH = Pathname.new("#{ENV["HOME"]}/.amalgam")

        pluggable :plugins,         :base_class  => AmalgamPlugin,
                                    :search_path => (PATH + "plugins").to_s
        pluggable :default_plugins, :base_class  => AmalgamPlugin,
                                    :search_path => (NSBundle.mainBundle.resourcePath + "/plugins").to_s

        Default = {
                :hotkey => "Command+`",
        }.freeze

        def initialize(controller)
                @controller = controller
                begin
                        @config = Default.merge(YAML.load((PATH+"config.yaml").read))
                rescue Errno::ENOENT
                        @config = Default
                end
                plugins.init(controller)
                default_plugins.init(controller)
        end

        def [](key)
                @config[key]
        end

        def initrc
                (PATH + "initrc.rb").read
        rescue Errno::ENOENT
                ""
        end

        def reload
                reloaded = []
                [self.plugins, self.default_plugins].each do |pl|
                        pl.reload.first.each do |c|
                                log c
                                reloaded << [c, pl[c]]
                                pl[c].init(@controller)
                        end
                end
                reloaded
        end

        def inspect
                "#<%s:%#08x>" % [self.class.to_s, self.object_id]
        end
end

class AppController < NSObject
        ib_outlet :view
        ib_outlet :input
        ib_outlet :results

        attr_reader :candidates, :sublaunchers

        def candidates
                if @sublaunchers.empty?
                        @candidates.inject([]) {|r,(k,v)| r.concat(v) }
                else
                        @sublaunchers.last.candidates
                end
        end

        def search_text
                @input.stringValue
        end

        def search_text=(val)
                @input.stringValue = val
        end

        # Tableview
        def numberOfRowsInTableView(table)
                @now.first(100).length
        end

        def tableView_objectValueForTableColumn_row(table, column, row)
                case column.identifier.to_s.to_sym
                when :icon
                        @now[row].icon || 
                                NSWorkspace.sharedWorkspace.iconForFileType('unknown')
                when :name
                        "#{@now[row].name}\n\t#{@now[row].desc}"
                end
        end

        def tableView_setObjectValue_forTableColumn_row(table, value, column, row)
        end

        def tableView_willDisplayCell_forTableColumn_row(table, cell, column, row)
                case column.identifier.to_s.to_sym
                when :icon
                when :name
                        cell.allowsEditingTextAttributes = true
                        str = NSMutableAttributedString.alloc.init
                        str.appendAttributedString(NSAttributedString.alloc.initWithString_attributes(@now[row].name + "\n", {
                                NSForegroundColorAttributeName => NSColor.blackColor
                        }))
                        str.appendAttributedString(NSAttributedString.alloc.initWithString_attributes(@now[row].desc, {
                                NSForegroundColorAttributeName => NSColor.lightGrayColor,
                                NSFontAttributeName            => NSFont.systemFontOfSize(10)
                        }))
                        cell.attributedStringValue = str
                end
        end

        def run_current_selection(*)
                if @now[@results.selectedRow]
                        begin
                                @now[@results.selectedRow].call
                        rescue Exception => e
                                log e
                                $stderr.puts e.backtrace
                                alert("Error", e.inspect)
                        end
                end
        end

        def controlTextDidChange(anot)
                filtering @input.stringValue
                @results.selectRowIndexes_byExtendingSelection(NSIndexSet.alloc.initWithIndex(0), false)
                @results.scrollRowToVisible(0)
        end

        def windowDidResignKey(anot)
                #@window.orderOut(nil)
        end

        def windowDidResignMain(anot)
                NSApp.hide(nil)
        end

        def windowDidBecomeMain(anot)
                @window.makeFirstResponder(@input)
        end

        def windowDidBecomeKey(anot)
                @window.makeFirstResponder(@input)
                @sublaunchers.clear
                self.clear
                @history.reset
                @results.selectRowIndexes_byExtendingSelection(NSIndexSet.alloc.initWithIndex(0), false)
        end

        def applicationWillFinishLaunching(n)
                #set_status("Finish Launching", false)
                #@combo.cell.placeholderString = "Finish Launching"
        end

        def awakeFromNib
                @sublaunchers = []
                @input.stringValue
                @history = History.new
                log "Loading Config"
                @config  = AmalgamConfig.new(self)

                rect = @view.frame

                @window = AmalgamWindow.alloc.objc_send(
                        :initWithContentRect, rect,
                        :styleMask, NSBorderlessWindowMask,
                        :backing, NSBackingStoreBuffered,
                        :defer, 0
                )
                #@window.setLevel(1000) # NSScreenSaverWindowLevel

                @window.opaque = true
                @window.setContentView(@view)
                @window.delegate = self

                screenFrame = NSScreen.mainScreen.frame
                @window.setFrameOrigin([screenFrame.size.width / 2, screenFrame.size.height / 2])

                raise "HotKey is not defined" if @config[:hotkey].nil?
                NSApp.register_hotkey(@config[:hotkey]) do
                        if NSApp.isActive?
                                NSApp.hide(nil)
                        else
                                NSApp.activateIgnoringOtherApps(true)
                                @window.makeMainWindow
                                @window.orderFrontRegardless
                                @window.makeKeyAndOrderFront(@window)
                        end
                end


                build_candidates()
                @results.dataSource = self

                NSApp.activateIgnoringOtherApps(true)
                @window.makeFirstResponder(@input)

                eval(@config.initrc, binding)
        end

        def filtering(str)
                str = str.to_s

                if sublaunchers.empty? ||
                   !sublaunchers.last.respond_to?(:filter)

                        r = /(#{str.split(//).map {|c| Regexp.escape(c) }.join(").*?(")})/i
                        @now = candidates.select {|i|
                                if i.kind_of? Command
                                        /^#{Regexp.escape(i.name)}/ === str
                                else
                                        r === i.name
                                end
                        }.sort_by {|i|
                                # 文字が前のほうに集っているほど高ランクになるように
                                m = r.match(i.name)
                                if m
                                        (0...m.size).map {|j| m.begin(j) }.inject {|s,j| s + j } * 1000 + i.name.length
                                else
                                        # Command 引数ありのとき
                                        i.name.length
                                end
                        }
                else
                        @now = sublaunchers.last.filter(candidates, str)
                end
                @results.reloadData
        end

        def nextCandidate(sender)
                if @history.pointer > 0
                        @input.stringValue = @history.next
                else
                        if @results.selectedRow <= @now.size
                                @results.selectRowIndexes_byExtendingSelection(NSIndexSet.alloc.initWithIndex(@results.selectedRow+1), false)
                                @results.scrollRowToVisible(@results.selectedRow)
                        end
                end
                filtering @input.stringValue
        end

        def prevCandidate(sender)
                if @results.selectedRow > 0
                        @results.selectRowIndexes_byExtendingSelection(NSIndexSet.alloc.initWithIndex(@results.selectedRow-1), false)
                        @results.scrollRowToVisible(@results.selectedRow)
                else
                        unless @history.empty?
                                @input.stringValue = @history.prev(@input.stringValue)
                        end
                end
                filtering @input.stringValue
        end

        def process_keyevent(e)
                key = key_string(e)
                #log key
                case key
                when "C-n"
                        nextCandidate nil
                when "C-p"
                        prevCandidate nil
                when "\r"
                        @history.reset
                        if @input.stringValue.strip.empty?
                                if @sublaunchers.empty?
                                        NSApp.hide(nil)
                                else
                                        n = @sublaunchers.size
                                        run_current_selection
                                        NSApp.hide(nil) if @sublaunchers.size <= n
                                end
                        else
                                @history.add @input.stringValue
                                run_current_selection
                                NSApp.hide(nil) if @sublaunchers.empty?
                        end
                when "\t"
                        return true
                when "S-\t"
                        return true
                when "C-u"
                        @input.stringValue = ""
                        filtering ""
                when "C-b"
                        @sublaunchers.pop
                        filtering ""
                when "C-c"
                        NSApp.hide(nil)
                end

                false
        end

        def key_string(e)
                key = ""
                m = e.modifierFlags
                key << "S-" if m & NSShiftKeyMask > 0
                key << "C-" if m & NSControlKeyMask > 0
                key << "M-" if m & NSAlternateKeyMask > 0
                key << "G-" if m & NSCommandKeyMask > 0 # TODO
                key << e.charactersIgnoringModifiers.to_s
                key
        end

        def restart(*)
                log "restart"
                path = NSBundle.mainBundle.executablePath.to_s
                fork do
                        sleep 2
                        system(path)
                end
                NSApp.terminate(nil)
        end

        def build_candidates
                @candidates = {}
                @sublaunchers.clear
#
#               @candidates << Candidate.new("Exit", "Exit Amalgam", :sh) do
#                       if OSX.NSRunAlertPanel("Sure?", "exit ok?", "Exit", "Cancel", nil) == NSAlertDefaultReturn
#                               NSApp.terminate(nil)
#                       end
#               end

                @config.default_plugins.candidates.each do |k,v|
                        @candidates[k] = v
                end
                @config.plugins.candidates.each do |k,v|
                        @candidates[k] = v
                end

                @now = candidates
                log "Search done"
        end

        def clear
                @input.stringValue = ""
                filtering ""
        end

        def reload_plugins
                ret = []
                @sublaunchers.clear
                @config.reload.each do |k,v|
                        ret << k
                        @candidates[k] = v.candidates
                end
                ret
        end

        # match するプラグインを強制リロード
        def r(match)
                @sublaunchers.clear
                ret = []
                [@config.plugins, @config.default_plugins].each do |pl|
                        pl.each do |k,v|
                                next unless match === k
                                ret << k
                                @candidates[k] = v.candidates
                        end
                end
                ret
        end


end