The Basics of the Number Class

Let’s start with the bare bones of this Number class. Add a new Class to a Xojo project and name it Number in the Inspector Panel.

The value of the Number class is going to be backed by a primitive double property. So add a new Property to the Number class and use the Inspector Panel with the following values:

• Name: Value
• Type: Double
• Scope: Protected

We also want to know when a value is set to any of the Number instances, so go ahead and add a new Property to the Class using the following values in the Inspector Panel:

• Name: IsSet
• Type: Boolean
• Scope: Protected

And of course we want to have the ability to enable or disable any Number instance, so its assigned value may or may not be taken into account when used in any mathematical operation, for example. Add the third of the properties required by our Number class:

• Name: Enabled
• Type: Boolean
• Scope: Public

The next step is to add some constructor Methods to our class, so we can create new instances of it covering several common cases:

• Creating a new instance with no value provided: IsSet property will be set to False, and the Enabled property will be set to True.
• Creating a new instance with the Integer/Double provided: IsSet property will be set to True, and the Enabled property will be set to True.
• Creating a new instance with the numeric value from the provided String: IsSet property will be set to True and the Enabled property will be set to True too.

The default constructor for the class will be the one with no parameters. So add a new method to the Number class using the following values in the Inspector Panel:

• Method Name: Constructor
• Scope: Public

And type the following line of code in the associated Code Editor:

Self.Enabled = True

Add a second method to the class and use the following values in the Inspector Panel (this constructor will create a new instance from the received Integer/Double value):

• Method Name: Constructor
• Parameters: value As Double
• Scope: Public

And type the following lines of code in the associated Code Editor:

Self.Constructor
Self.Value = value
Self.IsSet = True

Let’s add the third constructor, the one taking a String as the parameter. Add a third method to the class using the following values in the Inspector Panel:

• Method Name: Constructor
• Parameters: value As String
• Scope: Public

And type the following lines of code in the associated Code Editor:

Self.Constructor

Self.Value = Double.FromString(value, Locale.Raw)
Self.IsSet = True

But, wait! Wouldn’t it be great if we could create new Number instances from another Number instance received as the parameter? Of course it would! So add a new Method again using the following values in the Inspector Panel:

• Method Name: Constructor
• Parameters: value As Number
• Scope: Public

And type the following lines of code in the associated Code Editor:

Self.Constructor

If value <> Nil and value.IsSet And value.Enabled Then
  Self.Value = value.Value
  Self.IsSet = True
End If

By now our class has four special methods, all of them with the same name: Constructor. If defined in any of your classes, this is the method that will be called/executed every time your code uses the New keyword in combination with the class data type. For example:

Var n As New Number // This calls the by default Constructor.
Var i As New Number(10) // This calls the Constructor taking an Integer/Double as the parameter.
Var s As New Number("120.20") // This calls the Constructor taking a String as the parameter.
Var objNumber As New Number(n) // This calls the Constructor taking a Number instance as the parameter.

When several methods are added to a class using the same method name but with different number of arguments or arguments data types (or returned values), that is called Method Overloading and you will find it in any object-oriented programming language. So our constructor method is overloaded to cover all the expected cases.

As you see, there is nothing fancy in the previous examples. I mean, creating a new instance from the received value in the constructor method is ok, but it would be even better and more simple if we could do something like:

Var i As Number = 10
Var s As Number = "120.20"
Var objNumber = n

Overloading the Assignment Operator

The good news is that we can do that! The Xojo programming language has the ability to overload operators too, just like we did with the constructor method! And when it is about to overload the assignment operator we implement the Operator_Convert method. This one will be called every time our class receives a value from another data type or needs to convert itself to the expected data type; for example:

Var i As Number = 10 // 10 Integer value needs to be converted to a Number instance.
Var intValue As Integer = i // The variable "i" (Number data type) needs to be converted to an Integer data type.

The most important thing to remember is that when Operator_Convert gets into play, the class Constructor is never called! So the code in the Operator_Convert method implementation needs to take care of properly initialising the instance as you expect.

So let’s start implementing the Operator_Convert that will be called every time a Number instance needs to be converted to an Integer or Double value.

Add a new method to the Number class using the following values:

• Method Name: Operator_Convert
• Return Type: Double
• Scope: Public

And type the following line of code in the associated Code Editor:

Return If(Self.Enabled, Self.Value, 0)

Add a second Operator_Convert method, this time change the returned value to a String so our Number instances internal values can be easily assigned to a String variable (or used in other operations with Strings) like this:

