Piggy 0.4.2.4 → 0.4.3.0

data/lib/piggy-gui/piggy_image_browser.rb

@@ -34,30 +34,30 @@ class PiggyImageBrowser < Fox::FXMainWindow
   MsgStyle = MBOX_OK|DECOR_TITLE|DECOR_CLOSE|PIGGY_WINDOW_PLACEMENT
   UseImageView = false
   
-  attr_reader(:imageProcessor)
+  attr_reader(:image_processor)
   
-  def chosenSequence
-    @filelist.chosenSequence
+  def chosen_sequence
+    @filelist.chosen_sequence
   end
   
   #INIT
   
   def initialize(app)
     super(app, "Piggy", nil, nil, DECOR_ALL,
-    0, 0, 200, 700, 0, 0)
+      0, 0, 200, 700, 0, 0)
     # now in critical order
-    initVars
-    initMenubar
-    initToolbar
-    initView
-    initIcons
-    initMenu
-    initToolbarButtons
+    init_vars
+    init_menubar
+    init_toolbar
+    init_view
+    init_icons
+    init_menu
+    init_toolbar_buttons
     @tooltip = FXTooltip.new(getApp, TOOLTIP_NORMAL)
-    connect(SEL_CLOSE, method(:onCmdClose)) unless FOXVERSION_GE_1_2
+    connect(SEL_CLOSE, method(:on_cmd_close)) unless FOXVERSION_GE_1_2
   end
   
-  def initVars
+  def init_vars
     @slideManager = nil
     @fullscreen = nil
     @fullscreenView = nil
@@ -65,7 +65,7 @@ class PiggyImageBrowser < Fox::FXMainWindow
     @history = Array.new
     @historyPos = @history.size
     @optionStore = PiggyOptionsPersistence.new
-    @options = @optionStore.loadYaml
+    @options = @optionStore.load_yaml
     @imageProcessor = ImageProcessor.new(getApp)
     @fileInfos = FileRepository.new
     @filename = ''
@@ -89,39 +89,39 @@ class PiggyImageBrowser < Fox::FXMainWindow
     @iconStyle = ICON_ABOVE_TEXT|BUTTON_TOOLBAR|FRAME_RAISED
   end
   
-  def initIcons
-    @windowIcon = getIcon("gallery.ico")
-    @generateIcon = getIcon("generate.ico")
-    @addToPreviewIcon = getIcon("plus.png")
-    @removeFromPreviewIcon = getIcon("minus.png")    
-    @uplevelIcon  = getIcon("dirup.ico")
-    @uploadIcon = getIcon("upload.ico")
-    @filesaveIcon = getIcon("filesave.ico")
-    @rotateIcon = getIcon("rotate.ico")
-    @backIcon = getIcon("back.ico")
-    @nextImageIcon = getIcon("next-image.ico")
-    @previousImageIcon = getIcon("previous-image.ico")
-    @slideshowImageIcon = getIcon("slides.ico")
-    @slideshowOffImageIcon = getIcon("stop-slides.ico")
-    @fullscreenIcon = getIcon("fullscreen.ico")
+  def init_icons
+    @windowIcon = get_icon("gallery.ico")
+    @generateIcon = get_icon("generate.ico")
+    @addToPreviewIcon = get_icon("plus.png")
+    @removeFromPreviewIcon = get_icon("minus.png")
+    @uplevelIcon  = get_icon("dirup.ico")
+    @uploadIcon = get_icon("upload.ico")
+    @filesaveIcon = get_icon("filesave.ico")
+    @rotateIcon = get_icon("rotate.ico")
+    @backIcon = get_icon("back.ico")
+    @nextImageIcon = get_icon("next-image.ico")
+    @previousImageIcon = get_icon("previous-image.ico")
+    @slideshowImageIcon = get_icon("slides.ico")
+    @slideshowOffImageIcon = get_icon("stop-slides.ico")
+    @fullscreenIcon = get_icon("fullscreen.ico")
   end
 
-  def initStatusbar
+  def init_statusbar
     @statusbar = FXStatusbar.new(self, STATUSBAR_WITH_DRAGCORNER)
     @statusbar.setLayoutHints(LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X)
     @orientationStatus = FXTextField.new(@statusbar, 4)
     @orientationStatus.disable
   end
 
-  def initMenubar
+  def init_menubar
     @menubar = FXMenubar.new(self, FRAME_RAISED)
     @menubar.setLayoutHints(LAYOUT_SIDE_TOP|LAYOUT_FILL_X)
     FXToolbarGrip.new(@menubar, @menubar, FXMenubar::ID_TOOLBARGRIP,
-                      TOOLBARGRIP_DOUBLE)
+      TOOLBARGRIP_DOUBLE)
   end
   
