What is an Interface?

An Interface in Object-Oriented Programming acts as a contract or a blueprint. It defines a set of methods (functions) that a class must implement, but it does not provide the actual implementation of those methods. Think of it as a list of rules or requirements that a class agrees to follow. This approach makes your code more flexible, reusable, and easier to maintain.

For example, imagine you are building a game with different types of characters, such as warriors, wizards, and archers. Each character might have an attack method, but the way they attack is different. An Interface ensures that all characters have an attack method, but each class can implement it in its own unique way.

Why Use Interfaces?

1. Flexibility: Interfaces allow different classes to be used interchangeably if they implement the same Interface. This makes your code adaptable and scalable.
2. Reusability: You can write code that works with any class that implements the Interface, promoting code reuse.
3. Consistency: Interfaces enforce consistency across classes, ensuring they all have the required methods.
4. Polymorphism: Interfaces enable polymorphism, allowing you to handle different objects through the same interface.

How to Use Interfaces in Xojo

In Xojo, you can create and implement Interfaces to define a set of methods that multiple classes can share, even if they do not share a common superclass. Follow these steps to use Interfaces in Xojo:

1. Create an Interface: Go to the Insert menu in the Xojo IDE and select Class Interface. Give the Interface a descriptive name.

1. Define Methods: Add methods to the Interface. These methods have no code; they only define the method names and parameters.

1. Implement the Interface in a Class: For a class to use the Interface, select the class and from the Inspector, press the Choose button and mark the newly created Interface.

Example 1: Beginner-Friendly Interface

Let’s start with a simple example. Create an Interface called IAnimal that defines a Speak method. Then, create two classes, Dog and Cat, that implement this Interface.

Step-by-Step Guide

1. Define the Interface
   • From the Insert menu, select Class Interface, name it IAnimal and then create a new method Speak.
2. Create the Dog Class
   • Create a class named Dog (Insert menu > Class) and from the Inspector, make sure to select the Interface. Xojo will automatically add the Speak method to the class so let’s add some code:MessageBox("Woof!")
3. Create the Cat Class
   • Create another class, named Cat (Insert menu > Class) and add the following code to the Speak method:MessageBox("Meow!")
4. Test the Interface

Add the following code, to test the Interface, either in the Pressed event of a DesktopButton, or to the Opening event of a DesktopWindow:

Var animals() As IAnimal
animals.Add(New Dog)
animals.Add(New Cat)

For Each animal As IAnimal In animals
  animal.Speak()
Next

Example 2: Interface with Parameters

Now, create a new Class Interface called ICalculator that defines a Calculate method. This method takes two numbers as parameters and returns a result. Then, create two classes, Adder and Multiplier, that implement this Interface.

Step-by-Step Guide

1. Define the Interface
   • Add the following method to define the Interface: Public Function Calculate(a As Integer, b As Integer) As Integer
2. Create the Adder Class
   • Add the following code to theCalculate function: Return a + b
3. Create the Multiplier Class
   • Add the following code to theCalculate function: Return a * b
4. Test the Interface

  Var calculators() As ICalculator
  calculators.Add(New Adder)
  calculators.Add(New Multiplier)

  For Each calc As ICalculator In calculators
    MessageBox("Result: " + calc.Calculate(7, 2).ToString)
  Next

Some Practical Use Cases for Interfaces

Interfaces are versatile and can be used in many situations to make your code more modular and easier to maintain. Here are some practical use cases for Interfaces in Object-Oriented Programming:

1. Data Access Abstraction

Abstract data access using Interfaces. For example, define an IDatabase Interface with methods Connect, Query, and Disconnect. Classes that implement this Interface can interact with different database systems (like MySQL, PostgreSQL, SQLite), allowing you to switch databases without changing your core code.

2. Cross-Platform Development

Abstract platform-specific functionality using Interfaces. For instance, define an IFileSystem Interface with methods ReadFile and WriteFile. Implement this Interface differently for Windows, macOS, and Linux. Your main code can remain the same across platforms.

3. Polymorphism

Enable polymorphism with Interfaces. This lets you process objects differently based on their actual class, but through the same Interface. This is useful when you want to write code that works with any class that implements a particular Interface.

Key Takeaways

• Interfaces define a set of methods that classes must implement.
• They make your code flexible, reusable, and easier to understand.
• Interfaces enforce consistency across different classes.
• They enable polymorphic behavior, allowing you to write generic code.

Conclusion

Whether you’re building a simple application or a complex system, interfaces are a powerful tool in your Object-Oriented Programming toolkit, and Xojo makes them incredibly easy to use. They promote better code organization, flexibility, and reusability. Start experimenting with Interfaces in your projects, and you will see how they can improve your code!

Additional info on Interfaces: https://documentation.xojo.com/getting_started/object-oriented_programming/interfaces.html

If you have questions or want to share your own Interface examples, feel free to start a forum discussion. Happy coding!

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

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Throughout that time, software development has generally become more difficult with developers having to learn a wide variety of tools and programming languages, many of which are the hot thing for a short while and then disappear afterwards for the next hot new thing as the cycle repeats.

Up until recently this was not as big a deal for tech companies because they could just hire their way out of the problem. Teams got big and bloated, often because the tools being used were large, complex, rapidly changing and difficult to learn. So the solution, in opposition of the Mythical Man Month, was to throw more people at it. This was feasible because of 0% interest rates and the relative ease of raising capital.

But that era is over. Interest rates are no longer historically low and raising capital for companies is now much harder and less desirable than it once was. This means technology companies are reducing staff and hiring more judiciously. Fewer people now have to do more with less.

The idea of a “one person framework” is that there should be a way for a single developer to create software using just one development framework. This is not a new idea, but it is being talked about again because of these recent changes with how technology companies work. In many ways, Xojo is the original one person framework. From its inception, with inspiration from Visual Basic, Xojo let you make complete apps more efficiently without having to also learn other tools, languages or frameworks.

So what can Xojo, as a one person framework, do for you? Xojo lets you build most of the apps your company is likely to need, using only Xojo itself and its easy-to learn object-oriented programming language (which is similar to Visual Basic and Python, languages that many people already are familiar with). Xojo is a cross-platform, integrated development environment (IDE) that combines an object-oriented programming language, visual designer, code editor, debugger and more into one tool and one framework.

With Xojo you can make apps for most of the commonly used platforms that your business is likely to need.

Desktop Apps

Xojo has been a great way to make desktop apps since its inception in 1998. Unlike Java, Electron or other frameworks you’ve seen throughout the years, Xojo makes native apps and can do so for the major desktop platforms: Windows, macOS and Linux. Yes, that includes native ARM and x86 apps as well.

With a single project, you can click one button to have Xojo build separate native apps for each of those platforms. To further drive that point home, the Xojo IDE itself is a desktop app made with Xojo that runs on Windows, macOS and Linux.

With Xojo you have access to many commonly-used controls and the Xojo framework with support for databases, JSON, XML, RegEx, Zip/Unzip, networking and so much more.

Web Apps

Since 2010, Xojo has been able to make web apps. Xojo uses a somewhat unique approach to web apps by running compiled code on the web server. This code communicates to the app running on the web browser using an internal JavaScript framework and Bootstrap for the UI, which you don’t really need to worry about. It’s all handled automatically.

This approach is great for business purposes as it lets you make web apps using a development pattern that is very similar to what is used to make desktop apps.

If you don’t want to deal with the hassle of managing your own web app server, Xojo even offers Xojo Cloud as a fully managed web hosting service with 1-click deployment of your Xojo web apps.

Mobile Apps

Mobile support first appeared for iOS in 2013 and Android support was recently added in 2023. Using Xojo to make native mobile apps that can be deployed in their respective app stores is yet another way Xojo can help one person make more apps.

A developer that already knows how to use Xojo can jump right into mobile development without having to learn yet another IDE and programming language.

Console Apps

Console apps are text apps that run from the command line. These app are great for automating internal processes or other command-line tools. You can even build Console apps that communicate with other console apps to build a chain of tools for processing or converting data, for example.

Xojo Framework

A single person can create all of the above types of apps because Xojo uses the same programming language for all of them. And as mentioned above, the Xojo framework has many built-in features and is broadly compatible across all the different project types. There are differences, of course, but we strive for consistency and compatibility.

For just a few of its many capabilities, all platforms have the same framework classes and methods for things such as Dictionary, Set, URLConnection, files, SQLite, and most graphics. And speaking of examples, Xojo includes over 400 example projects from which to learn.

Could Xojo Work For You?

As you should now realize, a single developer using Xojo could reasonably create a desktop app (for Windows, macOS and Linux), a web app, and mobile apps for iOS and Android. If you previously had multiple teams of multiple people creating that many apps, then Xojo could really save you a lot of money and time.

