On Mar 28, 12:25 pm, adamr...@microsoft.com wrote:

I'm sorry, I'm rusty with Timers... My previous post is valid if you
are going to use that specific Timer, but the
System.Windows.Forms.Timer class does the Invoke for you! So using
that class would clean up your code a bit. Check out this article for
in-depth explanations of the differences of the Timer classes in .NET:

http://msdn2.microsoft.com/en-us/magazine/cc164015.aspx

On Mar 29, 1:02 am, "Peter Duniho" <NpOeStPe...@nnowslpianmk.com>
wrote:

Hi Arthur
Its good if you already know about the BeginInvoke() method.
Anyways i'll illustrate it again along with the BackgroundWorker.

I'll use an example here. Suppose you have an applilcation where
the user can chose any image folder from disk and the app will
display
the thumbnails of those images one by one. Now thumbnail generation
is a relatively slow procedure and if the operation is carried out on
the
UI thread, the app will hang and will go to the NOT RESPONDING state.

The correct way to do this would be :
After the user selects a folder from the disk (using a folderDialog
dialog)
1. Get the list of image files which will be a string array of file
paths and
   start a background thread to generate the thumbnail of the image.
2. Report the serial no. of file being processed to the main form from
within
   the background thread by raising the ProgressChanged event.
3. Handle the ProgressChanged event of the background thread and then
   call BeginInvoke to execute the method which actually displays the
progress
   but runs on the UI thread.

I made a small application and its working fine. I don't know how to
upload
files here so i'll copy paste the code.
Its a simple thumbnail browser. Create a new windows application and
1. Label with Text = "Folder Path"
2. TextBox with name "txtFolderPath"
3. Button Text = "Browse" Name = "btnBrowse"
4. Button Text = "Generate Thumbnails" Name = "btnGenerate"
5. Button Text = "Clear Thumbnails" Name = "btnClear"
6. A FlowLayoutPanel
7. A StatusBar and add a StatusLabel and a ProgressBar to it.

Here's the code

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace ThumbnailBrowser
{
   public partial class Form1 : Form
   {
       public Form1()
       {
           InitializeComponent();
       }

       private BackgroundWorker bgWorker = new BackgroundWorker();

       private void btnBrowse_Click(object sender, EventArgs e)
       {
           using (FolderBrowserDialog fbd = new
FolderBrowserDialog())
           {
               fbd.ShowNewFolderButton = false;
               if (fbd.ShowDialog() == DialogResult.OK)
               {
                   txtFolderPath.Text = fbd.SelectedPath;
               }
           }
       }

       private void btnGenerate_Click(object sender, EventArgs e)
       {
           try
           {
               string[] sImageFiles =
System.IO.Directory.GetFiles(txtFolderPath.Text, "*.jpg");
               if (sImageFiles != null && sImageFiles.Length > 0)
               {
                   bgWorker.DoWork += new
DoWorkEventHandler(bgWorker_GenerateThumbnails);
                   bgWorker.ProgressChanged += new
ProgressChangedEventHandler(bgWorker_ProgressChanged);
                   bgWorker.WorkerReportsProgress = true;
                   bgWorker.WorkerSupportsCancellation = true;

bgWorker.RunWorkerAsync(sImageFiles);
               }
           }
           catch (Exception exp)
           {
               MessageBox.Show(exp.Message, "Error");
           }
       }

       public delegate void
UpdateStatusAndAppendThumbnailDelegate(ProgressChangedEventArgs
e);

       private void bgWorker_ProgressChanged(object sender,
ProgressChangedEventArgs e)
       {
           object[] oArgs = new object[] { e };
           this.BeginInvoke(new
UpdateStatusAndAppendThumbnailDelegate(UpdateStatusAndAppendThumbnail),
oArgs);
       }

       private void
UpdateStatusAndAppendThumbnail(ProgressChangedEventArgs e)
       {
           toolStripProgressBar1.Value = e.ProgressPercentage;
           toolStripStatusLabel1.Text =
e.ProgressPercentage.ToString() + " % complete.";
           AppendThumbnail((Image)e.UserState);
       }

       private void AppendThumbnail(Image thumbnail)
       {
           PictureBox pb = new PictureBox();
           pb.SizeMode = PictureBoxSizeMode.Zoom;
           pb.Image = thumbnail;
           this.flowLayoutPanel1.Controls.Add(pb);
       }

       public bool ThumbnailCallback()
       {
           return false;
       }

       private void bgWorker_GenerateThumbnails(object sender,
DoWorkEventArgs e)
       {
           try
           {
               BackgroundWorker currBgWorker = sender as
BackgroundWorker;
               Size szContentSize = new Size(170, 170);
               string[] sImageFiles = (string[])e.Argument;
               int i = 0;
               int iTotal = sImageFiles.Length;
               foreach (string sFile in sImageFiles)
               {
                   i++;
                   Image img = null;
                   img = Image.FromFile(sFile);

                   // Determine scaling for new rectangle:
                   double xScale = (1.0 * img.Width) /
szContentSize.Width;
                   double yScale = (1.0 * img.Height) /
szContentSize.Height;
                   Rectangle destRect;
                   if (xScale > yScale)
                   {
                       if (img.Height / xScale <
szContentSize.Height)
                       {
                           destRect = new Rectangle(0, 0, (int)
(img.Width / xScale), (int)(img.Height / xScale));
                       }
                       else
                       {
                           destRect = new Rectangle(0, 0, (int)
(img.Width / yScale), (int)(img.Height / yScale));
                       }
                   }
                   else
                   {
                       if (img.Width / yScale < szContentSize.Width)
                       {
                           destRect = new Rectangle(0, 0, (int)
(img.Width / yScale), (int)(img.Height / yScale));
                       }
                       else
                       {
                           destRect = new Rectangle(0, 0, (int)
(img.Width / xScale), (int)(img.Height / xScale));
                       }
                   }
                   Size szThumbnailSize = destRect.Size;
                   Image.GetThumbnailImageAbort myCallback = new
Image.GetThumbnailImageAbort(ThumbnailCallback);
                   Image imgThumbnail = img.GetThumbnailImage(
                       szThumbnailSize.Width,
                       szThumbnailSize.Height,
                       myCallback,
                       IntPtr.Zero);
                   object[] oArgs = new object[] { imgThumbnail };
                   int iProgressPercent = (i*100)/iTotal;
                   currBgWorker.ReportProgress(iProgressPercent,
imgThumbnail);
               }
           }
           catch (Exception exp)
           {
               MessageBox.Show(exp.Message, "Error");
           }
       }

       private void btnClear_Click(object sender, EventArgs e)
       {
           foreach (Control ctl in this.flowLayoutPanel1.Controls)
           {
               ctl.Dispose();
           }
           this.flowLayoutPanel1.Controls.Clear();
       }
   }
}

This is working fine.
You can add handlers to cancel the generation of thumbnails and
some other code to prevent the user from clicking the Generate
Thumbnail
button when one operation is already in progress.

Regards
Prateek Raman