Piggy 0.4.2.2

data/lib/piggy-core/winshell.rb

@@ -0,0 +1,240 @@
+#!/usr/bin/ruby
+## $Id: winshell.rb 176 2007-11-21 21:35:51Z Sascha $
+
+require 'singleton'
+
+# Windows oriented but platform independent file system abstraction.
+class ShellInterface
+  def initialize
+    @specialFolderIds = {
+      "ALTSTARTUP" => 0x1d,
+      "APPDATA" => 0x1a,
+      "BITBUCKET" => 0xa,
+      "COMMONALTSTARTUP" => 0x1e,
+      "COMMONAPPDATA" => 0x23,
+      "COMMONDESKTOPDIR" => 0x19,
+      "COMMONFAVORITES" => 0x1f,
+      "COMMONPROGRAMS" => 0x17,
+      "COMMONSTARTMENU" => 0x16,
+      "COMMONSTARTUP" => 0x18,
+      "CONTROLS" => 0x3,
+      "COOKIES" => 0x21,
+      "DESKTOP" => 0x0,
+      "DESKTOPDIRECTORY" => 0x10,
+      "DRIVES" => 0x11,
+      "FAVORITES" => 0x6,
+      "FONTS" => 0x14,
+      "HISTORY" => 0x22,
+      "INTERNETCACHE" => 0x20,
+      "LOCALAPPDATA" => 0x1c,
+      "MYPICTURES" => 0x27,
+      "NETHOOD" => 0x13,
+      "NETWORK" => 0x12,
+      "PERSONAL" => 0x5,
+      "PRINTERS" => 0x4,
+      "PRINTHOOD" => 0x1b,
+      "PROFILE" => 0x28,
+      "PROGRAMFILES" => 0x26,
+      "PROGRAMS" => 0x2,
+      "RECENT" => 0x8,
+      "SENDTO" => 0x9,
+      "STARTMENU" => 0xb,
+      "STARTUP" => 0x7,
+      "SYSTEM" => 0x25,
+      "TEMPLATES" => 0x15,
+      "WINDOWS" => 0x24
+    }
+  end
+  
+  # try to provide a platform independent default
+  def pathForSpecialFolder(name)
+    home = ENV['HOME']
+    home = ENV['HOMEPATH'] unless home
+    home = '/' unless home
+    return home
+  end
+  
+  def tmpPath
+    tmp = ENV['TEMP']
+    tmp = ENV['TMP'] unless tmp
+    tmp = '/' unless tmp
+    return tmp
+  end
+
+  # platform dependent path (no better default possible)
+  def osPath(pathString)
+    return winPath(pathString)
+  end
+  
+  # for use in commandline execution
+  def escape(pathString)
+    return pathString
+  end
+  
+  # old name, use osPath instead
+  def winPath(pathString)
+    return pathString
+  end
+  
+  # Get a path string usable by common ruby classes such as Dir and File.
+  # Default: convert '\' to '/' on all systems, even on Unix
+  def rubyPath(pathString)
+    return pathString.gsub(/\\/, separator)
+  end
+  
+  def pictureDirectory
+    return pathForSpecialFolder("MYPICTURES")
+  end
+  
+  def desktopDirectory
+    return pathForSpecialFolder("DESKTOPDIRECTORY")
+  end
+  
+  def specialFolderListing
+    @specialFolderIds.keys.sort.each do |aFolder|
+      printf "#{aFolder}: "
+      puts "#{pathForSpecialFolder aFolder}"
+    end
+  end
+  
+  # Get the path separator used by common ruby classes such as Dir and File.
+  def separator
+    return File::SEPARATOR
+  end
+  
+  def removePath(filenameWithPath)
+    return rubyPath(filenameWithPath).split(separator)[-1]
+  end
+  
+  # Is filename a Windows shortcut? - Default: no file is a shortcut
+  def link?(filename)
+    return false
+  end
+  
+  # Has filename the Extension ext (e. g. ".jpg")
+  def hasExtension?(filename, ext)
+    raise ArgumentError, "Extension missing" if ext.empty?
+    pExt = (ext[0] == '.'[0] ? ext : '.' + ext).downcase
+    dcFilename = filename.downcase
+    return File.basename(dcFilename, pExt) != File.basename(dcFilename)
+  end
+end
+
+
+# Default access to file system abstraction.
+# A platform dependent singleton will be instantiated.
+class WinShell < ShellInterface
+  include Singleton
+end
+
+if RUBY_PLATFORM =~ /win32/
+  require 'win32ole'
+  
+  class WinShell < ShellInterface
+    
+    def initialize
+      @shell = WIN32OLE.new('Shell.application')
+      super
+    end
+    
+    def pathForSpecialFolder(name)
+      return desktopDirectory if name=="DESKTOP"
+      oleFolder = specialFolder(name)
+      return "" if !oleFolder
+      return pathForFolder(specialFolder(name))
+    end
+    
+    # Is filename a Windows shortcut?
+    def link?(filename)
+      return hasExtension?(filename, '.lnk')
+    end
+    
+    # Get a path string usable by Windows systems.
+    def winPath(pathString)
+      return pathString.gsub(separator, "\\")
+    end
+    
+    # Get a path string usable by common ruby classes such as Dir and File.
+    def rubyPath(pathString)
+      return pathString.gsub(/\\/, separator)
+    end
+    
+    # for use in commandline execution
+    def escape(pathString)
+      return "\"#{pathString}\""
+    end
+    
+    #Get the path stored in the Windows shortcut filename. PRE: link?(filename)
+    def getLinkTarget(filename, pathString = Dir.getwd)
+      raise(ArgumentError, "Kein Link") if !link?(filename)
+      filenameOnly = removePath(filename) # avoid errors ignore performance
+      ext = '.' + filenameOnly.split('.')[-1]
+      linkdef = File.basename(filenameOnly,  ext)
+      raise ArgumentError, "Linkname leer" if linkdef.empty?
+      item = getFolderItems(pathString).find { |fi|
+        linkdef == (fi.Name.to_s) }
+      return item ? rubyPath(item.GetLink.Path.to_s) : ''
+    end
+    
+    def pathForFolder(folder)
+      current = folder.ParentFolder
+      path = folder.Title
+      while current do
+        title = current.Title
+        if title == "Desktop" # winXP, nicht win2000
+          current = specialFolder("DESKTOPDIRECTORY").ParentFolder
+          title = current.Title
+        end
+        if title =~ /(.):/
+          title.gsub!(/.*\((\w:)\)/, '\1')
+          return title + separator + path
+        end
+        path = title + separator + path
+        current = current.ParentFolder
+      end
+      return path
+    end
+    
+    # private; public for better testing only
+    
+    # My shell is the ole object "Shell" as described in the Windows SDK.
+    def shell
+      return @shell
+    end
+    
+    def specialFolder(name)
+      id = @specialFolderIds[name]
+      return shell.NameSpace(id)
+    end
+    
+    # Get Directory entries as ole-objects, not as strings!
+    def getFolderItems(directoryPathString)
+      folder = shell.NameSpace(winPath(directoryPathString))
+      raise "Folderermittlung fehlgeschlagen" if !folder
+      items = folder.items
+      return (0..items.Count-1).collect { |i| items.item(i) }
+    end
+  end
+end
+# Example
+
+if $0 == __FILE__
+  def example
+    aShell = WinShell.instance
+    h = "Example 1: WinShell.new.specialFolderListing"
+    hLine = (1..h.size).collect { |c| '*'}
+    puts "#{hLine}\n#{h}\n#{hLine}"
+    aShell.specialFolderListing
+    h = "Example 2. Links on Desktop"
+    hLine = (1..h.size).collect { |c| '*'}
+    puts "#{hLine}\n#{h}\n#{hLine}"
+    desktopDir = aShell.desktopDirectory
+    links = Dir[desktopDir + '/*'].select { |p| aShell.link?(File.basename(p)) }
+    links.each do |l|
+      lName = File.basename l
+      puts "#{lName} => \"#{aShell.getLinkTarget lName, desktopDir}\""
+    end
+  end
+  example  
+end
+