-  def initMenu
-    menuTitles = {
+  def init_menu
+    menu_titles = {
       'file' => '&File',
       'view' => '&View',
       'actions' => '&Actions',
@@ -129,178 +129,184 @@ class PiggyImageBrowser < Fox::FXMainWindow
       'help' => '&Help' }
     menus = Hash.new(6)
     @menus = menus # destroy panes on closure
-    menuTitles.each_pair { |key, value|
+    menu_titles.each_pair { |key, value|
       menus[key] = FXMenuPane.new(self) }
     [ 'file', 'view', 'actions', 'options' ].each { | key |
-      FXMenuTitle.new(@menubar, menuTitles[key], nil, menus[key]) }
-    FXMenuTitle.new(@menubar, menuTitles['help'], nil, menus['help'],
-    LAYOUT_RIGHT)    
+      FXMenuTitle.new(@menubar, menu_titles[key], nil, menus[key]) }
+    FXMenuTitle.new(@menubar, menu_titles['help'], nil, menus['help'],
+      LAYOUT_RIGHT)
     
     # File menu entries
     tmp = FXMenuCommand.new(menus['file'],
-			    "&Open...\tCtl-O\tOpen image file.")
-    tmp.connect(SEL_COMMAND, method(:onCmdOpen))
+      "&Open...\tCtl-O\tOpen image file.")
+    tmp.connect(SEL_COMMAND, method(:on_cmd_open))
     tmp = FXMenuCommand.new(menus['file'],
-			    "B&ack\t\tBack in history",
-			    @backIcon)
-    tmp.connect(SEL_COMMAND, method(:onCmdBack))
+      "B&ack\t\tBack in history",
+      @backIcon)
+    tmp.connect(SEL_COMMAND, method(:on_cmd_back))
     tmp = FXMenuCommand.new(menus['file'],
-			    "&Save image\t\tSave image.",
-			    @filesaveIcon)
-    tmp.connect(SEL_COMMAND, method(:onCmdSaveSelectedImage))
+      "&Save image\t\tSave image.",
+      @filesaveIcon)
+    tmp.connect(SEL_COMMAND, method(:on_cmd_save_selected_image))
     tmp = FXMenuCommand.new(menus['file'],
-			    "&Quit\tAlt-X\tQuit Application")
-    tmp.connect(SEL_COMMAND, method(:onTerminate))
+      "&Quit\tAlt-X\tQuit Application")
+    tmp.connect(SEL_COMMAND, method(:on_terminate))
     
     # View menu entries
-#    tmp = FXMenuCheck.new(menus['view'],
-#			  "S&lides\t\tSlideshow.")
-#    tmp.connect(SEL_COMMAND, method(:onCmdSlideshow))
+    #    tmp = FXMenuCheck.new(menus['view'],
+    #			  "S&lides\t\tSlideshow.")
+    #    tmp.connect(SEL_COMMAND, method(:on_cmd_slideshow))
     tmp = FXMenuCommand.new(menus['view'],
-			    "&Rotate 90\t\tRotate 90 degrees.",
-			    @rotateIcon)
-    tmp.connect(SEL_COMMAND, method(:onRotate90))
+      "&Rotate 90\t\tRotate 90 degrees.",
+      @rotateIcon)
+    tmp.connect(SEL_COMMAND, method(:on_rotate_90))
 
     # Action menu entries
     tmp = FXMenuCommand.new(menus['actions'],
-			    "&Html\t\tGenerate Html page.",
-			    @generateIcon)
-    tmp.connect(SEL_COMMAND, method(:onCmdGenerateHtml))
+      "&Html\t\tGenerate Html page.",
+      @generateIcon)
+    tmp.connect(SEL_COMMAND, method(:on_cmd_generate_html))
     tmp = FXMenuCommand.new(menus['actions'],
-			    "Upl&oad\t\tUpload Files",
-			    @uploadIcon)
-    tmp.connect(SEL_COMMAND, method(:onCmdUpload))    
+      "Upl&oad\t\tUpload Files",
+      @uploadIcon)
+    tmp.connect(SEL_COMMAND, method(:on_cmd_upload))
     
     # Options menu entries
     tmp = FXMenuCommand.new(menus['options'],
-			    "&Options...\t\tOpen options dialog.")
-    tmp.connect(SEL_COMMAND, method(:onCmdOptions))
+      "&Options...\t\tOpen options dialog.")
+    tmp.connect(SEL_COMMAND, method(:on_cmd_options))
     
     # Help Menu entries
+    tmp = FXMenuCommand.new(menus['help'], "Sample galleries")
+    tmp.textColor = FXColor::Blue
+    tmp.connect(SEL_COMMAND) {
+      open_hyperlink("http://piggy.rubyforge.org/caps/index.htm", '.')
+    }
+
     msg = "Piggy: (P)ick (i)mages and (g)enerate a (g)aller(y)\n"
     msg += "Piggy is a generator for html picture albums.\n\n"
     msg += "Using the FOX C++ GUI Library (http://www.fox-toolkit.org)\n"
     msg += "Using Patrick Fitzgerald's Javascript slideshow (http://slideshow.barelyfitz.com/)\n"
     msg += "\n"
-    msg += "#{PiggyVersion.copyrightString}\n\n"
+    msg += "#{PiggyVersion.copyright_string}\n\n"
     msg += "Version information:\n"
     msg += "- Plattform #{RUBY_PLATFORM}\n"
     msg += "- Ruby #{RUBY_VERSION} (released #{RUBY_RELEASE_DATE})\n"
     msg += "- FXRuby #{Fox.fxrubyversion}\n"
     msg += "- FOX Toolkit #{Fox.fxversion}\n"
     msg += "- Javascript slideshow no version information availiable\n"
-    msg += "- Piggy #{PiggyVersion.displayString}\n"
-    aboutTitle = "About Piggy"
+    msg += "- Piggy #{PiggyVersion.display_string}\n"
+    about_title = "About Piggy"
     tmp = FXMenuCommand.new(menus['help'], "&About Piggy...")
     tmp.connect(SEL_COMMAND) do
-      FXMessageBox.new(self, ruby2Fox(aboutTitle), ruby2Fox(msg), nil, MsgStyle).execute
+      FXMessageBox.new(self, ruby_2_fox(about_title), ruby_2_fox(msg), nil, MsgStyle).execute
     end
   end
   
-  def initToolbar
+  def init_toolbar
     @dragshell = FXToolbarShell.new(self, 0)
     @toolbar = FXToolbar.new(self, @dragshell)
     @toolbar.setFrameStyle(FRAME_RAISED)
     @toolbar.setPackingHints(PACK_UNIFORM_WIDTH|PACK_UNIFORM_HEIGHT)
     @toolbar.setLayoutHints(LAYOUT_SIDE_TOP|LAYOUT_FILL_X)
     FXToolbarGrip.new(@toolbar, @toolbar, FXToolbar::ID_TOOLBARGRIP,
-                      TOOLBARGRIP_DOUBLE)
+      TOOLBARGRIP_DOUBLE)
   end
   
