Follow this tutorial to create active, aka clickable, words in the text of a TextArea control in your Xojo projects. Learn to use the Object-oriented Delegate design pattern to dynamically change how your app reacts when the user clicks on those active words. Best of all, this project is cross-platform, so you can use it for macOS, Windows and Linux!

The active words will be based on the use of Pairs, so one piece of information will be the active word and the other piece of information will be the associated data, which is always a String. The associated data could be a link or text you want to show in another control when the user clicks on the active word.

For the sake of this tutorial, the class we are creating has some limitations. For example, you won’t be able to repeat the same word and assign it to take different actions. If you want your code to react the same to the same active word or words throughout your project, well then, that’s what it will do. Anyway, this tutorial serves as a good starting point and you’ll be able to modify and improve it to meet your own needs.

Download the class with the example project from here.

TextArea Subclass

This feature will be based in the TextArea class, the first step is add a new TextArea control from the Library panel to the Navigator, change its name to LinkDetectorTextArea. Next, add the following Event Handlers to the TextArea subclass. These will be responsible for following the pointer movement and reacting to the registered active words for the instance.

• Open. To assign the pointer cursor, more appropriate for the kind of functionality this subclass will provide
• MouseMove. To detect if there is an active word under the cursor pointer to click on
• MouseDown. To call all the registered Observers when the user clicks on an active word, passing along the detected word and the associated information

Since we also want to make these events available for any instance created from the subclass, we have to create them again as Event Definitions. With the subclass selected in the Navigator, select Insert > Event Definition using the following signatures:

• Event Name. Open.
• Event Name. MouseMove. Parameters: X as Integer, Y as Integer.
• Event Name. MouseDown. Parameters: X as Integer, Y as Integer. Return Type: Boolean.

Add some Private properties used by the added Event Handlers and other methods we have yet to define to the class. Set these properties as private because they just need to be accessed from the class itself and not from other pieces of external code or additional classes inherited from the subclass:

• Name. boundedWord. Type: Pair. This is the property that will point to the current matched active word from the text.
• Name. previousBoundedWord. Type: Pair. This property points to the previous matched word from the text.
• Name. linkedWords. Type: Dictionary. This is the Dictionary that will contain all the active words / additional data pairs.
• Name. observers(). Type: ActionDelegate. This is an Array containing all the registered observers of the type ActionDelegate yet to be defined.

As we have seen, we need to define a Delegate type for the class. Select Insert > Delegate with the following data:

• Delegate Name: ActionDelegate.
• Parameters: boundedWord as Pair.
• Scope: Public.

Assigning the Cursor Type

Select the Open Event and add the following code in the corresponding Code Editor:

Me.MouseCursor = System.cursors.standardpointer
RaiseEvent open

We simply use this Event for assigning the Arrow cursor type that is most appropriate.

Matching the Active Words

Next, select the MouseMove Event Handler and type the following code in the corresponding Code Editor:

Var tlen As Integer = Me.Text.Length
If previousBoundedWord <> Nil Then
  setStyleForWord(previousBoundedWord, False)
  previousBoundedWord = Nil
End If

Var boundLeft, boundRight As Integer = -1
Var startPosition As Integer = Me.CharacterPosition(x,y)

If CharacterPosition(x,y) >= tLen Then
  If boundedWord <> Nil Then setStyleForWord( boundedWord, False )
  mboundedWord = Nil
ElseIf Me.Text.Middle(startPosition,1) <> Chr(32) And Me.Text.Middle(startPosition,1) <> EndOfLine Then
  For n As Integer = startPosition DownTo 0
    If Me.Text.Middle(n,1) = Chr(32) Or Me.Text.Middle(n,1) = EndOfLine or n = 0 Then
      boundLeft = n
      Exit
    End
    
  Next
  For n As Integer = startPosition To tlen
    If Me.Text.Middle(n+1,1) = Chr(32) Or Me.Text.Middle(n+1,1) = EndOfLine Or n = tlen Then
      boundRight = n+1
      Exit
    End
  Next
End

If boundLeft <> -1 And boundRight <> -1 Then
  Var isolatedWord As String = Me.Text.Middle(boundLeft, boundRight - boundLeft)
  Var check As pair = wordInDictionary( isolatedWord, boundleft, boundRight )
  If check  <> Nil Then 
    mboundedWord  = check
    If previousBoundedWord = Nil Then previousBoundedWord = mboundedWord
    setStyleForWord(previousBoundedWord, True)
  Else
    mboundedWord = Nil 
  End If
End If

RaiseEvent mouseMove(X, Y)

This code is in charge of detecting the limits of the word under the cursor and finding if it is one of the active words registered for the class.

Reacting to Active Words

Finally, select the MouseDown Event Handler and write the following code into the associated Code Editor:

If linkedWords <> Nil And boundedWord <> Nil Then
  Var p As New pair(mboundedWord.Left,linkedWords.Value(mboundedWord.Left))
  For Each item As LinkDetectorTextArea.ActionDelegate In observers
    item.Invoke p
  Next
  Return True
End If

Return RaiseEvent mousedown(x,y)

This code will invoke all the registered Observers for the active word detected under the cursor.

Registering the Active Words

We need a way to inform the instances about the active words to be aware of. We could do that from a Constructor or using a Computed Property. In this case, we will use a method for assigning the received Dictionary of Pairs to the Property in charge of storing that information. Select Insert > Method and use this data in the associated Inspector Panel:

• Name: setDictionary.
• Parameters: d As Dictionary.
• Scope: Public.

In the associated Code Editor, put this simple line of code:

linkedWords = d

Registering (and Deregistering) Observers

As we have said, the class will be able to react to the active words, so we need to provide a couple of methods to register and deregister Observers at any time. Use the following information for the first method:

• Method Name: registerObserver.
• Parameters: observer as ActionDelegate.
• Scope: Public.

And write this line of code in the associated Code Editor:

if observer <> nil then observers.add observer

Add a second method that will be in charge of deregistering an Observer. Use the following data for that:

• Method Name: deleteObserver.
• Parameters: observer As LinkDetectorTextArea.ActionDelegate.
• Scope: Public.

This is the code that will search and remove the received ActionDelegate from the instance Array of Observers:

If observer <> Nil Then
  Var n As Integer = observers.IndexOf(observer)
  observers.RemoveAt(n)
end

Regular Expressions to the Rescue … and Styling!

Finally, add a couple of methods to finish the TextArea subclass. These will be Private for the class, auxiliary methods called mainly from the Event Handlers. The first one is the method that does the matching with the received candidate and upon finding a match, will return the corresponding data pair to the caller. To do this, add a new Method using the following data:

• Method Name: wordInDictionary.
• Parameters: word As string, leftposition As integer, RightPosition As integer.
• Return Type: Pair.
• Scope: Private.