Var i As Number = 10
Var s As String = i

Use the following values in the associated Inspector Panel and type the line of code in the associated Code Editor:

• Method Name: Operator_Convert
• Return Type: String
• Scope: Public

Return If(Self.Enabled, Self.Value.ToString(Locale.Raw), "")

We need to overload the Operator_Convert method two more times so it can handle the assignment operation when the received value is at the right of the equal operator instead of the left.

Use the following values in the Inspector Panel for every one of the new two overloaded methods (typing the line(s) of code following each of these):

• Method Name: Operator_Convert
• Parameters: value As Double
• Scope: Public

Self.Enabled = True
Self.Value = value
Self.IsSet = True

• Method Name: Operator_Convert
• Parameters: value As String
• Scope: Public

Self.Enabled = True
Self.Value = Double.FromString(value, locale.Raw)
Self.IsSet = True

Overloading the Add Operator

Assigning values to Number variables or properties or Number instances to Integer / Double or String variables and properties is fine, but not so useful now. So the next step is adding Number instances with another Number instances, Integer / Double data types and also even with all the values from an array. To do this we need to overload the “+” (Add) operator implementing the Operator_Add method in the Number class.

This will allow us to write code like this:

Var n2 As Number = i + 10

Here the “10” value is first converted to a Number instance that is going to be added to the “i” Number instance and then assigned to the “n2” variable.

Var n3 As Integer = i + 10

Here the “10” value is first converted to a Number instance that is added to the “i” number instance and, then, the result converted to an integer value assigned to the “n3” variable.

So we need to implement the Operator_Add taking a Number parameter and returning also a Number data type.

Add a new method to the Number class using the following values in the Inspector Panel, and typing the lines of code following them in the associated Inspector Panel:

• Method Name: Operator_Add
• Parameters: Value As Number
• Return Type: Number
• Scope: Public

If value <> Nil Then
  Var no As New Number(If(Self.Enabled, Self.Value, 0) + value.Value)
  Return no
End If

That one works well when we have a Number instance to the left of the add operation, but not when the Number instance is to the right. For that scenarios we need to overload another method: Operator_AddRight.

Add another method to the Number class using the following values in the associated Inspector Panel:

• Method Name: Operator_AddRight
• Parameters: value As Double
• Return Type: Double
• Scope: Public

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

Return If(Self.Enabled, Self.Value, 0) + value

Adding Number Instances to an Array of Integers

It would be also really helpful if we could add a Number to an array of integer values or even a Number instance to an array containing other array instances. For example, it would look like this in code:

Var arrayNumbers() As Number
Var arrayIntegers() As Integer

For z As Integer = 0 To 10
  arrayNumbers.Add(System.Random.InRange(10, 200))
  arrayIntegers.Add(System.Random.InRange(10, 200))
Next

Var z1 As Number = i + arrayNumbers
Var z3 As Integer = i + arrayIntegers

Of course this implies implementing new overloaded methods both for Convert_Add and Convert_AddRight. These are the implementations for overloading Convert_Add taking an Array of Doubles and also taking an Array of Number instances. I will let the Convert_AddRight implementation to you as exercice:

• Method Name: Operator_AddRight
• Parameters: value() As Integer
• Return Type: Double
• Scope: Public

Var sum As Double

For Each item As Double In values
  sum = sum + item
Next

Return sum + If(Self.Enabled, Self.Value, 0)

• Method Name: Operator_AddRight
• Parameters: value() As Number
• Return Type: Number
• Scope: Public

Var sum As Double

For Each item As Number In values
  If item <> Nil And item.Enabled Then sum = sum + item.Value
Next

Return sum + If(Self.Enabled, Self.Value, 0)

Unset Number Instances

The last step in this Number class is to implement the Method that will take care of Unset the instance; that is, kind of “reset” state where the value is still not defined.

Add a new Method to the Number class using the following values:

• Method Name: Unset
• Scope: Public

And adding the following lines of code to the associated Code Editor:

Self.IsSet = False
Self.Value = 0

Conclusion

As you see, method overloading is a powerful technique as we have done with the constructor method and also with the Operator_Convert, Operator_Add and Operator_AddRight methods. This Number class, with a little work, can be made to to cover other scenarios like the subtract, multiply or divide operations, among others. That wouldn’t be too difficult based on the implementations already exposed for the overloaded Operator_Add and Operator_AddRight methods. Download the Numbers class project.