-  def newToolbarButton(icon, bubble, method)
+  def new_toolbar_button(icon, bubble, method)
     button = FXButton.new(@toolbar, bubble, icon, nil, 0, @iconStyle)
     button.connect(SEL_COMMAND, method)
     button
   end
 
-  def newToolbarToggleButton(icon1, icon2, bubble1, bubble2, method)
+  def new_toolbar_toggle_button(icon1, icon2, bubble1, bubble2, method)
     button = FXToggleButton.new(@toolbar, bubble1, bubble2, icon1, icon2, nil, 0, @iconStyle)
     button.connect(SEL_COMMAND, method)
     button
   end
   
-  def initToolbarButtons
-    newToolbarButton(@uplevelIcon, "&Up\tGo up to higher directory",
-		     method(:onOneLevelUp))
-    newToolbarButton(@backIcon, "&Back\tBack to previous directory",
-		     method(:onCmdBack))
-    newToolbarButton(@previousImageIcon, "&Previous\tShow previous selected image",
-		     method(:onCmdPreviousImage))
-    newToolbarButton(@nextImageIcon, "&Next\tShow next selected image",
-		     method(:onCmdNextImage))
-    slideshowButton = newToolbarToggleButton(@slideshowImageIcon,
-					     @slideshowOffImageIcon,
-					     "S&lides on\tStart slideshow",
-					     "S&lides off\tStop slideshow",
-					     method(:onCmdSlideshow))
+  def init_toolbar_buttons
+    new_toolbar_button(@uplevelIcon, "&Up\tGo up to higher directory",
+      method(:on_one_level_up))
+    new_toolbar_button(@backIcon, "&Back\tBack to previous directory",
+      method(:on_cmd_back))
+    new_toolbar_button(@previousImageIcon, "&Previous\tShow previous selected image",
+      method(:on_cmd_previous_image))
+    new_toolbar_button(@nextImageIcon, "&Next\tShow next selected image",
+      method(:on_cmd_next_image))
+    slideshow_button = new_toolbar_toggle_button(@slideshowImageIcon,
+      @slideshowOffImageIcon,
+      "S&lides on\tStart slideshow",
+      "S&lides off\tStop slideshow",
+      method(:on_cmd_slideshow))
     @delayField = FXTextField.new(@toolbar, 2)
     @delayField.setText(@options.slideshowDelay.to_s + ' sec')
     @delayField.connect(SEL_COMMAND) { |sender, sel, ptr|
       @options.slideshowDelay = @delayField.getText.to_i
     }
-    newToolbarButton(@fullscreenIcon, "&Full\tOpen fullscreen",
-		     method(:onCmdFullscreen))
+    new_toolbar_button(@fullscreenIcon, "&Full\tOpen fullscreen",
+      method(:on_cmd_fullscreen))
 
-    newToolbarButton(@rotateIcon, "&Rotate\tRotate 90� right",
-		     method(:onRotate90))
-    newToolbarButton(@addToPreviewIcon, "&Add\tSelect image(s)",
-		     method(:onCmdAddFiles))
-    newToolbarButton(@removeFromPreviewIcon, "S&kip\tDeselect image(s)",
-		     method(:onCmdRemoveFiles))
-    newToolbarButton(@generateIcon, "&Html\tGenerate HTML",
-		     method(:onCmdGenerateHtml))
-    newToolbarButton(@uploadIcon, "Upl&oad\tUpload files",
-		     method(:onCmdUpload))
-  end
-  
-  def initView
-    initStatusbar
-    initFrames
-    initFrameContents
-  end
-  
-  def initFrames
-    fillMode = LAYOUT_FILL_X|LAYOUT_FILL_Y
-    frameStyle = FRAME_SUNKEN
-    splitterMode = SPLITTER_TRACKING
-    vSplit = FXSplitter.new(self,
-                            splitterMode|SPLITTER_REVERSED|SPLITTER_VERTICAL)
-    vSplit.setLayoutHints(fillMode)
-    hSplit = FXSplitter.new(vSplit,
-                            splitterMode|SPLITTER_HORIZONTAL)
-    hSplit.setLayoutHints(fillMode)
-    @fileframe = FXVerticalFrame.new(hSplit, frameStyle|fillMode)
-    hSplit2 = FXSplitter.new(hSplit,
-                             splitterMode|SPLITTER_REVERSED|SPLITTER_HORIZONTAL)
-    hSplit2.setLayoutHints(fillMode)
-    @imageviewframe = FXVerticalFrame.new(hSplit2, frameStyle|fillMode)
-    hSplit3 = FXSplitter.new(hSplit2,
-                             splitterMode|SPLITTER_REVERSED|SPLITTER_HORIZONTAL)
-    hSplit3.setLayoutHints(fillMode)
-    @exifFrame = FXVerticalFrame.new(hSplit3, FRAME_NONE|fillMode)
-    @previewFrame = FXVerticalFrame.new(hSplit3, frameStyle|fillMode)
-    @logFrame = FXVerticalFrame.new(vSplit, FRAME_NONE|fillMode)
-  end
-  
-  def initFrameContents
-    fillMode = LAYOUT_FILL_X|LAYOUT_FILL_Y
+    new_toolbar_button(@rotateIcon, "&Rotate\tRotate 90� right",
+      method(:on_rotate_90))
+    new_toolbar_button(@addToPreviewIcon, "&Add\tSelect image(s)",
+      method(:on_cmd_add_files))
+    new_toolbar_button(@removeFromPreviewIcon, "S&kip\tDeselect image(s)",
+      method(:on_cmd_remove_files))
+    new_toolbar_button(@generateIcon, "&Html\tGenerate HTML",
+      method(:on_cmd_generate_html))
+    new_toolbar_button(@uploadIcon, "Upl&oad\tUpload files",
+      method(:on_cmd_upload))
+  end
+  
+  def init_view
+    init_statusbar
+    init_frames
+    init_frame_contents
+  end
+  
+  def init_frames
+    fill_mode = LAYOUT_FILL_X|LAYOUT_FILL_Y
+    frame_style = FRAME_SUNKEN
+    splitter_mode = SPLITTER_TRACKING
+    v_split = FXSplitter.new(self,
+      splitter_mode|SPLITTER_REVERSED|SPLITTER_VERTICAL)
+    v_split.setLayoutHints(fill_mode)
+    h_split = FXSplitter.new(v_split,
+      splitter_mode|SPLITTER_HORIZONTAL)
+    h_split.setLayoutHints(fill_mode)
+    @fileframe = FXVerticalFrame.new(h_split, frame_style|fill_mode)
+    h_split2 = FXSplitter.new(h_split,
+      splitter_mode|SPLITTER_REVERSED|SPLITTER_HORIZONTAL)
+    h_split2.setLayoutHints(fill_mode)
+    @imageviewframe = FXVerticalFrame.new(h_split2, frame_style|fill_mode)
+    h_split3 = FXSplitter.new(h_split2,
+      splitter_mode|SPLITTER_REVERSED|SPLITTER_HORIZONTAL)
+    h_split3.setLayoutHints(fill_mode)
+    @exifFrame = FXVerticalFrame.new(h_split3, FRAME_NONE|fill_mode)
+    @previewFrame = FXVerticalFrame.new(h_split3, frame_style|fill_mode)
+    @logFrame = FXVerticalFrame.new(v_split, FRAME_NONE|fill_mode)
+  end
+  
+  def init_frame_contents
+    fill_mode = LAYOUT_FILL_X|LAYOUT_FILL_Y
     @filelist = FilteredFileList.new(@fileframe)
     @filelist.choosable = proc { |filename| supports(filename) }