Will you use Xojo to make the next Photoshop, FaceBook, Excel or Google Docs clone? Perhaps not, but most companies don’t create those types of apps. Xojo does a lot, but it does not and cannot do everything. There is a limit to what any single framework can do, otherwise it becomes too large for its own good, collapsing under its own weight.

Instead, most businesses have much different needs and often require specially created software. For business apps, especially bespoke small-business apps, Xojo can often be an ideal solution by allowing apps to be created faster, more easily and at less cost than can be done with other tools. This saves you money and time, both of which are in short supply these days.

Xojo is free for learning, development and testing! Give it a spin to see what it can do for you.

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.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

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

What about getting the ComboBox to do things not included in the class? In this tutorial you will learn how to add the text typed by the user as an option in the associated ComboBox menu. We’ll make sure entries are not duplicated and that they are sorted alphabetically. We’ll use the AddAllRows method to add a strings array to those already available in the ComboBox menu. In addition, we will add a new method to the ComboBox so you can retrieve all the menu entries as an Array of Strings.

You’ll find it very convenient that Xojo is an Object-Oriented Programming language as you create any subclass from any existing one. Creating your own specialized subclasses adds tons of extra functionality to any of your projects since they can be used in your other desktop projects. Keep reading to create your own subclasses! Download this Xojo project

1. Adding a Class to the Project

Start a new Xojo Desktop project and select the Insert > class option from the menu in order to add a new class to the Navigator.

With the new Class1 item selected in the Navigator, change the following values in the associated Inspector Panel:

• Name: MyComboBox (you may use any other class name you want).
• Super: ComboBox

Confirm the changes. You’ll see how the new class item is now named MyComboBox in the Navigator, while its icon has changed to the one for the ComboBox control.

2. Adding Event Handlers to the Class

Keep MyComboBox selected in the Navigator and then select the Insert > Event Handler option from the menu. That action will open a new window listing all the available Event Handlers for the ComboBox class and, thus, also for all the subclasses created from it – like our new class.

Select the Change, KeyDown, Open and LostFocus entries from the list and confirm the changes by clicking on the “OK” button. The “Add Event Handler” window will close and the selected entries will be added to the MyComboBox item in the Navigator.

Use the KeyDown and LostFocus event handlers to add the text typed by the user as new entries in the ComboBox menu.

Select the KeyDown event under the MyComboBox item in the Navigator and type the following code in the associated Code Editor:

AddNewEntry(key)
Return RaiseEvent KeyDown(Key)

The AddNewEntry method will add the new entry to our ComboBox menu. Notice the RaiseEvent KeyDown(Key) line of code. Because our subclass makes use of this event handler, that means that it will not be available to any instances (objects) created from the class, as for example those created when adding the class to a Window in the Layout Editor.

3. Adding Event Definitions

With MyComboBox still selected in the Navigator, choose the Insert > Event Definition menu option and add the following values in the associated Inspector Panel:

• Event Name: KeyDown
• Parameters: Key As String
• Return Type: Boolean

This creates the same Event Handler for the class so it can be implemented by any of the instances created from the class, while the RaiseEvent KeyDown(Key) line of code will make sure that this event will also be called for its instances.

Now select the LostFocus event handler from the MyComboBox item in the Navigator and type the following code in the associated Code Editor:

Me.AddRow(Me.Text)
RaiseEvent LostFocus

Once again, because we are implementing this event handler, we need to make it available for our class instances. With MyComboBox selected, choose the Insert > Event Definition menu option adding the following value in the associated Inspector Panel:

• Event Name: LostFocus

Now select the Open event handler under MyComboBox, typing the following code in the associated Code Editor:

Var selectedIndex As Integer = Me.mSelectedRowIndex

Var s() As String = Me.Rows
s.Sort
Me.RemoveAllRows
Me.AddAllRows(s)

If selectedIndex = -1 Then
  Me.mSelectedRowIndex = -1
  Me.Text = ""
End If

RaiseEvent Open

Once again, we need to create a new Event Definition for the class using the values:

• Event Name: Open

And repeat the last operation to add the last Event Definition with the following:

• Event Name: Change

Type this snippet of code in the associated Code Editor for the Change Event Handler:

Var s() As String = Me.rows
Var n As Integer = s.LastRowIndex

For i As Integer = 0 To n
  If s(i) = Me.Text Then
    Me.mSelectedRowIndex = i
    Exit For
  End If
Next

RaiseEvent Change

4. Adding Methods to the Class

While MyComboBox is still selected in the Navigator, select the Insert > Method option from the menu, using the following values in the associated Inspector Panel:

• Method Name: AddNewEntry
• Parameters: Key As String
• Scope: Protected

And type the following snippet of code in the Code Editor associated with the new method:

// If return key or tab key is pressed then we add the current text to the menu options

If (key.Asc = 13 Or key.Asc = 9) And Me.Text <> "" Then

  Me.AddRow(Me.Text)

End If

Now add a second method to the class, using the following values:

• Method Name: Rows
• Return Type: String()
• Scope: Public

And type the following code in the method’s Code Editor:

Var r() As String
Var i As Integer = Me.RowCount - 1

For n As Integer = 0 To i
  r.Add(Me.RowValueAt(n))
Next

Return r

5. Overriding existing Methods

You always want your ComboBox menu items to be sorted alphabetically. And that means taking care of the default functionality of the AddRow and AddAllRows methods. At the same time, we don’t want the AddRowAt ComboBox method to be available for our subclass (it wouldn’t make much sense to add a new entry at a particular spot in the menu if it wouldn’t stay at that position afterwards).

Add a couple of new methods to MyComboBox using the following values:

• Method Name: AddAllRows
• Parameters: Items() As String
• Scope: Public

• Method Name: AddRow
• Parameters: Item As String
• Scope: Public

Select the AddAllRows method and type the following code in the associated Code Editor:

Var selectedItem As String = Me.SelectedRow
Var lastAddedItem As String = items(items.LastIndex).Trim.Titlecase

Var d As New Dictionary

Var s() As String = Me.Rows

For n As Integer = 0 To s.LastIndex

  d.Value(s(n)) = Me.RowTagAt(n)

Next

For Each item As String In items
  If Not d.HasKey(item) And item <> "" Then s.Add(item.Trim.Titlecase)
Next

s.Sort
Me.RemoveAllRows

// Calling the overridden superclass method.
Super.AddAllRows(s)

For n As Integer = 0 To s.LastIndex

  If d.HasKey(s(n)) Then
    Me.RowTagAt(n) = d.Value(s(n))
  End If

  If s(n) = selectedItem Then
    Me.mSelectedRowIndex = n
  End If

  If s(n) = lastAddedItem Then
    Me.mLastAddedRowIndex = n
  End If

Next

Select next the AddRow method and type the following code in the associated Code Editor:

If item = "" Then Return

item = item.Trim.Titlecase

If Not Me.HasMember(item) Then

  Var selectedItem As String = Me.SelectedRow

  Var d As New Dictionary

  Var s() As String = Me.rows

  For n As Integer = 0 To s.LastIndex

    d.Value(s(n)) = Me.RowTagAt(n)

  Next

  s.Add(item)
  s.Sort

  Me.RemoveAllRows
  Super.AddAllRows(s)

  // Let's restore the original rowtags to their new spot in the menu

  For n As Integer = 0 To s.LastIndex

    If d.HasKey(s(n)) Then
      Me.RowTagAt(n) = d.Value(s(n))
    End If

    If s(n) = selectedItem Then
      Me.mSelectedRowIndex = n
    End If

    If s(n) = item Then
      Me.mLastAddedRowIndex = n
    End If

  Next
End If

We still need a last method to our class that will check if an item is already among the current entries for the menu. So, add it using the following values:

• Method Name: HasMember
• Parameters: Item As String
• Return Type: Boolean
• Scope: Protected

Type the following code in the associated Code Editor:

Var b As Boolean

For Each s As String In Me.Rows
  If s = item Then
    b = True
    Exit For
  End If
Next

Return b

6. Overriding Existing Properties

Because we are sorting the entries in the menu, we also need to make sure that the LastAddedRowIndex and SelectedRowIndex properties are pointing to the right item and selected row index. That means that we need to override the current functionality of the base class.

In order to do that, select the Insert > Property option from the menu with the following values in the associated Inspector Panel:

• Name: LastAddedRowIndex
• Type: Integer
• Scope: Public

With the new property still selected in the MyComboBox class, access the contextual menu and choose the Convert to Computed Property option. That action will add a Get and Set method under the property item, in addition of adding a new mLastAddedRowIndex property whose scope will be Private.

Let’s add the second Property using these values:

• Name: SelectedRowIndex
• Type: Integer
• Scope: Public

Once again, with the just added property still selected under the MyComboBox class in the Navigator, select the Convert to Computed Property option from the contextual menu. Then select the Set method under SelectedRowIndex and type the following code in the associated Code Editor:

Var r() As String = Me.Rows