Further Reading from the Xojo Blog Archives

Methods Overloading: Computed Properties, Setters and Getters

More on Object-Oriented Programming from the Xojo Blog and Xojo Documentation

Javier Menendez is an engineer at Xojo and has been using Xojo since 1998. He lives in Castellón, Spain and hosts regular Xojo hangouts en español. Ask Javier questions on Twitter at @XojoES or on the Xojo Forum.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

When we define and implement the Operator_Lookup method in our classes, we will be able to use the dot notation to access and assign a value to a class member that has not been defined for the class! That is, it will be the code implemented in this method that will decide how it will act, not the Xojo Compiler. Among other possibilities, this will bring us the flexibility to create a Preferences class that is not attached to a particular project, and that is multiplatform, of course, backed by as many pairs of Keys/Values in a Dictionary as we need to store our apps preferences. This way we can use the simple dot notation both to store and assign the stored values. Let’s put this into practice.

The first step is adding a new Class item to the project without assigning a Super class; that is, this will be a base class. For this example, we will use MyPreferences as the name of the class. Then, we will add a property with Data as the Name and Xojo.Core.Dictionary as the data type, setting its scope to Private (this means that the property will be accessible only from the own class). This property will act as the storage for the Key/Value pairs used for our Preference Class.

Add now a new Constructor method in charge of initializing the just defined Dictionary property:

• Name: Constructor
• Scope: Public

And put this line of code in the Code Editor for the Constructor method:

Data = New Xojo.Core.Dictionary

Now we will add the method that we are really interested in. This is, the overload for the Operator_Lookup method:

• Name: Operator_Lookup
• Parameters: key as string, assigns value as auto
• Scope: Public

Writing the following line of code in the resulting Code Editor:

data.Value( key ) = value

Once implemented, we can take advantage of the feature. If we add the Open Event to the project and write the below snippet of code, we will see how we can use the dot notation to use and access class members that have never been added to the class. These members are captured by the Operator_Lookup method, adding the member as the key for a new entry in the dictionary (this is the text we write after the dot) and assigning to it the value we put after the equal symbol (the assignation operator); thanks to the use of the assigns keyword in the parameters declaration for the Operator_Lookup method.

Dim pr As New MyPreferences
pr.page = 10
pr.index = "20"
pr.baseColor = &c204060

As you can see, Page, Index and BaseColor are not members of our class; these are captured as Keys for the Dictionary thanks to the Operator_Lookup operator. In addition, you can see how we can assign several types of values to these: an Integer, a String and a Color value.

Retrieving data with Operator_Lookup

Now, how can we retrieve values for these not existing members using the dot notation? As you probably guessed, we need to add an additional method that overloads Operator_Lookup. In this case the method signature will accept as the parameter the Key we want to retrieve (the class member put after the dot), returning always a String, in order to simplify this example. Thus, add a new method for the class using the following signature:

• Name: Operator_Lookup
• Parameters: Key As String
• Return Type: String
• Scope: Public

Writing the following code in the associated Code Editor:

Dim a As Auto
Dim s As String
If data.HasKey(key) Then
  a = data.Value(key)
  Dim info As Xojo.Introspection.TypeInfo
  info = xojo.Introspection.GetType(a)
  If info = GetTypeInfo(Text) Or info = GetTypeInfo(String) Then
    s = a
  Elseif info = GetTypeInfo(Integer) Then
    s = CType(a, Integer).totext
  Elseif info= GetTypeInfo(Color) Then
    Dim c As Color = a
    s = Str(c)
  End If
End If
Return s

As you can see, and after verifying that the Dictionary has the Key, we use the Introspection mechanisms provided by the language in order to see what type is associated with the key. Once we have its type, we will convert the value to a String using the appropriate approach for each case: an Integer, a Text/String or a Color. Of course, for brevity, this example doesn’t take into account other possible value types; but that is something you can implement yourself!

Let’s go back to the Open Event for the project and add the following line of code at the end:

MsgBox pr.page + EndOfLine + pr.index + EndOfLine + pr.baseColor

Run it and observe how we can assign values and retrieve them (always as a String) simply using the dot notation. We can take this class from one project to other and use the dot notation to reference the elements we want to save and retrieve as preferences.

Final Word

If you decide to use this approach for your projects, there are some considerations you have to take into account. For example, you will not be able to take advantage of the Autocompletion feature provided by the IDE. In addition, we will have to pay special attention to write exactly the same “member” in all the cases we want refer to it; otherwise we will be using a different key with unexpected results. After all, once implemented, Operator_Lookup for the class the Compiler will not complain about the undefined members you are trying to access!