And write the following code in the associated Code Editor:

#Pragma Unused RightPosition

Var theRightPosition As Integer
Var re As New RegEx
re.SearchPattern = "[a-zA-Z]+"
Var rm As RegExMatch
rm = re.Search(word)

If rm <> Nil Then 
  Var foundword As String = rm.SubExpressionString(0)
  Var characterPosition As Integer = word.LeftBytes(rm.SubExpressionStartB(0)).Length
  word = foundword
  leftposition = leftposition + characterPosition
  therightposition = leftposition + word.Length
End If

If linkedWords.HasKey(word) Then Return New pair(word,leftposition.ToString+"-"+ theRightPosition.ToString)

Var blu As Integer
Var dictionaryKeys() as variant = linkedWords.Keys

for each thekey as string in dictionaryKeys  
  If thekey.IndexOf(word) <> -1 Then
    blu = Me.Text.IndexOf(thekey)
    If leftposition >= blu And leftposition <= (blu + thekey.Length) Then
      Var finalposition As Integer =blu+thekey.Length
      Return New pair(thekey,blu.ToText+"-"+finalposition.ToString)
    end if
  end
next

Return nil

Adding Style

Finally, we need to choose how to inform the user that the word below the cursor is an active word so they can click on it. For this example, I’ve used the Underline text style, but you can change that. Add the last method for the class using the following data:

• Method Name: setStyleForWord
• Parameters: word As pair, mode As Boolean.
• Scope: Private.

Use the mode parameter in order to use the method to apply or delete the style. For example, removing the style from the previous detected active word and styling the new one. Write the following code in the associated Code Editor:

Var cStart, cEnd As Double
cStart = word.Right.StringValue.NthField("-",1).Val
cEnd = word.Right.StringValue.NthField("-",2).Val - cStart

Var t As StyledText

t = Me.StyledText

cstart = If( cstart - 1 < 0, 0, cstart)

t.Underline(cstart, cEnd) = mode

Putting it all together!

With the subclass finished it is time to do some Window Layout so we can test the subclass functionality. Select the Window1 item in the Navigator to access the Window Layout Editor and drag the LinkDetectorTextArea subclass from the Navigator onto the Window Layout. Use the Inspector to change its name to myURLField. Then add three Label controls and an HTMLViewer, both from the Library. The HTMLViewer will show the URL associated with the active word, while one of the three Label controls will show the detected active words. Both the URL loading as the displaying of the detected word will be done by a previously registered Observer (a window method). The finished window layout should look something like this:

Where the text under the “Sample Text” label is the one assigned to the Text property of the LinkDetectorTextArea instance.

Now, let’s add to the Window1 object the method that will act as an Observer, select the Add > Method option in combination with the following data:

• Name: updateContents
• Parameters: p as pair
• Scope: Public

And put the following code in the associated Code Editor:

linkedControl.Text = p.Left
HTMLViewer1.LoadURL p.Right

Lastly, add the Open event to the Window1 window, adding the following code to the associated Code Editor. This will initialize the LinkDetectorTextArea instance providing the clickable words and their associated URLs:

myURLField.setDictionary New Dictionary("Xojo":"https://www.xojo.com","iOS":"http://www.apple.com/ios/",_
"macOS":"http://www.apple.com/osx/", "Windows":"https://www.microsoft.com/en-US/windows","Linux":"https://es.wikipedia.org/wiki/GNU/Linux",_
"Raspberry Pi":"https://www.raspberrypi.org/","AprendeXojo":"https://www.aprendexojo.com","Web":"https://www.xojo.com/web")

myURLField.registerObserver WeakAddressOf updateContents

Run the project, move the cursor over the text and you will see the how the active words are underlined on the fly; and if you click on any of them, the Window will display the detected word, while loading the associated URL.

Of course, this can be vastly improved and expanded upon … enjoy!

Paul learned to program in BASIC at age 13 and has programmed in more languages than he remembers, with Xojo being an obvious favorite. When not working on Xojo, you can find him talking about retrocomputing at Goto 10 and on Mastodon @lefebvre@hachyderm.io.

If you need a refresher on the Singleton design pattern, read Design Patterns in Xojo: Singleton.

First, I inserted a class into my project and called it SessionSingleton (if you don’t name your class SessionSingleton you need to replace all references to that name in your class).

Next, I added a property to that class with the name SessionIdentifier As String with no default value and set as private scope. This will hold the Session.Identifier associated with this object.

Protected Property SessionIdentifier as String

Now add a method called Constructor and make it private, this is to prevent the object from being created outside control of the class.

Private Sub Constructor()

End Sub

Add another method called Constructor with a parameter SessionIdentifier As String and make it private. In this method add the code:

Protected Sub Constructor(SessionIdentifier As String)
  Me.SessionIdentifier = SessionIdentifier
  Constructor()
  
End Sub

This saves the Session Identifier and runs the constructor method (which may be used by you to initialize properties etc. of the object).

Now, add a shared Property mInstances() As SessionSingleton and make it private. This will hold the array of session Singletons.

Private Shared Property mInstances() as SessionSingleton

Lastly, we need to add two public Shared Methods. The first is:

Public Shared Function GetInstance(SessionIdentifier As String) as SessionSingleton
  // Find the instance.  If it exists return it.
  For i As Integer = 0 To mInstances.LastRowIndex
    If mInstances(i).SessionIdentifier = SessionIdentifier Then
      Return mInstances(i)
    End If
  Next
  
  // Not found so create a new instance and return it
  mInstances.AddRow(New SessionSingleton(SessionIdentifier))
  System.DebugLog("Creating new instance for Session with ID " + SessionIdentifier)
  
  Return mInstances(mInstances.LastRowIndex)
  
End Function

This code returns an existing instance or creates and returns a new one.

Now, because a Web application is multi-user app there’s the need to clean up when a session is closed so we need the second Shared Method:

Public Shared Sub DestroyInstance(SessionIdentifier As String)
  // This function will remove the instance and should be called from the 
  // Session.Closing event
  For i As Integer = 0 To mInstances.LastRowIndex
    If mInstances(i).SessionIdentifier = SessionIdentifier Then
      mInstances(i) = Nil
      mInstances.RemoveRowAt(i)
    End If
  Next
End Sub

In this code we find the instance that has the identifier of the current session and destroy that object.

To use the class you would:

Var Singleton As SessionSingleton = SessionSingleton.GetInstance(Session.Identifier)

Or if in a Session Event Handler:

Var Singleton As SessionSingleton = SessionSingleton.GetInstance(Identifier)

Add the code to the Session.Closing Event handler to clean up.

SessionSingleton.RemoveInstance(Identifier)

