Piggy 0.4.2.4 → 0.4.3.0

data/lib/piggy-gui/directory_diff_widget.rb

@@ -4,6 +4,7 @@
 require 'piggy-core/environment'
 require 'piggy-core/options'
 require 'piggy-core/file_info'
+require 'piggy-core/winshell'
 require 'piggy-gui/require-fox'
 require 'piggy-gui/image_processor'
 
@@ -11,30 +12,30 @@ require 'piggy-gui/image_processor'
 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)
+    super(app, title_string, 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)) 
+    set_main_widget(options)
+    @browser.quitButton.connect(SEL_COMMAND, method(:on_terminate))
   end
   
-  def titleString
+  def title_string
     "Piggy Directory Diff"
   end
   
-  def setMainWidget(options)
+  def set_main_widget(options)
     @browser = DirectoryDiffWidget.new(@frame, options)
   end
   
   def create
-    resize(800, 600)
+    resize(@browser.preferred_width + 20, 600)
     place(PIGGY_WINDOW_PLACEMENT)
     super
   end
   
-  def onTerminate(sender, sel, ptr)
-    @browser.prepareClosure
+  def on_terminate(sender, sel, ptr)
+    @browser.prepare_closure
     getApp.exit(0)
   end
 end
@@ -50,48 +51,50 @@ class DirectoryDiffWidget < Fox::FXScrollWindow
     super(window)
     @options = options
     @iconLoader = ImageProcessor.new(getApp)
-    loadIcons
-    initializeFrames
-    initializeControls
-    initializeLayout
-    setDefaults
-    connectEvents
-    @rightContents = DirectoryContents.new(rightPath)
-    @leftContents = DirectoryContents.new(leftPath)
-    @excludeFilters = ['~$', '#$', '^\.']
+    load_icons
+    initialize_frames
+    initialize_controls
+    initialize_layout
+    set_defaults
+    connect_events
+    @rightContents = DirectoryContents.new(right_path)
+    @leftContents = DirectoryContents.new(left_path)
+    @excludeFilters = @options.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')
+  def load_icons
+    @dirIcon = basic_load_icon('dir.ico')
+    @fileIcon = basic_load_icon('file.ico')
+    @dirupIcon = basic_load_icon('dirup.ico')
+    @fileAbsentIcon = basic_load_icon('unchecked.ico')
+    @dirAbsentIcon = basic_load_icon('unchecked-dir.ico')
+    @newerFileIcon = basic_load_icon('newer-file.ico')
   end
   
-  def basicLoadIcon(filename)
-    fileWithPath = File.join(PIGGY_PATH, 'icons', filename)
-    @iconLoader.loadIcon(fileWithPath)
+  def basic_load_icon(filename)
+    file_with_path = File.join(PIGGY_PATH, 'icons', filename)
+    @iconLoader.load_icon(file_with_path)
   end
   
-  def spaceInto(frame)
+  def space_into(frame)
     space = FXHorizontalFrame.new(frame)
     space.setLayoutHints(LAYOUT_FILL_X|LAYOUT_FILL_Y) 
   end
   
-  def hSepInto(frame)
+  def h_sep_into(frame)
     sep = FXHorizontalSeparator.new(frame, SEPARATOR_GROOVE)
     sep.setLayoutHints(LAYOUT_FILL_X|LAYOUT_FILL_Y) 
   end
   
-  def initializeFrames
+  def initialize_frames
     @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)
+    @horizontal_splitter = FXSplitter.new(@frame, SPLITTER_HORIZONTAL)
+    @left_frame = FXVerticalFrame.new(@horizontal_splitter)
+    @right_frame = FXVerticalFrame.new(@horizontal_splitter)
+    @splitOL = FXVerticalFrame.new(@left_frame)
+    @splitOR = FXVerticalFrame.new(@right_frame)
+    @splitUL = FXVerticalFrame.new(@left_frame)
+    @splitUR = FXVerticalFrame.new(@right_frame)
     @leftListPropFrame = FXMatrix.new(@splitOL, 2, MATRIX_BY_COLUMNS|LAYOUT_FILL_X)
     @rightListPropFrame = FXMatrix.new(@splitOR, 2, MATRIX_BY_COLUMNS|LAYOUT_FILL_X)
     @leftButtonsFrame = FXHorizontalFrame.new(@splitUL)
@@ -102,76 +105,80 @@ class DirectoryDiffWidget < Fox::FXScrollWindow
     @buttonsFrame = FXHorizontalFrame.new(@frame)
   end
   
-  def initializeControls
+  def initialize_controls
     @labels = Array.new
-    initializeControlsOL
-    initializeControlsOR
-    initializeControlsUL
-    initializeControlsUR
-    initializeButtons
+    initialize_controls_top_left
+    initialize_controls_top_right
+    initialize_controls_bottom_left
+    initialize_controls_bottom_right
+    initialize_buttons
   end