It would also be very easy to expand the class so it can work with other data types; adding an additional method to serialize the Key/Values pairs so they can be stored on file/database for a later retrieval and reconstruction via an additional Constructor. Finally, it is very probable that you only want to use a MyPreferences instance in your app, so you could implement this class as a Singleton. Do you dare? If you do, tell me about it!

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

“I have a constructor on my control and the values that I set in the constructor don’t stick.”

But, indeed IF you put a break point in the constructor for your control subclass you will see it definitely gets called. And the values you set are present when the constructor is exited.

What most people miss is that if you made your public properties into computed ones and put a break point in the setter you’d find that this gets called AFTER the constructor.

And this is REALLY relevant.

Normally a control instance on a layout is created and configured using code much like:

  // the next line obviously calls the constructor
  dim c as Control = new <your custom control subclass name>

  // and IF you had a computed property and
  // set a break point in each computed property setter
  // you will see each setter get called in turn

  c.SetAllProperties( paramarray of property names and values )

and so the first calls to the setters are what put the values you set in the Inspector onto your control.

And this is what people do not usually expect.

But how else would you get all those properties onto the control and NOT require every control subclass to have a special constructor ?

Usually the advice is “put your set up code in the Open event” which is often too late.

IF you do set property values you want to keep in the constructor there are a few choices.

1. Don’t make these properties “public” as every public property will be set in the “SetAllProperties” call. PER INSTANCE properties should be unique to that instance and so they all get set if they are public. Private and protected properties won’t.
2. Make your public properties into computed properties and “skip” the first call to the setter so whatever value you set in the constructor does not get written over by the call to SetAllProperties.
3. Make the properties public and set the initial values in the inspector (which is IMHO the “right” way to do this)

I’ve put together a sample you can put break points in to see that the constructor and setters for public properties are called exactly as described.

Creating the Class Interface

Our Xojo project will use three main items: a subclass from the TextField class, a Class Interface definition, and a Class that will do the job of the Dictionary containing the suggested words for the Autocomplete feature and that will conform to the Class Interface. This way, you’ll be able to use any object as the Dictionary source, as long as it conforms to the expected Class Interface.

Note: The Dictionary referred to here is not the Xojo Dictionary class, but is our collection of suggested words for use by autocomplete.

In fact let’s start creating a Class Interface; so run the Xojo IDE and create a new Desktop project.

1. Add a new Class Interface to the project selecting Insert > Class Interface.
2. Write ‘TextAutocompleteSource” in the Name field of the Inspector. This one will be the Data Type for the created Class Interface.
3. Select the icon for the ‘TextAutocompleteSource’ in the Navigator (the leftmost column in the IDE Window), open the contextual menu and choose the ‘Add to “TextAutocompleteSource” > Method’ option. This action will bring us to the Inspector, so we can define the new Method signature.
4. The first of the methods will be in charge of adding a new word to the dictionary, so use ‘AddWordToDictionary’ as the Method Name, and type ‘Value As String’ in the Parameters field.
5. Add a second Method, name it ‘Match’, type ‘Value As String’ in the Parameters field, and ‘String’ for the ‘Return Type’ field. This will be the invoked method in order to find and return a word suggested for the received string.

That’s all we need for our Class Interface. Simple, isn’t? Remember that Class Interfaces just deal with Method definitions, and the classes that conform to it will be responsible for implementing the code for the methods.

Defining our Dictionary

Now is time to create a new class that will play the role of the main Dictionary for the app of this Tutorial. This one will implement, in fact, the Class Interface defined in the previous section. This means that will implement the real functionality for the methods defined in the TextAutocompleteSource Class Interface.

• Create a new Class selecting Insert > Class from the main Toolbar or from the Insert menu.
• Type ‘StringStack’ in the Inspector as the name of the new Class. This will be the name for the just created Data Type.
• From the Inspector, click on the Choose button near to the ‘Interfaces’ label. As a result, this action will open a new Window showing all the available Class Interfaces… including the one created by us in the previous section! Select this one (TextAutocompleteSource) and confirm the selection clicking the ‘OK’ button.

• As result, Xojo will add the methods declared in the selected Class Interface. We will implement the code for these two methods in a later step.

