irecorder 0.0.4-linux → 0.0.5-linux

data/lib/mylibs.rb

@@ -218,17 +218,17 @@ module Enumerable
 end
 
 #
-class Hash
-    alias   old_blaket []
-    def [](key)
-        unless key.kind_of?(Regexp)
-            return old_blaket(key)
-        end
-
-        retk, retv = self.find { |k,v| k =~ key }
-        retv
-    end
-end
+# class Hash
+#     alias   old_blaket []
+#     def [](key)
+#         unless key.kind_of?(Regexp)
+#             return old_blaket(key)
+#         end
+#
+#         retk, retv = self.find { |k,v| k =~ key }
+#         retv
+#     end
+# end
 
 class Qt::Action
     def setVData(data)

data/lib/programmewin.rb

@@ -0,0 +1,182 @@
+
+#---------------------------------------------------------------------------------------------
+#
+#
+class ProgrammeTableWidget < Qt::TableWidget
+    slots   'filterChanged(const QString &)'
+
+    #
+    #
+    class Programme
+        attr_reader :titleItem, :categoriesItem, :updatedItem
+        attr_reader :content, :link
+
+        def initialize(title, categories, updated, content, link)
+            @titleItem = Item.new(title)
+            @categoriesItem = Item.new(categories)
+            @updatedItem = Item.new(updated)
+            @content = content
+            @link = link
+        end
+
+        def title
+            @titleItem.text
+        end
+
+        def categories
+            @categoriesItem.text
+        end
+
+        def updated
+            @updatedItem.text
+        end
+    end
+
+    #
+    #
+    class Item < Qt::TableWidgetItem
+        def initialize(text)
+            super(text)
+            self.flags = Qt::ItemIsSelectable | Qt::ItemIsEnabled
+            self.toolTip = text
+        end
+    end
+
+
+    #------------------------------------------------------------------------
+    #
+    #
+    attr_accessor :mediaFilter
+
+    def initialize()
+        super(0, 3)
+
+        setHorizontalHeaderLabels(['Title', 'Category', 'Updated'])
+        self.horizontalHeader.stretchLastSection = true
+        self.selectionBehavior = Qt::AbstractItemView::SelectRows
+        self.alternatingRowColors = true
+        self.sortingEnabled = true
+        sortByColumn(2, Qt::DescendingOrder )
+
+        @mediaFilter = ''
+
+        # Hash table : key column_0_item  => Programme entry.
+        @table = Hash.new
+    end
+
+    def addEntry( row, title, categories, updated, content, link )
+        entry = Programme.new(title, categories, updated, content, link)
+        setItem( row, 0, entry.titleItem )
+        setItem( row, 1, entry.categoriesItem )
+        setItem( row, 2, entry.updatedItem )
+        @table[entry.titleItem] = entry
+    end
+
+    # return Programme object.
+    def [](row)
+        @table[item(row,0)]
+    end
+
+
+    #
+    # slot : called when filterLineEdit text is changed.
+    #
+    public
+
+    def filterChanged(text)
+        return unless text
+
+        text += ' ' + @mediaFilter unless @mediaFilter.empty?
+
+        regxs = text.split(/[,\s]+/).map do |w|
+                    /#{Regexp.escape(w.strip)}/i
+        end
+        rowCount.times do |r|
+            i0 = item(r,0)
+            i1 = item(r,1)
+            i2 = item(r,2)
+            txt = ((i0 && i0.text) || '') + ((i1 && i1.text) || '') + ((i2 && i2.text) || '')
+            if regxs.all? do |rx| rx =~ txt end then
+                showRow(r)
+            else
+                hideRow(r)
+            end
+        end
+    end
+
+    GroupName = "ProgrammeTable"
+    def writeSettings
+        config = $config.group(GroupName)
+        config.writeEntry('Header', horizontalHeader.saveState)
+    end
+
+    def readSettings
+        config = $config.group(GroupName)
+        horizontalHeader.restoreState(config.readEntry('Header', horizontalHeader.saveState))
+    end
+
+    protected
+    def contextMenuEvent(e)
+        item = itemAt(e.pos)
+        menu = createPopup
+        execPopup(menu, e.globalPos, item)
+    end
+
+    def createPopup()
+        menu = Qt::Menu.new
+        insertPlayerActions(menu)
+        menu
+    end
+
+    def execPopup(menu, pos, item)
+        action = menu.exec(pos)
+        if action then
+            action.data
+#             $log.code { "execute : '#{action.vData}'" }
+                cmd, exe = action.vData.split(/@/, 2)
+#                 $log.code { "cmd(#{cmd}), exe(#{exe})" }
+                case cmd
+                when 'play'
+                    playMedia(exe, item)
+                else
+#                     self.method(cmd).call(item)
+                end
+        end
+        menu.deleteLater
+    end
+
+    def insertPlayerActions(menu)
+        Mime::services('.wma').each do |s|
+            if s.exec then
+                exeName = s.exec[/\w+/]
+                a = menu.addAction(KDE::Icon.new(exeName), 'Play with ' + exeName)
+                a.setVData('play@' + s.exec)
+            end
+        end
+    end
+
+    def playMedia(exe, item)
+        begin
+            prog = self[item.row]
+            url = prog.content[UrlRegexp]       # String[] method extract only 1st one.
+
+            $log.info { "episode Url : #{url}" }
+            minfo = BBCNet::MetaInfo.get(url).update
+            url = minfo.wma.url
+
+            cmd, args = exe.split(/\s+/, 2)
+            args = args.split(/\s+/).map do |a|
+                a.gsub(/%\w/, url)
+            end
+#             $log.debug { "execute cmd '#{cmd}', args '#{args.inspect}'" }
+            proc = Qt::Process.new(self)
+            proc.start(cmd, args)
+
+        rescue => e
+            $log.error { e }
+            KDE::MessageBox::information(self, i18n("There is not direct stream for this programme."))
+        end
+    end
+end
+
+