If value > r.LastIndex Then Raise New OutOfBoundsException

If value > 0 Then
  Me.Text = r(value)
Else
  value = -1
  Me.Text = ""
End If

mSelectedRowIndex = value
RaiseEvent Change

This is the code that will be executed every time our code sets a new value to the property, so we need to make sure it is between the allowed range, raising a new OutBoundsException exception if it is beyond the limits of the available entries in the menu.

At the same time, if it is not a positive number that would mean that the we don’t want to select any entry, so we can set the text property of the ComboBox to an empty string and the inner mSelectedRowIndex value to -1.

7. Putting it to Work

Now that you have the ComboBox subclass ready to work, choose the Window1 item in the Navigator in order to access its Layout Editor. Next, drag the MyComboBox item from the Navigator and drop it over the Window1 in the Layout Editor. You can use the layout guides in order to keep it aligned with the window margins.

With the MyCombobox1 item still selected in the Layout Editor, access its Panel Inspector in order to assign some initial values for its menu from the Appearance > Initial Value section. For our example, you could enter "One", "Two" and "Three" as the values in the associated editor. And you can also enable the autocomplete option for the control under Behavior > Allow Auto Complete.

Run the example app and observe how every new entry made by the user is added to those already available in the ComboBox menu, while keeping them sorted.

You can add more UI controls to Window1 in order to use the other methods and properties, or just download the example project and run it from the Xojo IDE. I hope you have found this tutorial helpful and that you can learn from it and adapt it to your needs. If you have questions about this post or the Xojo programming language you can find me at the Xojo Forums and on Twitter @xojoES.

Day 1: Wet your Feet!

Download Xojo to your platform of choice, Mac, Windows or Linux. Xojo is free for learning and development, you can write, run and debug your apps all without a license. Everyday in the 14 Day Guide can be done without a Xojo license. So go ahead and download Xojo to get started!

Tip: You can find the Xojo System Requirements for your operating system (OS) of choice here.

Once downloaded, launch the Xojo IDE (Independent Development Environment, i.e. the Xojo app) and you will be presented with a window pointing you to many of Xojo’s resources. I’ll show you where to start this time, so go ahead and click Start Using Xojo in the bottom left corner to get to the Project Chooser.

If you’re interested in developing Desktop apps, point your browser to the Xojo Desktop QuickStart and follow the steps to build a simple desktop application with Xojo in 30 minutes or less. You can do the same both for Web and iOS projects if you are interested in starting there. You can find resources in other languages in the International section of the Xojo Dev Center.

Video: If you prefer to video, there are videos you can listen to as your follow the QuickStarts on Xojo’s YouTube channel.

The QuickStarts will introduce you to main concepts and have you writing your first lines of code in Xojo! If you have extra time today, try the Tutorials next. They are just a bit more in depth than the QuickStart and will likely take you less than an hour to complete. The tutorials focus on further familiarizing you with the main areas in Xojo like the Editors and how to layout and interact with some of the native controls.

Tip: After completing these, try to reproduce the projects without relying on the documentation. Doing is a great way to learn, so try to do your own simple project from scratch.

Day 2: Getting Programming Basics

Whether you know other programming languages or if Xojo is your first language to learn, understanding the fundamentals of programming will give you a leg up. For day 2, I recommend that you download the Introduction to Programming with Xojo textbook (available in PDF and iBooks formats) and work along with the first 2 chapters.

This book will introduce you to more of the Xojo language and walk you through writing projects complete with code snippets that will help you grasp the basic concepts behind: variables, programming structures like loops, functions and parameters, plus you’ll get your first contact with the Xojo Debugger (the Debugger allows you to find and fix bugs in your app).

Tip: Don’t get discouraged if you don’t know a word or concept. You are learning a new language after all. Take a moment to Google it, yep, Google it, programmers Google things all the time or search the Xojo Documentation.

It will take some time to get through the content and all the examples in the textbook. The important thing is not how much you advance in one day, but to understand and retain what you learned! Don’t get down if you feel like you still don’t understand what the code does; it’s only day 2!

Day 3: Find Out More

On Day 3, continue with the Introduction to Programming with Xojo textbook. Try and get through chapter 5 today. Perhaps some broader aspects of coding are coming into focus. While going through the chapters of the textbook, you might have questions or want more information.

As with the Introduction to Programming with Xojo book, you will not read the Documentation in one day! But it will help you as you develop your own apps that put into practice what you have learned from the QuickStart, Tutorials and textbook.

Watch The Video: Watch the first video in our Programming with Xojo Course. It’s a on-going series of videos focused on taking you from zero coding knowledge to writing your own apps. And it’s just another way you can learn how to code with Xojo.

Day 4: Get Object-Oriented!

There are many Object-Oriented programming languages and OOP languages offer many advantages. As you have hopefully already learned, the Xojo language is OOP and that is one of the reasons it can be easy to grasp and start using.

Tip: Object-Oriented programming (OOP) is a style of programming based on “objects”, which are data structures that contain data (properties) and code (methods). These data structures are called “classes”. Classes are the fundamental building blocks of all Xojo applications.

To speed up that way of thinking, today I recommend you that you watch the Understanding Object-Oriented Programming with Xojo video. It’s 1 hour long so you should be able to also get through chapter 9 of the textbook

You want to start thinking and writing code so you can reuse it and evolve it without breaking what you have already done. Here is a good (and short!) tutorial that puts this into practice. It will teach you how to do one of the first things most developers want to do – modify the behavior of an existing control so it fits a specific need or create your own controls.

Day 5: Look at the Examples!

At this point you should feel pretty comfortable using Xojo and writing simple apps using the Xojo language.

There are 400 project examples included with Xojo. If you are looking for an example about how to do something specific, these are a great starting point. Use the example code “as-is” then modify the code to adapt it to your particular needs or simply to learn a particular technique.

Tip: Not quite comfortable yet? Take an extra day and do a Tutorial if you didn’t already, or try the Programming with Xojo Video Course.

Day 6: Databases

Modern apps make use of a wide variety of technologies and one of the most common you will hear about is databases. For a lot of projects, databases are a must. A database is “an organized collection of data generally stored and accessed electronically from a computer system.” Xojo comes bundled with the SQLite database and supports PostgreSQL, MySQL, Microsoft SQL Server and Oracle databases. Plus, you can use ODBC to connect to other databases such as Access, FoxPro, FileMaker, Firebird and even IBM iSeries.

The Xojo framework is large enough so you can find the classes you need, ready to use. Since Xojo comes bundled with SQLite, that’s a great place to start. Today, I recommend you do the “SQLite Basics” and “SQLiteDatabase and iOSSQLiteDatabase for Beginners” lessons that will teach you from the ground up, no previous experience working with databases is required.

Using Other Databases: In addition, there are videos in the Xojo Database playlist, topics range from designing a database, to the creation of a database based application, PostgreSQL, ODBC, or even creating REST web services in order to work with remote databases from mobile devices.

Day 7: Create Your Own Project

Doing is an excellent way to learn so today let’s start to create your own project from scratch. Start simple, something basic that can grow with you as a developer – a notes app, a shopping list, a time tracker…

Today is not about reproducing examples, but rather putting together all the pieces you’ve learned so far to make a new app. Sure you’ll may have questions about how to do something, so try using the multiple help features in the Xojo IDE. For example:

• Autocompletion: Start typing and the IDE will help you to autocomplete the name of a function, method, class or object instance. You don’t have to remember every class or object property, press the tab key and a popup menu will list them for you.
• Controls: Remember that the lower area of the Library panel offers information about the purpose of every user interface (UI) control, and that they are grouped by functionality; you only need to put the mouse pointer over to get a description about what they do.
• Event Handlers: Not sure about the Event Handler you need to implement in a control so it reacts to the user’s actions as you expect? The Add Handler panel is very descriptive about the mission of every supported Event for a particular control. Just go through them and read the provided information.
• Contextual help is everywhere: put the mouse pointer over the name of a function and you’ll see the expected parameters and their types.
• Global Help: Of course you can access the global help to get to the documentation for all the available Classes, concepts, datatype and language keywords among other topics. In addition, the documentation is full of example code snippets you can simply copy and paste in the Code Editor to implement (probably with some modifications to adapt it to your app).

Day 8: Get Stuck Unstuck

How’s your first project going? Don’t be down if it’s rough. It’s inevitable that you will reach a point when the information available is not enough to solve a particular problem. When that happens, I recommend joining the Xojo Forum and post your question there. Don’t be shy, the Xojo community is one of the best developer groups around. It’s likely you’re not the first one facing a particular problem and you may find your question and the answer already in the Forum! With the right search the solution could be in front of you in a few seconds!

Also check out this blog post on various ways to Get Unstuck.

Pro Tip: Ask for help after you tried everything you already know and after looking for the answer in the Xojo Dev Center! People appreciate that you have tried to figure it out on your own first and it helps to let them know what you have already tried that didn’t work.