-  
-  def initializeControlsOL
+
+  def txt_field_num_chars
+    32
+  end
+
+  def initialize_controls_top_left
     @labels.push(FXLabel.new(@leftListPropFrame, "Dir:"))
-    combo = FXHorizontalFrame.new(@leftListPropFrame)
+    combo = new_hframe_without_padding(@leftListPropFrame)
     combo.setLayoutHints(LAYOUT_FILL_X|LAYOUT_FILL_COLUMN) 
-    @leftPathField = FXTextField.new(combo, 32)
+    @leftPathField = FXTextField.new(combo, txt_field_num_chars)
     @leftPathField.setLayoutHints(LAYOUT_FILL_X)
-    dirChooserForField(@leftPathField, 'left')
+    dir_chooser_for_field(@leftPathField, 'left')
   end
   
-  def initializeControlsOR
+  def initialize_controls_top_right
     @labels.push(FXLabel.new(@rightListPropFrame, "Dir:"))
-    combo = FXHorizontalFrame.new(@rightListPropFrame)
-    combo.setLayoutHints(LAYOUT_FILL_X|LAYOUT_FILL_COLUMN) 
-    @rightPathField = FXTextField.new(combo, 32)
+    combo = new_hframe_without_padding(@rightListPropFrame)
+    combo.setLayoutHints(LAYOUT_FILL_X|LAYOUT_FILL_COLUMN)
+    @rightPathField = FXTextField.new(combo, txt_field_num_chars)
     @rightPathField.setLayoutHints(LAYOUT_FILL_X)
-    dirChooserForField(@rightPathField, 'right')
+    dir_chooser_for_field(@rightPathField, 'right')
   end
 
-  def dirChooserForField(field, side)
-    chooserButton = FXButton.new(field.parent, '...')
-    chooserButton.connect(SEL_COMMAND) {
+  def dir_chooser_for_field(field, side)
+    chooser_button = FXButton.new(field.parent, '...')
+    chooser_button.connect(SEL_COMMAND) {
       dialog = FXDirDialog.new(self, "Choose directory")
       dialog.directory = field.getText
       unless dialog.execute == 0
-	field.setText(dialog.directory)
-	dirChanged(side)
+        field.setText(dialog.directory)
+        dir_changed(side)
       end
     }
   end
   
-  def initializeControlsUL
+  def initialize_controls_bottom_left
     @dirLeftUpButton = FXButton.new(@leftButtonsFrame,
-                                    "\tGo up to higher directory",
-    @dirupIcon)
+      "\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
+  def initialize_controls_bottom_right
     @dirRightUpButton = FXButton.new(@rightButtonsFrame,
-                                    "\tGo up to higher directory",
-    @dirupIcon)
+      "\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
+  def initialize_buttons
     @quitButton = FXButton.new(@buttonsFrame, "&Quit")
   end
   
-  def initializeLayout
+  def initialize_layout
     @labels.each { |label| label.setLayoutHints LAYOUT_CENTER_Y }
     [
       self, @frame,
-      @fourSplitter,
+      @horizontal_splitter, @left_frame, @right_frame,
       #      @leftListPropFrame, @rightListPropFrame,
-      #      @splitUL, @splitUR,
+      @splitUL, @splitUR,
       #      @leftButtonsFrame, @rightButtonsFrame,
       @leftListFrame, @rightListFrame, 
       #      @serverField, @userField, @passwordField, @leftPathField,
@@ -179,6 +186,7 @@ class DirectoryDiffWidget < Fox::FXScrollWindow
       @leftFileList, @rightFileList
     ].each { |w| w.setLayoutHints(LAYOUT_FILL_X|LAYOUT_FILL_Y) }
     [
+      @left_frame, @right_frame,
       @splitOL, @splitOR, @splitUL, @splitUR,
       @leftButtonsFrame, @rightButtonsFrame,
       @leftListFrame, @rightListFrame
@@ -188,95 +196,100 @@ class DirectoryDiffWidget < Fox::FXScrollWindow
     @quitButton.setLayoutHints(LAYOUT_RIGHT)
   end
   
-  def dirChanged(side)
+  def dir_changed(side)
     if(side == 'right')
-       setRightPath(@rightPathField.getText)
-       updateRightList
-       updateStatusIcons
+      set_right_path(@rightPathField.getText)
+      update_right_list
+      update_status_icons
     else
-      setLeftPath(@leftPathField.getText)
-      updateLeftList
-      updateStatusIcons	
+      set_left_path(@leftPathField.getText)
+      update_left_list
+      update_status_icons
     end
   end
 
-  def connectEvents
+  def connect_events
     @rightPathField.connect(SEL_COMMAND) {
-      dirChanged('right')
+      dir_changed('right')
     }
     @leftPathField.connect(SEL_COMMAND)  {
-      dirChanged('left')
+      dir_changed('left')
     }
-    @dirLeftUpButton.connect(SEL_COMMAND, method(:onDirUpLeftList))
-    @dirRightUpButton.connect(SEL_COMMAND, method(:onDirUpRightList))
+    @dirLeftUpButton.connect(SEL_COMMAND, method(:on_dir_up_lef_list))
+    @dirRightUpButton.connect(SEL_COMMAND, method(:on_dir_up_right_list))
     
     @leftFileList.connect(SEL_DOUBLECLICKED,
-                          method(:onDoubleclickLeftFileList))
+      method(:on_doubleclick_left_file_list))
     @rightFileList.connect(SEL_DOUBLECLICKED,
-                           method(:onDoubleclickRightFileList))
+      method(:on_doubleclick_right_file_list))
     @leftFileList.connect(SEL_RIGHTBUTTONRELEASE,
-                          method(:onMenuLeftList))
+      method(:on_menu_left_list))
     @rightFileList.connect(SEL_RIGHTBUTTONRELEASE,
-                           method(:onMenuRightList))
+      method(:on_menu_right_list))
   end