-    @filelist.setLayoutHints(fillMode)
-    @filelist.connect(SEL_COMMAND, method(:onCmdFileListSelection))
+    @filelist.setLayoutHints(fill_mode)
+    @filelist.connect(SEL_COMMAND, method(:on_cmd_file_list_selection))
     @imageview = if UseImageView
       FXImageView.new(@imageviewframe)
     else
-      MultiImageCanvas.new(@imageviewframe, fillMode)
+      MultiImageCanvas.new(@imageviewframe, fill_mode)
     end
-    @imageview.setLayoutHints(fillMode)
-    @imageview.connect(SEL_CONFIGURE, method(:onConfigure))
+    @imageview.setLayoutHints(fill_mode)
+    @imageview.connect(SEL_CONFIGURE, method(:on_configure))
     @imageComment = FXTextField.new(@imageviewframe, 32)
     @imageComment.setLayoutHints(LAYOUT_FILL_X)
-    @imageComment.connect(SEL_COMMAND, method(:onCommentMightHaveChanged))
+    @imageComment.connect(SEL_COMMAND, method(:on_comment_might_have_changed))
     @exifView = FXText.new(@exifFrame)
     @exifView.setLayoutHints(LAYOUT_FILL_X|LAYOUT_FILL_Y)
-    @preview = MultiImageCanvas.new(@previewFrame, fillMode)
+    @preview = MultiImageCanvas.new(@previewFrame, fill_mode)
     @pipeLog = PipeLog.new(@logFrame)
     @pipeLog.setLayoutHints(LAYOUT_FILL_X|LAYOUT_FILL_Y)
   end
@@ -314,13 +320,13 @@ class PiggyImageBrowser < Fox::FXMainWindow
     resize(720, 620)
     place(PIGGY_WINDOW_PLACEMENT)
     setIcon(@windowIcon)
-    optionsChanged(@options)
+    options_changed(@options)
     super
   end
   
   # CHANGE VIEW
   
-  def frameVisible(frame, bool)
+  def frame_visible(frame, bool)
     if bool
       frame.show
     else
@@ -328,85 +334,85 @@ class PiggyImageBrowser < Fox::FXMainWindow
     end
   end
   
-  def refreshWithNewLayout
+  def refresh_with_new_layout
     # method layout missing
     resize(width, height - 1)
     resize(width, height + 1)
   end
   
   def preview
-    @preview.loadImages(chosenSequence)
+    @preview.load_images(chosen_sequence)
   end
   
-  def optionsChanged(newOptions)
+  def options_changed(newOptions)
     preview if newOptions.usePreview && !@options.usePreview
-    frameVisible(@logFrame, newOptions.useLog)
-    frameVisible(@previewFrame, newOptions.usePreview)
-    refreshWithNewLayout
+    frame_visible(@logFrame, newOptions.useLog)
+    frame_visible(@previewFrame, newOptions.usePreview)
+    refresh_with_new_layout
     @options = newOptions
   end
   
-  def runCommand(commandline, workingDir)
-    @pipeLog.runCommand(commandline, workingDir)
+  def run_command(commandline, workingDir)
+    @pipeLog.run_command(commandline, workingDir)
   end
 
   def log(msg)
     @pipeLog.appendText("#{msg}\n")
   end
   
-  def loadImage(file)
+  def load_image(file)
     @filename = file # needs to be called this early
-    info = currentFileInfo
-    @imageComment.setText(ruby2Fox(info.comment))
-    setCurrentRotation(info.rotation)
-    reloadImage(file)
+    info = current_file_info
+    @imageComment.setText(ruby_2_fox(info.comment))
+    set_current_rotation(info.rotation)
+    reload_image(file)
   end
 
-  def reloadImage(file)
+  def reload_image(file)
     if UseImageView
-      old = @imageview.image.nil? ? nil : fox2Ruby(@imageview.image) 
-      image = @imageProcessor.loadImage(file, false)
-      @imageProcessor.fitImage(image, 800, 600)
+      old = @imageview.image.nil? ? nil : fox_2_ruby(@imageview.image)
+      image = @imageProcessor.load_image(file, false)
+      @imageProcessor.fit_image(image, 800, 600)
       if @currentRotation > 0 
