Let’s build a simple but incredibly powerful Desktop app: a threaded image resizer. This tool will let you pick a folder of images and resize them all without ever locking up the app. It’s a perfect showcase of how easy and effective threading can be in Xojo.

Let’s get started!

Step 1: Designing the User Interface

First things first, let’s lay out our app’s window. We’re going for a clean and simple design. All you need to do is create a new Xojo Desktop project and add the following controls from the Library onto your main window:

1. DesktopButton: This will be our “start” button. The user will click this to select a folder and begin the resizing process. Let’s set its Caption to “Select folder && Start”.
2. DesktopProgressBar: This will give the user visual feedback on the progress of the resizing operation.
3. DesktopLabel: We’ll use this label to display status updates, like which file is currently being processed or when the job is complete. Let’s call it StatusLabel.

Your app layout should look something like this:

Step 2: Adding the Magic Ingredient: The Thread

Now for the star of the show! Go to the Library and find the Thread object. Drag and drop one onto your window. By default, it might be named Thread1, but I’ve renamed mine to ResizeThread to make its purpose crystal clear. This object is where our background work will happen.

Quick note on thread types: Cooperative threads (the default) share a single CPU core with the main/UI thread and other cooperative threads. Preemptive threads can run on separate CPU cores and deliver true parallelism for CPU-bound work. More info on this subject: Cooperative to Preemptive: Weaving New Threads into your Apps

Why this project uses Preemptive threads: resizing many images is CPU-bound and benefits from parallel cores without blocking the UI.

Step 3: Kicking Off the Process

With the UI and thread in place, let’s add the code to get things moving. Double-click the “Select folder & Start” button to add its Pressed event. This is what will run when the user clicks it.

Here’s the code for the Pressed event:

' Ask the user for a source folder (contains images)
Var f As FolderItem = FolderItem.ShowSelectFolderDialog
If f = Nil Then Return ' user cancelled

mSourceFolder = f

' Reset UI
ProgressBar1.Value = 0
StatusLabel.Text = "Starting…"

' Kick off background work!
ResizeThread.Start

Let’s break this down. First, we ask the user to select a folder. If they don’t pick one, we simply exit. If they do, we store the selected folder in a window property called mSourceFolder (Public Property mSourceFolder As FolderItem). We then reset our progress bar and status label and, most importantly, we call ResizeThread.Start. That one simple line tells our thread to wake up and get to work by running its Run event.

Step 4: The Heavy Lifting (in the Background)

The Run event of the ResizeThread is where the core logic lives. This is where we’ll find, load, resize, and save the images. Remember, the golden rule of threads is: never touch the UI directly from the Run event. Doing so can cause crashes and unpredictable behavior.

Instead, we perform our task and then send a message back to the main thread with an update. We do this using a method called AddUserInterfaceUpdate.

Here’s the Run event code:

' Quick validation up-front
If mSourceFolder = Nil Or Not mSourceFolder.Exists Or Not mSourceFolder.IsFolder Then
  Me.AddUserInterfaceUpdate(New Dictionary("progress":0, "msg":"No folder selected"))
  Return
End If