Don’t forget to replace all references to SessionSingleton to your class name.

You may have noticed I haven’t excluded an empty string as the SessionIdentifier and indeed have defaulted the constructor to this empty string. This allows me to use this same class in my desktop projects and potentially when handling Special URL’s in a web project.

Wayne Golding has been a Xojo developer since 2005 and is a Xojo MVP. He operates the IT Company Axis Direct Ltd which primarily develops applications using Xojo that integrate with Xero www.xero.com. Wayne’s hobby is robotics where he uses Xojo to build applications for his Raspberry Pi, often implementing IoT for remote control.

Our active words will be based on the use of Pairs, so one of the pieces of information will be the active word (or words) we want to detect on the text, and the other piece of information for the Pair will be any associated data you want…this is always a String. For example, the associated data could be a link or text you want to show in another control when the user clicks on the word.

For the sake of this tutorial, the class created has some limitations. For example, you can’t repeat the same word (or same combination of words) assigning them to different actions. If you do that, the class will alway react to the first occurrence found; if you want your code to always react the same to the same active word or words…then that’s ok. Anyway, this tutorial serves as a good starting point so you can modify and improve it to meet your own needs.

You can download the class with the example project from here.

TextArea subclass

This feature will be based in the TextArea class, so the first step is add a new TextArea control from the Library panel to the Navigator, changing its name to LinkDetectorTextArea. Next, add the following Event Handlers to our TextArea subclass. These will be responsible for following the pointer movement and reacting to the registered active words for the instance:

• Open. Just to assign the Pointer cursor, more appropriate for the kind of functionality this subclass will provide.
• MouseMove. Here is where we will detect if there is an active word (or combination of words) found under the cursor pointer.
• MouseDown. This is the Event Handler that will call all the registered Observers when the user clicks on an active word, passing along the detected word and the associated information.

As we want to make these events also available for any instance created from our subclass, then we have to create them again as Event Definitions. With the subclass selected in the Navigator, select Insert > Event Definition using the following signatures:

• Event Name. Open.
• Event Name. MouseMove. Parameters: X as Integer, Y as Integer.
• Event Name. MouseDown. Parameters: X as Integer, Y as Integer. Return Type: Boolean.

Next we will need to add to the class some Private properties used by the added Event Handlers and other methods yet to define. These properties will be set as private because they just need to be accessed from the class itself, and not from other pieces of external code or additional classes inherited from our own subclass:

• Name. boundedWord. Type: Pair. This is the property that will point to the current matched active word from the text.
• Name. previousBoundedWord. Type: Pair. This property points to the previous matched word from the text.
• Name. linkedWords. Type: Dictionary. This is the Dictionary that will contain all the active words / additional data pairs.
• Name. observers(). Type: ActionDelegate. Array containing all the registered observers of the type ActionDelegate yet to define.

As we have seen, we need to define a Delegate type for our class. Select Insert > Delegate with the following data:

• Delegate Name: ActionDelegate.
• Parameters: boundedWord as Pair.
• Scope: Public.

Assigning the Cursor type

Select the Open Event and add the following code in the corresponding Code Editor. We simply use this Event for assigning the Arrow cursor type that is more appropriate for the kind of functionality offered:

Me.MouseCursor = System.cursors.standardpointer
RaiseEvent open

Matching the Active Words

Next, select the MouseMove Event Handler and type the following code in the corresponding Code Editor. This code is in charge of detecting the limits of the word under the cursor and finding if it is one of the active words registered for the class:

Dim length As Integer = Me.Text.Len
if previousBoundedWord <> nil then
  setStyleForWord(previousBoundedWord, false)
  previousBoundedWord = nil
end if
dim boundLeft, boundRight as integer

Dim startPosition As Integer = Me.CharPosAtXY(x,y)

If CharPosAtxy(x,y) >= length Then
  if boundedWord <> nil then setStyleForWord( boundedWord, false )
  mboundedWord = nil
elseif me.text.mid(startPosition,1) <> chr(32) and me.Text.mid(startPosition,1) <> EndOfLine then
  for n as integer = startPosition DownTo 1
    if me.Text.mid(n-1,1) = chr(32) or me.Text.mid(n-1,1) = EndOfLine then
      boundLeft = n
      exit
    end
  next
  for n as integer = startPosition to length
    if me.Text.mid(n+1,1) = chr(32) or me.Text.mid(n+1,1) = EndOfLine or n = length then
      boundRight = n+1
      exit
    end
  next
end
dim isolatedWord as string = me.Text.mid(boundLeft, boundRight - boundLeft)
dim check as pair = wordInDictionary( isolatedWord, boundleft, boundRight )
if check  <> nil then
  mboundedWord  = check
  if previousBoundedWord = nil then previousBoundedWord = mboundedWord
  setStyleForWord(previousBoundedWord, true)
else
  mboundedWord = nil
end if
RaiseEvent mouseMove(X, Y)

Reacting to Active Words

Finally, select the MouseDown Event Handler and write the following code into the associated Code Editor. This code will invoke all the registered observers for the active word detected under the cursor pointer (if any):

If linkedWords <> Nil And boundedWord <> Nil Then
  Dim p As New pair(mboundedWord.Left,linkedWords.Value(mboundedWord.Left))
  For Each item As LinkDetectorTextArea.ActionDelegate In observers
    item.Invoke p
  Next
  Return True
End If
Return RaiseEvent mousedown(x,y)

Registering the Active Words

We need a way to inform the instances about the active words it has to be aware of. We could do that from a Constructor or using a Computed Property instead of a regular one. In this case, we will use a method for assigning the received Dictionary of Pairs to the Property in charge of storing that information. So, select Insert > Method and use this data in the associated Inspector Panel:

• Name: setDictionary.
• Parameters: d As Dictionary.
• Scope: Public.

In the associated Code Editor we just need to put this simple line of code:

linkedWords = d

Registering (and deregistering) Observers

As we have said, our class will be able to react to the active words, so we need to provide a couple of methods to register and deregister Observers at any time. Use the following information for the first method:

• Method Name: registerObserver.
• Parameters: observer as ActionDelegate.
• Scope: Public.

And write this line of code in the associated Code Editor:

if observer <> nil then observers.Append observer

Add a second method that will be in charge of deregistering an observer. Use the following data for that:

• Method Name: deleteObserver.
• Parameters: observer As LinkDetectorTextArea.ActionDelegate.
• Scope: Public.

This is the code that will search and remove the received ActionDelegate from the instance Array of observers:

If observer <> Nil Then
  observers.Remove( observers.IndexOf( observer ) )
end

Regular Expressions to the rescue… and Styling!