Day 9: Be Cross-Platform

Remember that Xojo is a cross-platform development tool. That means that you can develop for any platform from your preferred development platform, Mac, Windows or Linux.

Note: A Mac is required to compile your apps for macOS. You can develop your desktop app on a Windows or Linux computer but ultimately, testing and compiling for macOS must be done from a Mac. A Mac is required for developing and compiling an iOS application.

The ability to write one app, with one set of code, and deploy it for 3 operating systems is pretty excellent! Of course, you will likely need to do some amount of testing (and debugging) on each OS. There are several solutions that let you create virtual machines running on other operating systems. For example, you can choose between Parallels, VMware Fusion or VirtualBox on macOS. Any of these will let you install Windows and/or Linux on your Mac computer. 

Creating a cross-platform app also means that you will need to make sure that the user interface behaves as expected on each different operating system. At some point, your app might need to change slightly for a particular operating system. For example, on Windows you might want to use the Registry, but on Mac you might want to use a plist. You can handle these special cases using conditional compilation. You can also use Target Attributes in the Attributes section of the Inspector Panel for items like classes, methods or properties, to decide what should be compiled for a particular target.

If you haven’t already try and finish the textbook today.

Day 10: Make the Xojo IDE Fit You

As you spend more time using Xojo, you’ll feel the need to change some preferences so they best fit the way you use it. Take a deep look at the Preference panels; you can chose your code font of choice, the keyboard shortcuts you prefer to use, the Navigator behavior, you can even choose your theme for the IDE.

These preferences, among others, will let you feel more comfortable and even code faster! For example, what if you prefer to have the Inspector Panel and Library in their own floating panels? Would that make a difference for you? And what if you edit the keyboard shortcuts so they fit better with the layout of your keyboard?

More From the Xojo Blog: Menu Shortcut Editor and Xojo Navigator Tip- Show or Hide

Day 11: Advanced Topics

As you move on in your 14 day learning path, let’s focus on more advanced topics for the development of more complex products. For example, XojoScript lets you execute new Xojo code dynamically in an already compiled application.

From the code and language sides, you should definitely learn about Design Patterns. The Xojo Blog has some great introductory posts about the Singleton and Observer Design Patterns, among others.

Take a look at Modules, Interfaces, Delegates, Enumerations, Declares and the related Xojo data types that let you access external libraries from your code. Is also a good point in time to explore differences like Internal or External project Items, adding your own properties to the Inspector Panel, and the use of Git, SVN or other source control solutions.

In addition to debugging your apps, Xojo includes a feature that will Analyze and Profile the execution of your project, letting you know where your app bottlenecks are (if any) so you can put your efforts on optimizing that portions of code.

From the Xojo Blog: The Xojo Blog has a lot of posts that offer examples on more advanced concepts and topics.

Day 12: Let’s Review

You’ve learned a lot in the last 12 days, so let’s take a breath today. Take some time to review, maybe look up in the Documentation that question you were thinking about in the shower yesterday. Or watch some of the videos in the Programming with Xojo Video Course. Take today to reinforce and refine the skills you have acquired. And don’t forget to pat yourself on the back for a job well done!

Day 13: Refactorization

Compare the code you wrote the first days with the one you’re writing now with all the acquired knowledge. I bet you’ll find something that can be done better. Do it! Don’t hesitate to rewrite your code and optimize it so it runs faster, better and is more reusable, making it easier to maintain and evolve.

This is known as refactorization, aka spit and polish, and there are many books focused on the topic. Xojo includes some options that will help you to do that, mostly from the contextual menu, every time you select an item in the Navigator a block of code or even using the Search and Replace panel.

Day 14: Keep Learning!

Don’t stop here, coding is a journey! As you advance writing code, you’ll feel the need to learn new things, and there are tons of resources at your disposal!

A good place to visit is the Community Portal and also the Open Source section of the Xojo Dev Center. Here you’ll find a number of ready-to-use libraries from other reputed Xojo developers, ready to download, inspect and, thus, to learn from!

We hope you have enjoyed our 14 day coding adventure. Tweet to us @xojo and let us know how it’s going and if you have any questions, reach out to us at hello@xojo.com.

1. Adding the database file

You probably created your SQLite database file using an external editor; so first add that file to your Xojo project.

You can do that in several ways, but usually it’s best to add a Build Step. This way, the file will be added automatically to the folder of your choice every time you compile your app. Bonus: Doing this allows you to decide to use different paths when debugging or deploying your app.

In order to add a new Build Step in a Desktop project select the target in the Build Settings then, from the contextual menu, choose the “Add to Build Settings > Build Step > Copy Files” option.

The previous action will give you access to the Inspector Panel for the just-added item where you will be able to type a name for the Build Step, choose if the copy file action will be executed both for debugging or deployment and, most importantly, choose the location where the file should be copied when the app compiles.

In fact, the Destination menu contains a number of typical paths (or most relevant folders). For example, a good Destination option would be “Resources Folder”. Of course, don’t forget to add the database file itself using the buttons on the Build Editor toolbar.

When you’re working with a Web project, you’ll find exactly the same behavior, even if you choose to deploy with Xojo Cloud.

On iOS, the only change is that you’ll have to choose the icon with an iPhone picture in it in order to access the Build Step contextual menu; in addition to the fact that every added resource needs to be signed with a certificate.

2. Copying the database file to a “Working” folder

You may think that the previous step is all you need to do, because if the database file is already copied in a well know path then you only need to provide that path as the DatabaseFile property on a new SQLiteDatabase or iOSSQLiteDatabase instance. But this is not the case.

They are many reasons you shouldn’t do that, specifically because the database would be open in read/write mode and if you write to that database file inside an application bundle, then you’ll be modifying a resource that would invalidate any certificate signature on your app.

The best thing to do is o detect every time you run the app if the database file has already been copied from the app bundle (or folder) into a target folder that doesn’t have an access problem when it is time to use the database. The Application Support folder is a good place for Desktop apps, while the Documents folder is fine for Xojo Cloud and iOS apps.

For example, if our database file is named “EddiesElectronics.sqlite” and our app name is “Xojotest”, then we can add the following code fragment into the Open Event Handler of a Desktop app:

Var source As FolderItem = SpecialFolder.Resource("EddiesElectronics.sqlite")
Var name As String = app.ExecutableFile.name.NthField(".",1)

// We check if there is a folder with the App name in special Application Data
// if not, we create it and copy the database file from Resources bundle/directory
If Not (SpecialFolder.ApplicationData.Child(name).Exists And SpecialFolder.ApplicationData.Child(name).IsFolder) Then SpecialFolder.ApplicationData.Child(name).CreateFolder
If Not SpecialFolder.ApplicationData.child(name).child(source).exists Then source.CopyTo(SpecialFolder.ApplicationData.Child(name))

Try
  // Create a SQLiteDatabase instance and try to open our database file from
  // the path
  pDatabase = New SQLiteDatabase
  pDatabase.DatabaseFile = SpecialFolder.ApplicationData.Child(name).Child("EddiesElectronics.sqlite")
  pDatabase.Connect

Catch e As DatabaseException
  MessageBox e.Message
End Try

For an iOS app, the code would be:

Var source As Xojo.IO.FolderItem = xojo.io.SpecialFolder.GetResource("EddiesElectronics.sqlite")

// We check if there is our database file already copied on the Documents Sandbox folder
// if not, we copy the database file from Resources bundle/directory
If Not xojo.io.SpecialFolder.Documents.Child("EddiesElectronics.sqlite").Exists Then
  source.CopyTo(xojo.io.SpecialFolder.documents)
End If

Try
  // Create a SQLiteDatabase instance and try to open our database file from
  // the path
  pDatabase = New iosSQLiteDatabase

  Var f As FolderItem = xojo.io.SpecialFolder.Documents
  pDatabase.DatabaseFile = f.Child("EddiesElectronics.sqlite")
  Call pDatabase.Connect

Catch e As RuntimeException
  MessageBox e.Reason
End Try

If you’re working on Xojo Cloud, the code will be even shorter. First, make sure that the Copy File Build Step has the following values in the Inspector Panel:

• Destination: Contents Folder
• Subdirectory: Documents

Then, the code will be:

Try
  pDatabase = new SQLiteDatabase
  pDatabase.DatabaseFile = SpecialFolder.Documents.Child("EddiesElectronics.sqlite")
  pDatabase.connect
Catch e as RuntimeException
  MessageBox e.Reason
End Try

What about a Web app that you host? That would mean you are in control about the folder/directory you want to use to store the app resources. Thus, it wouldn’t make much sense to automatize this process (but it is certainly doable following the same principles).

3. Simplifying the process