-	@imageProcessor.rotateImage(image, @currentRotation)
+        @imageProcessor.rotate_image(image, @currentRotation)
       end
       image.create
       @imageview.image = image
     else
       if fullscreen? && @fullScreenView
-	old = @fullScreenView.image
-	@fullScreenView.loadImage(@filename, false, @currentRotation)
-	@imageProcessor.garbageImage(old) unless old.nil?
+        old = @fullScreenView.image
+        @fullScreenView.load_image(@filename, false, @currentRotation)
+        @imageProcessor.garbage_image(old) unless old.nil?
       else
-	old = @imageview.image
-	@imageview.loadImage(file, false, @currentRotation)
-	@imageProcessor.garbageImage(old) unless old.nil?
+        old = @imageview.image
+        @imageview.load_image(file, false, @currentRotation)
+        @imageProcessor.garbage_image(old) unless old.nil?
       end
     end
-    @imageProcessor.garbageImage(old) unless old.nil?
+    @imageProcessor.garbage_image(old) unless old.nil?
   end
 
-  def openFileOrLink(filename)
+  def open_file_or_link(filename)
     @exifView.setText('')
-    rubyFile = rubyPath(filename)
-    if FileTest.directory? rubyFile
-      setDirectory(rubyFile)
+    ruby_file = ruby_path(filename)
+    if FileTest.directory? ruby_file
+      set_directory(ruby_file)
       return 1
     end
-    if @shell.link?(rubyFile)
+    if @shell.link?(ruby_file)
       # file is a windows-shortcut
-      rubyFile = getLinkPath(@filelist.getDirectory, rubyFile)
-      return 0 if !rubyFile || rubyFile.empty?
-      log("Shortcut to: #{rubyFile}")
-      if FileTest.directory?(rubyFile)
-        setDirectory(rubyFile)
+      ruby_file = get_link_path(@filelist.getDirectory, ruby_file)
+      return 0 if !ruby_file || ruby_file.empty?
+      log("Shortcut to: #{ruby_file}")
+      if FileTest.directory?(ruby_file)
+        set_directory(ruby_file)
         return 1
       end
     end
     if(supports(filename))
-      loadImage(rubyFile)
-      @exifView.setText(ruby2Fox("#{File.basename(rubyFile)}\n#{@exif.to_s}"))
-      @filelist.assumeSelected(rubyFile)
+      load_image(ruby_file)
+      @exifView.setText(ruby_2_fox("#{File.basename(ruby_file)}\n#{@exif.to_s}"))
+      @filelist.assume_selected(ruby_file)
       return 1
     end
     return 0
@@ -420,71 +426,71 @@ class PiggyImageBrowser < Fox::FXMainWindow
     return @supportedImageTypes.include?(extension)
   end
 
-  def hasExtension?(filename, ext)
+  def has_extension?(filename, ext)
     File.basename(filename.upcase, ext.upcase) !=
-    File.basename(filename.upcase)
+      File.basename(filename.upcase)
   end
   
   # ACCESSING
   
-  def generatorClass
-    return NconvertThumbnailPageGenerator if @options.useNconvert?
-    if RMAGICK_AVAILIABLE && @options.useRmagick?
+  def generator_class
+    return NconvertThumbnailPageGenerator if @options.use_nconvert?
+    if RMAGICK_AVAILIABLE && @options.use_rmagick?
       return RmagickThumbnailPageGenerator
     end
     return FoxThumbnailPageGenerator
   end
   
-  def setDirectory(dirname)
+  def set_directory(dirname)
     if @historyPos < @history.size
       @history.pop
     else
       @history.push(dirname)
       @historyPos = @history.size
     end
-    @filelist.goToDirectory(dirname)
+    @filelist.go_to_directory(dirname)
     if(@options.preselectDirectories?)
-      @filelist.chooseAllInFilelist
-      nextImage
+      @filelist.choose_all_in_filelist
+      next_image
     end
     preview if @options.usePreview
   end
   
-  def defaultStartupDirectory
-    return @shell.pictureDirectory
+  def default_startup_directory
+    return @shell.picture_directory
   end
   
-  def getLinkPath(dirname, linkname)
-    return @shell.getLinkTarget(linkname, dirname)
+  def get_link_path(dirname, linkname)
+    return @shell.get_link_target(linkname, dirname)
   end
   
-  def rubyPath(path)
-    @shell.rubyPath(path)
+  def ruby_path(path)
+    @shell.ruby_path(path)
   end
   
-  def getIcon(filename)
-    iconPath = File.join(PIGGY_PATH, 'icons', filename)
-    icon = @imageProcessor.loadIcon(iconPath)
+  def get_icon(filename)
+    icon_path = File.join(PIGGY_PATH, 'icons', filename)
+    icon = @imageProcessor.load_icon(icon_path)
     @icons.push(icon)
     return icon
   end
   
-  def infoForFile(osPathString)
-    pathString = @shell.rubyPath(osPathString)
-    @exif = ExifrAdapter.new(pathString)
-    info = CommentedFile.new(File.basename(pathString), File.dirname(pathString))
+  def info_for_file(osPathString)
+    path_string = @shell.ruby_path(osPathString)
+    @exif = ExifrAdapter.new(path_string)
+    info = CommentedFile.new(File.basename(path_string), File.dirname(path_string))
     if @fileInfos.has_key?(info)
       info = @fileInfos[info]
     else
-      info.rotation = @exif.viewDegrees
+      info.rotation = @exif.view_degrees
       info.comment = @exif.comment
       @fileInfos[info] = info
     end
     return info
   end
   
-  def currentFileInfo
-    infoForFile(@filename)
+  def current_file_info
+    info_for_file(@filename)
   end
   
   # MESSAGES