• Add a new Property to the class: with StringBack selected, choose Insert > Property. In the resulting Inspector, type ‘Collector(-1)’ in the Name field. This means, that our Property will be an Empty Array. Type ‘String’ for the ‘Type’ field and choose ‘Private’ as the Scope for the property.
• Let’s implement the code for the Class Interface methods! Select the ‘addWordToDictionary’ method and type the following code in the associated Code Editor:

if not Value.IsEmpty then Collector.Addrow(Value)

Select now the ‘Match’ method and type the following code in the associated Code Editor:

Var n As Integer = Value.Length
Var t As String
For Each item As String In Collector
  t = element.Middle(0, n)
  if t = Value then return item
Next
Return ""

This method is the one responsible to find a suggested word for the received string. Probably you’ll want to improve the algorithm in your own implementation (depending mainly on the kind of object you will use as a Dictionary), but this one will serve for our testing app.

Adding a Constructor to the Class

Now we are going to define a very special method to the Class: the Constructor. When a Class has this method it will execute the code from this method every time we create a new instance (object) from the Class. Usually we use the class Constructor (you can have several of them thanks to the OOP feature of Method Overloading) to define the initial state of the new instantiated object. In our case, we will use the Constructor to assign the initial state of the dictionary (the Collector property we’ve defined in a previous step) during the instantiation of the object.

1. Add a new method to the Class (Insert > Method). Next, select the ‘Constructor’ item from the ‘Method Name’ drop-down menu or type it.
2. As we would do with a regular Method, we can modify the Constructor method signature to define, for example, the amount and type of the parameters. In fact, for our Constructor we will type ‘Value() As String’ for the Parameters field.

Add the following code to it:

Collector = Value

Subclassing: TextField Specialization

We have finished the auxiliary items needed for the project, so it is time to focus on the main point: create a TextField subclass to include the autocomplete feature on it.

1. Add a new class to the project using Insert > Class. Type ‘TextFieldAutocomplete’ as the Class name in the Inspector, and type ‘TextField’ as its ‘Super’ class.
2. Add a new property (Insert > Property). Type ‘Autocomplete’ as the property Name, ‘Boolean’ as the Type, and ‘True’ for the Default field. Finally, select the ‘Public’ option for the scope. This property will let us to use the objects from the class as regular TextField, without autocompletion, or with the Autocomplete functionality.
3. Add another property, typing ‘AutocompleteSource’ for the property Name, setting the scope to ‘Public’ and its type to ‘TextAutocompleteSource’. That is the Data Type we have created as a Class Interface. This allows us to use any object that conforms to TextAutocompleteSource as the source for the Autocompletion Dictionary.
4. Let’s add a third property. In this case, use ‘TabKeyAutcompletes’ as the property name, ‘Boolean’ for the Type, set the Scope to Public, and its default value to ‘True’. We will use this property to set the behaviour of the Tab key between autocomplete the suggested word, or change to its regular behaviour when used on a TextField control.

Shared Properties

All the properties created for the subclass are Instance Properties. That is, every new instance (object) from this class will have its own set of values for these properties. In some cases, however, we want to share the value of one or several properties for all the class instances…and this is what we can achieve using the Shared Properties.

We will use two of these shared properties for our TextFieldAutocomplete class to see them in action. One of these will let us use the Suggestions Dictionary globally for all the class instances, always the property is not set to Nil. The second one will be an Array of Strings that will contain all the characters that we want to exclude from the typed on the textfield.

1. Add a new Shared Property to the Class, typing ‘globalAutocompleteSource’ for the Name field, setting the Scope to ‘Public’ and typing ‘TextAutocompleteSource’ as the Data Type for the Property.
2. Add the second Shared Property typing ‘SpecialCharacters(-1)’ as its name, setting the Scope to ‘Protected’ and ‘String’ for the Data Type.

TextFieldAutocomplete: a Matter of Methods

The next step is to add a couple of method to our class: the public interface. With them, the user of the class can set the no allowed characters.

• Add a new method to the class typing ‘AddSpecialCharacters’ as the name, ‘Value() as String’ for the Parameters field, and setting the Scope to ‘Public’. Type this line of code in the associated Code Editor for the method:

SpecialCharacters = Value

• Add the second method, using ‘SpecialCharacter’ as the method name, ‘Value as String’ for the parameters field, ‘Boolean’ as returned Type and setting the Scope to ‘Protected’. Type this block of code for the method:

If SpecialCharacters.LastRowIndex > 0 Then
  For Each item As String In SpecialCharacters
    If item = Value then Return true
  Next
