AStringList.Add(t.Item[x].Location);

Synchronize(
procedure
begin
  AStringList.Add(Form1.t.Item[x].Location);
end);

unit Unit1;
{$WARN SYMBOL_PLATFORM OFF}
{$WARN UNIT_PLATFORM OFF}

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
  System.Classes, Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs,
  imageenview, Vcl.ExtCtrls, iemio, ieview, iemview, Vcl.StdCtrls,
  Vcl.ComCtrls;

type

  { A TThread descendent for Loading an Image }
  TImageLoadingThread = class(TThread)
  private
    { Private declarations }
  protected
    { Protected declarations }
    procedure Execute; override;
  public
    { Public declarations }
    constructor Create(CreateSuspended: Boolean);
  end;

  TForm1 = class(TForm)
    ImageEnMView1: TImageEnMView;
    ImageEnMIO1: TImageEnMIO;
    Panel1: TPanel;
    Splitter1: TSplitter;
    ImageEnView1: TImageEnView;
    FillWithThread1: TButton;
    Folder1: TEdit;
    Browse1: TButton;
    FillFromFolder1: TButton;
    Fit1: TCheckBox;
    Clear1: TButton;
    StatusBar1: TStatusBar;
    procedure FormCreate(Sender: TObject);
    procedure Browse1Click(Sender: TObject);
    procedure FillFromFolder1Click(Sender: TObject);
    procedure FillWithThread1Click(Sender: TObject);
    procedure Clear1Click(Sender: TObject);
    procedure ImageEnMView1AllDisplayed(Sender: TObject);
    procedure Folder1Change(Sender: TObject);
    procedure ImageEnMView1ImageSelect(Sender: TObject; idx: Integer);
    procedure Fit1Click(Sender: TObject);
  private
    { Private declarations }
    AImageLoadingThread: TImageLoadingThread;
    procedure ThreadTerminate(Sender: TObject);
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

uses Vcl.FileCtrl, Winapi.ShlObj, Winapi.ShellApi, hyieutils, imageenio;

{ Global }

function DesktopFolder: string;
{ Find Desktop folder location }
var
  iR: Bool;
  iPath: array [0 .. MAX_PATH] of Char;
begin
  iR := Winapi.ShlObj.ShGetSpecialFolderPath(0, iPath, CSIDL_DESKTOP, False);
  if not iR then
    raise Exception.Create('Could not find Desktop folder location.');
  Result := IncludeTrailingPathDelimiter(iPath);
end;

function BrowseForFolder(AFolder: string): string;
{ BrowseForFolder }
begin
  if System.SysUtils.DirectoryExists(AFolder) then
    if Vcl.FileCtrl.SelectDirectory('Select Folder', 'Desktop', AFolder) then
      Result := AFolder;
end;

function GetAllFiles(AMask: string; AStringList: TStringList): Integer;
{ Get all supported image files matching mask (*.*.. '*.jpg') and add them to a stringlist }
var
  iSearch: TSearchRec;
  iDirectory: string;
  iCount: Integer;
  iFileAttrs: Integer;
begin
  iCount := 0;
  iDirectory := ExtractFilePath(AMask);
  iFileAttrs := faArchive - faHidden;
  { Find all files matching AMask }
  if FindFirst(AMask, iFileAttrs, iSearch) = 0 then
  begin
    repeat
      if IsKnownFormat(iDirectory + iSearch.name) then
      begin
        { Add the imageenio supported files to the stringlist }
        AStringList.Add(iDirectory + iSearch.name);
        Inc(iCount);
      end;
    until FindNext(iSearch) <> 0;
  end;
  { Subdirectories }
  if FindFirst(iDirectory + '*.*', faDirectory, iSearch) = 0 then
  begin
    repeat
      if ((iSearch.Attr and faDirectory) = faDirectory) and
        (iSearch.name[1] <> '.') then
        GetAllFiles(iDirectory + iSearch.name + '\' + ExtractFileName(AMask),
          AStringList);
    until FindNext(iSearch) <> 0;
    FindClose(iSearch);
  end;
  Result := iCount;
end;

{ TImageLoadingThread }

constructor TImageLoadingThread.Create(CreateSuspended: Boolean);
{ Create the thread. }
begin
  inherited;
end;

procedure TImageLoadingThread.Execute;
{ Load images ImageENMView in the thread.
  Note: All references to GUI elements must occur inside a Synchronize method.
  Synchronize suspends the current thread and has the main thread call the procedure. When
  the procedure finishes, control returns to the current thread. }
var
  i: Integer;
  iFolder: string;
  iFileCount: Integer;
  iStringList: TStringList;