@@ -498,7 +504,7 @@ class PiggyImageBrowser < Fox::FXMainWindow
     MBOX_CLICKED_YES == FXMessageBox.question(self, MBOX_YES_NO, title, question)
   end
   
-  def checkLocalDestinationPath
+  def check_local_destination_path
     output = @options.localDestinationPath
     if(!File.directory?(output))
       error("#{output} ist no directory}")
@@ -509,264 +515,300 @@ class PiggyImageBrowser < Fox::FXMainWindow
   
   # ACTIONS
   
-  def fitImage
+  def fit_image
     @imageview.fit unless UseImageView
   end
   
-  def saveImage
-    saveDialog = FXFileDialog.new(self, "Save Image")
-    saveDialog.filename = @filename.gsub(/([^.])\.(.*)/, '\1.piggy.\2')
-    return if saveDialog.execute == 0
-    if File.exists? saveDialog.filename
+  def save_image
+    save_dialog = FXFileDialog.new(self, "Save Image")
+    save_dialog.filename = @filename.gsub(/([^.])\.(.*)/, '\1.piggy.\2')
+    return if save_dialog.execute == 0
+    if File.exists? save_dialog.filename
       #      return unless question("Overwrite existing image?", "Overwrite Image")
       return error('Sorry, overwrite an existing image is not implemented, yet.')
     end
     getApp().beginWaitCursor do
-      manipulatedImage = @imageProcessor.loadImage(@filename)
-      @imageProcessor.rotateImage(manipulatedImage, @currentRotation)
-      @imageProcessor.saveImage(manipulatedImage, saveDialog.filename)
-      @imageProcessor.garbageImage(manipulatedImage) 
-      @filelist.updateFileList
+      manipulatedImage = @imageProcessor.load_image(@filename)
+      @imageProcessor.rotate_image(manipulatedImage, @currentRotation)
+      @imageProcessor.save_image(manipulatedImage, save_dialog.filename)
+      @imageProcessor.garbage_image(manipulatedImage)
+      @filelist.update_file_list
     end
-    setDirectory(saveDialog.getDirectory)
-    openFileOrLink(saveDialog.filename)
+    set_directory(save_dialog.getDirectory)
+    open_file_or_link(save_dialog.filename)
   end
   
-  def setCurrentRotation(newRotation)
+  def set_current_rotation(newRotation)
     @currentRotation = newRotation
     if @currentRotation >= 360
       @currentRotation = @currentRotation - 360
     end
-    @orientationStatus.setText(@currentRotation.to_s + '�')
-    currentFileInfo.rotation = @currentRotation
+    @orientationStatus.setText(ruby_2_fox(@currentRotation.to_s + '�'))
+    current_file_info.rotation = @currentRotation
   end
 
   def rotate(degree)
-    setCurrentRotation(@currentRotation + degree)
+    set_current_rotation(@currentRotation + degree)
     getApp().beginWaitCursor do
-      reloadImage(@filename)
+      reload_image(@filename)
     end
   end
   
-  def openHtmlBrowserOnResult(generator)
-    if(!File.exist? generator.mainIndexPath)
-      return error("#{generator.mainIndexPath} doesn't exist")
+  def open_html_browser_on_result(generator)
+    if(!File.exist? generator.main_index_path)
+      return error("#{generator.main_index_path} doesn't exist")
     end
-    if(!File.exist? generator.mainIndexWithPath)
-      return error("#{generator.mainIndexWithPath} doesn't exist")
+    if(!File.exist? generator.main_index_with_path)
+      return error("#{generator.main_index_with_path} doesn't exist")
     end
-    if(@options.browser?)
-      getApp.beginWaitCursor
-      begin
-	cmd = @options.browser
-	args = @shell.osPath(generator.mainIndexWithPath)
-	path = generator.mainIndexPath		     
-        @pipeLog.runCommand(cmd + ' ' + args, path, true)
-      rescue StandardError => ex
-	log(ex.to_s)
+    url = @shell.os_path(generator.main_index_with_path)
+    working_dir = generator.main_index_path
+    open_hyperlink(url, working_dir)
+  end
+
+  # Modified an idea of David Naseby on how to
+  # do Hyperlinks with FXRuby
+  def add_hyperlink_to(container, url)
+    link = FXButton.new(container, ruby_2_fox(url), nil, nil, 0, FRAME_NONE)
+    link.textColor = FXColor::Blue
+    link.connect(SEL_COMMAND) { open_hyperlink(url, '.') }
+  end
+
+  def open_hyperlink(url, working_dir)
+    getApp.beginWaitCursor
+    begin
+      if(@options.browser?)
+        cmd = @options.browser
+        @pipeLog.run_command(cmd + ' ' + url, working_dir, true)
+      else
+        if PLATFORM =~ /mswin/
+          require 'win32ole'
+          ie = WIN32OLE.new('InternetExplorer.Application')
+          ie.visible = TRUE
+          ie.navigate(url)
+        end
       end
+    rescue StandardError => ex
+      log(ex.to_s)
+    ensure
       getApp.endWaitCursor
     end
   end
   
   # EVENTS
   
-  def onCmdSaveSelectedImage(sender, sel, ptr)
-    saveImage
+  def on_cmd_save_selected_image(sender, sel, ptr)
+    save_image
   end
   
-  def onRotate90(sender, sel, ptr)
+  def on_rotate_90(sender, sel, ptr)
     image = @imageview.image
     return error('Doubleclick image file first') if image == nil
     rotate(90)
   end
   
-  def onCmdUpload(sender, sel, index)
-    uploadDialog = FtpBrowserDialog.new(self, @options.clone)
-    uploadDialog.connect(SEL_CLOSE, method(:onFtpBrowserDialogClosed))
-    uploadDialog.execute
-    optionsChanged(uploadDialog.options)
+  def on_cmd_upload(sender, sel, index)
+    upload_dialog = FtpBrowserDialog.new(self, @options.clone)
+    upload_dialog.connect(SEL_CLOSE, method(:on_ftp_browser_dialog_closed))
+    upload_dialog.execute
+    options_changed(upload_dialog.options)
   end
   