data/lib/settings.rb

@@ -313,9 +313,6 @@ class PlayerSettingsPage < Qt::Widget
         @SelectWebPlayerDlg = SelectWebPlayerDlg.new(self, IRecSettings.webPlayerName)
         @SelectDirectPlayerDlg = SelectDirectPlayerDlg.new(self, IRecSettings.directPlayerName)
         IRecSettings.instance.regConverter(@SelectWebPlayerDlg, @SelectDirectPlayerDlg)
-        puts "web player:" + IRecSettings.webPlayerCommand.to_s
-        puts "direct player:" +  IRecSettings.directPlayerCommand.to_s
-
 
         @playerTypeSmall = Qt::RadioButton.new(i18n('small iplayer'))
         @playerTypeBeta = Qt::RadioButton.new(i18n('beta iplayer'))

data/lib/taskwin.rb

@@ -122,33 +122,28 @@ class TaskWindow < Qt::Widget
             poRow =  wItem.row
             poColumn = wItem.column
             $log.misc { "right clicked item (row:#{poRow}, column:#{poColumn})" }
-            url = getContextUrl(wItem)
-            sts = taskItemAtRow(wItem.row).status
+            process = taskItemAtRow(wItem.row).process
 
             menu = Qt::Menu.new
-            insertDefaultActions(menu, poColumn, url, sts)
-            if url then
-                menu.addSeparator
-                insertPlayerActions(menu, url)
-                menu.addSeparator
-                insertMPlayerAction(menu)
-            end
+            insertDefaultActions(menu, poColumn, process)
+            createPlayerMenu(menu, poColumn, process)
             action = menu.exec(pos)
             if action then
                 $log.code { "execute : '#{action.data.toString}'" }
                 cmd, exe = action.data.toString.split(/@/, 2)
                 $log.code { "cmd(#{cmd}), exe(#{exe})" }
-                case cmd
-                when 'play'
-                    playMedia(exe, wItem)
+                if cmd =~ /^play/
+                    playMedia(cmd, process, exe)
+                elsif self.respond_to?(cmd)
+                    self.method(cmd).call(process, wItem)
                 else
-                    self.method(cmd).call(wItem)
+                    $log.warn { "No method #{cmd} in contextmenu." }
                 end
             end
             menu.deleteLater
         end
 
-        def insertDefaultActions(menu, poColumn, url, sts)
+        def insertDefaultActions(menu, poColumn, process)
             a = menu.addAction(KDE::Icon.new('edit-copy'), 'Copy Text')
             a.setVData('copyText@')
             if poColumn == FILE
@@ -157,13 +152,15 @@ class TaskWindow < Qt::Widget
                 a = menu.addAction(KDE::Icon.new('kfm'), 'Open Temp Folder')
                 a.setVData('openTempFolder@')
             end
-            if sts =~ /Error/i
+            if process.error?
                 a = menu.addAction(KDE::Icon.new('view-refresh'), 'Retry')
                 a.setVData('retryTask@')
                 a = menu.addAction(KDE::Icon.new('list-remove'), 'Remove')
                 a.setVData('removeTask@')
+                a = menu.addAction(KDE::Icon.new('list-remove-data'), 'Remove Task and Data')
+                a.setVData('removeTaskData@')
             end
-            if sts =~ /\w+ing\b/i
+            if process.running?
                 a = menu.addAction(KDE::Icon.new('edit-delete'), 'Cancel')
                 a.setVData('cancelTask@')
             end
@@ -174,125 +171,122 @@ class TaskWindow < Qt::Widget
         end
 
 