Try
  ' Ensure output subfolder "<selected>/resized" exists
  Var outFolder As FolderItem = mSourceFolder.Child("resized")
  If Not outFolder.Exists Then outFolder.CreateFolder
  
  ' Build a list of candidate image files.
  ' Note: Using Picture.Open to validate images is simple and robust.
  '       (For very large folders, you could pre-filter by extension first.)
  Var images() As FolderItem
  For Each it As FolderItem In mSourceFolder.Children
    If it = Nil Or it.IsFolder Then Continue ' Ignore subfolders
    Try
      Var p As Picture = Picture.Open(it)
      If p <> Nil Then images.Add(it)
    Catch e As RuntimeException
      ' Non-image or unreadable; skip
    End Try
  Next
  
  Var total As Integer = images.Count
  If total = 0 Then
    Me.AddUserInterfaceUpdate(New Dictionary("progress":0, "msg":"No images found"))
    Return
  End If
  
  ' Resize settings (simple “fit within 800x800” bounding box)
  Const kMaxW As Double = 800.0
  Const kMaxH As Double = 800.0
  
  ' Short delay after each file so the main thread can repaint the UI
  Const kDelayMS As Integer = 50
  
  For i As Integer = 0 To total - 1
    Var src As FolderItem = images(i)
    Try
      ' Load source (immutable)
      Var pic As Picture = Picture.Open(src)
      If pic = Nil Or pic.Width <= 0 Or pic.Height <= 0 Then Continue
      
      ' Compute proportional scale (never upscale)
      Var sW As Double = kMaxW / pic.Width
      Var sH As Double = kMaxH / pic.Height
      Var scale As Double = Min(Min(sW, sH), 1.0)
      
      Var newW As Integer = Max(1, pic.Width * scale)
      Var newH As Integer = Max(1, pic.Height * scale)
      
      ' Render into a new mutable bitmap of the target size
      Var outPic As New Picture(newW, newH)
      outPic.Graphics.DrawPicture(pic, 0, 0, newW, newH, 0, 0, pic.Width, pic.Height)
      
      ' Build a safe base name (strip the last extension; handle dotfiles)
      Var name As String = src.Name
      Var ext As String = name.LastField(".")
      Var baseName As String
      If ext = name Then
        ' No dot in the name
        baseName = name
      Else
        baseName = name.Left(name.Length - ext.Length - 1)
      End If
      If baseName.Trim = "" Then baseName = "image"
      
      ' Save JPEG (fallback PNG if JPEG export not supported)
      Var outFile As FolderItem = outFolder.Child(baseName + "_resized.jpg")
      If Picture.IsExportFormatSupported(Picture.Formats.JPEG) Then
        outPic.Save(outFile, Picture.Formats.JPEG, Picture.QualityHigh) ' adjust the quality of the jpeg here
      Else
        outPic.Save(outFolder.Child(baseName + "_resized.png"), Picture.Formats.PNG)
      End If
      
    Catch io As IOException
      ' Likely a write/permission/disk issue; skip this file
    Catch u As UnsupportedOperationException
      ' Unsupported format/operation on this platform; skip
    End Try
    
    ' Progress + message to the UI (safe handoff)
    Var pct As Integer = ((i + 1) * 100) / total
    Me.AddUserInterfaceUpdate(New Dictionary("progress":pct, _
    "msg":"Resized " + src.Name + " (" + pct.ToString + "%)"))
    
    ' Let the main thread paint the update
    Me.Sleep(kDelayMS, True) ' wakeEarly=True allows early resume when idle
  Next
  
  ' Final UI message
  Me.AddUserInterfaceUpdate(New Dictionary("progress":100, "msg":"Done"))
  
Catch e As RuntimeException
  ' Any unexpected failure: report a friendly error
  Me.AddUserInterfaceUpdate(New Dictionary("progress":0, "msg":"Error: " + e.Message))
End Try

Step 5: Receiving Updates and Safely Changing the UI

So, how does the main thread “hear” these updates? Through the UserInterfaceUpdate event on the ResizeThread itself! This event fires on the main thread, making it the one and only safe place to update our controls.

Here’s the code for the UserInterfaceUpdate event:

' This event runs on the main thread – SAFE to update controls here.
If data.Count = 0 Then Return

Var latest As Dictionary = data(data.LastIndex)

If latest.HasKey("progress") Then ProgressBar1.Value = latest.Value("progress")
If latest.HasKey("msg") Then StatusLabel.Text = latest.Value("msg")

' A little bonus: when we are done, open the output folder!
If latest.HasKey("msg") And latest.Value("msg") = "Done" Then
  Var outFolder As FolderItem = mSourceFolder.Child("resized")
  If outFolder <> Nil And outFolder.Exists Then
    outFolder.Open
  End If
End If

In this event, we receive an array of Dictionaries (all the updates that have queued up). We usually only care about the very latest one, so we grab data(data.LastIndex). Then, we safely access the values from the dictionary and assign them to ProgressBar1.Value and StatusLabel.Text. That’s it!

Conclusion

And there you have it! A fully functional, non-blocking image resizer. By moving the heavy work to a Thread, we’ve created an application that provides a smooth, professional user experience.

The pattern is simple:

1. Start the task from the main thread (ResizeThread.Start).
2. Work inside the thread’s Run event.
3. Communicate back to the UI with AddUserInterfaceUpdate.
4. Update the UI safely in the UserInterfaceUpdate event.

That’s pretty much it! Go ahead, download this project’s source code from GitHub, play around with it, and think about how you can use threads in your own applications!

Happy coding!

Gabriel is a digital marketing enthusiast who loves coding with Xojo to create cool software tools for any platform. He is always eager to learn and share new ideas!

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

This article will cover the Pair class, highlight its strengths, compare it with Arrays and Dictionaries, and assist you in identifying the most suitable tool for your needs.

What is the Pair Class?

In Xojo, the Pair class is a basic structure that stores two associated values: Left and Right. These properties can be of any data type, allowing you to pair together any two pieces of data.

Var myPair As New Pair("Pie", 15)
// or
Var myPair As Pair = "Pie" : 15

In the example above, myPair.Left is "Pie" (a String), and myPair.Right is 15 (an Integer). The Pair class is especially handy when you need to associate two pieces of data without the overhead of creating a dedicated class or structure.

Advantages of Using the Pair Class

1. Returning Multiple Values from a Method

Sometimes, you need a method to return more than one value. While you could use ByRef parameters or create a custom class, using a Pair provides a quick and clean solution.