data/lib/piggy-gui/directory_diff_widget.rb

@@ -0,0 +1,398 @@
+#!/usr/bin/ruby
+# $Id: directory_diff_widget.rb 190 2008-02-02 18:52:57Z Sascha $
+
+require 'piggy-core/environment'
+require 'piggy-core/options'
+require 'piggy-core/file_info'
+require 'piggy-gui/require-fox'
+require 'piggy-gui/image_processor'
+
+# DirectoryDiffWidget shows differences between two directories.
+class DirectoryDiffMainWindow < Fox::FXMainWindow
+  include Fox
+  def initialize(app, options = PiggyOptions.new)
+    super(app, titleString, nil, nil, DECOR_ALL,
+          0, 0, 200, 700, 0, 0)
+    @frame = FXVerticalFrame.new(self)
+    @frame.setLayoutHints(LAYOUT_FILL_X|LAYOUT_FILL_Y)
+    setMainWidget(options)
+    @browser.quitButton.connect(SEL_COMMAND, method(:onTerminate)) 
+  end
+  
+  def titleString
+    "Piggy Directory Diff"
+  end
+  
+  def setMainWidget(options)
+    @browser = DirectoryDiffWidget.new(@frame, options)
+  end
+  
+  def create
+    resize(800, 600)
+    place(PIGGY_WINDOW_PLACEMENT)
+    super
+  end
+  
+  def onTerminate(sender, sel, ptr)
+    @browser.prepareClosure
+    getApp.exit(0)
+  end
+end
+
+class DirectoryDiffWidget < Fox::FXScrollWindow
+  include Fox
+  Placement = PIGGY_WINDOW_PLACEMENT
+  MsgStyle = MBOX_OK|DECOR_TITLE|DECOR_CLOSE|PIGGY_WINDOW_PLACEMENT
+  
+  attr_reader(:options, :quitButton)
+  
+  def initialize(window, options = PiggyOptions.new)
+    super(window)
+    @options = options
+    @iconLoader = ImageProcessor.new(getApp)
+    loadIcons
+    initializeFrames
+    initializeControls
+    initializeLayout
+    setDefaults
+    connectEvents
+    @rightContents = DirectoryContents.new(rightPath)
+    @leftContents = DirectoryContents.new(leftPath)
+    @excludeFilters = ['~$', '#$', '^\.']
+  end
+  
+  def loadIcons
+    @dirIcon = basicLoadIcon('dir.ico')
+    @fileIcon = basicLoadIcon('file.ico')
+    @dirupIcon = basicLoadIcon('dirup.ico')
+    @fileAbsentIcon = basicLoadIcon('unchecked.ico')
+    @dirAbsentIcon = basicLoadIcon('unchecked-dir.ico')
+    @newerFileIcon = basicLoadIcon('newer-file.ico')
+  end
+  
+  def basicLoadIcon(filename)
+    fileWithPath = File.join(PIGGY_PATH, 'icons', filename)
+    @iconLoader.loadIcon(fileWithPath)
+  end
+  
+  def spaceInto(frame)
+    space = FXHorizontalFrame.new(frame)
+    space.setLayoutHints(LAYOUT_FILL_X|LAYOUT_FILL_Y) 
+  end
+  
+  def hSepInto(frame)
+    sep = FXHorizontalSeparator.new(frame, SEPARATOR_GROOVE)
+    sep.setLayoutHints(LAYOUT_FILL_X|LAYOUT_FILL_Y) 
+  end
+  
+  def initializeFrames
+    @frame = FXVerticalFrame.new(self)
+    @fourSplitter = FX4Splitter.new(@frame, FOURSPLITTER_TRACKING)
+    @splitOL = FXVerticalFrame.new(@fourSplitter)
+    @splitOR = FXVerticalFrame.new(@fourSplitter)
+    @splitUL = FXVerticalFrame.new(@fourSplitter)
+    @splitUR = FXVerticalFrame.new(@fourSplitter)
+    @leftListPropFrame = FXMatrix.new(@splitOL, 2, MATRIX_BY_COLUMNS)
+    @rightListPropFrame = FXMatrix.new(@splitOR, 2, MATRIX_BY_COLUMNS)
+    @leftButtonsFrame = FXHorizontalFrame.new(@splitUL)
+    @rightButtonsFrame = FXHorizontalFrame.new(@splitUR)
+    @leftListFrame = FXHorizontalFrame.new(@splitUL)
+    @rightListFrame = FXHorizontalFrame.new(@splitUR)
+    @separator = FXHorizontalSeparator.new(@frame, SEPARATOR_GROOVE)
+    @buttonsFrame = FXHorizontalFrame.new(@frame)
+  end
+  
+  def initializeControls
+    @labels = Array.new
+    initializeControlsOL
+    initializeControlsOR
+    initializeControlsUL
+    initializeControlsUR
+    initializeButtons
+  end
+  
+  def initializeControlsOL
+    @labels.push(FXLabel.new(@leftListPropFrame,
+			     "Dir:"))
+    @leftPathField = FXTextField.new(@leftListPropFrame, 32)
+  end
+  
+  def initializeControlsOR
+    @labels.push(FXLabel.new(@rightListPropFrame, "Dir:"))
+    @rightPathField = FXTextField.new(@rightListPropFrame, 32)
+  end
+  
+  def initializeControlsUL
+    @dirLeftUpButton = FXButton.new(@leftButtonsFrame,
+                                    "\tGo up to higher directory",
+    @dirupIcon)
+    @leftFileList = FXIconList.new(@leftListFrame)
+    @leftFileList.setListStyle(ICONLIST_DETAILED)
+    @leftFileList.appendHeader("Name", nil, 200)
+    @leftFileList.appendHeader("Date", nil, 200)
+  end
+  
+  def initializeControlsUR
+    @dirRightUpButton = FXButton.new(@rightButtonsFrame,
+                                    "\tGo up to higher directory",
+    @dirupIcon)
+    @rightFileList = FXIconList.new(@rightListFrame)
+    @rightFileList.setListStyle(ICONLIST_DETAILED)
+    @rightFileList.appendHeader("Name", nil, 200)
+    @rightFileList.appendHeader("Date", nil, 200)
+  end
+  
+  def initializeButtons
+    @quitButton = FXButton.new(@buttonsFrame, "&Quit")
+  end
+  
+  def initializeLayout
+    @labels.each { |label| label.setLayoutHints LAYOUT_CENTER_Y }
+    [
+      self, @frame,
+      @fourSplitter,
+      #      @leftListPropFrame, @rightListPropFrame,
+      #      @splitUL, @splitUR,
+      #      @leftButtonsFrame, @rightButtonsFrame,
+      @leftListFrame, @rightListFrame, 
+      #      @serverField, @userField, @passwordField, @leftPathField,
+      #      @rightPathField,
+      @leftFileList, @rightFileList
+    ].each { |w| w.setLayoutHints(LAYOUT_FILL_X|LAYOUT_FILL_Y) }
+    [
+      @splitOL, @splitOR, @splitUL, @splitUR,
+      @leftButtonsFrame, @rightButtonsFrame,
+      @leftListFrame, @rightListFrame
+    ].each { |w| w.setFrameStyle(FRAME_NONE) }
+    @buttonsFrame.setLayoutHints(LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X)
+    @buttonsFrame.setPackingHints(PACK_UNIFORM_WIDTH)
+    @quitButton.setLayoutHints(LAYOUT_RIGHT)
+  end
+  
+  def connectEvents
+    @rightPathField.connect(SEL_COMMAND) {
+      setRightPath(@rightPathField.getText)
+      updateRightList
+      updateStatusIcons
+    }
+    @leftPathField.connect(SEL_COMMAND)  {
+      setLeftPath(@leftPathField.getText)
+      updateLeftList
+      updateStatusIcons	
+    }
+    @dirLeftUpButton.connect(SEL_COMMAND, method(:onDirUpLeftList))
+    @dirRightUpButton.connect(SEL_COMMAND, method(:onDirUpRightList))
+    
+    @leftFileList.connect(SEL_DOUBLECLICKED,
+                          method(:onDoubleclickLeftFileList))
+    @rightFileList.connect(SEL_DOUBLECLICKED,
+                           method(:onDoubleclickRightFileList))
+    @leftFileList.connect(SEL_RIGHTBUTTONRELEASE,
+                          method(:onMenuLeftList))
+    @rightFileList.connect(SEL_RIGHTBUTTONRELEASE,
+                           method(:onMenuRightList))
+  end
+  
+  def setDefaults
+    @rightPathField.setText(@options.localDestinationPath)
+    @leftPathField.setText(@options.localDestinationPath)
+  end
+  
+  # accessing
+  
+  def rightPath
+    @options.localDestinationPath
+  end
+  
+  def setRightPath(p)
+    @options.localDestinationPath = FilePath.internPath(p)
+    @rightPathField.setText(p) # fixme winpath
+  end
+  
+  def leftPath
+    FilePath.internPath(@leftPathField.getText)
+  end
+  
+  def setLeftPath(p)
+    @leftPathField.setText(p) # fixme winpath
+  end
+  
+  def selectionInList(list)
+    selectedInd = (0..list.getNumItems-1).select { |i|
+      list.isItemSelected(i)
+    }
+    return selectedInd.collect { |i| itemFilename(list, i) }
+  end
+  
+  def itemFilename(list, index)
+    txt = fox2Ruby(list.getItemText(index))
+    return txt.split(Regexp.compile("\t"))[0]
+  end
+  
+  # update
+  
+  def updateLeftList
+    @leftContents = updateLocalList(@leftFileList, leftPath)
+  end
+  
+  def updateRightList
+    @rightContents = updateLocalList(@rightFileList, rightPath)
+  end
+  
+  def updateLocalList(listWidget, newPath)
+    listWidget.clearItems
+    contents = DirectoryContents.new(newPath)
+    return contents unless newPath && File.directory?(newPath)
+    getApp.beginWaitCursor
+    begin
+      updateList(Dir.entries(newPath), listWidget, contents) do
+        |file, path|
+        info = FileInfo.new(file, path)
+        info.mtime = File.stat(info.nameWithPath).mtime
+        info.directory! if File.directory?(info.nameWithPath)
+        info
+      end
+    rescue StandardError => ex
+      error(ex.message)
+    end
+    getApp.endWaitCursor
+    return contents
+  end
+  
+  def includeFile?(filename)
+    @excludeFilters.select { |pattern|
+      Regexp.compile(pattern) =~ filename
+    }.empty?
+  end
+  
+  def updateList(dirEntries, listWidget, contents, &getInfoblock)
+    listWidget.clearItems
+    items = Hash.new
+    dirEntries.each do
+      |file|
+      if includeFile?(file)
+        info = getInfoblock.call(file, contents.path)
+        text = ruby2Fox("#{info.name}\t#{info.mtimeString}") 
+        if info.directory?
+          items[file] = FXIconItem.new(text, nil, @dirIcon)
+        else
+          items[file] = FXIconItem.new(text, nil, @fileIcon)
+        end
+        contents.add(info)
+      end
+    end
+    contents.directories.each { |n| listWidget.appendItem(items[n]) }
+    contents.files.each { |n| listWidget.appendItem(items[n]) }
+  end
+  
+  def updateStatusIconsFor(listWidget, myContents, otherContents)
+   (0..listWidget.getNumItems - 1).each do
+      |index|
+      file = itemFilename(listWidget, index)
+      myInfo = myContents[file]
+      otherInfo = otherContents[file]
+      icon = if myInfo.directory?
+        otherInfo ? @dirIcon : @dirAbsentIcon
+      else
+        if otherInfo
+          otherInfo.mtime < myInfo.mtime ? @newerFileIcon : @fileIcon
+        else
+          @fileAbsentIcon
+        end
+      end
+      listWidget.setItemMiniIcon(index, icon)
+    end
+  end
+  
+  def updateStatusIconsLeft
+    updateStatusIconsFor(@leftFileList, @leftContents, @rightContents)
+  end
+  
+  def updateStatusIconsRight
+    updateStatusIconsFor(@rightFileList, @rightContents, @leftContents)
+  end
+  
+  def updateStatusIcons
+    updateStatusIconsLeft
+    updateStatusIconsRight
+  end
+  
+  # messages
+  
+  def error(msg, title = 'Error')
+    FXMessageBox::warning(self, MsgStyle, title, msg)
+    return false
+  end
+  
+  # actions
+  
+  # events
+  
+  def onDirUpLeftList(sender, sel, ptr)
+    return false unless leftPath
+    suggestion = FilePath.oneDirUp(leftPath)
+    return false if leftPath == suggestion
+    setLeftPath(suggestion)
+    updateLeftList
+    updateStatusIcons
+    return true
+  end
+  
+  def onDirUpRightList(sender, sel, ptr)
+    return false unless rightPath
+    suggestion = FilePath.oneDirUp(rightPath)
+    return false if rightPath == suggestion
+    setRightPath(suggestion)
+    updateRightList
+    updateStatusIcons
+    return true
+  end
+  
+  def onDoubleclickLeftFileList(sender, sel, index)
+    fileOrFolder = @leftFileList.getItemText(index)
+    file = fileOrFolder.split(Regexp.compile("\t"))[0]
+    info = @leftContents[file]
+    return false unless info && info.directory?
+    fileWithPath = FilePath.join(leftPath, file)
+    setLeftPath(fileWithPath)
+    updateLeftList
+    updateStatusIcons
+    return true
+  end
+  
+  def onDoubleclickRightFileList(sender, sel, index)
+    fileOrFolder = @rightFileList.getItemText(index)
+    file = fileOrFolder.split(Regexp.compile("\t"))[0]
+    info = @rightContents[file]
+    return false unless info && info.directory?
+    fileWithPath = FilePath.join(rightPath, file)
+    setRightPath(fileWithPath)
+    updateRightList
+    updateStatusIcons
+    return true
+  end
+  
+  def onMenuLeftList(sender, sel, event)
+  end
+  
+  def onMenuRightList(sender, sel, event)
+  end
+  
+  # open/close
+  
+  def inCreate
+    updateLeftList
+    updateRightList
+    updateStatusIcons
+    @fourSplitter.setVSplit(600)
+  end
+  
+  def create
+    inCreate
+    super
+  end
+  
+  def prepareClosure
+  end
+end
+