Finally we just need to add a couple of methods more for finishing our TextArea subclass. These will be Private for the class, auxiliary methods called mainly from the Event Handlers. The first one will be the method in charge of doing the matching from the received candidate, and if it finds it, then it will return the corresponding pair of data to the caller. For this one, add a new Method using the following data:

• Method Name: wordInDictionary.
• Parameters: word As string, leftposition As integer, RightPosition As integer.
• Return Type: Pair.
• Scope: Private.

And write the following code in the associated Code Editor:

Dim theRightPosition As Integer
dim re as new RegEx
re.SearchPattern = "[a-zA-Z]+"
dim rm as RegExMatch
rm = re.Search(word)
if rm <> nil then
  dim foundword as string = rm.SubExpressionString(0)
  dim characterPosition as integer = word.LeftB(rm.SubExpressionStartB(0)).Len
  word = foundword
  leftposition = leftposition + characterPosition
  therightposition = leftposition + word.Len
end if
if linkedWords.HasKey(word) then Return new pair(word,leftposition.ToText+"-"+ theRightPosition.ToText)
dim blu as integer
dim dictionaryKeys() as variant = linkedWords.Keys
for each thekey as string in dictionaryKeys
  if thekey.InStr(word) > 0 then
    blu = me.text.instr(thekey)
    if leftposition >= blu and leftposition <= (blu + thekey.Len) then
      dim finalposition as integer =blu+thekey.len
      Return new pair(thekey,blu.ToText+"-"+finalposition.totext)
    end if
  end
next
Return nil

Adding some style

Finally, we need a way to inform the user that the word down the pointer cursor is active so she can click on it. For this example I’ve used the Underline text style, but you can adapt it once you see how this is done. So, let’s add the last method for the class using the following data:

• Method Name: setStyleForWord
• Parameters: word As pair, mode As Boolean.
• Scope: Private.

We use the mode parameter so we can use the method to apply or delete the style to the received word; removing for example the style from the previous detected active word and styiling the new one. Write the following code in the associated Code Editor:

Dim cStart, cEnd, sStart As Double
cStart = NthField(word.Right,"-",1).Val
cEnd = NthField(word.Right,"-",2).Val - cStart
Dim t As StyledText
t = Me.StyledText
cstart = If( cstart - 1 < 0, 0, cstart-1)
t.Underline(cstart, cEnd) = mode

Putting it all together!

With our subclass finished it is time to do some Window Layout so we can test the subclass functionality. Select the Window1 item in the Navigator to access the Window Layout Editor and drag the LinkDetectorTextArea subclass from the Navigator onto the Window Layout in order to create a new instance. Use the Inspector to change its name to myURLField. Then add three Label controls from the Library and an HTMLViewer. The HTMLViewer will show the URL associated with the active word, while one of the three Label controls will show the detected active words. Both the URL loading as the displaying of the detected word will be done by a previously registered observer (a window method). The Finished window layout should be something like this:

Where the text under the “Sample Text” label is the one assigned to the Text property of the LinkDetectorTextArea instance.

Let’s add now to the Window1 object the method that will act as an observer, so select the Add > Method option in combination with the following data:

• Name: updateContents
• Parameters: p as pair
• Scope: Public

And put the following code in the associated Code Editor:

linkedControl.Text = p.Left
HTMLViewer1.LoadURL p.Right

Lastly, add now the Open event to the Window1 window, adding the following code to the associated Code Editor. Here is where we will initialize our LinkDetectorTextArea instance providing the clickable words and their associated URL:

myURLField.setDictionary New Dictionary("Xojo":"http://www.xojo.com","Web":"https://www.w3.org","iOS":"http://www.apple.com/ios/",_"OS X":"http://www.apple.com/osx/", "Windows":"https://www.microsoft.com/en-US/windows","Linux":"https://es.wikipedia.org/wiki/GNU/Linux",_
"Raspberry Pi":"https://www.raspberrypi.org/","AprendeXojo":"http://www.aprendexojo.com")
myURLField.registerObserver WeakAddressOf updateContents

Run the project, move the pointer cursor over the text and you will see the how the detected active words are underlined on the fly; and if you click on any of them, then the Window will display the detected word, loading the associated URL.

Of course, this can be vastly improved…and that is something that maybe you can do in any number of ways!

Javier Rodri­guez has been the Xojo Spanish Evangelist since 2008, he’s also a Developer, Consultant and Trainer who has be using Xojo since 1998. He manages AprendeXojo.com and is the developer behind the GuancheMOS plug-in for Xojo Developers, Markdown Parser for Xojo, HTMLColorizer for Xojo and the Snippery app, among others

*Read this post in Spanish

Whether you’re new to programming or an experienced developer, there are some things you’ll just never find in a reference manual. We’re passionate about writing good code and these are our 10 tips to be a better programmer.

1. Be curious – ask questions and seek answers

Computers aren’t magical. They do things in a methodical and predictable way. If you are curious about why they are doing what they are doing, you can learn a lot.

2. Be methodical

Computers follow the steps we tell them in our code one after the other (even in multithreaded programs although there can be fun side effects in this case). They start at the beginning and work their way along until they either finish, the user quits them or maybe – unfortunately- they crash. But they just do what we tell them.

3. Read the docs