What we have seen already works, but that means that you need to change the file database name and probably that would change on every app you build. That also means that you’ll have to write the same code snippet again and again on every new app. Wouldn’t it be great to be able to extend the SQLiteDatabase and iOSSQLiteDatabase classes in order to simplify that?

Well, you can do that! Start by adding a new Module to the example project (for example one named “DatabaseExtensions”) with a couple of methods on it. The first method will be the one executed on our Desktop, Web and Console apps, because all of these targets use the SQLiteDatabase class.

So, add a new method using the following signature in the just-created module:

OpenDatabase( databaseName as String )

It extends the SQLiteDatabase class, adding a new method that takes as parameter the name of the file we want to copy on the “work” folder/directory.

The code you should type on this method is:

pDatabase = New SQLiteDatabase

#If TargetDesktop Or TargetConsole Or TargetWeb Then

  Var source As FolderItem = SpecialFolder.Resource( databaseName )
  Var name As String = app.ExecutableFile.name.NthField(".",1)
  // We check if there is a folder with the App name in special Application Data
  // if not, we create it and copy the database file from Resources bundle/directory
  If Not (SpecialFolder.ApplicationData.Child(name).Exists And SpecialFolder.ApplicationData.Child(name).IsFolder) Then
SpecialFolder.ApplicationData.Child(name).CreateFolder
If Not SpecialFolder.ApplicationData.Child(nam).Child(Source).exists Then source.CopyTo(SpecialFolder.ApplicationData.Child(name))

  Try
    // Create a SQLiteDatabase instance and try to open our database file from
    // the path
    pDatabase.DatabaseFile = SpecialFolder.ApplicationData.Child(name).Child(databaseName)
    pDatabase.Connect

  Catch e As DatabaseException
    MessageBox e.Message
  End Try

#ElseIf TargetXojoCloud
  Try
    pDatabase.DatabaseFile = SpecialFolder.Documents.Child( databaseName )
    pDatabase.connect
  Catch e As RuntimeException
    MessageBox e.Reason
  End Try
#EndIf

Of course, we need to add the “pDatabase” property to our module too: pDatabase As SQLiteDatabase

Now, you’ll only need to use:

OpenDatabase("EddiesElectronics.sqlite")

With the method selected in the Project Browser, click on the Attributes section of the Inspector Panel (the Cog Wheel icon), and uncheck the “iOS 64” checkbox. This way, that method will not be included when compiling for iOS apps.

Do the same thing with the “pDatabase” property, so it is only compiled on the supported targets.

The second method is the one we will be using for iOS apps. The method signature would be:

OpenDatabase(databseName as String)

And typing the following fragment of code in the associated Code Editor:

pIOSDatabase = New iOSSQLiteDatabase

Var source As Xojo.IO.FolderItem = xojo.io.SpecialFolder.GetResource( databaseName )

// We check if there is our database file already copied on the Documents Sandbox folder
// if not, we copy the database file from Resources bundle/directory
If Not xojo.io.SpecialFolder.Documents.Child( databaseName ).Exists Then
  source.CopyTo(xojo.io.SpecialFolder.documents)
End If

Try
  // Create a SQLiteDatabase instance and try to open our database file from
  // the path

  Var f As FolderItem = xojo.io.SpecialFolder.Documents
  pIOSDatabase.DatabaseFile = f.Child( databaseName )
  Call db.Connect

Catch e As RuntimeException
  MessageBox e.Reason
End Try

Lastly, and with the method item still selected in the Project Browser, go to the Attributes section of the Inspector Panel and make sure that the “iOS 64” checkbox is the only one selected under the “Include In” section. This way, we make sure that the method will be compiled only on iOS targets.

And do the same thing with the “piOSDatabase”, so it is only compiled for iOS targets.

To Summarize

As we see, the use of Modules in combination with OOP Class Extension is a good way to get more flexibility when developing your apps; using a common function (or method) name no matter if you are working on Desktop, Web or iOS. Additionally, that leads to a more convenient reutilization of your codeand, of course, less code to maintain through all our projects!

(You can find this article in Spanish here)

1. Xojo is for everyone

It doesn’t matter if you are just starting to learn how to develop software or if you are already a seasoned developer, Xojo is for everyone! If you are getting your feet wet in coding, then you’ll find that Xojo offers a programming language that is extremely easy to grasp from the start. In fact, you’ll find a lot of contextual help in Xojo while coding, and access to the global Help menu is only a click away.

In addition, the Xojo Documentation website offers really easy-to-follow QuickStarts, Tutorials and Guides letting you make your own Desktop, Web, Android, iOS, Raspberry Pi or Console apps in no time! Add that to the more than 300 video-tutorials you can find in the Xojo YouTube channel, and the fact that all the Xojo language documentation is packed with code snippets showing how to implement a particular feature- copy, paste and you are set.

Need some starting points for a better understanding of how Xojo Projects work? The Examples folder included with the Xojo Download includes dozens of complete example projects you can open, run and inspect to see in detail how to implement a particular task or behavior; then you can  adapt and use these for your own projects. Even you can use the Search feature for filtering the example projects by platform, operating system or other criteria.

One thing you’ll notice the very first time you run Xojo is that you aren’t inundated with features you don’t even know what to do with yet! Everything is clear and concise in front of you, hiding the complexity generally associated with the development workflow.

As you advance in your learning process and get more experienced in coding, you can discover more advanced features at your own pace. And even then, things like Web debugging, iOS or Android deployment or truly multi-platform development, are still effortless. Xojo does all of this without installing thousands of files on each operating system or requiring the additional installation of other components in order to properly work.

What if you’re an experienced developer coming from another development environment or language? Then you’ll be able to learn and master the Xojo programming language in a blink while watching your productivity increase! In fact, Xojo is an Event-Driven OOP (Object Oriented Programming) language, sharing the same “dot notation” syntax used by the most modern programming languages; and Xojo offers guides to port your existing projects, for example, from FoxPro or VB6 to modern and truly multi-platform deployment with Xojo. And even if you are coming from other development environments as FileMaker or 4D, Xojo makes your solutions available for a more wide range of platforms as native apps and without hidden or extra deployment costs.

Being an OOP language means that Xojo will share the same set of paradigms and/or syntax you are used to dealing with in other programming languages; ranging from PHP to C++, Objective-C, Swift, JavaScript, Python, and others. In fact, you’ll discover that several of the language keywords, instruction blocks and function or methods calling conventions are very similar to the ones found in those.

Add that to the rich and complete Xojo Framework and the fact that you can even use external libraries if you need to; and you’ll realize all the possibilities you have at your hands for creating apps and complete solutions that can be used by individuals or companies of all sizes.

2. Make all kind of apps!

While several languages and IDEs are more suited or focused on developing a particular kind of products (database driven, mobile, IoT, etc.), with Xojo you’ll be using the same IDE and programming language to create all of these and more!

For what it is worth, that means that even if you are a self-employed developer, a Citizen Developer or need to develop a solution for a company, you’ll be saving a huge amount of time, money and resources in order to get all these things done with a single development environment. That translates into reduced costs and increased ROI in your development investments; from the simplest ones to the more complex and demanding, including Console apps acting as Daemons, background processes, task helpers… or APIs development as the middleware to interact with both Mobile, Web, Desktop or Raspberry Pi clients!

Do you offer consultancy services or are you working as a freelance developer? With Xojo you’ll significantly reduce the amount of time you usually spend following multiple changes and evolutions in programming languages, frameworks, SDKs, technologies and, probably, third parties IDEs (among other resources) in order to keep going with your business.

At the same time, due to the fact that Xojo shares the programming language and IDE among all the supported platforms (Desktop, Web, Android, iOS and Raspberry Pi) and architectures (both 32 and 64-bit / Intel and ARM), you can also expand the kind of solutions you can offer to you current or potential clients and keep them running as the technology evolves!

3. Truly Native, Cross-Compiled, Multi-Platform Apps!

Some development environments or programming languages are focused (or are more appropriate) to a particular platform or target. With Xojo you’ll find that all of your apps will be compiled to native binary code on every supported platform.

That means that they will not incur the performance penalties imposed by byte code translations or that they can be easily reverted to source code, even your Web products!

What’s more important: the compiled apps will look and behave as you expect on every one of the supported operating systems.

In general, all of this means that you can be more confident about the fact that your intellectual property will not be the targeted or exposed by the most common techniques or exploiting attacks; and that translates into additional peace of mind regarding how you protect your investment in developing and deploying your solutions.

Even Xojo is created with Xojo! That is, the IDE offers the same look and feel and set of features from Windows, macOS and Linux.

4. Do more with less

During the designing, coding, testing or deployment phases of the product you won’t need to do complex set-ups or check for ever-changing dependencies! The Xojo IDE abstracts you from all the inherent and underlaying complexity, so you can focus on what really matters: the features that make your product truly unique.

This kind of complexity abstraction is evident not only for Desktop apps, but also for Android and iOS deployments and is especially evident when deploy web apps in combination with Xojo Cloud.