begin
  inherited;
  { Free the thread onTerminate }
  FreeOnTerminate := True;

  if not Terminated then
  begin

    { Get the foldername }
    Synchronize(
      procedure
      begin
        iFolder := IncludeTrailingPathDelimiter(Form1.Folder1.Text);
      end);

    { Create a string list to hold the filenames }
    iStringList := TStringList.Create;
    try
      iFileCount := GetAllFiles(iFolder + '*.*', iStringList);
      if iFileCount > 0 then
      begin
        for i := 0 to iFileCount - 1 do
          { Add the images to ImageEnMView }
          Synchronize(
            procedure
            begin
              if iFileCount > 0 then
              begin
                Form1.ImageEnMView1.ImageFileName
                  [Form1.ImageEnMView1.AppendImage()] := iStringList.Strings[i];
              end;
            end);
      end
      else
        MessageBox(0, 'No supported images were found', 'Warning',
          MB_ICONWARNING or MB_OK);

    finally
      iStringList.Free;
    end;

  end;

  { Terminate the thread }
  Terminate;
end;

{ TForm1 }

procedure TForm1.Folder1Change(Sender: TObject);
{ Folder1Change }
begin
  StatusBar1.Panels[0].Text := Folder1.Text;
end;

procedure TForm1.FormCreate(Sender: TObject);
{ Set parameters }
begin
  ImageEnMView1.SetModernStyling(True, 225, 225);
  Folder1.Text := DesktopFolder;
end;

procedure TForm1.ImageEnMView1AllDisplayed(Sender: TObject);
{ ImageEnMView1AllDisplayed }
begin
  ImageEnMView1.SelectedImage := 0;
  StatusBar1.Panels[2].Text := 'Images: ' + IntToStr(ImageEnMView1.ImageCount);
end;

procedure TForm1.ImageEnMView1ImageSelect(Sender: TObject; idx: Integer);
{ ImageEnMView1ImageSelect }
var
  iFilename: string;
begin
  iFilename := ImageEnMView1.ImageFileName[idx];
  ImageEnView1.IO.LoadFromFile(iFilename);
  ImageEnView1.AutoFit := Fit1.Checked;
  if Fit1.Checked then
    ImageEnView1.Fit;
end;

procedure TForm1.Browse1Click(Sender: TObject);
{ Browse for a folder }
var
  iFolder: string;
begin
  iFolder := BrowseForFolder(DesktopFolder);
  Folder1.Text := IncludeTrailingPathDelimiter(iFolder);
end;

procedure TForm1.Clear1Click(Sender: TObject);
{ Clear }
begin
  ImageEnMView1.Clear;
  ImageEnView1.Clear;
  Caption := 'Fill ImageEnMView In a Thread';
  StatusBar1.Panels[1].Text := '';
  StatusBar1.Panels[2].Text := '';
end;

procedure TForm1.FillFromFolder1Click(Sender: TObject);
{ Fill ImageEnMView with fill from directory }
var
  iFilename: string;
begin
  if System.SysUtils.DirectoryExists(Folder1.Text) then
  begin
    ImageEnMView1.Clear;
    ImageEnView1.Clear;
    Caption := 'Fill ImageEnMView In a Thread- ' + Folder1.Text;
    ImageEnMView1.FillFromDirectory(Folder1.Text, -1, False, '', True, '',
      False, True);
    Screen.Cursor := crHourGlass;
    try
      ImageEnMView1.SelectedImage := 0;
      iFilename := ImageEnMView1.ImageFileName[0];
      ImageEnView1.IO.LoadFromFile(iFilename);
      if Fit1.Checked then
      begin
        ImageEnView1.AutoFit := True;
        ImageEnView1.Fit;
      end;
      ImageEnView1.Bitmap.Modified := False;
      ImageEnMView1.SelectedImage := -1;
    finally
      Screen.Cursor := crDefault;
    end;
  end
  else
    MessageBox(0, PChar('The folder ' + Folder1.Text + ' does not exist.'),
      'Warning', MB_ICONWARNING or MB_OK);
end;

procedure TForm1.FillWithThread1Click(Sender: TObject);
{ Fill ImageEnMView with a thread }
begin
  if System.SysUtils.DirectoryExists(Folder1.Text) then
  begin
    ImageEnMView1.Clear;
    ImageEnView1.Clear;
    Caption := 'Fill ImageEnMView In a Thread- ' + Folder1.Text;
    { Create the thread suspended }
    AImageLoadingThread := TImageLoadingThread.Create(True);
    { Set the threads OnTerminate event }
    AImageLoadingThread.OnTerminate := ThreadTerminate;
    { Start the thread }
    AImageLoadingThread.Start;
    { Processing will occur in the TImageLoadingThread.Execute event }
  end;
end;

procedure TForm1.Fit1Click(Sender: TObject);
{ Auto Fit }
begin
  ImageEnView1.AutoFit := Fit1.Checked;
  if Fit1.Checked then
    ImageEnView1.Fit;