-  def onConfigure(sender, sel, ptr)
-    fitImage
+  def on_configure(sender, sel, ptr)
+    fit_image
   end
   
-  def onCmdOptions(sender, sel, index)
+  def on_cmd_options(sender, sel, index)
     dialog = OptionsDialog.new(self, @options.clone)
-    optionsChanged(dialog.options) if dialog.execute
+    options_changed(dialog.options) if dialog.execute
   end
   
   # Open a new file
-  def onCmdOpen(sender, sel, ptr)
-    openSystemFileChooser
+  def on_cmd_open(sender, sel, ptr)
+    open_system_file_chooser
     return 1
   end
   
-  def openSystemFileChooser
-    openDialog = FXFileDialog.new(self, "Open Image")
+  def open_system_file_chooser
+    open_dialog = FXFileDialog.new(self, "Open Image")
     #openDialog.filename = @filename
-    openDialog.setDirectory(@filelist.getCurrentDirectory)
+    open_dialog.set_directory(@filelist.get_current_directory)
     patterns = ["All Files (*)" ] + @supportedImageTypes.values
-    openDialog.patternList = patterns
-    openDialog.currentPattern = @preferredFileFilter
-    if openDialog.execute
-      @preferredFileFilter = openDialog.currentPattern
-      filename = openDialog.filename
-      setDirectory(openDialog.getDirectory)
-      openFileOrLink(filename)
+    open_dialog.patternList = patterns
+    open_dialog.currentPattern = @preferredFileFilter
+    if open_dialog.execute
+      @preferredFileFilter = open_dialog.currentPattern
+      filename = open_dialog.filename
+      set_directory(open_dialog.getDirectory)
+      open_file_or_link(filename)
     end
   end
   
   # Command message from the file list
   
-  def onCmdFileListSelection(sender, dummy, index)
-    selectIndex(index)
+  def on_cmd_file_list_selection(sender, dummy, index)
+    select_index(index)
   end
   
-  def onCmdNextImage(sender, sel, dummy)
-    nextImage
+  def on_cmd_next_image(sender, sel, dummy)
+    next_image
   end
   
-  def onCmdPreviousImage(sender, sel, dummy)
-    previousImage
+  def on_cmd_previous_image(sender, sel, dummy)
+    previous_image
   end
   
-  def nextImage
-    i = @filelist.selectNextChosen
-    selectIndex(i) unless i < 0
+  def next_image
+    i = @filelist.select_next_chosen
+    select_index(i) unless i < 0
   end
   
-  def previousImage
-    i = @filelist.selectPreviousChosen
-    selectIndex(i) unless i < 0
+  def previous_image
+    i = @filelist.select_previous_chosen
+    select_index(i) unless i < 0
   end
 
-  def startSlideshow
+  def start_slideshow
     @slideManager = 1
     Thread.new {
       while(@slideManager) do
-	# Threading issues: addChore seems to provide enough
-	# synchronisation to avoid segfaults here
-	getApp().addChore { |x, y, z| nextImage }
-	delay = @options.slideshowDelay
-	sleep(delay > 0 ? delay : 1)
+        # Threading issues: addChore seems to provide enough
+        # synchronisation to avoid segfaults here
+        getApp().addChore { |x, y, z| next_image }
+        delay = @options.slideshowDelay
+        sleep(delay > 0 ? delay : 1)
       end
     }
   end
 
-  def stopSlideshow
+  def stop_slideshow
     @slideManager = nil
-    stopFullscreen
+    stop_fullscreen
   end
 
-  def startFullscreen
-    fillMode = LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_CENTER_X|LAYOUT_CENTER_Y
+  def start_fullscreen
+    fill_mode = LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_CENTER_X|LAYOUT_CENTER_Y
     @fullscreen = Fullscreen.new(getApp, "Piggy fullscreen", nil, nil,
-				   DECOR_BORDER|DECOR_TITLE|DECOR_CLOSE)
-    @fullScreenView = MultiImageCanvas.new(@fullscreen, fillMode)
+      DECOR_BORDER|DECOR_TITLE|DECOR_CLOSE)
+    @fullScreenView = MultiImageCanvas.new(@fullscreen, fill_mode)
     @fullscreen.connect(SEL_CLOSE){ |sender, sel, ptr|
-      stopFullscreen
+      stop_fullscreen
     }
     @fullscreen.create
     @fullscreen.show(PLACEMENT_MAXIMIZED)
-    reloadImage(@filename)
+    reload_image(@filename)
   end
 
-  def stopFullscreen
+  def stop_fullscreen
     @fullscreen.destroy if fullscreen?
     @fullscreen = nil
     @fullScreenView = nil
-    reloadImage(@filename)
+    reload_image(@filename)
   end
 
   def fullscreen?
     @fullscreen && @fullscreen.shown?
   end
 
-  def selectIndex(index)
+  def select_index(index)
     return 0 if index < 0
     if @filelist.isItemDirectory(index)
-      setDirectory(@filelist.getItemRubyPathname(index))
+      set_directory(@filelist.get_item_ruby_pathname(index))
       return 1
     end
     return 0 if !@filelist.isItemFile(index)
-    filename = @filelist.getItemRubyPathname(index)
-    return openFileOrLink(filename)
-  end 
+    filename = @filelist.get_item_ruby_pathname(index)
+    return open_file_or_link(filename)
+  end
   
-  def onOneLevelUp(sender, sel, unused)
-    oldDir = rubyPath(@filelist.getCurrentDirectory)
-    newDir = FilePath.oneDirUp(oldDir)
-    if(oldDir == newDir)
-      newDir = FXDirDialog.getOpenDirectory(self, "Choose directory", oldDir)
+  def on_one_level_up(sender, sel, unused)
+    old_dir = ruby_path(@filelist.get_current_directory)
+    new_dir = FilePath.one_dir_up(old_dir)
+    if(old_dir == new_dir)
+      new_dir = FXDirDialog.getOpenDirectory(self, "Choose directory", old_dir)
     end