In this last case, you only need to click a button in Xojo to have your web app transferred from the IDE to your Xojo Cloud server. Your app will be up and running in a matter of seconds, without needing to deal with complex server configurations or investing all the required time in being sure that you have all the server security issues covered and under control. Think about that for a moment: if you are a small company or just an independent developer, you don’t need to invest  extra resources, time and money in order to have your web apps secured and running with confidence.

Of course, if you have the resources and/or the required knowledge, you can deploy your web apps yourself on any VPS or web hosting service of your choice that meets the Xojo Web deployment requirements.

But the best part is that it doesn’t mind if you’re developing for Web, Android, iOS, Desktop or Raspberry Pi: you can develop for any of the Xojo supported platforms from the operating system of your choice! In the case of macOS and iOS apps, development can be done on any platform a Mac computer is required for compilation.

In summary: it doesn’t matter what OS or platform you want or need to code for, you’ll be using the same IDE and programming language in all the cases, abstracting you from all the particularities and underlaying complexity on every case. And that means doing more in less time!

5. Rapid Application Development

It doesn’t matter if you are creating a Desktop, Web, Android or iOS app; or if you want to build your solutions for Intel or ARM based architectures. With Xojo you will be able to design the user interface via Drag & Drop from a rich set of controls ready to use. It’s that simple. In fact, the Layout Editor provides visual clues to precisely align every control in the Window, View or Page of the app; and if you’re targeting for macOS, Web, Android or iOS you’ll be able to see how your designs react when used in Dark Mode!

Reacting to users’ interactions in your apps is as easy as selecting a user interface control in the Layout Editor, adding the kind of event you’re interested in from a list (with contextual help about what it does and when it is fired), and writing the code you want to be associated and executed to that particular Event.

Add that to the fact you can reuse your already developed Classes, Modules and other resources; you can even reuse your code between different kinds of projects and targeted platforms!

6. No chains!

It doesn’t matter if the apps or solutions created with Xojo are intended to be used by dozens or thousands of users, even if they are database driven! With Xojo you don’t have to pay royalties for absolutely anything! Even better: you don’t need to buy a license in order to try, learn and use Xojo! There is no limited trial, feature limitations or other drawbacks when using the free IDE. Download Xojo and begin learning, developing, running and debugging your projects all without a license.

Features include, the access and use of the supported database engines: from SQLite to MySQL/MariaDB, PostgreSQL, or any other you can access using ODBC, and of course the included features to work with Reports.

You can buy a Xojo license when you decide that is the time to build your projects. Further, all Xojo licenses are covered by a 90-day money-back guarantee.

In addition, you don’t even need to pay for what you are not going to use (or going to use right now). What does this mean? Well, let’s say that if you only work with Windows and only want to create apps for Windows, then you only need to buy the Windows Lite Edition license for that ($99 USD), while if you need your apps to be run from all the supported Desktop platforms (including Raspberry Pi), then the Xojo Desktop Edition license is probably what you’re looking for ($299 USD); or if you really want to grasp all the Xojo power and target all the Xojo supported platforms (Desktop, iOS, Web and Raspberry Pi), then Xojo Pro is undoubtedly for you ($699 USD)! Oh and Xojo Pi, for building desktop and console apps, is free!

You can even upgrade to Xojo Desktop or Pro at any time if you decide that you need to use more advanced features not present in your current edition. In other words, you don’t need to buy a new license from scratch if you don’t want to. You can even change your Xojo Cloud plan at any time you require!

7. You’re not alone!

With more than 400,000 users around the world and more than 20 years on the market, the awesome Xojo community is one of the best programming resources you can find around to join to. In the Xojo Forum you’ll find the largest community and best place to get your questions answered by a large group of enthusiastic and seasoned Xojo developers.

It doesn’t matter if it’s a simple or a more complex problem, you’ll feel welcomed and probably have your problem solved in record time! In fact, many of the replies come from members of the Xojo Staff, ranging from Customer Service to anyone on the Engineering Team or even the Founder and CEO of Xojo himself!

Of course, you have other resources you can (and should!) visit, ranging from a dedicated publication about Xojo development, to Users Groups and Xojo Pages in Facebook, developers blogs about Xojo, and of course the official Xojo channels in Twitter, Instagram or Facebook. Don’t worry, you don’t need to search the entire web to find these, we have collected some of these valuable resources here and here.

And if you need to get a richer experience and more in-depth knowledge, in a face to face way, then you won’t want to miss any of the usual Xojo Events taking place in several American and European cities each year! There you can chat with other Xojo developers to exchange experiences, attend technical sessions, socialize and create new relationships that can lead in new work projects, etc.

The biggest of these Events is XDC, with Xojo developers coming in from all around the world, and where you will be able to attend sessions from expert Xojo developers and where you can talk with all the Xojo Team!

8. And you won’t be left behind

Did you know that Xojo is still able to open and run projects from earlier releases, even many, many years ago? Sure that in more complex projects you will need to upgrade code, and that’s because Xojo has evolved, and continues to evolve, to match the own industry changes and evolution.

In fact, the apps created with Xojo are 64-bit compliant (although you can still generate 32-bit code, if you need), with support for HiDPI graphics, Dark Mode support both on macOS and iOS, the latest iOS SDK, native Silicon and M1 compilation and meeting other non-visual changes imposed by any of the current operating systems.

You can expect several Xojo version releases every year, adding new features, improving existing ones and fixing bugs. But we also keep a bigger picture about the medium to long term evolution of Xojo, so you can always see the big features we are working on that will be coming in future releases of Xojo. That way, all the effort you’re putting in the apps, products and solutions you create today won’t be left behind in the future. You’ll be able to improve and enrich them for your users, keeping them current as operating systems evolve.

Need to request a feature is important for you or did you find a bug you can’t workaround? We listen to you. Go to our Issues tracker system to get in touch with us about the things you want to be added or improved.

9. Add your own features!

The Xojo Framework is large enough to accomplish most of the usual app requirements you may need; but sometimes you need to go a bit further, even the thousands of already existing external libraries around whose functions you can use directly from your code … and in these cases you’re covered too!

Xojo Provides SDKs (Software Development Kits) both for Desktop and Web applications; so you just need to start digging in the provided documentation and example projects in order to create your own Xojo Plug-Ins. These will be loaded from the IDE and you’ll be able to use their exposed features with the same simplicity you do when using the rest of the internal Xojo Framework.

10. Xojo Ecosystem

Don’t be afraid if you don’t have the time, resources or knowledge needed to develop your own plug-ins.

You can resort to the broad offer of excellent third-parties plug-ins, add-ons, libraries and classes you can choose from. These range from commercial software to Open-Source projects, or just plain free classes, modules or libraries ready to download and use in your own Xojo projects.

We are here to help!

All in all it’s time to give Xojo a try, isn’t? It’s just a click ahead right now, so download Xojo and rediscover the pleasure of coding!

The main advantage of a class hierarchy is that all the derived classes share the same set of methods, properties and events declared in their upper classes (those not set with a Private scope) and, thus, we can make our code more flexible, easier to maintain and get more dynamism from our apps at run time thanks to the Casting of types.

Download the Demo Project

What is this all about? Very simple. For the subject at hand, every graphic control or User Interface (UI) control included in the Desktop Xojo Framework share the common base class RectControl (this one based, at the same time, on the base class Control); and among the methods available in that class we can find DrawInto.

This means that every UI control has the ability to draw itself in any given Graphic context. However, when drawn in the target graphic context they will lose their usual response to any user interaction. That is, they would be a mere graphic representation of themselves; something that is really useful in many cases. For example, this is the technique used for drawing all the contents of a given page or range of pages in AXControlGrid.

As you can see in the Xojo documentation, the DrawInto signature is as follows:

RectControl.DrawInto(g as Graphics,x as Integer, y as Integer)

• The first thing you can see is that the method is called on the instance (UI control) we want to draw into a given graphic context.
• Second, the first argument we provide in the DrawInto method is the graphic context we want to use to draw the control. As you probably know, we can get such graphic context from several kind of classes, for example Picture. In addition, the target graphic context can be of any size we need it to be!
• Third, the x and y arguments are the top-left coordinates used to draw the control in the target graphic context and, of course, these coordinates should be in the range of the width and height of the target graphic context passed as the first argument.

For most of the cases, you don’t need to do anything special to use this method in your own classes. That means that the object calling the DrawInto method will draw itself using the same code you put in its Paint event. The unique difference in this case is that the Paint event will use the external graphic context and receive x and y coordinates that may be (or may not be) outside its own width and height range.

But there might be other times you don’t want to draw the control using the same code as the one written in the Paint event. Maybe because you need a more refined representation of the control or you simply want to leave out some details that are useful when the control is drawn as part of the UI but not when it is printed or used in a PDF document. In addition, it can be the case that inside the Paint event you may need to do some calculations on the x and y coordinates that would not make sense (or would be out of range) when done on an external graphic context.

