Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

lblSearching.Visible = true; pictureBoxSearch.Visible = true; I've created these two and…

  1. User

    lblSearching.Visible = true; pictureBoxSearch.Visible = true;

    I've created these two and want to turn them on when the search process is running and turn them off after it's done. this is my code: using EmreIstikam001.component.TehranOffice.ToosForAll; using Rhino; using Rhino.Display; using Rhino.DocObjects; using Rhino.FileIO; using Rhino.Geometry; using Rhino.Runtime.InProcess; using Rhino.UI; using System; using System.Collections.Generic; using System.Drawing; using System.IO; using System.Linq; using System.Threading.Tasks; using System.Windows.Forms;

    namespace EmreIstikam001.component.TehranOffice.Components.Other.CustomLibrary { public partial class CustomLibraryFrm : Form { public event EventHandler PictureBoxClicked; public event EventHandler PictureBoxDoubleClicked;

        private PictureBox selectedPictureBox = null;
        public DateTime selectTime = DateTime.Now;
        private List<PictureBox> pictureBoxes = new List<PictureBox>();
        private List<FileInfo> cachedFiles = new List<FileInfo>();
        public string SelectedFilePath { get; private set; }
        public string FileName { get; private set; }
        public string UserPath { get; private set; }
    
        private ToolTip toolTip;
        private string initialPath;
        private Timer searchTimer;
    
        public CustomLibraryFrm()
        {
            InitializeComponent();
    
            initialPath = @"C:\PARDUS_CEPHE_YAZILIMI\Pardus_CY\01_BLOK";
    
            InitializeGrid();
            toolTip = new ToolTip();
            SetPlaceholder();
    
            lblSearching.Visible = false;
            pictureBoxSearch.Visible = false;
    
            // Subscribe to TreeView events
            treeView1.BeforeExpand += TreeView1_BeforeExpand;
            treeView1.AfterSelect += TreeView1_AfterSelect;
    
            // Initialize ImageList for the TreeView
            InitializeImageList();
            SetPlaceholderLogin();
            // Populate the TreeView
            PopulateTreeView(initialPath);
    
            // Initialize the search timer
            searchTimer = new System.Windows.Forms.Timer();
            searchTimer.Interval = 800; // Set the debounce delay to 500 milliseconds
            searchTimer.Tick += SearchTimer_Tick;
    
        }
    
        /// <summary>
        /// Initializes the ImageList for the TreeView control.
        /// </summary>
        private void InitializeImageList()
        {
            ImageList imageList = new ImageList();
    
            // Set the desired image size (e.g., 64x64 pixels)
            imageList.ImageSize = new Size(32, 32);
    
            // Add images to the image list
            imageList.Images.Add("folder", Properties.Resources.noun_folder);  // folder icon
            imageList.Images.Add("file", Properties.Resources.kutuphane);    // file icon
            imageList.Images.Add("file3dm", Properties.Resources.PardusLogo1); // .3dm file icon
    
            // Assign the ImageList to the TreeView
            treeView1.ImageList = imageList;
    
            //// Adjust the ItemHeight to accommodate larger images
            //treeView1.ItemHeight = 70;
        }
    
    
        /// <summary>
        /// Sets the placeholder text in the search TextBox.
        /// </summary>
        private void SetPlaceholder()
        {
            txtSearch.Text = "search...";
            txtSearch.ForeColor = Color.Gray;
        }
        private void SetPlaceholderLogin()
        {
            txtUser.Text = "Staff ID...";
            txtPass.Text = "Password...";
            txtUser.ForeColor = Color.FromArgb(170, 170, 170);
            txtPass.ForeColor = Color.FromArgb(170, 170, 170);
        }
    
        /// <summary>
        /// Event handler for when the user enters the search TextBox.
        /// </summary>
        private void txtSearch_Enter(object sender, EventArgs e)
        {
            if (txtSearch.Text == "search...")
            {
                txtSearch.Text = "";
                txtSearch.ForeColor = Color.Black;
            }
        }
    
        /// <summary>
        /// Event handler for when the user leaves the search TextBox.
        /// </summary>
        private void txtSearch_Leave(object sender, EventArgs e)
        {
            if (string.IsNullOrWhiteSpace(txtSearch.Text))
            {
                SetPlaceholder();
            }
        }
    
        /// <summary>
        /// Initializes the grid layout for displaying thumbnails.
        /// </summary>
        private void InitializeGrid()
        {
            tableLayoutPanel01.RowCount = 3;
            tableLayoutPanel01.ColumnCount = 3;
            tableLayoutPanel01.AutoScroll = true;
    
            // Set the padding of the TableLayoutPanel
            tableLayoutPanel01.Padding = new Padding(10); // Adjust the padding value as needed
            tableLayoutPanel01.BackColor = Color.White; // Ensure the background is white
        }
    
        /// <summary>
        /// Populates the TreeView with directories and files from the given root path.
        /// Implements lazy loading for better performance.
        /// </summary>
        private void PopulateTreeView(string rootPath)
        {
            if (!Directory.Exists(rootPath))
            {
                string systemDriveRoot = Path.GetPathRoot(Environment.SystemDirectory);
                string newFolderName = "PARDUS_CEPHE_YAZILIMI";
                string newFolderPath = Path.Combine(systemDriveRoot, newFolderName);
    
                if (!Directory.Exists(newFolderPath))
                {
                    Directory.CreateDirectory(newFolderPath);
                }
    
                rootPath = newFolderPath;
            }
    
            DirectoryInfo rootDirectory = new DirectoryInfo(rootPath);
    
            TreeNode rootNode = new TreeNode(rootDirectory.Name)
            {
                Tag = rootDirectory,
                ImageKey = "folder"
            };
    
            // Add a dummy node for lazy loading
            rootNode.Nodes.Add(new TreeNode("Loading..."));
            treeView1.Nodes.Add(rootNode);
            rootNode.Expand();
            textBox1.Text = rootPath;
        }
    
        /// <summary>
        /// Event handler for when a TreeView node is about to expand.
        /// Implements lazy loading by loading subdirectories and files at this point.
        /// </summary>
        private void TreeView1_BeforeExpand(object sender, TreeViewCancelEventArgs e)
        {
            TreeNode node = e.Node;
    
            // Check if node contains a dummy "Loading..." node
            if (node.Nodes.Count == 1 && node.Nodes[0].Text == "Loading...")
            {
                node.Nodes.Clear();
    
                if (node.Tag is DirectoryInfo dir)
                {
                    GetDirectories(dir, node);
                }
            }
        }
    
        /// <summary>
        /// Recursively adds subdirectories and files to the TreeView node.
        /// </summary>
        private void GetDirectories(DirectoryInfo dir, TreeNode nodeToAddTo)
        {
            try
            {
                // Add subdirectories
                DirectoryInfo[] subDirs = dir.GetDirectories();
    
                foreach (DirectoryInfo subDir in subDirs)
                {
                    TreeNode subNode = new TreeNode(subDir.Name)
                    {
                        Tag = subDir,
                        ImageKey = "folder"
                    };
                    // Add a dummy node for lazy loading
                    subNode.Nodes.Add(new TreeNode("Loading..."));
                    nodeToAddTo.Nodes.Add(subNode);
                }
    
                // Add files
                FileInfo[] files = dir.GetFiles();
                foreach (FileInfo file in files)
                {
                    TreeNode fileNode = new TreeNode(file.Name)
                    {
                        Tag = file,
                        ImageKey = file.Extension.Equals(".3dm", StringComparison.OrdinalIgnoreCase) ? "file3dm" : "file"
                    };
                    nodeToAddTo.Nodes.Add(fileNode);
                }
            }
            catch (UnauthorizedAccessException ex)
            {
                Console.WriteLine($"Access denied to {dir.FullName}: {ex.Message}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error occurred accessing {dir.FullName}: {ex.Message}");
            }
        }
    
        /// <summary>
        /// Event handler for when a node in the TreeView is selected.
        /// </summary>
        private void TreeView1_AfterSelect(object sender, TreeViewEventArgs e)
        {
            var selectedNode = e.Node;
            FileName = selectedNode.Text;
    
            if (selectedNode.Tag is DirectoryInfo selectedDirectory)
            {
                pictureBoxes.Clear();
                PopulateTableWithThumbnails(selectedDirectory);
            }
            else if (selectedNode.Tag is FileInfo selectedFile)
            {
                SelectedFilePath = selectedFile.FullName;
    
                // Clear existing controls
                pictureBoxes.Clear();
                tableLayoutPanel01.Controls.Clear();
                tableLayoutPanel01.RowStyles.Clear();
                tableLayoutPanel01.ColumnStyles.Clear();
    
                tableLayoutPanel01.RowCount = 0;
                tableLayoutPanel01.ColumnCount = 0;
    
                tableLayoutPanel01.RowCount = 1;
                tableLayoutPanel01.ColumnCount = 1;
    
                tableLayoutPanel01.RowStyles.Add(new RowStyle(SizeType.Percent, 100));
                tableLayoutPanel01.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100));
    
                // Create the PictureBox
                PictureBox pictureBox = new PictureBox
                {
                    Width = 1300,
                    Height = 1500,
                    SizeMode = PictureBoxSizeMode.Zoom,
                    Anchor = AnchorStyles.None,
                    Margin = new Padding(0),
                    Tag = selectedFile.FullName,
                    Cursor = Cursors.Hand,
    
    
                };
    
                // Load the thumbnail
                try
                {
                    Bitmap rhinoThumbnail = WindowsThumbnailProvider.GetThumbnail(selectedFile.FullName, 400, 600, ThumbnailOptions.InCacheOnly);
                    if (rhinoThumbnail != null)
                    {
                        pictureBox.Image = rhinoThumbnail;
                    }
                    else
                    {
                        // If no thumbnail is available, you can display a placeholder image
                        // pictureBox.Image = Properties.Resources.PlaceholderImage;
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Error loading thumbnail for {selectedFile.FullName}: {ex.Message}");
                    // Optionally display an error image
                    // pictureBox.Image = Properties.Resources.ErrorImage;
                }
    
                // Add the PictureBox to the tableLayoutPanel in the center cell
                tableLayoutPanel01.Controls.Add(pictureBox, 0, 0);
    
                pictureBoxes.Add(pictureBox);
            }
    
            // Remove existing event handlers to prevent multiple subscriptions
            foreach (Control control in tableLayoutPanel01.Controls)
            {
                if (control is PictureBox pictureBox)
                {
                    pictureBox.Click += PictureBox_Click;
    
                    pictureBox.Paint += PictureBox_Paint;
                }
            }
        }
    
        /// <summary>
        /// Event handler for the "Browse" button click to select a custom directory.
        /// </summary>
        private void button1_Click(object sender, EventArgs e)
        {
            if (fbd1.ShowDialog() == DialogResult.OK)
            {
                UserPath = fbd1.SelectedPath;
                treeView1.Nodes.Clear();
                PopulateTreeView(UserPath);
            }
        }
    
        /// <summary>
        /// Populates the TableLayoutPanel with thumbnails of the files in the given directory.
        /// </summary>
        public void PopulateTableWithThumbnails(DirectoryInfo directory)
        {
            // Clear existing data
            pictureBoxes.Clear();
            tableLayoutPanel01.Controls.Clear();
            tableLayoutPanel01.RowStyles.Clear();
            tableLayoutPanel01.ColumnStyles.Clear();
    
            tableLayoutPanel01.RowCount = 0;
            tableLayoutPanel01.ColumnCount = 0;
    
            // Begin layout suspension
            tableLayoutPanel01.SuspendLayout();
    
            int fixedColumnCount = 3;
            int pictureBoxSize = 220;
    
            // Get files with .3dm extension
            FileInfo[] files = directory.GetFiles()
                .Where(f => f.Extension.Equals(".3dm", StringComparison.OrdinalIgnoreCase))
                .ToArray();
    
            int rowCount = (int)Math.Ceiling((double)files.Length / fixedColumnCount);
    
            tableLayoutPanel01.RowCount = rowCount;
            tableLayoutPanel01.ColumnCount = fixedColumnCount;
    
            // Set up styles
            for (int i = 0; i < fixedColumnCount; i++)
            {
                tableLayoutPanel01.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100f / fixedColumnCount));
            }
    
            for (int i = 0; i < rowCount; i++)
            {
                tableLayoutPanel01.RowStyles.Add(new RowStyle(SizeType.Absolute, pictureBoxSize));
            }
    
            tableLayoutPanel01.AutoSize = false;
            tableLayoutPanel01.AutoScroll = true;
    
            // Populate controls
            for (int i = 0; i < files.Length; i++)
            {
                FileInfo file = files[i];
                PictureBox pictureBox = CreatePictureBoxForFile(file, pictureBoxSize);
    
                int row = i / fixedColumnCount;
                int col = i % fixedColumnCount;
                tableLayoutPanel01.Controls.Add(pictureBox, col, row);
                pictureBoxes.Add(pictureBox);
            }
    
            // End layout suspension and refresh
            tableLayoutPanel01.ResumeLayout();
            tableLayoutPanel01.Refresh();
        }
    
        /// <summary>
        /// Creates a PictureBox for the given file.
        /// </summary>
        private PictureBox CreatePictureBoxForFile(FileInfo file, int pictureBoxSize)
        {
            PictureBox pictureBox = new PictureBox
            {
                Width = pictureBoxSize,
                Height = pictureBoxSize,
                BorderStyle = BorderStyle.None,
                SizeMode = PictureBoxSizeMode.StretchImage,
                Cursor = Cursors.Hand,
                BackColor = Color.LightGray,
                Tag = file.FullName,
                Margin = new Padding(5) // Adjust the margin value as needed
            };
    
    
            toolTip.SetToolTip(pictureBox, file.Name);
    
            // Load thumbnail image
            try
            {
                Bitmap rhinoThumbnail = WindowsThumbnailProvider.GetThumbnail(file.FullName, 200, 200, ThumbnailOptions.InCacheOnly);
                if (rhinoThumbnail != null)
                {
                    pictureBox.Image = rhinoThumbnail;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error loading thumbnail for {file.FullName}: {ex.Message}");
            }
    
            return pictureBox;
        }
    
        /// <summary>
        /// Click event handler for PictureBox.
        /// </summary>
        private void PictureBox_Click(object sender, EventArgs e)
        {
            if (sender is PictureBox clickedPictureBox)
            {
                if ((DateTime.Now.Ticks - selectTime.Ticks) / 10000 < 300 && selectedPictureBox == clickedPictureBox)
                {
                    //PictureBox_DoubleClick(sender, e);
                    // Raise the custom event
                    SelectedFilePath = clickedPictureBox.Tag.ToString();
                    FileName = Path.GetFileNameWithoutExtension(clickedPictureBox.Tag.ToString());
                    OnPictureBoxClicked(clickedPictureBox);
                }
                selectTime = DateTime.Now;
                if (selectedPictureBox != null)
                {
                    selectedPictureBox.BorderStyle = BorderStyle.None;
                    //selectedPictureBox.Invalidate();
                }
    
                selectedPictureBox = clickedPictureBox;
    
                selectedPictureBox.BorderStyle = BorderStyle.FixedSingle;
                //selectedPictureBox.Invalidate();
            }
        }
    
        /// <summary>
        /// Double-click event handler for PictureBox.
        /// </summary>
        private void PictureBox_DoubleClick(object sender, EventArgs e)
        {
            if (sender is PictureBox doubleClickedPictureBox)
            {
                SelectedFilePath = doubleClickedPictureBox.Tag.ToString();
                // Raise the custom event
                //OnPictureBoxDoubleClicked(doubleClickedPictureBox);
            }
            
        }
    
        protected virtual void OnPictureBoxDoubleClicked(PictureBox clickedPictureBox)
        {
            PictureBoxDoubleClicked?.Invoke(this, new PictureBoxEventArgs(clickedPictureBox));
        }
    
    
        protected virtual void OnPictureBoxClicked(PictureBox clickedPictureBox)
        {
            PictureBoxClicked?.Invoke(this, new PictureBoxEventArgs(clickedPictureBox));
        }
    
    
    
    
        /// <summary>
        /// Paint event handler for PictureBox to draw a border around the selected PictureBox.
        /// </summary>
        private void PictureBox_Paint(object sender, PaintEventArgs e)
        {
            if (sender is PictureBox picBox && picBox == selectedPictureBox)
            {
                var borderWidth = 10;
                var borderColor = Color.CadetBlue;
    
                Rectangle rect = new Rectangle(0, 0, picBox.Width - 3, picBox.Height - 3);
    
                using (Pen pen = new Pen(borderColor, borderWidth))
                {
                    e.Graphics.DrawRectangle(pen, rect);
                }
            }
        }
    
        private async void SearchTimer_Tick(object sender, EventArgs e)
        {
            // Stop the timer
            searchTimer.Stop();
    
            // Perform the search asynchronously
            await PerformSearchAsync();
        }
    
        private async Task PerformSearchAsync()
        {
            if (InvokeRequired)
            {
                Invoke(new Action(async () => await PerformSearchAsync()));
                return;
            }
    
            // Clear existing controls and display "Searching..." message
            tableLayoutPanel01.Controls.Clear();
            tableLayoutPanel01.RowStyles.Clear();
            tableLayoutPanel01.ColumnStyles.Clear();
            tableLayoutPanel01.RowCount = 1;
            tableLayoutPanel01.ColumnCount = 1;
            tableLayoutPanel01.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100));
            tableLayoutPanel01.RowStyles.Add(new RowStyle(SizeType.Percent, 100));
    
            //Label searchingLabel = new Label()
            //{
            //    Text = "Searching...",
            //    AutoSize = true,
            //    //Dock = DockStyle.Fill,
            //    TextAlign = ContentAlignment.MiddleCenter
            //};
            //tableLayoutPanel01.Controls.Add(searchingLabel, 0, 0);
            //searchingLabel.Visible = true;
    
    
            string searchText = txtSearch.Text.ToLower();
            bool searchSubdirectories = chbSearchAll.Checked;
            List<FileInfo> matchingFiles = null;
    
            if (searchSubdirectories && !string.IsNullOrEmpty(txtSearch.Text))
            {
                if (cachedFiles == null || cachedFiles.Count == 0)
                {
                    await CacheAllFilesAsync(); // Build the cache if not already done
                }
    
                lblSearching.Visible = true;
                pictureBoxSearch.Visible = true;
    
                // Perform search on cached files asynchronously
                matchingFiles = await Task.Run(() =>
                    cachedFiles.Where(file => file.Name.ToLower().Contains(searchText)).ToList()
                );
            }
            else
            {
                DirectoryInfo currentDirectory = GetCurrentSelectedDirectory();
    
                if (currentDirectory == null)
                {
                    // Remove "Searching..." label
                    tableLayoutPanel01.Controls.Clear();
                    return;
                }
    
                matchingFiles = await Task.Run(() =>
                    SearchInCurrentDirectory(currentDirectory, searchText)
                );
            }
    
            // Update the UI with the matching files
            UpdatePictureBoxes(matchingFiles);
        }
    
        private DirectoryInfo GetCurrentSelectedDirectory()
        {
            if (treeView1.SelectedNode?.Tag is DirectoryInfo dir)
            {
                return dir;
            }
            else if (treeView1.SelectedNode?.Tag is FileInfo file)
            {
                return file.Directory;
            }
            else
            {
                return null;
            }
        }
    
    
    
        private async void chbSearchAll_CheckedChanged(object sender, EventArgs e)
        {
            if (chbSearchAll.Checked)
            {
                // Rebuild the cache asynchronously
                await CacheAllFilesAsync();
            }
            else
            {
                // If the checkbox is unchecked, clear the cache to free memory
                cachedFiles.Clear();
            }
        }
    
    
        private async Task CacheAllFilesAsync()
        {
    
            lblSearching.Visible = true;
            pictureBoxSearch.Visible = true;
            DirectoryInfo rootDirectory = new DirectoryInfo(initialPath);
    
            // Begin caching files
            cachedFiles = await Task.Run(() =>
            {
                List<FileInfo> allFiles = new List<FileInfo>();
                GetAllFilesRecursive(rootDirectory, allFiles);
                return allFiles;
            });
        }
    
        // Recursive method to get all files
        private void GetAllFilesRecursive(DirectoryInfo directory, List<FileInfo> allFiles)
        {
            try
            {
                allFiles.AddRange(directory.GetFiles()
                    .Where(file => file.Extension.Equals(".3dm", StringComparison.OrdinalIgnoreCase)));
    
                foreach (DirectoryInfo subDir in directory.GetDirectories())
                {
                    GetAllFilesRecursive(subDir, allFiles);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error accessing {directory.FullName}: {ex.Message}");
            }
        }
    
        private void ResetPictureBoxesToCurrentDirectory()
        {
            if (treeView1.SelectedNode?.Tag is DirectoryInfo selectedDirectory)
            {
                pictureBoxes.Clear();
                PopulateTableWithThumbnails(selectedDirectory);
            }
            else if (treeView1.SelectedNode?.Tag is FileInfo selectedFile)
            {
                pictureBoxes.Clear();
                PopulateTableWithThumbnails(selectedFile.Directory);
            }
            else
            {
                // Handle case when nothing is selected
                pictureBoxes.Clear();
                tableLayoutPanel01.Controls.Clear();
            }
        }
    
        /// <summary>
        /// Event handler for text changes in the search TextBox.
        /// </summary>
        private void txtSearch_TextChanged(object sender, EventArgs e)
        {
            string searchText = txtSearch.Text.ToLower();
    
            if (searchText == "search..." || string.IsNullOrWhiteSpace(searchText))
            {
                // Reset the displayed PictureBoxes
                ResetPictureBoxesToCurrentDirectory();
                return;
            }
    
            // Restart the timer for debouncing
            searchTimer.Stop();
            searchTimer.Start();
        }
    
        /// <summary>
        /// Searches for files containing the search text in the current directory.
        /// </summary>
        // Search only in the current directory
        private List<FileInfo> SearchInCurrentDirectory(DirectoryInfo directory, string searchText)
        {
            try
            {
                var matchingFiles = directory.GetFiles()
                    .Where(file => file.Name.ToLower().Contains(searchText) &&
                                   file.Extension.Equals(".3dm", StringComparison.OrdinalIgnoreCase))
                    .ToList();
                return matchingFiles;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error occurred during search: {ex.Message}");
                return new List<FileInfo>();
            }
        }
    
        /// <summary>
        /// Searches for files containing the search text recursively in all subdirectories.
        /// </summary>
        // Search recursively through all subdirectories
        private List<FileInfo> SearchInAllDirectories(DirectoryInfo directory, string searchText)
        {
            List<FileInfo> matchingFiles = new List<FileInfo>();
            GetMatchingFilesRecursive(directory, searchText, matchingFiles);
    
            //UpdatePictureBoxes(matchingFiles);
            return matchingFiles;
        }
    
    
        /// <summary>
        /// Recursively gets matching files containing the search text.
        /// </summary>
        // Recursive method to get all matching files
        private void GetMatchingFilesRecursive(DirectoryInfo directory, string searchText, List<FileInfo> matchingFiles)
        {
            try
            {
                matchingFiles.AddRange(directory.GetFiles()
                    .Where(file => file.Name.ToLower().Contains(searchText) &&
                                   file.Extension.Equals(".3dm", StringComparison.OrdinalIgnoreCase)));
    
                foreach (DirectoryInfo subDir in directory.GetDirectories())
                {
                    GetMatchingFilesRecursive(subDir, searchText, matchingFiles);
                }
            }
            catch (UnauthorizedAccessException ex)
            {
                Console.WriteLine($"Access denied to directory: {directory.FullName}, {ex.Message}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error occurred accessing {directory.FullName}: {ex.Message}");
            }
        }
    
        /// <summary>
        /// Updates the PictureBox controls with the matching files.
        /// </summary>
        // Updates the PictureBox controls with the matching files
        private void UpdatePictureBoxes(List<FileInfo> matchingFiles)
        {
            if (InvokeRequired)
            {
                Invoke(new Action(() => UpdatePictureBoxes(matchingFiles)));
                return;
            }
    
            lblSearching.Visible = false;
            pictureBoxSearch.Visible = false;
    
            // Clear existing controls and styles
            pictureBoxes.Clear();
            tableLayoutPanel01.Controls.Clear();
            tableLayoutPanel01.RowStyles.Clear();
            tableLayoutPanel01.ColumnStyles.Clear();
            tableLayoutPanel01.RowCount = 0;
            tableLayoutPanel01.ColumnCount = 0;
    
            // Begin layout suspension
            tableLayoutPanel01.SuspendLayout();
    
            if (matchingFiles.Count == 0)
            {
                // Display "No files found" message
                tableLayoutPanel01.RowCount = 1;
                tableLayoutPanel01.ColumnCount = 1;
                tableLayoutPanel01.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100));
                tableLayoutPanel01.RowStyles.Add(new RowStyle(SizeType.Percent, 100));
    
                Label noResultsLabel = new Label()
                {
                    Text = "No files found.",
                    AutoSize = true,
                    Dock = DockStyle.Fill,
                    TextAlign = ContentAlignment.MiddleCenter
                };
                tableLayoutPanel01.Controls.Add(noResultsLabel, 0, 0);
            }
            else
            {
                int fixedColumnCount = 3;
                int pictureBoxSize = 250;
    
                int rowCount = (int)Math.Ceiling((double)matchingFiles.Count / fixedColumnCount);
    
                tableLayoutPanel01.RowCount = rowCount;
                tableLayoutPanel01.ColumnCount = fixedColumnCount;
    
                // Set up styles
                for (int i = 0; i < fixedColumnCount; i++)
                {
                    tableLayoutPanel01.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100f / fixedColumnCount));
                }
    
                for (int i = 0; i < rowCount; i++)
                {
                    tableLayoutPanel01.RowStyles.Add(new RowStyle(SizeType.Absolute, pictureBoxSize));
                }
    
                tableLayoutPanel01.AutoSize = false;
                tableLayoutPanel01.AutoScroll = true;
    
                // Populate controls
                for (int i = 0; i < matchingFiles.Count; i++)
                {
                    FileInfo file = matchingFiles[i];
                    PictureBox pictureBox = CreatePictureBoxForFile(file, pictureBoxSize);
    
                    int row = i / fixedColumnCount;
                    int col = i % fixedColumnCount;
                    tableLayoutPanel01.Controls.Add(pictureBox, col, row);
                    pictureBoxes.Add(pictureBox);
                }
            }
           
            // End layout suspension and refresh
            tableLayoutPanel01.ResumeLayout();
            tableLayoutPanel01.Refresh();
        }
    
        /// <summary>
        /// Custom event arguments for PictureBox events.
        /// </summary>
        public class PictureBoxEventArgs : EventArgs
        {
            public PictureBox ClickedPictureBox { get; set; }
    
            public PictureBoxEventArgs(PictureBox pictureBox)
            {
                ClickedPictureBox = pictureBox;
            }
        }
    
      
    
        private void txtUser_Enter(object sender, EventArgs e)
        {
            if (txtUser.Text == "Staff ID...")
            {
                txtUser.Text = "";
                txtUser.ForeColor = Color.FromArgb(86, 106, 127);
            }
        }
    
        private void txtUser_Leave(object sender, EventArgs e)
        {
            if (string.IsNullOrEmpty(txtUser.Text))
            {
                txtUser.Text = "Staff ID...";
                txtUser.ForeColor = Color.FromArgb(170, 170, 170);
            }
        }
    
    
        private void txtPass_Enter(object sender, EventArgs e)
        {
            if (txtPass.Text == "Password...")
            {
                txtPass.Text = "";
                txtPass.ForeColor = Color.FromArgb(86, 106, 127);
            }
        }
    
        private void txtPass_Leave(object sender, EventArgs e)
        {
            if (string.IsNullOrEmpty(txtPass.Text))
            {
                txtPass.Text = "Password...";
                txtPass.ForeColor = Color.FromArgb(170, 170, 170);
            }
        }
    }
    

    }

  2. Assistant

    It looks like you're trying to display lblSearching and pictureBoxSearch while the search process is running and hide them after it's done. From your description and the code you've provided, you're setting their visibility to true when the search starts and to false when it ends. However, they're not appearing as expected during the search.

    The issue likely arises due to how Windows Forms handles UI updates and threading. Let's dive into the problem and see how we can fix it.

    Understanding the Problem

    In Windows Forms applications, all UI controls run on the main UI thread. If you perform long-running operations (like searching files) on the UI thread, it blocks the thread, preventing the UI from updating until the operation is complete. This means that any changes to control properties (like setting Visible = true) won't take effect until the UI thread is free to process them.

    Additionally, updating UI controls from a background thread can cause exceptions or undefined behavior. Therefore, we need to ensure that:

    1. Long-running operations run on a background thread to keep the UI responsive.
    2. All UI updates happen on the UI thread.

    In your code, the search is supposed to be asynchronous, but there might be issues with how the UI updates are being invoked. Let's look at your PerformSearchAsync method.

    Analysis of PerformSearchAsync

    Your PerformSearchAsync method tries to use InvokeRequired and Invoke to ensure that the method runs on the UI thread:

    private async Task PerformSearchAsync()
    {
        if (InvokeRequired)
        {
            Invoke(new Action(async () => await PerformSearchAsync()));
            return;
        }
        // ... rest of the method ...
    }
    

    However, this approach leads to a recursive call to PerformSearchAsync on the UI thread, which can cause deadlocks or stack overflows because the method is async and awaits itself.

    Solution

    Here's how you can fix the problem:

    1. Remove the recursive Invoke call in PerformSearchAsync.
    2. Ensure that long-running operations run on a background thread using Task.Run.
    3. Update UI controls before and after the search operation on the UI thread.
    4. Avoid blocking the UI thread by properly using await.

    Let's rewrite your PerformSearchAsync method accordingly.

    Revised PerformSearchAsync Method

    private async Task PerformSearchAsync()
    {
        // Show the searching labels on the UI thread
        lblSearching.Visible = true;
        pictureBoxSearch.Visible = true;
    
        string searchText = txtSearch.Text.ToLower();
        bool searchSubdirectories = chbSearchAll.Checked;
        List<FileInfo> matchingFiles = null;
    
        if (searchSubdirectories && !string.IsNullOrEmpty(txtSearch.Text))
        {
            if (cachedFiles == null || cachedFiles.Count == 0)
            {
                lblSearching.Text = "Building file cache...";
                await CacheAllFilesAsync(); // Build the cache if not already done
                lblSearching.Text = "Searching...";
            }
    
            // Perform search on a background thread
            matchingFiles = await Task.Run(() =>
                cachedFiles.Where(file => file.Name.ToLower().Contains(searchText)).ToList()
            );
        }
        else
        {
            DirectoryInfo currentDirectory = GetCurrentSelectedDirectory();
    
            if (currentDirectory == null)
            {
                // Remove "Searching..." label
                tableLayoutPanel01.Controls.Clear();
                lblSearching.Visible = false;
                pictureBoxSearch.Visible = false;
                return;
            }
    
            // Perform search on a background thread
            matchingFiles = await Task.Run(() =>
                SearchInCurrentDirectory(currentDirectory, searchText)
            );
        }
    
        // Update the UI with the matching files
        UpdatePictureBoxes(matchingFiles);
    
        // Hide the searching labels on the UI thread
        lblSearching.Visible = false;
        pictureBoxSearch.Visible = false;
    }
    

    Explanation

    • Removing InvokeRequired and Invoke: Since PerformSearchAsync is already called on the UI thread (from the timer tick event handler), there's no need to check InvokeRequired or invoke the method again on the UI thread.

    • Updating UI controls before the search: We set lblSearching.Visible = true; and pictureBoxSearch.Visible = true; before the search starts. Since we're on the UI thread, these updates will take effect immediately, and the controls will be visible during the search.

    • Running the search on a background thread: We use await Task.Run(() => { ... }); to run the search operation on a background thread, preventing the UI thread from being blocked.

    • Awaiting the search operation: The await ensures that the method will asynchronously wait for the search to complete without blocking the UI thread.

    • Updating UI controls after the search: After the search is complete and we've updated the UI with the results, we hide the searching labels.

    Updating the UpdatePictureBoxes Method

    In your UpdatePictureBoxes method, you're checking InvokeRequired and invoking the method on the UI thread if necessary:

    private void UpdatePictureBoxes(List<FileInfo> matchingFiles)
    {
        if (InvokeRequired)
        {
            Invoke(new Action(() => UpdatePictureBoxes(matchingFiles)));
            return;
        }
    
        // ... rest of the method ...
    }
    

    Since UpdatePictureBoxes is called from PerformSearchAsync after the await, it's already on the UI thread. However, keeping the InvokeRequired check is safe in case you call it from other places.

    Adjusting the Timer Tick Event Handler

    Ensure that your timer tick event handler is properly awaiting PerformSearchAsync:

    private async void SearchTimer_Tick(object sender, EventArgs e)
    {
        // Stop the timer
        searchTimer.Stop();
    
        // Perform the search asynchronously
        await PerformSearchAsync();
    }
    

    This ensures that PerformSearchAsync runs asynchronously and doesn't block the UI thread.

    Removing Recursive Invocations

    In your original PerformSearchAsync method, you had:

    if (InvokeRequired)
    {
        Invoke(new Action(async () => await PerformSearchAsync()));
        return;
    }
    

    This recursive approach is problematic, especially with async methods. It's better to structure your code so that you don't need to invoke the method on the UI thread recursively.

    General Tips

    • Use async and await Properly: When you have an async method, ensure that you're awaiting asynchronous operations. This allows the method to return control to the caller while the operation is in progress.

    • Avoid Blocking the UI Thread: Any long-running operations should be offloaded to background threads using Task.Run or other asynchronous patterns.

    • Update UI Controls on the UI Thread: Any updates to UI controls must happen on the UI thread. You can use Invoke or BeginInvoke if you're on a background thread.

    • Be Careful with Invoke and BeginInvoke: Overusing these methods, especially with recursive calls, can lead to complex issues like deadlocks or stack overflows.

    Putting It All Together

    Here's the revised PerformSearchAsync method with comments:

    private async Task PerformSearchAsync()
    {
        // Show the searching labels on the UI thread
        lblSearching.Visible = true;
        pictureBoxSearch.Visible = true;
    
        string searchText = txtSearch.Text.ToLower();
        bool searchSubdirectories = chbSearchAll.Checked;
        List<FileInfo> matchingFiles = null;
    
        if (searchSubdirectories && !string.IsNullOrEmpty(txtSearch.Text))
        {
            if (cachedFiles == null || cachedFiles.Count == 0)
            {
                lblSearching.Text = "Building file cache...";
                await CacheAllFilesAsync(); // Build the cache if not already done
                lblSearching.Text = "Searching...";
            }
    
            // Perform search on a background thread
            matchingFiles = await Task.Run(() =>
                cachedFiles.Where(file => file.Name.ToLower().Contains(searchText)).ToList()
            );
        }
        else
        {
            DirectoryInfo currentDirectory = GetCurrentSelectedDirectory();
    
            if (currentDirectory == null)
            {
                // Remove "Searching..." label
                tableLayoutPanel01.Controls.Clear();
                lblSearching.Visible = false;
                pictureBoxSearch.Visible = false;
                return;
            }
    
            // Perform search on a background thread
            matchingFiles = await Task.Run(() =>
                SearchInCurrentDirectory(currentDirectory, searchText)
            );
        }
    
        // Update the UI with the matching files
        UpdatePictureBoxes(matchingFiles);
    
        // Hide the searching labels on the UI thread
        lblSearching.Visible = false;
        pictureBoxSearch.Visible = false;
    }
    

    Conclusion

    By restructuring your code to properly use asynchronous patterns and ensuring that UI updates happen on the UI thread, you can make lblSearching and pictureBoxSearch appear while the search is running and disappear afterward.

    Remember:

    • Always perform long-running tasks on background threads.
    • Use await to keep the UI responsive.
    • Update UI controls on the UI thread without blocking it.
    • Be cautious with recursive methods and invoking on the UI thread.

    I hope this helps you solve the issue!