-    setDirectory(newDir) unless(oldDir == newDir)
+    set_directory(new_dir) unless(old_dir == new_dir)
   end
   
-  def onCmdAddFiles(sender, sel, unused)
-    @filelist.addSelectedFiles
+  def on_cmd_add_files(sender, sel, unused)
+    @filelist.add_selected_files
     preview if @options.usePreview
   end
   
-  def onCmdRemoveFiles(sender, sel, unused)
-    @filelist.removeSelectedFiles
-    preview if @options.usePreview   
+  def on_cmd_remove_files(sender, sel, unused)
+    @filelist.remove_selected_files
+    preview if @options.usePreview
   end
   
-  def onCmdBack(sender, unused1, unused2)
+  def on_cmd_back(sender, unused1, unused2)
     if(@historyPos > 1)
       @historyPos -= 1
-      setDirectory(@history[@historyPos - 1])
+      set_directory(@history[@historyPos - 1])
     end
   end
   
-  def onCmdSlideshow(sender, sel, index)
+  def on_cmd_slideshow(sender, sel, index)
     if @slideManager
-      stopSlideshow
+      stop_slideshow
     else
-      startSlideshow
+      start_slideshow
     end
   end
 
-  def onCmdFullscreen(sender, sel, index)
+  def on_cmd_fullscreen(sender, sel, index)
     if fullscreen?
-      stopFullscreen
+      stop_fullscreen
     else
-      startFullscreen
+      start_fullscreen
     end
   end
 
-  def onCmdGenerateHtml(sender, sel, index)
-    unless @filelist.anyFilesChosen?
+  def on_cmd_generate_html(sender, sel, index)
+    unless @filelist.any_files_chosen?
       return error("Select some image files first!")
     end
-    optionsDialog = HtmlGenerationDialog.new(self, @options.clone)
-    return false unless optionsDialog.execute
-    @options = optionsDialog.options
-    directory = @filelist.getDirectory
-    outputDir = optionsDialog.getSubdir
-    subdir = File.join(@options.localDestinationPath, outputDir)
-    title = optionsDialog.getTitle
+    options_dialog = HtmlGenerationDialog.new(self, @options.clone)
+    return false unless options_dialog.execute
+    @options = options_dialog.options
+    output_dir = options_dialog.get_subdir
+    title = options_dialog.get_title
     title = "" if(!title)
-    generator = generatorClass.new(@options)
+    generator = generator_class.new(@options)
+    generator.set_title(title)
+    generator.set_output_directory(output_dir)
     generator.client = @pipeLog
-    generator.setOutputDirectory(outputDir)
-    generator.setTitle(title)
-    generator.setFiles(chosenSequence.collect { |f| infoForFile(f) })
+    generator.set_files(chosen_sequence.collect { |f| info_for_file(f) })
     getApp.beginWaitCursor
     progress = ProgressWithDialog.new(self)
-    progress.setTask('Generating', @filelist.numFilesChosen)
+    progress.set_task('Generating', @filelist.num_files_chosen)
+    success = false
+    overwrite = true # user has been asked in dialog
     begin
-      success = generator.generate(progress, false, @options.addZip?) 
-      while @pipeLog.hasOpenPipes?
+      if(@options.stylesSample?)
+        actual_options = @options.clone
+        begin
+          get_style_list.each { |style|
+            @options.style = style
+            @options.skipImageProcessing = (style != 'basic')
+            @options.stylesSample = (style != 'basic')
+            generator.set_title(style)
+            generator.set_output_directory(style)
+            success = success & generator.generate(progress, overwrite, @options.addZip?)
+          }
+        ensure
+          @options = actual_options
+        end
+      else
+        success = generator.generate(progress, overwrite, @options.addZip?)
+      end
+      while @pipeLog.has_open_pipes?
       end
     ensure
       progress.finish
       getApp.endWaitCursor
     end
     if(success)
-      openHtmlBrowserOnResult(generator)
+      open_html_browser_on_result(generator)
     else
       @pipeLog.appendText('Error')
       error("Error in html generation!")
@@ -774,41 +816,41 @@ class PiggyImageBrowser < Fox::FXMainWindow
     return success
   end
   
-  def onFtpBrowserDialogClosed(sender, sel, ptr)
+  def on_ftp_browser_dialog_closed(sender, sel, ptr)
     # get options?
     return 0
   end
   
-  def onCommentMightHaveChanged(sender, sel, ptr)
-    currentFileInfo.comment = fox2Ruby(@imageComment.getText)
+  def on_comment_might_have_changed(sender, sel, ptr)
+    current_file_info.comment = fox_2_ruby(@imageComment.getText)
   end
   
   # EXIT
   
-  def prepareClosure
+  def prepare_closure
     puts 'About to quit'
-    @optionStore.saveYaml(@options)
-    @pipeLog.closePipes
+    @optionStore.save_yaml(@options)
+    @pipeLog.close_pipes
   end
 
   if FOXVERSION_GE_1_2
     def close(notify=false)
-      prepareClosure
+      prepare_closure
       super(notify)
     end
-    def onTerminate(sender, sel, ptr)
+    def on_terminate(sender, sel, ptr)
       close
     end
   else
     # Send whenever this window is about to close
-    def onCmdClose(sender, sel, ptr)
-      prepareClosure
+    def on_cmd_close(sender, sel, ptr)
+      prepare_closure
       return 0
     end
     # Use this to react on termination signals
-    def onTerminate(sender, sel, ptr)
-      prepareClosure
+    def on_terminate(sender, sel, ptr)
+      prepare_closure
       getApp.exit(0)
     end
   end
-end  
+end