After all, the key about using DrawInto is this:

• When a instance calls this method, what really happens is the code in the Paint event will be executed on the new graphic context received as argument. Of course, if you have not implemented the Paint event yourself, then Xojo will execute the default implementation.

Customizing the DrawInto Behavior

In other cases, especially on Windows, it is possible that we won’t get the right drawing when using the default implementation of the DrawInto method. If you find yourself in this situation, you can fix it by overwriting the DrawInto method for your own UI classes.

When you do that, evey time you call this method it will execute the code you included in it, and that means that you will be in control of the received graphic context as parameter, its size and origin coordinates, and especially the drawing operations available through the methods from the Graphics class.

The way to implement (overwrite) the DrawInto method in your own UI controls (derived from the RectControl class) is as simple as for any other overwritten method or Event in your own subclasses.

With your class selected in the Xojo IDE Navigator, access the contextual menu to select the Add to "instanceName" > Method option, choosing the DrawInto(graphics as Graphics, Left as Integer, Top as Integer) item in the Name field popup from the Inspector Panel.

Once selected, you will see that the associated Code Editor will contain by default a call to the same method signature on the Super class. This gives the class the control is based on the oportunity to drawn itself.

From a practical point of view, you will probably want to delete that call when you don’t want to use the same kind of representation for the control on the external graphic context when that is drawn in the UI. In addition you will save some drawing time thus improving the overall speed.

Now you only need to include in the DrawInto method the code you want to use in order to paint your control on the received context and you’ll be set! From that point on, every time you call:

aRectControlInstance.DrawInto( tContext, 100, 100 )

Xojo will execute the code put in your own implementation of the DrawInto method, and that means more flexibility and control about what is drawn and how it is drawn; especially if your UI control is going to be used both in macOS and Windows.

DrawInto in Practice

In order to see how everything works, let’s create a simple Xojo Desktop project where we will make use of our own DrawInto implementation on one Canvas based class.

Create a new Xojo Desktop project, drag the Canvas control from the Library panel into the Navigator.

Next, and with the new Canvas class selected, access the Inspector Panel to set the following values:

• Name: MyOwnControl
• Super: Canvas

With our new class still selected in the Navigator, add the Paint Event. For that, you may access the contextual menu and choose the Add to "MyOwnControl" > Event Handler…" option, selecting the Paint entry afterwards in the resulting window.

Then, write the following code in the Code Editor associated with the Paint Event:

g.DrawingColor = &cff0000
g.FillRectangle(0,0,g.Width, g.Height)

Nothing especially significant here. As you can see, it sets the foreground color to Red and then fills all the control area using the FillRect method on the control graphic context.

Now it is time to overwrite the DrawInto method. With our class still selected in the Navigator, add the DrawInto method and write the following code in the associated Code Editor:

// Uncomment the following line of code to see what happens!
// In that Case, the control first executes the code from the Paint Event,
// executing the drawing code from the overriden DrawInto method afterwards.

//super.DrawInto(graphics, left, top)

Var s As String = "From DrawInto"

Var sLen As Double = graphics.TextWidth( s ) / 2

graphics.DrawingColor = &c00FF00

// No matter what the "Left" and "Top" values are, we don't use them
// for our custom drawing.

graphics.DrawRectangle(0,0, graphics.Width, graphics.Height)

graphics.DrawingColor = &c000000
graphics.PenSize = 1
graphics.AntiAlias = True

graphics.DrawText("From DrawInto", (graphics.Width/2) - sLen, (graphics.Height / 2) )

Basically, what we are doing here is substantially changing the graphical representation of the control between what is seen when it is drawn in the user interface through the Paint Event and what we will get when calling the DrawInto method on the Control instance.

In the second case, it will draw a non-filled green rectangle using the same width and height that the control itself, writting the string “From DrawInto” centered in the control area.

You can see that the Super.DrawInto(graphics, Left, Top) code line is commented. After the initial running of the demo app, you can uncoment that line if you want in order to see how it changes the drawing when the Super class is called (remember, that means executing the code on the Paint event for the Class).

Putting it all Together

With our class already finished, it is time to start the layout of our minimal user interface. Something really simple. Choose the Window1 window in order to access the Layout Editor. Then drag the MyOwnControl item from the Project Broswer into the the Window1 area in the Layout Editor. With that action we will have added a new instance from our class. The resulting name for the instance will be MyOwnControl1.

Then, drag a standard Canvas control from the Library panel into the Window1 area in the Layout Editor. This action will result in the creation of a new Canvas instance with the by-default name Canvas1.

Lastly, add a new button from the Library into the Window1 area in the Layout Editor and use the Inspector Panel to set its name to pbDrawInto and its caption to “DrawInto”. This will be the button in charge to order our MyOwnControl1 instance to draw itself in the graphic context provided by Canvas1.

For that, and with the pbDrawInto selected, add an Action Event Handler and write the following code in the associated Code Editor:

// We create a Picture we can use to give a Graphics context to the
// Canvas1 backdrop (it would be "Nil" by default)

Var p As New Picture( canvas1.Width, Canvas1.Height, 32 )

canvas1.Backdrop = p

// And we instruct our "MyOwnControl" instance to draw itself on the
// "Canvas1" graphics context.

MyOwnControl1.DrawInto(Canvas1.Backdrop.Graphics,0,0)

If you want, you can layout your user interface like the one displayed in the following screenshot:

Now we have our app ready to test. Press the Run button in the IDE and verify the results you get between what is drawn by the Paint Event and what you get when you click on the button labeled “DrawInto”.

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, GuancheID, AXControlGrid, AXImageCanvas, Markdown Parser for Xojo, and HTMLColorizer for Xojo among others.

Just as people have varying levels of skill and interest in video games, the same is true of app development. There are those that are happy to devote enormous amounts of time to learning everything they possibly can. They don’t care how long it takes. They want to have control over everything and are willing to do whatever is necessary to make that happen. I’m so glad those people exist because there’s a lot of great software that might not otherwise have been created without them. I’m not one of those people. I really want to focus mostly on what makes my application unique, abstracted from the nitty-gritty of app development.

That’s why I have always been attracted to tools like Xojo. I am a citizen developer. Of all the job titles I have had over the years, all of them in tech,  none have ever included words like programmer or engineer. I do some software development but it’s just a part of my job. It’s something I do to help me in my work or to help my co-workers.

When I founded Xojo, Inc., tools like Xojo were called RAD (Rapid Application Development) tools. Now the term du jour is Low-Code. Put simply, it means that a development tool provides a lot of built-in functionality so you don’t have to write too much code compared to more traditional languages and tools. That’s Xojo. You can build your user interface visually via drag and drop.

The set of built-in commands (the framework) provides you with everything you’ll likely need to handle the things that do require some coding. Xojo is a cross-platform tool making it easy to create apps for different platforms such as MacOS, Windows, Linux, the web, iOS and even Raspberry Pi, without having to learn all the details of each one. Unlike some cross-platform solutions, Xojo builds complete native apps which means your apps have the look, feel and performance of those written in the more complicated tools that require so much more code.

It’s not all upside. There are sometimes very specific features for which Xojo has no built-in support. An example of this is notifications. The good news is that should you find yourself needing functions like this, there’s a vibrant Xojo community of users who have likely already created that functionality and you can just add it to your project. And Xojo is updated multiple times per year so new functionality is always appearing.

If you’re like me and you want to be able to quickly and easily build applications that make life easier for you and perhaps your co-workers, Xojo is something you should seriously consider. Xojo is also free to use and learn. You only need buy a license if you decide you want to deploy your application. We provide lots of free resources including a video library with over 250 videos, tutorials, and documentation as well as a textbook designed to help you learn app development.

It’s tremendously empowering to be able to build even a simple app that helps you accomplish tasks more quickly and efficiently. A low-code development tool like Xojo is a great place to start.

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

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

As developers, the computed properties definitions don’t differ a lot from regular ones. For example, every time we create one of these properties via Insert > Computed Property, we will define the property name, type and scope as we would do in the case of a regular property; and when we refer to these kind of properties from our code, we will use the usual dot notation and, at the same time, we will assign new values using the habitual equal symbol (“=”).

As you can see in the screenshot, below the property name we find both methods: Get and Set. ‘Get’ is automatically invoked (and showed by the Debugger) every time we write for instance:

Dim textVar As String = myProperty

While ‘Set’  is the one automatically invoked every time we want to assign a new value to the property, using, for instance, a sentence like:

miPropiedad = MyTextField.text

But if you try to execute these examples just as they are, you will get errors from the Compiler. The property itself doesn’t exists yet, just this wireframe or umbrella! When we create a new Computed Property this way, we are creating the wrapper but still have to define the real container (the property itself) in charge to store the values processed by Set and Get. This is something we can fix very easily; just a matter of adding a new property and defining its scope as private. This way we will be sure that no other object can directly access the property. The only way to get and/or set its value would be from the Computed Property methods previously created.