end;

procedure TForm1.ThreadTerminate(Sender: TObject);
{ ThreadTerminate }
var
  iObject: TObject;
begin
  { Show a message if exception takes place in the thread }
  Assert(Sender is TThread);
  iObject := TThread(Sender).FatalException;
  if Assigned(iObject) then
  begin
    { Thread terminated due to an exception }
    if iObject is Exception then
      Application.ShowException(Exception(iObject))
    else
      ShowMessage(iObject.ClassName);
  end
  else
  begin
    { Thread terminated without an exception }
  end;
  { Free the AImageLoadingThread }
  AImageLoadingThread := nil;
end;

end.

procedure Tfrm_FindAndSell_Inventory.ImageThreadWork(Worker: TBackgroundWorker);
var 
  errormsg: string;
  error: Boolean;
  t     : tImageDataCollection;
  x    : Integer;
  idx : Integer;
begin
  try
    iowriteln('ImageThread - Work');  // logs to a console that can be open for debugging 

    Image_Browser.LockPaint; // locks paint
    Image_Primary.LockPaint;

    image_Browser.Enabled := false; // disable user interactions
    Image_Primary.Enabled := false;

    Image_Browser.Clear; // clear our image containers
    Image_Primary.Clear;

    if Assigned(image_Browser) = false then // if somehow the image_Browser got killed exit
      Exit;

    if Assigned(lastitem) = false then  // if our grid record last item is not assigned then exit
      Exit;

    if lastitem.SearchPart_Data.GUID = '' then  // if the GUID is blank then exit
      Exit;

    FreeAndNil(lastImages); 

// Get a List of Images from our given GUID and store to the T object

    if cmImage.Get_PartImages(lastitem.SearchPart_Data.GUID, errormsg, t) then

      if t.Count > 0 then
      begin

        lastImages := t; 

        for x := t.Count - 1 downto 0 do
        begin

          if worker.CancellationPending then
          begin
            worker.AcceptCancellation;
            Exit;
          end;

          IDX := Image_Browser.AppendImage;
          Image_Browser.ImageID[idx] := X; // ID will store our item index ID in the list
           
	// checks if file exists
          if io.newFileExists(t.Item[x].ThumbLocation) then
	          begin
	            Image_Browser.ImageFileName[idx] := t.Item[x].Location;
	             end 
	                 else
	 	          begin // if did not exist show our Generic Image saying so
		            Image_Browser.SetImage(idx, Generic_Data.Images.Items[0].bitmap);
		          end;
          Sleep(10); // sleep a momment
        end;
      end
      else
      begin
        iowriteln('ImageThreadWork Error 1 : ' + ErrorMsg); // we had an error of some sort from the cmImage.Get_PartImages call
      end;


   if assigned(t) then
	begin  
	    idx := t.PrimaryImageIdx; // get an index of our lists "Primary Image"
	    if idx > -1 then	// if it was -1 then don't bother
	    begin
		      if io.newFileExists(t.Item[idx].WebLocation) then
		        image_primary.IO.LoadFromFile(t.Item[idx].WebLocation)   // Load image into Image_Primary container
		      else
		        Image_primary.Bitmap.Assign(Generic_Data.Images.Items[0].bitmap); // file did not exist so load generic Image saying so
	    end;
	end;
    lastImages := t;

  except
    on e:
    Exception do
    begin
      iowriteln('ImageThreadWork Error 2 : ' + E.Message);
    end;
  end;
end;

procedure Tfrm_FindAndSell_Inventory.ImageThreadWorkComplete(Worker: TBackgroundWorker;
  Cancelled: Boolean);
begin
  iowriteln('ImageThread - Complete');
  image_Browser.Enabled := true;
  Image_Primary.Enabled := true;

  Image_Browser.UnLockPaint;
  Image_Primary.UnLockPaint;

  image_browser.Update;
  image_primary.Update;
end;

quote:

---

I used the background thread deal with great results.

---

procedure TForm.Button1Click(Sender: TObject);
begin
   // if worker thread is still processing cancel the thread
   if BackgroundWorker.IsWorking then
   begin
      // inform user we are cancelling the last operation
       StatusBar.SimpleText := 'Cancelling...';
       // cancel the operation
       BackgroundWorker.Cancel;
       // and wait for worker to stop
       BackgroundWorker.WaitFor;
   end;
   // clear the old thumbnails
   ClearThumbnails;
   // inform user we are working
   StatusBar.SimpleText := 'Creating thumbnails...';
   // create new thumbnails
   BackgroundWorker.Execute;
end;

The thread is executed here:
procedure TMainForm.BackgroundWorkerWork(Worker: TBackgroundWorker);
// Add your code to fill ImageEnMView here...
begin
end;