-  
-  def setDefaults
+
+  def fox_pah(ruby_path)
+    ruby_2_fox(WinShell.instance.os_path(ruby_path))
+  end
+
+  def set_defaults
+    p = fox_pah(@options.localDestinationPath)
     @rightPathField.setText(@options.localDestinationPath)
     @leftPathField.setText(@options.localDestinationPath)
   end
   
   # accessing
   
-  def rightPath
+  def right_path
     @options.localDestinationPath
   end
   
-  def setRightPath(p)
-    @options.localDestinationPath = FilePath.internPath(p)
+  def set_right_path(p)
+    @options.localDestinationPath = FilePath.intern_path(p)
     @rightPathField.setText(p) # fixme winpath
   end
   
-  def leftPath
-    FilePath.internPath(@leftPathField.getText)
+  def left_path
+    FilePath.intern_path(@leftPathField.getText)
   end
   
-  def setLeftPath(p)
+  def set_left_path(p)
     @leftPathField.setText(p) # fixme winpath
   end
   
-  def selectionInList(list)
-    selectedInd = (0..list.getNumItems-1).select { |i|
+  def selection_in_list(list)
+    selected_ind = (0..list.getNumItems-1).select { |i|
       list.isItemSelected(i)
     }
-    return selectedInd.collect { |i| itemFilename(list, i) }
+    return selected_ind.collect { |i| item_filename(list, i) }
   end
   
-  def itemFilename(list, index)
-    txt = fox2Ruby(list.getItemText(index))
+  def item_filename(list, index)
+    txt = fox_2_ruby(list.getItemText(index))
     return txt.split(Regexp.compile("\t"))[0]
   end
   
   # update
   
-  def updateLeftList
-    @leftContents = updateLocalList(@leftFileList, leftPath)
+  def update_left_list
+    @leftContents = update_local_list(@leftFileList, left_path)
   end
   
-  def updateRightList
-    @rightContents = updateLocalList(@rightFileList, rightPath)
+  def update_right_list
+    @rightContents = update_local_list(@rightFileList, right_path)
   end
   
-  def updateLocalList(listWidget, newPath)
+  def update_local_list(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
+      update_list(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.mtime = File.stat(info.name_with_path).mtime
+        info.directory! if File.directory?(info.name_with_path)
         info
       end
     rescue StandardError => ex
@@ -286,20 +299,20 @@ class DirectoryDiffWidget < Fox::FXScrollWindow
     return contents
   end
   
-  def includeFile?(filename)
+  def include_file?(filename)
     @excludeFilters.select { |pattern|
       Regexp.compile(pattern) =~ filename
     }.empty?
   end
   
-  def updateList(dirEntries, listWidget, contents, &getInfoblock)
-    listWidget.clearItems
+  def update_list(dir_entries, list_widget, contents, &get_info_block)
+    list_widget.clearItems
     items = Hash.new
-    dirEntries.each do
+    dir_entries.each do
       |file|
-      if includeFile?(file)
-        info = getInfoblock.call(file, contents.path)
-        text = ruby2Fox("#{info.name}\t#{info.mtimeString}") 
+      if include_file?(file)
+        info = get_info_block.call(file, contents.path)
+        text = ruby_2_fox("#{info.name}\t#{info.mtime_string}")
         if info.directory?
           items[file] = FXIconItem.new(text, nil, @dirIcon)
         else
@@ -308,14 +321,14 @@ class DirectoryDiffWidget < Fox::FXScrollWindow
         contents.add(info)
       end
     end
-    contents.directories.each { |n| listWidget.appendItem(items[n]) }
-    contents.files.each { |n| listWidget.appendItem(items[n]) }
+    contents.directories.each { |n| list_widget.appendItem(items[n]) }
+    contents.files.each { |n| list_widget.appendItem(items[n]) }
   end
   
-  def updateStatusIconsFor(listWidget, myContents, otherContents)
-   (0..listWidget.getNumItems - 1).each do
+  def update_status_icons_for(listWidget, myContents, otherContents)
+    (0..listWidget.getNumItems - 1).each do
       |index|
-      file = itemFilename(listWidget, index)
+      file = item_filename(listWidget, index)
       myInfo = myContents[file]
       otherInfo = otherContents[file]
       icon = if myInfo.directory?
@@ -331,17 +344,17 @@ class DirectoryDiffWidget < Fox::FXScrollWindow
     end
   end
   
-  def updateStatusIconsLeft
-    updateStatusIconsFor(@leftFileList, @leftContents, @rightContents)
+  def update_status_icons_left
+    update_status_icons_for(@leftFileList, @leftContents, @rightContents)
   end
   
-  def updateStatusIconsRight
-    updateStatusIconsFor(@rightFileList, @rightContents, @leftContents)
+  def update_status_icons_right
+    update_status_icons_for(@rightFileList, @rightContents, @leftContents)
   end
   
-  def updateStatusIcons
-    updateStatusIconsLeft
-    updateStatusIconsRight
+  def update_status_icons
+    update_status_icons_left
+    update_status_icons_right
   end
   
   # messages
@@ -355,71 +368,75 @@ class DirectoryDiffWidget < Fox::FXScrollWindow
   
   # events
   
-  def onDirUpLeftList(sender, sel, ptr)
-    return false unless leftPath
-    suggestion = FilePath.oneDirUp(leftPath)
-    return false if leftPath == suggestion
-    setLeftPath(suggestion)
-    updateLeftList
-    updateStatusIcons
+  def on_dir_up_lef_list(sender, sel, ptr)
+    return false unless left_path
+    suggestion = FilePath.one_dir_up(left_path)
+    return false if left_path == suggestion
+    set_left_path(suggestion)
+    update_left_list
+    update_status_icons
     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
+  def on_dir_up_right_list(sender, sel, ptr)
+    return false unless right_path
+    suggestion = FilePath.one_dir_up(right_path)
+    return false if right_path == suggestion
+    set_right_path(suggestion)
+    update_right_list
+    update_status_icons
     return true
   end
   
-  def onDoubleclickLeftFileList(sender, sel, index)
-    fileOrFolder = @leftFileList.getItemText(index)
-    file = fileOrFolder.split(Regexp.compile("\t"))[0]
+  def on_doubleclick_left_file_list(sender, sel, index)
+    file_or_folder = @leftFileList.getItemText(index)
+    file = file_or_folder.split(Regexp.compile("\t"))[0]
     info = @leftContents[file]
     return false unless info && info.directory?
-    fileWithPath = FilePath.join(leftPath, file)
-    setLeftPath(fileWithPath)
-    updateLeftList
-    updateStatusIcons
+    file_with_path = FilePath.join(left_path, file)
+    set_left_path(file_with_path)
+    update_left_list
+    update_status_icons
     return true
   end
   
-  def onDoubleclickRightFileList(sender, sel, index)
-    fileOrFolder = @rightFileList.getItemText(index)
-    file = fileOrFolder.split(Regexp.compile("\t"))[0]
+  def on_doubleclick_right_file_list(sender, sel, index)
+    file_or_folder = @rightFileList.getItemText(index)
+    file = file_or_folder.split(Regexp.compile("\t"))[0]
     info = @rightContents[file]
     return false unless info && info.directory?
-    fileWithPath = FilePath.join(rightPath, file)
-    setRightPath(fileWithPath)
-    updateRightList
-    updateStatusIcons
+    file_with_path = FilePath.join(right_path, file)
+    set_right_path(file_with_path)
+    update_right_list
+    update_status_icons
     return true
   end
   
-  def onMenuLeftList(sender, sel, event)
+  def on_menu_left_list(sender, sel, event)
   end
   
-  def onMenuRightList(sender, sel, event)
+  def on_menu_right_list(sender, sel, event)
   end
   
   # open/close
+
+  def preferred_width
+    780
+  end
   
-  def inCreate
-    updateLeftList
-    updateRightList
-    updateStatusIcons
-    @fourSplitter.setVSplit(660)
+  def in_create
+    update_left_list
+    update_right_list
+    update_status_icons
+    @horizontal_splitter.setSplit(0, preferred_width/2)
   end
   
   def create
-    inCreate
+    in_create
     super
   end
   
-  def prepareClosure
+  def prepare_closure
   end
 end