Example:

Public Function GetMinMax(values() As Integer) As Pair
  Var minValue As Integer = values(0)
  Var maxValue As Integer = values(0)
  
  For Each value As Integer In values
    If value < minValue Then minValue = value
    If value > maxValue Then maxValue = value
  Next
  
  Return New Pair(minValue, maxValue)
End Function

// Usage
Var numbers() As Integer = Array(5, 2, 8, 3, 9)
Var result As Pair = GetMinMax(numbers)
MessageBox("Min: " + result.Left.StringValue + ", Max: " + result.Right.StringValue)

2. Associating Related Data Temporarily

When processing data, you might need to temporarily associate two values without persisting them or creating a complex data structure.

Example:

Var people() As Pair
people.Append(New Pair("Alice", 30))
people.Append(New Pair("Bob", 25))
people.Append(New Pair("Charlie", 35))

For Each person As Pair In people
  MessageBox(person.Left.StringValue + " is " + person.Right.IntegerValue.ToString + " years old.")
Next

3. Representation of Key-Value Pairs

While Dictionaries are designed for key-value storage, sometimes you might need to represent key-value pairs explicitly, such as when iterating over a Dictionary’s entries.

Example:

Var dict As New Dictionary
dict.Value("Red") = "#FF0000"
dict.Value("Green") = "#00FF00"
dict.Value("Blue") = "#0000FF"

For Each key As Variant In dict.Keys
  Var entry As New Pair(key, dict.Value(key))
  MessageBox(entry.Left.StringValue + " color code is " + entry.Right.StringValue)
Next

Comparison: Pair vs. Arrays vs. Dictionaries

Understanding when to use the Pair class over Arrays or Dictionaries is crucial for writing efficient code.

Pair

• Structure: Holds exactly two related values (Left and Right).
• Type Safety: Both Left and Right can be any data type.
• Usage: Ideal for associating two pieces of data temporarily or for methods that need to return two values.
• Performance: Lightweight and minimal overhead.

Arrays

• Structure: Ordered collection of elements, accessible by index.
• Type Safety: Elements are of the same data type (unless you use Variant arrays).
• Usage: Best when dealing with lists of items where order matters.
• Performance: Efficient for iterating over large collections.

Dictionaries

• Structure: Collection of key-value pairs, with unique keys.
• Type Safety: Keys are typically String or Integer, values can be any data type.
• Usage: When you need fast lookup of values by keys.
• Performance: Optimized for key-based access; overhead of hash table management.

Considerations for Using Pair Instead of Arrays or Dictionaries

• Simplicity: When you need to associate two items without creating a complex structure.
• Temporary Associations: For short-lived pairings within methods or loops.
• Returning Multiple Values: When methods need to return two related results.

Best Practices with Pair

• Immutable Data: Since Pair is a class, be cautious when modifying Left or Right properties, especially if the Pair is shared among different parts of your code.
• Descriptive Code: Use comments or naming conventions to clarify what Left and Right represent, as they do not provide semantic meaning on their own.

Example:

// Pair: Left = Product Name, Right = Price
Var productPair As New Pair("Laptop", 999.99)

Drawbacks and Constraints of the Pair Class

• Lack of Clarity: Unlike custom classes or structures, Pair does not convey the meaning of its contents through property names.
• Fixed Size: Limited to exactly two items; for more complex data, consider using a class or structure.
• Reference Type: Being a class, Pair is a reference type, which can have implications for memory management and threading.

Conclusion

The Pair class is a handy tool that can simplify your code when you need to associate two related values. While it doesn’t replace Arrays or Dictionaries, the Pair class is valuable in particular situations that prioritize simplicity and efficiency.

Resources:

• Learn more about Pair
• Learn more about Arrays
• Learn more about Dictionary

Gabriel is a digital marketing enthusiast who loves coding with Xojo to create cool software tools for any platform. He is always eager to learn and share new ideas!

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

You commonly use the Value method to add and get items from the Dictionary. For example, this adds “Red Sox” as the value for the key “TeamName”:

Dim teamDictionary As New Dictionary
teamDictionary.Value("TeamName") = "Red Sox"

Additional items are added the same way:

teamDictionary.Value("City") = "Boston"

This can get a bit tedious if you have lots of items to add. Instead you can make use of the Dictionary Constructor which takes a ParamArray of Pairs to populate it. A Pair is a class that has a Left value and a Right value. You could create a Pair like this:

Dim team As Pair = "TeamName":"Red Sox"

By using this Constructor, you can instead populate the Dictionary with one line like this:

Dim teamDictionary As New Dictionary("TeamName":"Red Sox", "City":"Boston")

I hope you find this tip useful. You can learn more about the Dictionary class here:

• Dictionary in Language Reference
• Dictionary in User Guide