No matter how many times you do something if you have problems read the documentation. You may learn something new from them even if you’ve been doing it for years. (This ties into point #1 as well). Documentation is there to help you learn how to use things.

4. Try things out

It usually can’t hurt… well, unless you’re writing something that may wipe out data on a hard drive, etc. In that case, you should have “testing” set up to be able to try out ideas – version control systems can help here.

5. Don’t be afraid to get help

Ask colleagues, friends, forums or wherever else you can get help AFTER you’ve read the docs. Being self-reliant and self-sufficient is, in many ways, the mark of a good programmer. They try out things and exhaust the resources they have ready access to before they come asking for help in emails lists and forums. Members appreciate it when they can say, “Did you try …” and the reply is, “I tried everything like ….” with a long of things already tried. Often we see forums, Twitter and Facebook are used as the first thing consulted without having looked over docs or existing samples and examples.

6. Learn from those who have come before you

The best thing a person can start out doing is maintenance work, you’ll learn good habits and those bad habits to avoid in code. And applying steps 1 to 5 along the way will result in learning a lot more. And hopefully you’ll have a good mentor!

7. Be a mentor

Sharing what you know with those less experienced helps you become better at what you do. You HAVE to know your subject VERY well in order to teach someone. Teaching is the best way to learn, even if you’re not that good, but answering questions (and maybe researching the answer) will only help you too.

8. Learn about design patterns

They’re invaluable when it comes to figuring out how to approach and solve a commonly occurring problem. Some key design patterns include: Observer and Singleton.

9. Review code, acquire ideas, refactor, and then do it again and again and again

Code is never “done”. It always needs to evolve, be updated, or rewritten. Get in the habit of reviewing your code with other programmers you work with. Even when you think it’s perfect, a different set of eyes can often find something you hadn’t considered or an optimization. A code review revealed a great one for me that I wrote about here.

10. Be brave

Don’t be afraid to tackle hard problems or to fail. It’s how we learn.

Bonus Tip: Look at various programming languages

Even check out ones you’ll likely never use! It helps you gain perspective on how other languages approach solutions and problems. Sometimes that perspective is whats needed to figure out how to solve a problem.

The Singleton and Observer Design Patterns have been described in previous blog entries and I highly recommend to read them now so you can get the flavor of the fundamentals behind them. I’ll wait here for you, I promise! Then we will deal with the code that varies to implement our NotificationCenter class, and to put it in practice with a Desktop example project.

Of course, before of continuing reading, you can download the example project, run it and review the code to get a first glance of what it does and how it works. Then, you can come back and continue reading if you want to better understand the NotificationCenter class inner, or how other objects can use this class.

The NotificationCenter Class

Execute the Xojo IDE and create a new Desktop project. Add a new class using Insert > Class. Go to the Inspector and change the Name attribute to “NotificationCenter”. This is the name of the new class we are designing (and, thus, a new Data Type).

With the new class still selected in the Navigator (the leftmost column on the Xojo IDE), add a new Shared Property (Insert > Shared Property). Use the Inspector again to change the Name attribute to “Instance”, the Type field to “NotificationCenter” and the Scope to “Private”. (You know, a Shared Property or Shared Method are those that you can access from the class itself, without needing to create previously a new instance from the class.)

Add a second Property to the class, this time via Insert > Property (this is, an instance property). Use this values on the associated Inspector:

• Name: Objects
• Type: Xojo.Core.Dictionary
• Scope: Private

Next, add a new Method (Insert > Method). Use the Inspector to choose the Constructor option from the “Method Name” dropdown menu, and set the method Scope to Private.

Write the following code on the associated Code Editor for the method:

Objects = new xojo.core.Dictionary

Defining the Constructor method with a Private scope prohibits the creation of several instances from the class. Instead of that, the class consumers will have to use the convenience method defined by us in order to retrieve the same —and unique— instance for all the cases.

So, now we will add a new Shared Method using Insert > Shared Method. Use the Inspector to put the following values on the created method:

• Name: SharedInstance
• Return Type: NotificationCenter

And write the following code in the associated Code Editor for the method:

if instance = nil then instance = new NotificationCenter
Return instance

These are the wires to write our Singleton class and to define our Data Model: the “Objects” property of data type Xojo.Core.Dictionary. This property will be responsible for storing the registered objects as observers of the desired Control(s), as well as the messages for whom it is interested in receiving notifications for the observed object(s). Probably this is better understood in the following figure:

That is, the “Observers” Xojo.Core.Dictionary Property uses as Key any object of RectControl data type (the observed object). The associated value for that key is a new Xojo.Core.Dictionary, whose entries will use as Key the Notification (message as Text data type) for what an object wants to register as observer for such Control.

This way, one same object can be registered to several controls and also to several messages (Notifications) on one or several controls.

Finally, the associated value for every Key on this second Xojo.Core.Dictionary is an Array data type whose items are instances of the NotificationReceiver data type.

I know, I know… Stop. Breathe. Execute again the example project. Review the code on the “Register” method to get a better grasp… and back to follow!

Registering Observers

With the class still selected on the Navigator, add a new method (Insert > Method) using the following values. This is the method responsible for registering the new observers on the shared Notification Center instance:

• Name: Register
• Parameters: sourceControl as NotificationReceiver, observedObject as RectControl, message as Text
• Scope: Public

As you can see in “Parameters”, the first parameter is the Observer object (this is the interesed object in receiving the notifications); the second parameter is the observed object (that is from which we want to receive notifications); and the third parameter is the message from which we are interested in receiving the notifications by the observed object.

Write the following code on the Code Editor associated for this method:

dim observedObjects as xojo.Core.Dictionary = Objects.Lookup( observedObject, new xojo.core.Dictionary )
dim messages() as NotificationReceiver
if observedObjects.HasKey( message ) then messages = observedObjects.Value( message )
messages.Append sourceControl
observedObjects.Value( message) = messages
objects.Value( observedObject ) = observedObjects

Sending Notifications

Now is time to add to the class the method responsible to send the notifications to those objects interested in receiving them from any previously registered object. Insert a new method for the NotificationCenter class and use the following values in the associated Inspector:

• Name: sendNotification
• Parameters: sourceObject as RectControl, message as text, value as Auto
• Scope: Public

And the following code in the Code Editor associated with the method:

dim observedObjects as xojo.Core.Dictionary = objects.Lookup(sourceObject, nil)
if observedObjects <> nil then
  dim sourceObjects() as NotificationReceiver
  if observedObjects.haskey(message) then sourceObjects = observedObjects.Value( message )
  for n as integer = 0 to sourceObjects.Ubound
    dim target as NotificationReceiver = sourceObjects(n)
    target.valueReceived( value, message )
  next
end if

As you can see, the first parameter of the method is the control that wants to send a notification (second parameter) to all the possible registered objects, passing the value that such objects can be interested to receive for processing it (third parameter).

Stop receiving Notifications

However, it is probable that one object wants to stop receiving notifications from any previously registered control. For that, we need to add a new method to the NotificationCenter class using this values:

• Name: RemoveObserver
• Parameters: sourceControl as NotificationReceiver

And the following code on the associated Code Editor:

for each observedObjects as xojo.Core.DictionaryEntry in objects
  dim d as xojo.Core.Dictionary = objects.Value(observedObjects.Key)
  for each messagesForObject as xojo.Core.DictionaryEntry in d
    dim sourceObjects() as NotificationReceiver = d.Value(messagesForObject.Key)
    for n as integer = sourceObjects.Ubound DownTo 0
      if sourceObjects(n) = sourceControl then sourceObjects.Remove(n)
    next
  next
next

Stop receiving some Notifications

It may also be the case that one object wants to unsuscribe from the Notification Center to stop receiving just one particular notification. For that, add a new method and use the following values on the Inspector:

• Name: removeObserverForMessage
• Parameters: sourceControl as NotificationReceiver, message as text

And write the following code in the associated Code Editor:

for each observedObjects as xojo.Core.DictionaryEntry in objects
  dim d as xojo.Core.Dictionary = objects.Value(observedObjects.Key)
  for each messagesForObject as xojo.Core.DictionaryEntry in d
    if messagesForObject.Key = message then
      dim sourceObjects() as NotificationReceiver = d.Value(messagesForObject.Key)
      for n as integer = sourceObjects.Ubound DownTo 0
        if sourceObjects(n) = sourceControl then sourceObjects.Remove(n)
      next
    end if
  next
next

One Class Interface that runs them all: NotificationReceiver

Along the implementation of our Notification Center class we have seen several times the reference to the NotificationReceiver data type. This is what we are going to get our hands on next.

In fact this is a Class Interface; what means that it works as a “glue” in order that any object can implement their defined methods. This way the objects can be seen as their native class and also as an instance from NotificationReceiver, so they can be registered as observers on the Notification Center independently the native class they are based on.

Use Insert > Class Interface to add a new Class Interface to the project. Next, write the following values in the associated Inspector:

• Name: NotificationReceiver

With the Class Interface still selected in the Navigator, add a new method using the following signature in the Inspector:

• Method Name: valueReceived
• Parameters: value as Auto, message as Text

Done! Depending on your own needs, you can add more methods for the interface class in combination with the Notification Center class itself.

Testing the Notification Center

Now it is time to design the user interface in order to test the Notification Center class. The changes made on a TextField control will automatically update the contents of a Label control, a Slider control, a ListBox control and a Canvas control. Moreover, the Label instance will subscribe in the Notification Center to receive two types of notifications, changing his behaviour (the text shown) based on the received notification.

We will also add a couple of CheckBox controls to test the functionality to unsuscribe the Label control from all or just some notifications.

But before we start with that, and as we have seen in the previous step, we need that all the objects that want to be able to register on the Notification Center be of the NotificationReceiver data type. That means that we need to create our own subclases for the Label, Slider, ListBox and Canvas controles. Let’s start with the Label!

Label Subclass

Create a new sublcass for the Label Class. You can do that selecting the Label control from the Library and choosing the “New Subclass” option from the contextual menu; or you can drag and drop the control from the Library to the Navigator. Anyway, the result will be the same: you will have created a new subclass with the name “CustomLabel” (it can vary, depending the Xojo release you use). By the way, you also can use Insert > Class in order to create a new subclass.

Regardless of the method used to create the new subclass, choose it in the Navigator and use this values in the associated Inspector:

• Name: MyLabel
• Super: Label // This way, our sublcass will inherit all the methods, events and properties from the base class.
• Interfaces: Click on the button and choose “NotificationReceived” from the resulting panel/Window. Confirm the selection clicking on the “OK” button.

As result of the last action, Xojo will automatically added the ValueReceived method to the class. Write the following code in the associated Code Editor:

RaiseEvent newValueReceived value, message

Here we raise a new event (not defined yet), so every instance from the class can be in charge of implement the real behavior in base of the parameters received.

So, with the “MyLabel” class still selected, use Insert > Event Definition to add the event definition we need. Use the following values in the associated Inspector:

• Event Name: newValueReceived
• Parameters: value as auto, message as Text

Slider Subclass

Add a new subclass and use these values in the associated Inspector:

• Name: MySlider
• Super: Slider
• Interfaces: Add the NotificationReceiver Class Interface as seen in the previous step.

Write the following code for the ValueReceived method:

RaiseEvent newValueReceived val(value)

And add the event definition using Insert > Event Definition, as we have seen in the previous step. Use this signature in the Inspector:

• Event Name: newValueReceived
• Parameters: value as integer

ListBox Subclass

Let’s create now the subclass for the ListBox, following basically the same steps already done with the previous subclasses. Use the following values:

• Name: MyListBox
• Super: ListBox
• Interfaces: NotificationReceiver

Write the following code in the Code Editor associated with the ValueReceived method added by the Class Interface:

RaiseEvent newValueReceived val(value)

And add the corresponding Event Definition using this signature:

• Event Name: newValueReceived
• Parameters: value as integer

Canvas Subclass

We have arrived to the last subclass definition for our example project. Add a new subclass to the project and use this values in the associated Inspector:

• Name: MyCanvas
• Super: Canvas
• Interfaces: NotificationReceiver

Write the following code for the ValueReceived method:

dim s as string = value
newValue = s.ToText
me.Refresh

Next, use Insert > Event Handler to add the Paint event to the subclass. Write this code in the associated Code Editor:

dim size as integer = val(newValue)
g.TextSize = size
dim centerx as integer = g.Width/2 - g.StringWidth(newValue)/2
dim centery as integer = g.Height/2+g.StringHeight(newValue,g.Width)/2
g.ForeColor = rgb(size, size, size)
g.FillRect(0,0,g.Width,g.Height)
g.ForeColor = if(size <= 50, rgb(255,255,255), rgb(0,0,0))
g.DrawString(newValue,centerx,centery)

Lastly, add a new property to the subclass using Insert > Property, and using this values:

• Name: newValue
• Type: Text
• Scope: Private

Designing the User Interface

Once we have created the subclasses for the Controls we will use as observers in our example app, it is time to design the user interface. For that, choose the window by default for the project (Window1).

Xojo will show the Layout Designer for the selected Window. Drag the subclass controls from the Navigator (or from the Library) so they are arranged as shown in this picture. In addition, drag a couple of CheckBox controls and one TextField too from the Library to the layout.

Choose the label instance (with the name “Label2” in the example project) and use Insert > Event Handler to add the “newValueReceived” event handler previously defined in our class. Write the following code in the associated Code Editor:

dim s as string = value
Select case message
  case "valueChanged"
    me.Text = "Value on source Control: "+ s
  case "charValue"
    me.Text = "ASCII Code for last keystroke: "+ str(asc(s))
End Select

As you can see, the event uses the received message to decide how to work with the value sent by the observed object. In one case it will show the value as is, and for the other it will show the ASCII code for the value received as Text.

Select now the Slider instance (with the name “Slider1” in the example project), and repeat the action to add the Event Handler “newValueReceived” to the control. Write the following code in the associated Code Editor:

me.Value = value

In this case, the control will simply assign to his “value” property the value received.

Select now the ListBox instance (“ListBox1” in the example project). Add the Event Handler “newValueReceived” and write this line of code:

me.ListIndex = value

We will also add the “Open” Event Handler, so we can populate some default values to use in the example. Once we’ve added this event, write the following code in the associated Code Editor:

for n as integer = 0 to 99
  me.AddRow str(n)
next

Lastly, select the TextField instance (“TextField1” in the example project), and add the “Keydown” and “Lost Focus” Event Handlers. Once added, select the KeyDown event handler and write the following code:

dim myNotificationCenter as NotificationCenter = NotificationCenter.sharedInstance
myNotificationCenter.sendNotification(me,"charValue",key)

Next, select the LostFocus event and writhe the following code:

dim myNotificationCenter as NotificationCenter = NotificationCenter.sharedInstance
mynotificationcenter.sendNotification(me,"valueChanged",me.Text)

For both cases, we retrieve the shared instance from the Notification Center class and publish a new notification, passing along the own control as first argument (acting as originator), the message or published notification as second argument, and the value sent as the third argument. From this point on, the Notification Center will be in charge of propagate the received notification to all the interested objects.

Subscribing and Unsubscribing to Notifications

Let’s get in charge of the user interface controls whose function is to enable and disable the notifications for our MyLabel instance (Label1).

Select the CheckBox1 control, add the Action event handler and write the following code in the associated Code Editor:

dim miNotificationCenter as NotificationCenter = NotificationCenter.sharedInstance
select case me.Value
  case true
    miNotificationCenter.register(Label2,TextField1, "valueChanged")
    miNotificationCenter.register(Label2, TextField1, "charValue")
  case False
    miNotificationCenter.removeObserver(Label2)
    CheckBox2.value = false
end select

Select now the CheckBox2 control, add the Action event handler and write the following code:

dim miNotificationCenter as NotificationCenter = NotificationCenter.sharedInstance
select case me.Value
  case true
    miNotificationCenter.register(Label2,TextField1, "valueChanged")
  case False
    miNotificationCenter.removeObserverForMessage(Label2,"valueChanged")
end select

As you can see, in the first block of code we register the “Label2” control so it can receive both notifications when the checkbox value is True, and unsubscribe the control from receiving any notification when the checkbox is False. For the second block of code, the “Label2” control just subscribe or unsubscribe for one of the two notifications, respectively.

Starting engines!

What we need to put all to work? Add the Open event handler to “Window1” and write the following code.

dim miNotificationCenter as NotificationCenter = NotificationCenter.sharedInstance
miNotificationCenter.register(Label2,TextField1, "valueChanged")
miNotificationCenter.register(Label2, TextField1, "charValue")
miNotificationCenter.register(Listbox1,TextField1, "valueChanged")
miNotificationCenter.register(Slider1,TextField1, "valueChanged")
miNotificationCenter.register(canvas1,TextField1, "valueChanged")

This code will register the interested controls (observers) to the Notification Center for those Notifications they are interested in. Of course, this can also be done inside the Open event handler for every interested control!

In brief

As we have seen, with the combination of the Observer and Singleton Design Patterns, and the help of one Class Interface definition, we have created our own Notification Center from scratch to greatly automatice and simplify the communication between the objects, their processes and easying also the maintenance and extension of the app functionallity.

You can watch the video (in Spanish only) that talks you though this example.

Javier Rodri­guez has been the Xojo Spanish Evangelist since 2008, he’s also a Developer, Consultant and Trainer who has used Xojo since 1998. He is in charge of AprendeXojo.com and the developer behind the GuancheMOS plug-in for Xojo Developers and the Snippery app, among others.

*Read this post in Spanish

In fact, this is the first of a two part series regarding the Observer Design Pattern. This one will focus on how easy is to implement using the interfaces already available in Xojo for UI controls like the PushButton, the BevelButton, and also for the Timer class. In Part 2, we will see how to implement the Observer Design Pattern from scratch, using our own Classes and Interfaces, so it will be easier to understand the mechanisms behind this Pattern and how to use it.

Why to use the Observer Design Pattern?

Let’s suppose we want to create an app where several Canvas controls have to randomly change their color every time we push a button. Of course, we can approach this from several angles. For instance, we can put the code in charge of iterating every window control into the “Action” event of the PushButton control, changing the color only if the iterated item is an instance of our Canvas based subclass (let’s call this class the ColorPatch class).

That will work, but undoubtedly is not the most elegant, flexible and decoupled of the possible solutions.

A better way of approaching this problem is using the Observer Design Pattern. This one consists on the ability for any class instance to register itself into other instance, in order to receive a message every time there is an action in the object we have registered on.

Sounds weird? Ok, it’s like a group of people interested in one event saying the organizer: “hey, notify me once the tickets are available for purchase”. Best of all, you already can do this kind of things via the ActionSource and ActionNotificationReceiver Class Interfaces.

In fact, the ActionSource and ActionNotificationReceiver work together, because an ActionSource instance (PushButton, BevelButton or Timer) will call the PerformAction method of every ActionNotificationReceiver object registered with it (i.e. the event organizer will notify every registered person about the availability of the tickets).

ActionSource and ActionNotificationReceiver at Work

So let’s use these Class Interfaces to see how they apply on our example app. Go ahead and create a new Desktop Project using the Xojo IDE. Then, drag the Canvas icon from the Library panel and drop it into the Project Browser (the leftmost column of the IDE). This action will create a new Canvas based subclass with the name “CustomCanvas”.

Select the CustomCanvas item and push the Interfaces button on the Inspector panel. This action will show a sheet window where we will be able to choose any of the already available Class Interfaces in the Xojo Framework for our subclass. In this case we are only interested on the actionNotificationReceiver Class Interface, so select the associated checkbox control and confirm the selection, clicking the “OK” button to dismiss the window. Now, our CustomCanvas class IsA Canvas and also IsA actionNotificationReceiver.

As result of the Class Interface selection, you will see that the PerformAction method has been automatically added to the CustomCanvas class; and, in fact, this is the method that will be invoked by the object acting as the source of notifications. Write the following sentence in the PerformAction Code Editor:

me.Refresh

Simple, isn’t? The truth is that the Paint event of our Canvas subclass (triggered with the Refresh method) will be in charge of executing the code needed to randomly change the control color. For that to happen, add the Paint Event to the CustomClass (Insert > Event) and write the following code inside:

Dim r as new Random
g.ForeColor = rgb(r.InRange(0,255),r.InRange(0,255),r.InRange(0,255))
g.FillRect(0,0,g.Width,g.Height)

We have finished the work on our CustomCanvas Class, so it’s time to create a mere functional user interface. Select the Window1 item on the Project Browser, then drag the CustomCanvas item from the Project Browser to the Window Editor. That action will create a new instance from our Canvas based class.

To reproduce several color patches, the easiest is to define a Control Set. Let’s think about it as a group of controls of the same type that share the same behaviour and that we can refer from code using their index, as the “position” they have inside the group.

To define a new Control Set, select the CustomCanvas instance on the Window1 control and select the Attributes tab of the Inspector Panel, as shown in the following image:

Select the popup menu “Member of” and choose the “New Control Set” option. When done, the Xojo IDE will create the “CustomCanvas1” group assigning the index “0” to the current selected instance.

Now, duplicate the control four times and align them side by side. You will notice that each control has its own index on the control group they belong to. In fact, this is shown in the Project Browser as a hierarchy.

The user interface should look like this:

To finish our user interface, just need to add a trigger control, and for that we will add a PushButton to the window. Remember that this control implements by default the “ActionSource-ActionNotificationReceiver” paradigm.

Observer Pattern Design into action

Now, we have to register all the objects that we want to be notified as result of the PushButton action (that is, the ActionSource control), so they can execute their associated action. For that, we will celebrate having grouped them in a Control Set!

Choose the item labeled “CustomCanvas1 Set” on the Project Browser; that is, the item that groups all the members, instead of selecting any one of its members.

Add the Open event to the selected item (Insert > Event) and write the following code on the associated Code Editor:

PushButton1.addActionNotificationReceiver me

This way we will have registered all the members of the group as objects interested on receiving the notification from the PushButton.

Run the app and push the PushButton control, you’ll see that every time you push the button… all the canvas will radomly change their color!

This way, we have seen how simple has been to achieve the solution (and the little amount of code that has been need). In fact, the PushButton added to the project has not one line of code! and best of all we have our code decoupled, easy to maintain and we can modify it without impacting the rest of the app.

You can watch the video (in Spanish only) that talks you though this example.

NEXT: Design Patterns in Xojo: Observer, Part II

Javier Rodríguez has been the Xojo Spanish Evangelist since 2008, he’s also a Developer, Consultant and Trainer who has used Xojo since 1998. He is in charge of AprendeXojo.com and the developer behind the GuancheMOS plug-in for Xojo Developers and the Snippery app, among others.

*Read this post in Spanish

But as these users advance in their Xojo skills, they probably will care about coding better and to embrace the OOP way of doing things. After all, Xojo is a modern programming language with Classes, Inheritance, Interfaces and a bunch of the usual OOP paradigms that have much to offer: reusability, better maintainability and a lot of flexibility.

When we talk about OOP, Design Patterns arise! Design Patterns are like  recipes, well known solutions or best practices, to a series of problems or situations that emerge again and again in our OOP designs.

These Design Patterns are so common that you are probably already using some without knowing it. And if you are curious about what are the most common and the code design problems they solve, then you have to definetly take a look into the BOOK (yes, in uppercase): “Design Patterns: Elements of Reusable Object-Oriented Software”

In this post I am going to focus on one of these particular Design Patterns and how to implement it in Xojo: Singleton.

OOP is mainly about the instantiation —or object creation— from a Class definition that acts like a template; so we can have several of these objects around sharing the same behaviour but with a state of their own. Well, the Singleton pattern is the “opposite” thing. The answer to having (generally) just one object around from a particular Class.

Why should we want this? The short answer: to limit the access or “enty point” to a main functionality of your apps, or when the created object has a high cost or high impact in used resources.

Implementing the Singleton Pattern

The key to implement this Design Pattern in your apps is to limit the instantiation of the Class to just one object. So let’s see how can we achieve this using the Xojo language features. These are the ingredients to the recipe!

A Class Constructor whose scope is set to Private. This is the way we will ensure that the Class consumer will not be able to create several instances using the usual syntax:

Dim myInstance as MyClass = new MyClass
Dim myInstance as new Myclass

A Shared Method (also known as Static Method or Class Method in other programming languages). This will be the entry point we will use in order to retrieve the unique instance allowed by the Class.

A Shared Property whose scope is set to Private. This one will be the responsible to hold (point to) the unique instance from… the same Class!

Now that we know what the ingredients are, let’s create our own “Hello Machine” as a Singleton Class. Obviously this is not the most useful class in the world, but maintaining the functionality to a minimum will help to focus on the main point about how to implement this Design Pattern in Xojo.

The “Hello Machine” Singleton

Start the new project creating a new Class using Insert > Class. Then, go to the Inspector panel and name the Class as “HelloMachine”.

With the new Class item selected in the Project Browser panel (the leftmost), add a new property to it using Insert > Property. Name the new property as “Counter”, set the Type as Integer and the “Default Value” to 1. This is the property that will inform us about how many times has been invoked the class.

Add a new method to the HelloMachine Class (Insert > Method). This will be in charge of providing the real functionality to our Singleton class. Use “Greet” for the method name and set the Scope to Public. Now, type the following code for the just created method:

MsgBox "Hello World! Is not funny being the only one instance on Earth?" + endofline + endofline + "You have invoked me " + counter.totext + " times."
counter = counter + 1

Now it is time to create the class members that will make our HelloMachine behave as a Singleton one.

Start adding the Shared Property that will be in charge to hold the unique class instance used by the App. Use Insert > Shared Property for that. Select the just added shared property and using the Inspector panel type “sharedInstance” for the “Name”, and set the type to “HelloMachine”; that is, the same Class type we are just defining (it sounds kind of weird, I know).

Now is time to add our Class Constructor. Remember that this one is the special Method whose code is executed every time we want to create a new instance (object) from a particular class.

Use Insert > Method and type “Constructor” on the “Method Name” field of the associated Inspector panel (or choose “Constructor” from the dropdown menu). Make sure you set the Scope of the Constructor method as Private. This way we will be sure that nobody will be able to directly instantiate new objects from the class.

Finally we will write the method that will act as the entry point to retrieve the unique instance available from the class; that is, the instance shared among the App.

Use Insert > Shared Method and type “getInstance” for the “Method Name” field. Make sure to set the “Return Type” field to “HelloMachine”.

Select the “getInstance” shared method and type the following code on the associated Code Editor:

If sharedInstance is Nil then sharedInstance = new HelloMachine
Return sharedInstance

As you can see, all the “magic” consists to verify if has been created already a HelloMachine instance (holded by the sharedInstance Property), returning it if is the case or instantiating and returning it, if otherwise. Voilá, a Singleton Class!

Singleton At Work

Once we have finished our Singleton class definition, let’s use it in our App. Add the Open event to the default window, for example, and type the following code in the Code Editor:

Dim myHelloMachine as HelloMachine = HelloMachine.getInstance
myHelloMachine.Greet
Dim myOtherHelloMachine as HelloMachine = HelloMachine.getInstance
myOtherHelloMachine.Greet

As you can see, we are not instantiating new objects from the Class, just using the Public method to retrieve the unique instance managed by the own Class.

Just for fun, try to instantiate a new object from the class using the regular syntax (I mean, with “Dim myHellowMachine as new HelloMachine”) and you will get a Compiler error. That is, no way to have several objects around!

Download an example using the Singleton Design Patter from this link.

You can watch the video (in Spanish only) that talks you though this example.

Javier Rodríguez has been the Xojo Spanish Evangelist since 2008, he’s also a Developer, Consultant and Trainer who has used Xojo since 1998. He is in charge of AprendeXojo.com and the developer behind the GuancheMOS plug-in for Xojo Developers and the Snippery app, among others.

More Posts From Javier:

*Read this post in Spanish