-        def insertMPlayerAction(menu)
-            player = 'mplayer'
-            mplayerPath = %x(which #{player})
-            return if mplayerPath =~ /no #{player}/
-            insertPlayer(menu, player, player +  ' %U')
-        end
 
-        def insertPlayerActions(menu, url)
-            Mime::services(url).each do |s|
-                if s.exec then
-                    exeName = s.exec[/\w+/]
-                    insertPlayer(menu, exeName, s.exec)
+        def createPlayerMenu(menu, poColumn, process)
+            case poColumn
+            when SOURCE
+                menu.addSeparator
+                createPlayers(menu, i18n('Play Source with'), "playSource@", '.wma')
+            when FILE
+                menu.addSeparator
+                if process.rawDownloaded? then
+                    createPlayers(menu, i18n('Play File with'), "playMP3@", '.mp3')
                 end
+                createPlayers(menu, i18n('Play Temp File with'), "playTemp@", '.wma')
             end
         end
 
-        def insertPlayer(menu, exeName, exec = exeName)
-            a = menu.addAction(KDE::Icon.new(exeName), 'Play with ' + exeName)
-            a.setVData('play@' + exec)
+        def createPlayers(menu, playText, playerCmd, url)
+            playersMenu = Qt::Menu.new(playText)
+            Mime::services(url).each do |s|
+                exeName = s.exec[/\w+/]
+                a = playersMenu.addAction(KDE::Icon.new(exeName), 'Play with ' + exeName)
+                a.setVData(playerCmd + s.exec)
+            end
+            menu.addMenu(playersMenu)
         end
 
 
-        def getContextUrl(wItem)
-            ti = taskItemAtRow(wItem.row)
-            return nil unless ti
-            rawFilePath = File.join(IRecSettings.rawDownloadDir.path, ti.savePath)
-            filePath = File.join(IRecSettings.downloadDir.path, ti.savePath)
-            url =   case wItem.column
-                    when SOURCE
-                        ti.sourceUrl
-                    when FILE
-                        ti.process.rawDownloaded? ? filePath : rawFilePath
-                    else
-                        nil
-                    end
-        end
-
+        def playMedia(cmd, process, exe)
+            case cmd
+            when /Temp/
+                url = process.rawFilePath
+            when /Source/
+                url = process.sourceUrl
+            when /MP3/
+                url = process.outFilePath
+            end
 
-        # contextMenu Event
-        def playMedia(exe, wItem)
-            url = getContextUrl(wItem)
-            return unless url
-            cmd, args = exe.split(/\s+/, 2)
+            playCmd, args = exe.split(/\s+/, 2)
             args = args.split(/\s+/).map do |a|
                 a.gsub(/%\w/, url)
             end
-#             cmd = 'test/testarg.rb'     # debug test
-            $log.debug { "execute cmd '#{cmd}', args '#{args.inspect}'" }
+            $log.debug { "execute cmd '#{playCmd}', args '#{args.inspect}'" }
             proc = Qt::Process.new(self)
-            proc.start(cmd, args)
+            proc.start(playCmd, args)
         end
 
         # contextMenu Event
-        def copyText(wItem)
+        def copyText(process, wItem)
             $app.clipboard.setText(wItem.text)
         end
 
         # contextMenu Event
-        def retryTask(wItem)
-            ti = taskItemAtRow(wItem.row)
-            if ti and ti.process.error? then
-                ti.process.retryTask
+        def retryTask(process, wItem)
+            if process.error? then
+                process.retryTask
                 $log.info { "task restarted." }
             end
         end
 
         # contextMenu Event
-        def cancelTask(wItem)
-            ti = taskItemAtRow(wItem.row)
-            if ti and ti.process.running? then
-                ti.process.cancelTask
+        def cancelTask(process, wItem)
+            if process.running? then
+                process.cancelTask
                 $log.info { "task canceled." }
             end
         end
 
         # contextMenu Event
-        def removeTask(wItem)
-            ti = taskItemAtRow(wItem.row)
-            if ti and ti.process.running? then
-                ti.process.cancelTask
-                $log.info { "task canceled." }
+        def removeTask(process, wItem)
+            if process.running? then
+                process.cancelTask
+                $log.info { "task removed." }
             end
+            ti = taskItemAtRow(wItem.row)
             deleteItem(ti)
         end
 
         # contextMenu Event
-        def openFolder(wItem)
+        def removeTaskData(process, wItem)
+            if process.running? then
+                process.removeData
+                $log.info { "task and data removed." }
+            end
             ti = taskItemAtRow(wItem.row)
-            return unless ti
-            filePath = File.join(IRecSettings.downloadDir.path, File.dirname(ti.savePath))
+            deleteItem(ti)
+        end
+
+        # contextMenu Event
+        def openFolder(process, wItem)
+            outFilePath = File.dirname(process.outFilePath)
             proc = Qt::Process.new(self)
-            proc.start('dolphin', [filePath])
+            proc.start('dolphin', [outFilePath ])
         end
 
         # contextMenu Event
-        def openTempFolder(wItem)
-            ti = taskItemAtRow(wItem.row)
-            return unless ti
-            rawFilePath = File.join(IRecSettings.rawDownloadDir.path, File.dirname(ti.savePath))
+        def openTempFolder(process, wItem)
+            rawFilePath = File.dirname(process.rawFilePath)
             proc = Qt::Process.new(self)
             proc.start('dolphin', [rawFilePath])
         end
 
         # contextMenu Event
-        def clearAllFinished(wItem)
+        def clearAllFinished(process, wItem)
             self.each do |i|
                 deleteItem(i) if i.process.finished?
             end
         end
 
         # contextMenu Event
-        def clearAllErrors(wItem)
+        def clearAllErrors(process, wItem)
             self.each do |i|
                 deleteItem(i) if i.process.error?
             end
         end
-
     end
 
+
     #--------------------------------------------
     #
     #