End If
Return False

Handling Events

Our TextFieldAutocomplete class needs to be aware of every key down, so we are going to add the handler triggered in response of this event.

• Make sure that the ‘TextFieldAutocomplete’ item is selected on the Navigator and select Insert > Event Handler. This action will show a new window with all the available Events for the class. Select the KeyDown event and confirm clicking on the ‘OK’ button.

• Select the just added KeyDown event and type the following block of code. This is the place where we put the main logic for the class!

If Autocomplete = False Then Return RaiseEvent KeyDown(Key)

If SpecialCharacter(key) = True Then Return False

If Asc(key) = 9 And TabKeyAutocompletes = True And Me.SelectionLength > 0 Then
  Me.SelectionStart = Me.value.Length
  Me.SelectionLength = 0
  Return True
End If

Var tempText As String = Me.Value.Left(Me.SelectionStart) + key

Var matchingText As String

If AutocompleteSource <> Nil Then

  matchingText = AutocompleteSource.Match(tempText)

Elseif GlobalAutocompleteSource <> Nil Then

  matchingText = GlobalAutocompleteSource.Match(tempText)
End If

If matchingText <> "" Then
  Me.Value = matchingText
  Var startOffset As Integer = tempText.Length
  Me.SelectionStart = startOffset
  Me.SelectionLength = matchingText.Length-startOffset
  Return True
End If

Return false

Adding Class Events

Our class uses the KeyDown event, and that means that it will not be available for the new controls added to the project that would be based on this class. The solution? The Xojo language allows us to define new events for our classes, and we will use that feature in order to “duplicate” the signature of the used event on the class.

Make sure it is selected the ‘TextFieldAutocomplete’ item in the Navigator and then select Insert > Event Definition. The last action will bring us to the Inspector. Type ‘KeyDown’ as the Event Name, ‘Key as String’ as the Parameter, and ‘Boolean’ as Returned Type.

As you can see in the block of code of the previous section, we will call our defined event using the statement ‘RaiseEvent’, passing as parameter the same ‘Key’ String received in the original event.

Design the User Interface

Everything is now ready to test our Autocomplete TextField with Xojo! The first step is to choose the Window1 item in the Navigator, using the available UI Controls in the Library in order to design the interface as shown in this screenshot:

In fact, you have to use two CheckBox controls, one PushButton and one TextFieldAutocomplete, dragging the last one from the Navigator over the Window1 Layout Editor.

Double click the ‘CheckBox1’ labeled as ‘Autocomplete’ and add a new Event Handler. Choose ‘Action’ and click on ‘Ok’ to confirm the selection. Type the following line of code in the resulting Code Editor for the added ‘Action’ Event Handler:

TextField1.Autocomplete = me.Value

Repeat the same operation on the “CheckBox2”. In this case, type the following line of code on the ‘Action’ Event Handler:

TextField1.TabKeyAutocompletes = me.Value

Lastly, add the ‘Action’ Event Handler on the ‘PushButton1’ control, typing the following line of code:

Stack.AddWordToDictionary TextField1.Text

Start Your Engines!

Now we need to define the ‘Stack’ and the code responsible of putting our demo to work.

Make sure that the ‘Window1’ item is selected in the Navigator and add a new Property using ‘Stack’ as its name, set the Scope to ‘Public’ and the Type to ‘StringStack’. That is the base class previously defined and that conforms to the TextAutocompleteSource protocol.

Now, add the ‘Open’ Event Handler to ‘Window1’ and type the following block of code:

Stack = New StringStack(Array("object", "objection", "objective", "objector", _
  "desert", "deserve", "descend", "destroyer", "destruction", _
  "trail", "train", "trainer", "cup", "cure", "curiosity"))

TextField1.AddSpecialCharacters(array(chr(8)))
TextField1.AutocompleteSource = Stack

As you can see, when we instantiate a new object from the StringStack class, we use the Constructor to pass the Array of Strings. This way we have a simple dictionary whose contents allow us to test the Autocomplete TextField. Obviously, we can change the Dictionary used to any other object that conforms to the ‘TextAutocompleteSource’ protocol… even if it is a database!

Run the project and start to type on the Autocomplete TextField. If you start typing the characters of any of the words in the “Dictionary”, you’ll see the TextField will show a suggestion for Autocompletion. Press the ‘Tab’ key… and done!

You can download the Example Project used in this tutorial from this link.

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

*Read this post in Spanish