rawfilewizard

MainForm.cs (22817B)

---

 using SilkypixFileMover.Properties;
 using SilkypixFileMover.Objects;
 using SilkypixFileMover.Enums;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Windows.Forms;
 using System.Text;
 
 namespace SilkypixFileMover
 {
     // TODO: Texte in Ressourcen verschieben wegen Lokalisierung
     public partial class MainForm : Form
     {
         List<RawFile> pendingFiles = new List<RawFile>();
 
         string startDir;
 
         private History destinationDirHistory;
 
         public MainForm()
         {
             InitializeComponent();
 
             destinationDirHistory = new History( (int)Settings.Default.DestinationDirHistoryCount );
             // wenn schon Verzeichnisse gespeichert sind, dann übernehmen
             if ( Settings.Default.DestinationDirHistory != null )
             {
                 destinationDirHistory.EntrysAsSpecializedStringCollection = Settings.Default.DestinationDirHistory;
             }
             // Zielpfad vorbelegen wenn vorhanden
             SetDestinationDirPath( Settings.Default.LastDestinationFolder );
         }
 
         #region EventHandler für die Listview
 
         private void lviFiles_SelectedIndexChanged( object sender, EventArgs e )
         {
             if ( lviFiles.SelectedItems.Count > 0 )
             {
                 btnRemoveFile.Enabled = true;
             }
             else
             {
                 btnRemoveFile.Enabled = false;
             }
         }
 
         /// <summary>
         /// Bei Doppelklick auf 1 Datei diese im Standardanzeiger öffnen
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
         private void lviFiles_MouseDoubleClick( object sender, MouseEventArgs e )
         {
             if ( e.Button == MouseButtons.Left )
             {
                 OpenFirstSelectedFile();
             }
         }
 
         /// <summary>
         /// Reagiert auf Tastendrücke in der Listview
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
         private void lviFiles_KeyUp( object sender, KeyEventArgs e )
         {
             switch ( e.KeyCode )
             {
                 case Keys.A:
                     if ( e.Modifiers == Keys.Control )
                     {
                         lviFiles.Items.OfType<ListViewItem>().ToList().ForEach( item => item.Selected = true );
                     }
                     break;
 
                 case Keys.Delete:
                     RemoveSelectItemsFromListview();
                     break;
 
                 case Keys.Enter:
                     OpenFirstSelectedFile();
                     break;
             }
         }
 
         private void RemoveSelectItemsFromListview()
         {
             if ( lviFiles.SelectedItems.Count > 0 )
             {
                 foreach ( ListViewItem item in lviFiles.SelectedItems )
                 {
                     RawFile selectedFile = item.Tag as RawFile;
                     pendingFiles.Remove( selectedFile );
                 }
 
                 UpdateListView(false);
             }
         }
 
         /// <summary>
         /// Fügt die übergebenen Dateien zur Liste der PendingFiles hinzu
         /// </summary>
         /// <param name="files">Ein Array von Dateinamen inkl. Verzeichnisangabe.</param>
         private void AddItemsToListView(string[] files)
         {
             statusLabel.Text = string.Empty;
             bool added = false;
             foreach ( string file in files )
             {
                 if ( ConditionalAdd( file ) )
                 {
                     added = true;
                 }
             }
 
             UpdateListView(added);
         }
 
         #endregion
 
         #region Hilfsmethoden für die ListView
 
         private void OpenFirstSelectedFile()
         {
             RawFile selectedFile = lviFiles.SelectedItems[ 0 ].Tag as RawFile;
             if ( selectedFile != null )
             {
                 // Bild oder Datei offnen mit Pfad 
                 NativeMethods.ShellExecute( 0, "open", selectedFile.RawFileFullPath, "", "", 5 );
             }
         }
 
         /// <summary>
         /// Aktualisiert den Inhalt der ListView mit der aktuellen Dateiliste
         /// </summary>
         private void UpdateListView(bool showBalloon )
         {
             lviFiles.SuspendLayout();
             lviFiles.Items.Clear();
 
             foreach ( RawFile dng in pendingFiles )
             {
                 // keine Datei-Duplikate zulassen
                 if ( lviFiles.Items.Contains( new ListViewItem( dng.RawFileName ) ) )
                 {
                     continue;
                 }
 
                 // nach Quellverzeichnis gruppieren
                 if ( lviFiles.Groups[ dng.RawFileSourcePath ] == null )
                 {
                     lviFiles.Groups.Add( new ListViewGroup( dng.RawFileSourcePath, dng.RawFileSourcePath ) );
                 }
 
                 // Item hinzufügen
                 ListViewItem newItem = lviFiles.Items.Add(
                     new ListViewItem( new string[] { dng.RawFileName, dng.Size, dng.TimeStamp.ToString() },
                     lviFiles.Groups[ dng.RawFileSourcePath ] ) );
                 newItem.Tag = dng;
             }
 
             lviFiles.ResumeLayout();
 
             UpdateNotifyIconText(showBalloon);
             SetActionButtonState();
         }
 
         /// <summary>
         /// Setz den Text des NotifyIcons auf den übergebenen Text oder den Standardtext
         /// </summary>
         /// <param name="showBalloon">Gibt an, ob der BalloonTip angezeigt werden soll oder nicht.</param>
         private void UpdateNotifyIconText(bool showBalloon)
         {
             string text;
 
             if ( pendingFiles.Count == 0 )
             {
                 text = "Kein Bild ausgewählt";
                 trayIcon.Icon = Resources.backups;
             }
             else
             {
                 text = string.Format( "{0} {1} ausgewählt", pendingFiles.Count, pendingFiles.Count == 1 ? "Bild" : "Bilder" );
                 trayIcon.Icon = Resources.backup_wizard;
             }
 
             trayIcon.Text = string.Format( "{0} - RawFileWizard", text );
             if ( showBalloon )
             {
                 ShowBalloonTipText( text );
             }
         }
 
         /// <summary>
         /// Zeigt eine Info mit dem übergebenen Text an
         /// </summary>
         /// <param name="text">Der anzuzeigende Text</param>
         /// <param name="timeInSeconds">Anzeigedauer des Infobanners in Sekunden</param>
         private void ShowBalloonTipText( string text, int timeInSeconds = 1 )
         {
             trayIcon.BalloonTipText = text;
             trayIcon.ShowBalloonTip( timeInSeconds * 1000 );
         }
 
         #endregion
 
         #region Eventhandler für die Buttons
 
         /// <summary>
         /// Button für Auswahl des Zielordners wurde angeklickt
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
         private void btnSelectDestination_Click( object sender, EventArgs e )
         {
             FolderBrowserDialog fbd = new FolderBrowserDialog();
             fbd.ShowNewFolderButton = true;
             fbd.Description = "Wählen Sie das Zielverzeichnis aus:";
 
             // Dialog vorbelegen
             if ( !string.IsNullOrEmpty( cboHistory.Text ) && Directory.Exists( cboHistory.Text ) )
             {
                 fbd.SelectedPath = cboHistory.Text;
             }
 
             if ( fbd.ShowDialog() == DialogResult.OK )
             {
                 SetDestinationDirPath( fbd.SelectedPath );
             }
         }
 
         /// <summary>
         /// Dateien löschen
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
         private void btnDelete_Click( object sender, EventArgs e )
         {
             if ( Settings.Default.MoveToRecycleBin || 
                  MessageBox.Show("Wollen sie wirklich alle gelisteten Dateien löschen?", "Dateien löschen", MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button2 ) == DialogResult.Yes )
             {
                 PrepareWorker( WorkerAction.Delete );
             }
         }
 
         /// <summary>
         /// Dateien verschieben!
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
         private void btnMove_Click( object sender, EventArgs e )
         {
             PrepareWorker( WorkerAction.Move );
         }
 
         private void PrepareWorker( WorkerAction workerAction )
         {
             statusLabel.Text = string.Empty;
             if ( !bgwWorker.IsBusy )
             {
                 statusProgress.Maximum = pendingFiles.Count;
                 statusProgress.Value = 0;
                 SetAllButtonState( false );
 
                 bgwWorker.RunWorkerAsync( new WorkerParams()
                 {
                     Action = workerAction,
                     DestinationDir = cboHistory.Text
                 } );
             }
         }
 
         private void btnRemoveFile_Click( object sender, EventArgs e )
         {
             RemoveSelectItemsFromListview();
         }
 
         /// <summary>
         /// Button für den Dateiauswahl-Dialog wurde gedrückt.
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
         private void btnAddFile_Click( object sender, EventArgs e )
         {
             // Parameter für den OpenFile-Dialog setzen
             OpenFileDialog fd = new OpenFileDialog();
             fd.AutoUpgradeEnabled = true;
             fd.CheckFileExists = true;
             fd.CheckPathExists = true;
             fd.Multiselect = true;
             fd.ReadOnlyChecked = true;
             fd.Title = "Bilder auswählen";
             fd.Filter = CreateFileFilter();
 
             // zuletzt verwendeten Ordner wiederherstellen
             if ( !string.IsNullOrWhiteSpace( Settings.Default.LastSourceFolder ) )
             {
                 fd.InitialDirectory = Settings.Default.LastSourceFolder;
             }
 
             if ( string.IsNullOrWhiteSpace( fd.InitialDirectory ) )
             {
                 fd.InitialDirectory = Environment.GetFolderPath( Environment.SpecialFolder.MyPictures );
             }
 
             if ( fd.ShowDialog() == DialogResult.OK )
             {
                 Settings.Default.LastSourceFolder = Path.GetDirectoryName( fd.FileName );
                 Settings.Default.Save();
 
                 AddItemsToListView( fd.FileNames );
             }
         }
 
         private string CreateFileFilter()
         {
             StringBuilder sb = new StringBuilder();
             sb.Append( "Bilddateien|*." );
             sb.Append( Settings.Default.RawFileExtension );
             sb.Append( ";*." );
             sb.Append( string.Join( ";*.", Settings.Default.JpegFileExtensions.Split( '|' ) ) );
             sb.Append("|Alle Dateien|*.*");
             return sb.ToString();
         }
 
         private bool ConditionalAdd( string file )
         {
             string fileExt = Path.GetExtension( file ).TrimStart( '.' ).ToLowerInvariant();
 
             if ( fileExt.Equals( Settings.Default.RawFileExtension.ToLowerInvariant() ) ||
                  Settings.Default.JpegFileExtensions.Split( '|' ).Any( p => p.ToLowerInvariant() == fileExt ) )
             {
                 RawFile dng = new RawFile( file );
 
                 // Dateien übernehmen, wenn noch nicht ausgewählt
                 if ( !pendingFiles.Contains( dng ) )
                 {
                     pendingFiles.Add( dng );
                     return true;
                 }
             }
 
             return false;
         }
 
         #endregion
 
         /// <summary>
         /// Setzt den Ziel-Pfad und aktualisiert die Buttons
         /// </summary>
         /// <param name="path">Pfad der gesetzt werden sollen</param>
         private void SetDestinationDirPath( string path )
         {
             if ( !string.IsNullOrEmpty( path ) )
             {
                 if ( !Directory.Exists( path ) )
                 {
                     if ( MessageBox.Show( "Soll das Verzeichnis angelegt werden?", "Frage",
                         MessageBoxButtons.YesNo,
                         MessageBoxIcon.Question,
                         MessageBoxDefaultButton.Button1 ) == DialogResult.Yes )
                     {
                         Directory.CreateDirectory( path );
                     }
                 }
 
                 if ( Directory.Exists( path ) )
                 {
                     cboHistory.Text = path;
                     startDir = path;
 
                     destinationDirHistory.Add( path );
                     Settings.Default.DestinationDirHistory = destinationDirHistory.EntrysAsSpecializedStringCollection;
                     Settings.Default.LastDestinationFolder = path;
                     Settings.Default.Save();
 
                     SetActionButtonState();
                     return;
                 }
             }
 
             if ( !string.IsNullOrEmpty( startDir ) )
             {
                 cboHistory.Text = startDir;
             }
         }
 
         /// <summary>
         /// Aktualisiert den Status des Verschieben-Buttons je nachdem ob was ausgewählt ist
         /// </summary>
         private void SetActionButtonState()
         {
             if ( pendingFiles != null &&
                 pendingFiles.Count > 0 )
             {
                 if ( !string.IsNullOrWhiteSpace( cboHistory.Text ) &&
                      Directory.Exists( cboHistory.Text ) )
                 {
                     btnMove.Enabled = true;
                 }
                 btnDelete.Enabled = true;
             }
             else
             {
                 btnMove.Enabled = false;
                 btnDelete.Enabled = false;
             }
         }
         
         private void SetAllButtonState( bool enabled )
         {
             btnMove.Enabled = enabled;
             btnDelete.Enabled = enabled;
             btnAddFile.Enabled = enabled;
             btnRemoveFile.Enabled = enabled;
             btnDirUp.Enabled = enabled;
             btnSelectDestination.Enabled = enabled;
             cboHistory.Enabled = enabled;
         }
 
         #region Eventhandler für das Zielverzeichnis-Feld
 
         private void btnDirUp_Click( object sender, EventArgs e )
         {
             int index = cboHistory.Text.LastIndexOf( Path.DirectorySeparatorChar );
             if ( index > 0 )
             {
                 SetDestinationDirPath( cboHistory.Text.Substring( 0, index ) );
             }
         }
 
         private void txtDestDir_KeyUp( object sender, KeyEventArgs e )
         {
 
         }
 
         private void txtDestDir_MouseDoubleClick( object sender, MouseEventArgs e )
         {
             switch ( e.Button )
             {
                 case MouseButtons.Right:
                     NativeMethods.ShellExecute( 0, "open", cboHistory.Text, "", "", 5 );
                     break;
             }
         }
 
         #endregion
 
         #region Eventhandler für Drag&Drop
 
         private void lviFiles_DragDrop( object sender, DragEventArgs e )
         {
             if ( e.Data.GetDataPresent( DataFormats.FileDrop ) )
             {
                 try
                 {
                     string[] files = ( string[] )e.Data.GetData( DataFormats.FileDrop );
                     AddItemsToListView( files );
                 }
                 catch ( Exception ex )
                 {
                     ShowBalloonTipText( ex.Message, 2 );
                     return;
                 }
             }
         }
 
         private void lviFiles_DragEnter( object sender, DragEventArgs e )
         {
             if ( e.Data.GetDataPresent( DataFormats.FileDrop ) )
             {
                 e.Effect = DragDropEffects.Copy;
             }
         }
 
         #endregion
 
         #region Handling der Combobox
 
         private void cboHistory_Leave( object sender, EventArgs e )
         {
             cboHistory_KeyUp( sender, new KeyEventArgs( Keys.Enter ) );
         }
 
         private void cboHistory_KeyUp( object sender, KeyEventArgs e )
         {
             switch ( e.KeyCode )
             {
                 case Keys.Enter:
                     SetDestinationDirPath( cboHistory.Text );
                     break;
 
                 case Keys.Escape:
                     SetDestinationDirPath( startDir );
                     break;
             }
         }
 
         private void cboHistory_DragEnter( object sender, DragEventArgs e )
         {
             if ( e.Data.GetDataPresent( DataFormats.FileDrop ) )
             {
                 e.Effect = DragDropEffects.Copy;
             }
         }
 
         private void cboHistory_DragDrop( object sender, DragEventArgs e )
         {
             if ( e.Data.GetDataPresent( DataFormats.FileDrop ) )
             {
                 try
                 {
                     string[] files = ( string[] )e.Data.GetData( DataFormats.FileDrop );
                     string path = files.FirstOrDefault();
                     if ( !Directory.Exists( path ) )
                     {
                         path = Path.GetDirectoryName( files.FirstOrDefault() );
                     }
                     SetDestinationDirPath( path );
                 }
                 catch ( Exception ex )
                 {
                     MessageBox.Show( ex.Message, "Fehler" );
                     return;
                 }
             }
         }
 
         private void cboHistory_DropDown( object sender, EventArgs e )
         {
             cboHistory.Items.Clear();
             cboHistory.Items.AddRange( destinationDirHistory.Entrys.Where( x => !string.IsNullOrWhiteSpace( x ) ).ToArray() );
         }
 
         private void cboHistory_SelectedIndexChanged( object sender, EventArgs e )
         {
             string path = ( string )cboHistory.SelectedItem;
 
             if ( !string.IsNullOrWhiteSpace( path ) )
             {
                 SetDestinationDirPath( path );
             }
         }
 
         #endregion
 
         #region Handling des BackgroundWorkers
 
         private void bgwWorker_DoWork( object sender, System.ComponentModel.DoWorkEventArgs e )
         {
             WorkerParams param = ( WorkerParams )e.Argument;
             if ( pendingFiles != null && param.Action != WorkerAction.None )
             {
                 // Statusbar zurücksetzen
                 int currentProgress = 0;
                 int errorCount = 0;
 
                 List<RawFile> removeFiles = new List<RawFile>();
 
                 // Dateien verschieben
                 foreach ( RawFile dng in pendingFiles )
                 {
                     try
                     {
                         switch ( param.Action )
                         {
                             case WorkerAction.Move:
                                 dng.Move( param.DestinationDir );
                                 break;
                             case WorkerAction.Delete:
                                 dng.Delete();
                                 break;
                         }
                         removeFiles.Add( dng );
                     }
                     catch ( Exception ex )
                     {
                         errorCount++;
                         string exceptionText = ex.Message;
                         // TODO: ExceptionText is too long for the status label
                         //statusLabel.Text = exceptionText;
                         ShowBalloonTipText( exceptionText, 2 );
                     }
                     currentProgress++;
                     bgwWorker.ReportProgress( currentProgress );
                 }
 
                 foreach ( RawFile dng in removeFiles )
                 {
                     pendingFiles.Remove( dng );
                 }
 
                 string okText = string.Empty;
                 string errorText = string.Empty;
                 switch ( param.Action )
                 {
                     case WorkerAction.None:
                         break;
                     case WorkerAction.Move:
                         okText = string.Format("Alle {0} Bilder verschoben.", currentProgress );
                         errorText = string.Format( "Von {0} Bildern konnten {1} nicht verschoben werden.", currentProgress, errorCount );
                         break;
                     case WorkerAction.Delete:
                         okText = string.Format( "Alle {0} Bilder gelöscht.", currentProgress );
                         errorText = string.Format("Von {0} Bildern konnten {1} nicht gelöscht werden.", currentProgress, errorCount );
                         break;
                 }
 
                 if ( errorCount == 0 )
                 {
                     statusLabel.Text = okText;
                     ShowBalloonTipText(okText, 1);
                 }
                 else
                 {
                     statusLabel.Text = errorText;
                     ShowBalloonTipText( errorText, 1 );
                 }
             }
         }
 
         private void bgwWorker_ProgressChanged( object sender, System.ComponentModel.ProgressChangedEventArgs e )
         {
             statusProgress.Value = e.ProgressPercentage;
             statusCounter.Text = string.Format( "Datei {0} von {1}", e.ProgressPercentage, statusProgress.Maximum );
         }
 
         private void bgwWorker_RunWorkerCompleted( object sender, System.ComponentModel.RunWorkerCompletedEventArgs e )
         {
             statusProgress.Value = 0;
             statusCounter.Text = string.Empty;
             UpdateListView(false);
             SetAllButtonState( true );
             SetActionButtonState();
         }
 
         #endregion
 
         private void btnAbout_Click( object sender, EventArgs e )
         {
             new About().ShowDialog();
         }
 
         private void btnSettings_Click( object sender, EventArgs e )
         {
             if ( new SettingsForm().ShowDialog() == DialogResult.OK )
             {
                 TopMost = Settings.Default.WindowTopMost;
             }
         }
 
         #region Eventhandler fürs TrayIcon
 
         private void trayIcon_DoubleClick( object sender, EventArgs e )
         {
             ToogleVisibility();
         }
 
         #endregion
 
         private void beendenItem_Click( object sender, EventArgs e )
         {
             Close();
         }
 
         private void toogleWindowItem_Click( object sender, EventArgs e )
         {
             ToogleVisibility();
         }
 
         private void ToogleVisibility()
         {
             if ( Visible )
             {
                 Hide();
             }
             else
             {
                 Show();
             }
         }
     }
 }