In fact, the way you can more clearly see the relationship between a regular property and the Calculated Property wrapper is by defining the regular property in first place. Add a new property, select it from the Project Browser, access the contextual menu and select the ‘Convert to Computed Property‘ option, as showed in the following screenshot:

As result, you’ll find that Xojo’s IDE has included the wrapper previously seen, modifying the original property’s name to include the “m” character as prefix. At the same time, the scope will change to Private too.

The magic behind Set and Get

Behind of the sugar syntax they provide, the real power found in Computed Properties, when compared with regular ones, resides in the code that we can write on both, and that will be executed just before we retrieve the property value or just before we make a new assignation to it.

Following with our example, if we would be using the property to store a person name, we could use Set on such property to provide a default value if the received one is an empty string:

Set (Value As String)

If Value = "" then mMyProperty = "New User"

On the other hand, we could use the Get on the property to retrieve the associated value using a predefined format. In our example, this could be getting the name using TitleCase (I know, I know… we can do this from the Set too, but just wanted to illustrate the topic exposed).

Get As String

Return mMyProperty.Titlecase

Method Overloading

Did you know Computed Properties always were feasible in Xojo? I mean, what we find behind the Computed Properties on Xojo’s IDE is a help to us as developers in order to simplify the process (and from an organizational point of view of our code).

The truth is that we always could achieve the same results (and still is possible) using the feature available in every Object Oriented Programming language, as is the case of Xojo! I’m referring to Method Overloading. This doesn’t mean that you have to choose between using Computed Properties or Method Overloading… the point here is to introduce what Method Overloading.

Method Overloading is the ability we have to define multiple methods using the same name, as long as their parameters types and/or number varies, and/or the type returned from the method itself. So, it’s time to see how we can achieve the same results of a Computed Property using Method Overloading.

Start adding a new property via Insert > Property. Define its type (String in this example) and its scope as Private. Make sure to add the “m” character at the beginning of the property name! (in fact you can use any other character, but we use the “m” as convention).

Now it’s time to create our Setter method. For that, use Insert > Method on the same project item where you created the property. Use the same name of the property without the initial “m” as the Method name, and write the following code in the Parameters field on the Method’s Inspector Panel:

Assigns Value as String

Leave empty the Return Type field (type returned by the method) and select Public as the Method Scope.

The ‘Assigns‘ keyword provides the syntax sugar to use the equal symbol (“=”) on the parameter pass to the method. This way, we can invoke our method (myProperty on the example) as follows:

myProperty = "New Value"

Does it seems like we are not calling a method but making an assignation to a Property?

Let’s create the method in charge of the Getter and, for that, we will repeat the same steps involved in the creation of a new method. When done, using the same name, you’ll see that the Project Browser will group together both methods. In this case, as we want to define the Getter, we don’t need to define the parameters, just the returned type (String for this example).

This is the way it will look in the Project Browser:

As we have previously seen, the method overloading is possible because they differ in the provided parameters and/or returned type, despite they use the same name. That way, the Compiler will know exactly which one has to execute on runtime based on such information.

Done! You’ve learned what Computed Properties are and how they work from the OOP side of the Xojo’s language.

Finally, probably you want to know too that:

* Computed Properties appear in the debugger and cannot be overloaded on subclassses
* Getter/Setter method overloading does not appear in the debugger, but can be overloaded on subclasses and specified in interfaces.

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

However, sometimes the combination can simply reach unstable situations by the very nature of our applications and here is where failures can arise in memory management. Fortunately, we can keep this under control with the help of the WeakRef class.

This is, in fact, what happened to me recently while implementing a new feature in Snippery my productivity application where one of those unlikely but possible cases one of the objects left in an unstable state. What does this mean? The referenced Control object stored in a property was not marked as nil once it was out of scope because its containing window was closed, so it was simply unsafe (an dangerous!) to check or access its properties and methods through a simple verification of the type:

if miPropiedad <> nil then

Despite the object referenced through the property would have been released, this condition will execute the code inside the block resulting in a unexpectedly exit from the app! In fact inspecting the object via Xojo’s debugger shows that the reference is still there but it inner structure is void.

So executing the previous code will bring a beautiful error message from OS X:

EXC_BAD_ACCESS (SIGSEGV)

That is an attempt to access a memory vector where we expected to find a data structure that is not there anymore.

I have to say that after further research on the subject I have found that this kind of error does not always occur and that it may depend on the type of object that we maintain the reference to, or even the property we want to access, or the method we try to call when the objects is in this “unstable” state. In the best of the cases, simply nothing happens. In the worst case, your application will suffer an unexpected exit you will not be able to trap using the Try … Catch block or exception handling mechanism offered by the Xojo language.

If you want to see for yourself what I’m talking about, you can download the example application that reproduces this kind of problem related with memory management.

WeakRef to the rescue!

How can we solve these kinds of situations? Easy! The WeakRef class allows code to maintain weak references to objects. When you wrap the object you’re interested in an instance of the class WeakRef, we will ensure that such reference is released (and thus becomes nil) through proper memory management. So, problem solved! From this point on we can perform and trust a conditional test of the reference against ‘nil’ before trying to access any of the properties of the object itself.

In the case of our sample application, we can fix the problem with the following changes:

1. We define the property SourceControl Worker class to be of the WeakRef Data Type
2. We make the following changes to Worker class constructor (where the referenced Control instance is now wrapped into a WeakRef instance):

sourceControl = new weakref( c )

3. We modify the conditional block of code for the Worker method to:

if sourceControl.Value <> nil then
  textArea(sourceControl).SelLength = 0
  textArea(sourceControl).Text = “This is a test”
end if

Note that in this case we Cast SourceControl to TextArea, so  we can work with the properties and methods of the control that we know are actually a control of TextArea type.

Make the changes, run the app again and you’ll notice that this time the app will continue running without errors once all the windows are closed.

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.

*Read this post in Spanish.

Do you have a free book so I can learn to code? Yes, Intro to Programming with Xojo is free!

Can I ask my beginner questions? Yes, the Xojo forum is a gateway to the friendly and helpful Xojo community.

The Xojo language is Object-Oriented. Object-Oriented programming is an excellent way to learn the fundamentals of computer programming. Xojo is also cross-platform, which means you can build apps for all kinds of platforms using a single code base. Xojo is a Rapid Application Development tool, which means it’s developed to make building apps simple and quick.

We offer a lot of resources to help anyone interested in learning to code with Xojo. But we do have some specific resources that will interest and assist students learning the fundamentals of coding and Xojo:

Books

Introduction to Programming With Xojo– This is a solid resource for learning the fundamentals of programming. While you will use Xojo, the concepts introduced are applicable to any language you want to learn later. In our experience, this book can be helpful to students as young 12 or 13 years old! We also have a Teacher’s Guide for educators planning on using Xojo in the classroom.

iOS Booklet– This booklet shows you how to use Xojo to develop for our latest supported platform, iOS!

Books, Magazines, Training & Tutorials from the Xojo community.

From the Xojo Blog Archives

First and foremost, who should learn to code!? Everyone!
Now that you have made your apps with Xojo, read how to Package, Sell & Market your apps.
Xoppy Bird – Building a Flappy Bird clone in Xojo
Hour of Code Projects for teachers & students: Spelling Test, Math Facts, iOS Doodle, Cat Pictures, Asteroid Run
The Flat Earth for Young Software Entrepreneurs– Today a 12 year old with a good idea and some determination can create an app and sell it with little up-front cost.
Earn the Boy Scout Programming Merit Badge with Xojo.

On-Demand Webinars & Videos

Retro Gaming – A fun webinar for beginners! Learn as we create a simple clone of the Atari 2600 game Combat.
This Playlist of videos is geared towards Getting Started with Xojo. Recorded webinars and video tutorials can be watched anytime.

Tutorials & Quizzes

Want to see it done? Tutorials take you step-by-step through the code for a Desktop, Web or iOS program. Or get into the details with how to create your own customer controls, build a messenger app, access the serial port, build an iOS app and more.

For a greater challenge see our Timer Tutorial & Quizzes, SQLite Basics Tutorial & Quizzes and the more in-depth SQLiteDatabase & iOSQLiteDatabase Tutorial & Quizzes. Keep checking in, we add new Tutorials all the time!

Other Resources

Here are step-by-step instructions on how to get started with Xojo. And of course the Xojo Blog is always full of tips, announcements, and news about Xojo and cross-platform development. The Xojo Forum is a good stop when you want to crowdsource your answers or ask a Xojo expert. There are also open-source Xojo projects to review and utilize.

What do you need to start learning to code with Xojo? Email me, I’m here to help you find the resource you need.