Changeset 1128


Ignore:
Timestamp:
Feb 2, 2010, 4:32:15 PM (12 years ago)
Author:
pretzsch
Message:

o FIX FileInput: Resolved threading error by using dispatcher

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/FileInput/WindowsFormsUserControl/HexBoxContainer.cs

    r4 r1128  
    217217using System.Threading;
    218218using System.Runtime.Remoting.Messaging;
     219using System.Windows.Threading;
    219220
    220221
     
    222223{
    223224
    224   public partial class HexBoxContainer : UserControl
    225   {
    226     public event PluginProgressChangedEventHandler OnStatusBarProgressbarValueChanged;   
    227     public event ExceptionOccured OnExceptionOccured;
    228     public event InformationOccured OnInformationOccured;
    229     public event SelectionChanged OnSelectionChanged;
    230     public event FileOpened OnFileOpened;
    231     public event FileClosed OnFileClosed;
    232 
    233     byte[] _findBuffer = new byte[0];
    234     string _fileName;
    235 
    236     public HexBoxContainer()
     225    public partial class HexBoxContainer : UserControl
    237226    {
    238       InitializeComponent();
    239       Init();           
     227        public event PluginProgressChangedEventHandler OnStatusBarProgressbarValueChanged;
     228        public event ExceptionOccured OnExceptionOccured;
     229        public event InformationOccured OnInformationOccured;
     230        public event SelectionChanged OnSelectionChanged;
     231        public event FileOpened OnFileOpened;
     232        public event FileClosed OnFileClosed;
     233
     234        byte[] _findBuffer = new byte[0];
     235        string _fileName;
     236
     237        public HexBoxContainer()
     238        {
     239            InitializeComponent();
     240            Init();
     241        }
     242
     243        public void SetSize(System.Windows.Size size)
     244        {
     245            this.Width = System.Convert.ToInt32(size.Width);
     246            this.Height = System.Convert.ToInt32(size.Height);
     247        }
     248
     249        void hexBox_SelectionLengthChanged(object sender, EventArgs e)
     250        {
     251            if (OnSelectionChanged != null) OnSelectionChanged(this);
     252            UpdateFileSizeStatus();
     253        }
     254
     255        /// <summary>
     256        /// Initializes the hex editor´s main form
     257        /// </summary>
     258        void Init()
     259        {
     260            hexBox.SelectionLengthChanged += new EventHandler(hexBox_SelectionLengthChanged);
     261            hexBox.OnStatusBarProgressbarValueChanged += hexBox_OnStatusBarProgressbarValueChanged;
     262            DisplayText(null);
     263            newFileName =
     264              Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) +
     265              @"\CryptoolAnotherEditor.cte";
     266        }
     267
     268        void hexBox_OnStatusBarProgressbarValueChanged(object sender, PluginProgressEventArgs args)
     269        {
     270            if (this.OnStatusBarProgressbarValueChanged != null)
     271                OnStatusBarProgressbarValueChanged(null, args);
     272        }
     273
     274        /// <summary>
     275        /// Updates the File size status label
     276        /// </summary>
     277        void UpdateFileSizeStatus()
     278        {
     279            if (this.hexBox.ByteProvider == null)
     280                this.toolStripStatusLblFileSieze.Text = string.Empty;
     281            else
     282                this.toolStripStatusLblFileSieze.Text = Util.GetDisplayBytes(this.hexBox.ByteProvider.Length);
     283
     284            if (this._fileName != null)
     285                this.toolStripStatusLblFile.Text = _fileName;
     286            else
     287                this.toolStripStatusLblFile.Text = string.Empty;
     288
     289            if (_fileName != null && IsReadOnly) toolStripStatusLblFile.Text += " (readonly)";
     290        }
     291
     292        /// <summary>
     293        /// Displays the file name in the Form´s text property
     294        /// </summary>
     295        /// <param name="fileName">the file name to display</param>
     296        void DisplayText(string fileName)
     297        {
     298            if (fileName != null && fileName.Length > 0)
     299            {
     300                string text = Path.GetFileName(fileName);
     301                this.Text = string.Format("{0} - Be.HexEditor", text);
     302            }
     303            else
     304            {
     305                this.Text = "Be.HexEditor";
     306            }
     307        }
     308
     309        public string FileName
     310        {
     311            get { return _fileName; }
     312        }
     313
     314        public bool CanSave
     315        {
     316            get { return true; }
     317        }
     318
     319        public bool CanClose
     320        {
     321            get { return _fileName != null && _fileName != string.Empty; }
     322        }
     323
     324        public bool CanCopy
     325        {
     326            get { return hexBox.CanCopy(); }
     327        }
     328
     329        public bool CanCut
     330        {
     331            get { return hexBox.CanCut(); }
     332        }
     333
     334        public bool CanPaste
     335        {
     336            get { return hexBox.CanPaste(); }
     337        }
     338
     339        public bool CanFind
     340        {
     341            get { return CanClose; }
     342        }
     343
     344        private bool canCancel;
     345        public bool CanCancel
     346        {
     347            get { return canCancel; }
     348        }
     349
     350        private string newFileName;
     351        public string NewFile()
     352        {
     353            if (CanClose) CloseFile();
     354            FileStream fs = null;
     355            try
     356            {
     357                fs = new FileStream(newFileName, FileMode.Create);
     358                fs.Close();
     359                OpenFile(newFileName, false);
     360                SaveFile();
     361                return _fileName;
     362            }
     363            catch (Exception exception)
     364            {
     365                if (OnExceptionOccured != null)
     366                    OnExceptionOccured(this, exception);
     367                return null;
     368            }
     369        }
     370
     371        delegate void VoidDelegate();
     372
     373        /// <summary>
     374        /// Opens a file.
     375        /// </summary>
     376        /// <param name="fileName">the file name of the file to open</param>
     377        public void OpenFile(string fileName, bool openReadOnly)
     378        {
     379            hexBox.Invoke(new VoidDelegate(delegate
     380            {
     381                OpenFileImpl(fileName, openReadOnly);
     382            }), null);
     383        }
     384
     385        public void OpenFileImpl(string fileName, bool openReadOnly)
     386        {
     387            if (fileName == null || !File.Exists(fileName))
     388            {
     389                ExceptionOccured(new Exception("File not found."));
     390            }
     391
     392            if (hexBox.ByteProvider != null)
     393            {
     394                if (CloseFile() == DialogResult.Cancel)
     395                    return;
     396            }
     397
     398            try
     399            {
     400                DynamicFileByteProvider dynamicFileByteProvider = null;
     401                try
     402                {
     403                    // dummy exception to force read-only mode
     404                    if (openReadOnly) throw new IOException();
     405                    // try to open in write mode
     406                    dynamicFileByteProvider = new DynamicFileByteProvider(fileName);
     407                    IsReadOnly = false;
     408                    // dynamicFileByteProvider.Changed += new EventHandler(byteProvider_Changed);
     409                    // dynamicFileByteProvider.LengthChanged += new EventHandler(byteProvider_LengthChanged);
     410                }
     411                catch (IOException) // write mode failed
     412                {
     413                    try
     414                    {
     415                        // try to open in read-only mode
     416                        dynamicFileByteProvider = new DynamicFileByteProvider(fileName, true);
     417                        IsReadOnly = true;
     418                        // dynamicFileByteProvider.Dispose();
     419                        // return;
     420                    }
     421                    catch (IOException ioexception) // read-only also failed
     422                    {
     423                        // IsReadOnly = false;
     424                        if (OnExceptionOccured != null)
     425                        {
     426                            // OnExceptionOccured(this, ioexception);
     427                            OnExceptionOccured(this, ioexception);
     428                        }
     429                    }
     430                }
     431
     432                hexBox.ByteProvider = dynamicFileByteProvider;
     433                _fileName = fileName;
     434
     435                DisplayText(null);
     436
     437                UpdateFileSizeStatus();
     438                if (OnFileOpened != null) OnFileOpened(this, new FileOpendedEventArgs(fileName));
     439            }
     440            catch (Exception exception)
     441            {
     442                if (OnExceptionOccured != null)
     443                {
     444                    OnExceptionOccured(this, exception);
     445                }
     446            }
     447            finally
     448            {
     449
     450            }
     451        }
     452
     453        private bool isReadOnly;
     454        public bool IsReadOnly
     455        {
     456            get { return isReadOnly; }
     457            set { isReadOnly = value; }
     458        }
     459
     460
     461        /// <summary>
     462        /// Saves the current file.
     463        /// </summary>
     464        public void SaveFile()
     465        {
     466            if (hexBox.ByteProvider == null)
     467                return;
     468
     469            try
     470            {
     471                FileByteProvider fileByteProvider = hexBox.ByteProvider as FileByteProvider;
     472                DynamicByteProvider dynamicByteProvider = hexBox.ByteProvider as DynamicByteProvider;
     473                DynamicFileByteProvider dynamicFileByteProvider = hexBox.ByteProvider as DynamicFileByteProvider;
     474                if (fileByteProvider != null)
     475                {
     476                    fileByteProvider.ApplyChanges();
     477                }
     478                else if (dynamicFileByteProvider != null)
     479                {
     480                    dynamicFileByteProvider.ApplyChanges();
     481                }
     482                else if (dynamicByteProvider != null)
     483                {
     484                    byte[] data = dynamicByteProvider.Bytes.ToArray();
     485                    using (FileStream stream = File.Open(_fileName, FileMode.Create, FileAccess.Write, FileShare.Read))
     486                    {
     487                        stream.Write(data, 0, data.Length);
     488                    }
     489                    dynamicByteProvider.ApplyChanges();
     490                }
     491            }
     492            catch (Exception ex1)
     493            {
     494                if (OnExceptionOccured != null)
     495                {
     496                    OnExceptionOccured(this, ex1);
     497                }
     498            }
     499            finally
     500            {
     501                if (_fileName == newFileName)
     502                {
     503                    string target = FileHelper.SaveFile();
     504                    if (target != null && target != string.Empty)
     505                    {
     506                        CleanUp();
     507                        try
     508                        {
     509                            if (File.Exists(target)) File.Delete(target);
     510                            File.Move(newFileName, target);
     511                            OpenFile(target, false);
     512                        }
     513                        catch (Exception exception)
     514                        {
     515                            if (OnExceptionOccured != null)
     516                            {
     517                                OnExceptionOccured(this, exception);
     518                            }
     519                        }
     520                        finally
     521                        {
     522                            if (File.Exists(newFileName)) File.Delete(newFileName);
     523                        }
     524                    }
     525                }
     526            }
     527        }
     528
     529        /// <summary>
     530        /// Closes the current file
     531        /// </summary>
     532        /// <returns>OK, if the current file was closed.</returns>
     533        public DialogResult CloseFile()
     534        {
     535            if (hexBox.ByteProvider == null)
     536                return DialogResult.OK;
     537
     538            try
     539            {
     540                if (CanCancel) hexBox.AbortFind();
     541                if (hexBox.ByteProvider != null && hexBox.ByteProvider.HasChanges() && _fileName != newFileName)
     542                {
     543                    DialogResult res = MessageBox.Show("Do you want to save changes?",
     544                      "FileInput",
     545                      MessageBoxButtons.YesNoCancel,
     546                      MessageBoxIcon.Warning);
     547
     548                    if (res == DialogResult.Yes)
     549                    {
     550                        SaveFile();
     551                        CleanUp();
     552                    }
     553                    else if (res == DialogResult.No)
     554                    {
     555                        CleanUp();
     556                    }
     557                    else if (res == DialogResult.Cancel)
     558                    {
     559                        return res;
     560                    }
     561                    UpdateFileSizeStatus();
     562                    if (res != DialogResult.Cancel && OnFileClosed != null) OnFileClosed(this);
     563
     564                    return res;
     565                }
     566                else
     567                {
     568                    CleanUp();
     569                    return DialogResult.OK;
     570                }
     571            }
     572            catch (Exception exception)
     573            {
     574                return DialogResult.Cancel;
     575            }
     576        }
     577
     578        void CleanUp()
     579        {
     580            if (hexBox.ByteProvider != null)
     581            {
     582                IDisposable byteProvider = hexBox.ByteProvider as IDisposable;
     583                if (byteProvider != null)
     584                    byteProvider.Dispose();
     585                hexBox.ByteProvider = null;
     586            }
     587            _fileName = null;
     588            DisplayText(null);
     589        }
     590
     591        public void AbortFind()
     592        {
     593            // sould result in quit search => bgworker returns
     594            hexBox.AbortFind();
     595
     596            // wait for abort     
     597            while (CanCancel)
     598            {
     599                // Console.WriteLine("Sleeping 10");       
     600                Thread.Sleep(10);
     601            }
     602        }
     603
     604        public void Find(string value)
     605        {
     606            if (value != null)
     607            {
     608                if (OnInformationOccured != null) OnInformationOccured(this, new Exception("Searching for: " + value));
     609                _findBuffer = System.Text.ASCIIEncoding.ASCII.GetBytes(value);
     610                if (CanCancel) AbortFind();
     611                FindNext();
     612            }
     613        }
     614
     615        private BackgroundWorker bgWorker = null;
     616
     617        /// <summary>
     618        /// Find next match
     619        /// </summary>
     620        void FindNext()
     621        {
     622            if (_findBuffer.Length == 0)
     623            {
     624                // Find();
     625                return;
     626            }
     627
     628            canCancel = true;
     629            findResult = long.MinValue;
     630            FindDelegate fd = new FindDelegate(FindInvoke);
     631            AsyncCallback ac = new AsyncCallback(FindCallbackMethod);
     632            IAsyncResult ar = fd.BeginInvoke(_findBuffer, hexBox.SelectionStart + hexBox.SelectionLength, ac, null);
     633        }
     634
     635
     636        private delegate void HexBoxFocusDelegate();
     637        private delegate object FindDelegate(byte[] findBuffer, long range);
     638        private long findResult;
     639
     640        private object FindInvoke(byte[] findBuffer, long range)
     641        {
     642            // return hexBox.Find(findBuffer, range);
     643            findResult = hexBox.Find(findBuffer, range);
     644            return findResult;
     645        }
     646
     647        private void FindCallbackMethod(IAsyncResult result)
     648        {
     649            canCancel = false;
     650            try
     651            {
     652                long res = findResult;
     653                // res = (long)e.Result;
     654
     655                if (res == -1) // -1 = no match
     656                {
     657                    if (OnInformationOccured != null) OnInformationOccured(this, new Exception("Search reached end of file."));
     658                }
     659                else if (res == -2) // -2 = find was aborted
     660                {
     661                    if (OnInformationOccured != null) OnInformationOccured(this, new Exception("Search aborted."));
     662                    return;
     663                }
     664                else // something was found
     665                {
     666                    // if (!hexBox.Focused)
     667                    // hexBox.Focus();
     668                    HexBoxFocusDelegate hexBoxFocusDelegate = delegate()
     669                    {
     670                        if (!hexBox.Focused) hexBox.Focus();
     671                    };
     672                    hexBox.Invoke(hexBoxFocusDelegate);
     673                    if (OnInformationOccured != null) OnInformationOccured(this, new Exception("Found on position: " + res.ToString()));
     674                }
     675            }
     676            catch (Exception exception)
     677            {
     678                if (OnExceptionOccured != null) OnExceptionOccured(this, exception);
     679            }
     680        }
     681
     682
     683
     684        /// <summary>
     685        /// Aborts the current find process
     686        /// </summary>
     687        void FormFindCancel_Closed(object sender, System.EventArgs e)
     688        {
     689            hexBox.AbortFind();
     690        }
     691
     692        /// <summary>
     693        /// Put focus back to the cancel form.
     694        /// </summary>
     695        void FocusToFormFindCancel(object sender, System.EventArgs e)
     696        {
     697            // _formFindCancel.Focus();
     698        }
     699
     700        ///<summary>
     701        ///Displays the goto byte dialog.
     702        ///</summary>
     703        void Goto()
     704        {
     705            //_formGoto.SetMaxByteIndex(hexBox.ByteProvider.Length);
     706            //_formGoto.SetDefaultValue(hexBox.SelectionStart);
     707            //if (_formGoto.ShowDialog() == DialogResult.OK)
     708            //{
     709            //  hexBox.SelectionStart = _formGoto.GetByteIndex();
     710            //  hexBox.SelectionLength = 1;
     711            //  hexBox.Focus();
     712            //}
     713        }
     714
     715        /// <summary>
     716        /// Enables drag&drop
     717        /// </summary>
     718        void hexBox_DragEnter(object sender, System.Windows.Forms.DragEventArgs e)
     719        {
     720            e.Effect = DragDropEffects.All;
     721        }
     722
     723        /// <summary>
     724        /// Processes a file drop
     725        /// </summary>
     726        void hexBox_DragDrop(object sender, System.Windows.Forms.DragEventArgs e)
     727        {
     728            string[] formats = e.Data.GetFormats();
     729            object oFileNames = e.Data.GetData(DataFormats.FileDrop);
     730            string[] fileNames = (string[])oFileNames;
     731            if (fileNames != null && fileNames.Length == 1)
     732            {
     733                OpenFile(fileNames[0], false);
     734            }
     735        }
     736
     737        void Position_Changed(object sender, System.EventArgs e)
     738        {
     739            // this.sbCharacterPosition.Text =
     740            toolStripLblCharPosition.Text = string.Format("Ln {0}    Col {1}",
     741              hexBox.CurrentLine, hexBox.CurrentPositionInLine);
     742        }
     743
     744        void FormHexEditor_Closing(object sender, System.ComponentModel.CancelEventArgs e)
     745        {
     746            if (CloseFile() == DialogResult.Cancel)
     747                e.Cancel = true;
     748        }
     749
     750
     751        public void Cut()
     752        {
     753            if (hexBox.CanCut()) hexBox.Cut();
     754        }
     755
     756        public void Copy()
     757        {
     758            hexBox.Copy();
     759        }
     760
     761        public void Paste()
     762        {
     763            hexBox.Paste();
     764        }
     765
     766        private void ExceptionOccured(Exception exception)
     767        {
     768            if (OnExceptionOccured != null)
     769                OnExceptionOccured(this, exception);
     770        }
     771
    240772    }
    241 
    242     public void SetSize(System.Windows.Size size)
    243     {
    244       this.Width = System.Convert.ToInt32(size.Width);
    245       this.Height = System.Convert.ToInt32(size.Height);
    246     }
    247 
    248     void hexBox_SelectionLengthChanged(object sender, EventArgs e)
    249     {
    250       if (OnSelectionChanged != null) OnSelectionChanged(this);
    251       UpdateFileSizeStatus();
    252     }
    253 
    254     /// <summary>
    255     /// Initializes the hex editor´s main form
    256     /// </summary>
    257     void Init()
    258     {
    259       hexBox.SelectionLengthChanged += new EventHandler(hexBox_SelectionLengthChanged);
    260       hexBox.OnStatusBarProgressbarValueChanged += hexBox_OnStatusBarProgressbarValueChanged;
    261       DisplayText(null);
    262       newFileName =
    263         Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) +
    264         @"\CryptoolAnotherEditor.cte";     
    265     }
    266 
    267     void hexBox_OnStatusBarProgressbarValueChanged(object sender, PluginProgressEventArgs args)
    268     {
    269       if (this.OnStatusBarProgressbarValueChanged != null)
    270         OnStatusBarProgressbarValueChanged(null, args);
    271     }
    272 
    273     /// <summary>
    274     /// Updates the File size status label
    275     /// </summary>
    276     void UpdateFileSizeStatus()
    277     {
    278       if (this.hexBox.ByteProvider == null)
    279         this.toolStripStatusLblFileSieze.Text = string.Empty;
    280       else
    281         this.toolStripStatusLblFileSieze.Text = Util.GetDisplayBytes(this.hexBox.ByteProvider.Length);
    282 
    283       if (this._fileName != null)
    284         this.toolStripStatusLblFile.Text = _fileName;
    285       else
    286         this.toolStripStatusLblFile.Text = string.Empty;
    287 
    288       if (_fileName != null && IsReadOnly) toolStripStatusLblFile.Text += " (readonly)";
    289     }
    290 
    291     /// <summary>
    292     /// Displays the file name in the Form´s text property
    293     /// </summary>
    294     /// <param name="fileName">the file name to display</param>
    295     void DisplayText(string fileName)
    296     {
    297       if (fileName != null && fileName.Length > 0)
    298       {
    299         string text = Path.GetFileName(fileName);
    300         this.Text = string.Format("{0} - Be.HexEditor", text);
    301       }
    302       else
    303       {
    304         this.Text = "Be.HexEditor";
    305       }
    306     }
    307 
    308     public string FileName
    309     {
    310       get { return _fileName; }
    311     }
    312 
    313     public bool CanSave
    314     {
    315       get { return true; }
    316     }
    317 
    318     public bool CanClose
    319     {
    320       get { return _fileName != null && _fileName != string.Empty; }
    321     }
    322 
    323     public bool CanCopy
    324     {
    325       get { return hexBox.CanCopy(); }
    326     }
    327 
    328     public bool CanCut
    329     {
    330       get { return hexBox.CanCut(); }
    331     }
    332 
    333     public bool CanPaste
    334     {
    335       get { return hexBox.CanPaste(); }
    336     }
    337    
    338     public bool CanFind
    339     {
    340       get { return CanClose; }
    341     }
    342 
    343     private bool canCancel;
    344     public bool CanCancel
    345     {
    346       get { return canCancel; }     
    347     }
    348 
    349     private string newFileName;
    350     public string NewFile()
    351     {
    352       if (CanClose) CloseFile();
    353       FileStream fs = null;
    354       try
    355       {
    356         fs = new FileStream(newFileName, FileMode.Create);
    357         fs.Close();
    358         OpenFile(newFileName, false);
    359         SaveFile();
    360         return _fileName;
    361       }
    362       catch (Exception exception)
    363       {
    364         if (OnExceptionOccured != null)
    365           OnExceptionOccured(this, exception);
    366         return null;
    367       }
    368     }
    369 
    370     /// <summary>
    371     /// Opens a file.
    372     /// </summary>
    373     /// <param name="fileName">the file name of the file to open</param>
    374     public void OpenFile(string fileName, bool openReadOnly)
    375     {
    376       if (fileName == null || !File.Exists(fileName))
    377       {
    378         ExceptionOccured(new Exception("File not found."));
    379       }
    380 
    381       if (hexBox.ByteProvider != null)
    382       {
    383         if (CloseFile() == DialogResult.Cancel)
    384           return;
    385       }
    386 
    387       try
    388       {
    389         DynamicFileByteProvider dynamicFileByteProvider = null;
    390         try
    391         {
    392           // dummy exception to force read-only mode
    393           if (openReadOnly) throw new IOException();
    394           // try to open in write mode
    395           dynamicFileByteProvider = new DynamicFileByteProvider(fileName);
    396           IsReadOnly = false;
    397           // dynamicFileByteProvider.Changed += new EventHandler(byteProvider_Changed);
    398           // dynamicFileByteProvider.LengthChanged += new EventHandler(byteProvider_LengthChanged);
    399         }
    400         catch (IOException) // write mode failed
    401         {
    402           try
    403           {
    404             // try to open in read-only mode
    405             dynamicFileByteProvider = new DynamicFileByteProvider(fileName, true);
    406             IsReadOnly = true;
    407             // dynamicFileByteProvider.Dispose();
    408             // return;
    409           }
    410           catch (IOException ioexception) // read-only also failed
    411           {
    412             // IsReadOnly = false;
    413             if (OnExceptionOccured != null)
    414             {
    415               // OnExceptionOccured(this, ioexception);
    416               OnExceptionOccured(this, ioexception);             
    417             }
    418           }
    419         }
    420        
    421         hexBox.ByteProvider = dynamicFileByteProvider;
    422         _fileName = fileName;
    423 
    424         DisplayText(null);
    425 
    426         UpdateFileSizeStatus();
    427         if (OnFileOpened != null) OnFileOpened(this, new FileOpendedEventArgs(fileName));
    428       }
    429       catch (Exception exception)
    430       {
    431         if (OnExceptionOccured != null)
    432         {
    433           OnExceptionOccured(this, exception);
    434         }
    435       }
    436       finally
    437       {
    438 
    439       }
    440     }
    441 
    442     private bool isReadOnly;
    443     public bool IsReadOnly
    444     {
    445       get { return isReadOnly; }
    446       set { isReadOnly = value; }
    447     }
    448 
    449 
    450     /// <summary>
    451     /// Saves the current file.
    452     /// </summary>
    453     public void SaveFile()
    454     {
    455       if (hexBox.ByteProvider == null)
    456         return;
    457 
    458       try
    459       {
    460         FileByteProvider fileByteProvider = hexBox.ByteProvider as FileByteProvider;
    461         DynamicByteProvider dynamicByteProvider = hexBox.ByteProvider as DynamicByteProvider;
    462         DynamicFileByteProvider dynamicFileByteProvider = hexBox.ByteProvider as DynamicFileByteProvider;
    463         if (fileByteProvider != null)
    464         {
    465           fileByteProvider.ApplyChanges();
    466         }
    467         else if (dynamicFileByteProvider != null)
    468         {
    469           dynamicFileByteProvider.ApplyChanges();
    470         }
    471         else if (dynamicByteProvider != null)
    472         {
    473           byte[] data = dynamicByteProvider.Bytes.ToArray();
    474           using (FileStream stream = File.Open(_fileName, FileMode.Create, FileAccess.Write, FileShare.Read))
    475           {
    476             stream.Write(data, 0, data.Length);
    477           }
    478           dynamicByteProvider.ApplyChanges();
    479         }
    480       }
    481       catch (Exception ex1)
    482       {
    483         if (OnExceptionOccured != null)
    484         {
    485           OnExceptionOccured(this, ex1);
    486         }
    487       }
    488       finally
    489       {
    490         if (_fileName == newFileName)
    491         {
    492           string target = FileHelper.SaveFile();
    493           if (target != null && target != string.Empty)
    494           {
    495             CleanUp();
    496             try
    497             {
    498               if (File.Exists(target)) File.Delete(target);
    499               File.Move(newFileName, target);
    500               OpenFile(target, false);
    501             }
    502             catch (Exception exception)
    503             {
    504               if (OnExceptionOccured != null)
    505               {
    506                 OnExceptionOccured(this, exception);
    507               }
    508             }
    509             finally
    510             {
    511               if (File.Exists(newFileName)) File.Delete(newFileName);
    512             }
    513           }
    514         }
    515       }
    516     }
    517 
    518     /// <summary>
    519     /// Closes the current file
    520     /// </summary>
    521     /// <returns>OK, if the current file was closed.</returns>
    522     public DialogResult CloseFile()
    523     {
    524       if (hexBox.ByteProvider == null)
    525         return DialogResult.OK;
    526 
    527       try
    528       {
    529         if (CanCancel) hexBox.AbortFind();
    530         if (hexBox.ByteProvider != null && hexBox.ByteProvider.HasChanges() && _fileName != newFileName)
    531         {
    532           DialogResult res = MessageBox.Show("Do you want to save changes?",
    533             "FileInput",
    534             MessageBoxButtons.YesNoCancel,
    535             MessageBoxIcon.Warning);
    536 
    537           if (res == DialogResult.Yes)
    538           {
    539             SaveFile();
    540             CleanUp();
    541           }
    542           else if (res == DialogResult.No)
    543           {
    544             CleanUp();
    545           }
    546           else if (res == DialogResult.Cancel)
    547           {
    548             return res;
    549           }
    550           UpdateFileSizeStatus();
    551           if (res != DialogResult.Cancel && OnFileClosed != null) OnFileClosed(this);
    552 
    553           return res;
    554         }
    555         else
    556         {
    557           CleanUp();
    558           return DialogResult.OK;
    559         }
    560       }
    561       catch (Exception exception)
    562       {
    563         return DialogResult.Cancel;
    564       }
    565     }
    566 
    567     void CleanUp()
    568     {
    569       if (hexBox.ByteProvider != null)
    570       {
    571         IDisposable byteProvider = hexBox.ByteProvider as IDisposable;
    572         if (byteProvider != null)
    573           byteProvider.Dispose();
    574         hexBox.ByteProvider = null;
    575       }
    576       _fileName = null;
    577       DisplayText(null);
    578     }
    579 
    580     public void AbortFind()
    581     {
    582       // sould result in quit search => bgworker returns
    583       hexBox.AbortFind();
    584 
    585       // wait for abort     
    586       while (CanCancel)
    587       {
    588         // Console.WriteLine("Sleeping 10");       
    589         Thread.Sleep(10);       
    590       }
    591     }
    592 
    593     public void Find(string value)
    594     {
    595       if (value != null)
    596       {
    597         if (OnInformationOccured != null) OnInformationOccured(this, new Exception("Searching for: " + value));
    598         _findBuffer = System.Text.ASCIIEncoding.ASCII.GetBytes(value);
    599         if (CanCancel) AbortFind();
    600         FindNext();
    601       }
    602     }
    603 
    604     private BackgroundWorker bgWorker = null;
    605 
    606     /// <summary>
    607     /// Find next match
    608     /// </summary>
    609     void FindNext()
    610     {
    611       if (_findBuffer.Length == 0)
    612       {
    613         // Find();
    614         return;
    615       }
    616 
    617       canCancel = true;
    618       findResult = long.MinValue;
    619       FindDelegate fd = new FindDelegate(FindInvoke);
    620       AsyncCallback ac = new AsyncCallback(FindCallbackMethod);
    621       IAsyncResult ar = fd.BeginInvoke(_findBuffer, hexBox.SelectionStart + hexBox.SelectionLength, ac, null);
    622     }
    623 
    624 
    625     private delegate void HexBoxFocusDelegate();
    626     private delegate object FindDelegate(byte[] findBuffer, long range);
    627     private long findResult;
    628 
    629     private object FindInvoke(byte[] findBuffer, long range)
    630     {
    631       // return hexBox.Find(findBuffer, range);
    632       findResult = hexBox.Find(findBuffer, range);
    633       return findResult;
    634     }
    635 
    636     private void FindCallbackMethod(IAsyncResult result)
    637     {
    638       canCancel = false;
    639       try
    640       {
    641         long res = findResult;
    642         // res = (long)e.Result;
    643 
    644         if (res == -1) // -1 = no match
    645         {
    646           if (OnInformationOccured != null) OnInformationOccured(this, new Exception("Search reached end of file."));
    647         }
    648         else if (res == -2) // -2 = find was aborted
    649         {
    650           if (OnInformationOccured != null) OnInformationOccured(this, new Exception("Search aborted."));
    651           return;
    652         }
    653         else // something was found
    654         {
    655           // if (!hexBox.Focused)
    656           // hexBox.Focus();
    657           HexBoxFocusDelegate hexBoxFocusDelegate = delegate()
    658           {
    659             if (!hexBox.Focused) hexBox.Focus();
    660           };         
    661           hexBox.Invoke(hexBoxFocusDelegate);
    662           if (OnInformationOccured != null) OnInformationOccured(this, new Exception("Found on position: " + res.ToString()));
    663         }
    664       }
    665       catch (Exception exception)
    666       {
    667         if (OnExceptionOccured != null) OnExceptionOccured(this, exception);
    668       }     
    669     }
    670 
    671    
    672 
    673     /// <summary>
    674     /// Aborts the current find process
    675     /// </summary>
    676     void FormFindCancel_Closed(object sender, System.EventArgs e)
    677     {
    678       hexBox.AbortFind();
    679     }
    680 
    681     /// <summary>
    682     /// Put focus back to the cancel form.
    683     /// </summary>
    684     void FocusToFormFindCancel(object sender, System.EventArgs e)
    685     {
    686       // _formFindCancel.Focus();
    687     }
    688 
    689     ///<summary>
    690     ///Displays the goto byte dialog.
    691     ///</summary>
    692     void Goto()
    693     {
    694       //_formGoto.SetMaxByteIndex(hexBox.ByteProvider.Length);
    695       //_formGoto.SetDefaultValue(hexBox.SelectionStart);
    696       //if (_formGoto.ShowDialog() == DialogResult.OK)
    697       //{
    698       //  hexBox.SelectionStart = _formGoto.GetByteIndex();
    699       //  hexBox.SelectionLength = 1;
    700       //  hexBox.Focus();
    701       //}
    702     }
    703 
    704     /// <summary>
    705     /// Enables drag&drop
    706     /// </summary>
    707     void hexBox_DragEnter(object sender, System.Windows.Forms.DragEventArgs e)
    708     {
    709       e.Effect = DragDropEffects.All;
    710     }
    711 
    712     /// <summary>
    713     /// Processes a file drop
    714     /// </summary>
    715     void hexBox_DragDrop(object sender, System.Windows.Forms.DragEventArgs e)
    716     {
    717       string[] formats = e.Data.GetFormats();
    718       object oFileNames = e.Data.GetData(DataFormats.FileDrop);
    719       string[] fileNames = (string[])oFileNames;
    720       if (fileNames != null && fileNames.Length == 1)
    721       {
    722         OpenFile(fileNames[0], false);
    723       }
    724     }
    725 
    726     void Position_Changed(object sender, System.EventArgs e)
    727     {
    728       // this.sbCharacterPosition.Text =
    729       toolStripLblCharPosition.Text = string.Format("Ln {0}    Col {1}",
    730         hexBox.CurrentLine, hexBox.CurrentPositionInLine);
    731     }
    732 
    733     void FormHexEditor_Closing(object sender, System.ComponentModel.CancelEventArgs e)
    734     {
    735       if (CloseFile() == DialogResult.Cancel)
    736         e.Cancel = true;
    737     }
    738 
    739 
    740     public void Cut()
    741     {
    742       if (hexBox.CanCut()) hexBox.Cut();
    743     }
    744 
    745     public void Copy()
    746     {
    747       hexBox.Copy();
    748     }
    749 
    750     public void Paste()
    751     {
    752       hexBox.Paste();
    753     }
    754 
    755     private void ExceptionOccured(Exception exception)
    756     {
    757       if (OnExceptionOccured != null)
    758         OnExceptionOccured(this, exception);
    759     }
    760 
    761   }
    762773}
Note: See TracChangeset for help on using the changeset viewer.