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

If you’re dealing with a situation in your code where two classes need to reference each other, then you could be leaking memory if you haven’t taken steps to prevent that.

Let’s look at this with a simple example.

• Create a new Xojo project and add two new classes to it, ClassA and ClassB.
• Add a ClassBReference As ClassB property to ClassA.
• Add a ClassAReference As ClassA property to ClassB.
• Add a Constructor to ClassB using the following signature:

Constructor(reference As ClassA)

And add this line of code to the method:

Me.ClassAReference = reference

Next, add the Destructor method to both classes and type “Break” as the only line of code for them. This will allow us to see if they leak memory or not. For example, if when debugging the example project the Debugger doesn’t reach the Break lines, that would mean that the Destructor has not been called and, thus, the objects are not released from memory. They are leaking!

• Now add the Opening event handler to Window1 and type these lines into it:

CreateReferences
Break

As you can see, it calls the CreateReferences method and then breaks into the debugger.

• Now add the CreateReferences method to Window1 and type these lines of code in the associated Code Editor:

Var ca As New ClassA
Var cb As New ClassB(ca)

ca.ClassBReference = cb

Now it’s clear what is going on here: ClassB instance is keeping a “hard” reference to ClassA (via the ca instance), and then the ca reference is keeping a “hard” reference to the classB instance cb.

Run the project. Is the debugger stopping in the Break lines of ClassA and ClassB Destructors? Nope. They are leaking because they are using hard cross-references with each other.

You can see it more clearly when accessing Global > Runtime > Contents in the Debugger panel. Both objects are still alive:

WeakRef to the Rescue!

But let’s say that your app design needs to keep these references. How do we solve this situation? The answer is using weak references instead of hard references, and the Xojo language has a class for it: WeakRef.

Let’s change ClassA and ClassB properties so their type is a WeakRef. Setting their definition as:

ClassBReference As WeakRef
ClassAReference As WeakRef

And let’s change the ClassB Constructor code so it creates a new WeakRef instance from the received object, instead of assigning it directly to the property.

ClassAReference = New WeakRef(reference)

And let’s change the code in the CreateReferences method to:

Var ca As New ClassA
Var cb As New Classb(ca)

ca.ClassBReference = New WeakRef(cb)

Run the example project again. Now you will see that the Debugger stops at the “Break” lines for each Class Destructor. Which means they are correctly released from memory. Problem solved!

WeakRef Memory Care

When using WeakRef objects through the code, keep in mind that accessing the real object they are referencing is done through the WeakRef.Value property in addition to Cast to the original Class.

To see it more clearly, add the “SayHello” method to ClassB and type this line of code into the associated code editor:

MessageBox("Hi From ClassB Instance")

Then, select the CreateReferences method from Window1 and add the following line of code at the end:

ClassB(ca.ClassBReference.Value).SayHello

First, we are accessing the ClassBRefence property from the ca instance; that gives us access to the WeakRef instance property, so we need to access its Value property in order to get access to the real object instance we are really interested (a ClassB instance).

But, because the Value property returns a generic Object, we need to Cast it to the class instance we expect (and should know) that is referenced by the Value property; in this case a “ClassB” instance. To do this, we are using the Cast expression:

ClassB(ca.ClassBReference.Value)

Next, and because we did Cast it to ClassB, we can continue using the dot notation in order to call any of the methods / properties exposed by ClassB, in this case the “SayHello” method.

Run the app again and now the ClassB instance referenced by the ClassA instance is displaying the MessageBox.

In addition, when accessing a hard referenced object in your class properties it can be good to do a sanity check like:

If ca.ClassBReference <> Nil Then
  ca.ClassBReference.SayHello
End If

But when using WeakRefs you need to do a double check. First against the WeakRef itself, because it can be a Nil object! And second, against the object referenced by the WeakRef itself. So the previous check will read now:

If ca.ClassBReference <> Nil And ca.ClassBReference.Value <> Nil then
  ClassB(ClassBReference.Value).SayHello
End If

Clearing It!

All in all, cross-referencing objects among class instances is probably not the best design, but sometimes it is needed. In case your app design needs to follow such a path, take care and use weak references (with Xojo’s WeakRef class) instead of hard references.

Keep it in memory (or not, if it is leaking)… and happy coding with Xojo!

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

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

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.

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

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

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

Protected Property SessionIdentifier as String

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

Private Sub Constructor()

End Sub

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

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

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

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

Private Shared Property mInstances() as SessionSingleton

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

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

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

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

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

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

To use the class you would:

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

Or if in a Session Event Handler:

Var Singleton As SessionSingleton = SessionSingleton.GetInstance(Identifier)

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

SessionSingleton.RemoveInstance(Identifier)

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

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

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

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.

In this two part tutorial you will see how easy it is to create a basic web service using Xojo Web. In the second part, we will create a Desktop client to talk with the web service (you may want to add iOS to the list).

Before we start, let me point out that this tutorial leaves out some details related to error checking, validation, data sanitizing and other specifics related to inputs and outputs in order to focus on the central topic. In addition, if you want to follow and reproduce the steps of this tutorial, then you need to download the Chinook Database, named “test.sqlite” in this tutorial.

Services in practice

Let’s start creating a web service! Open the Xojo IDE, create a new Web project, and name it WebService. The first thing you’ll notice is that Xojo adds a web page to the project by default – even when our web service does not display a UI. The good part is that you can mix both worlds, adding the webservice part to your regular Web app!.

In fact this tutorial will put all the logic in the App object. Start by adding a new property in charge of the reference to our SQLite database (of course, it will work also with PostgreSQL or MySQL engines). Select the App object from the Navigator (the left panel in the Xojo IDE), choosing the Insert > Property option from the contextual menu. With the new property selected, go to the Inspector to set the name, type and scope using these values:

• Name: Database
• Type: SQLiteDatabase
• Scope: Private

Next, we will add the Chinook Database to the Resources folder of our Web App. For that, select the deployment target under Build Settings (it can be macOS, Windows, Linux or Xojo Cloud, for example), and add a Copy Files build step to it. In the resulting Editor, add the Chinook database SQLite file and make sure you select the “Resources Folder” entry in the Destination popup menu, and the “Both” entry in the Applies To popup menu.

Now is time to create a new SQLiteDatabase instance and assign it to this property, so it will point to the SQLite database file when the app is running. For that, make sure the App object is selected and add the Opening Event Handler to it using the Insert > Event option. Write the following code in the resulting Code Editor:

#Pragma Unused args

Var f As FolderItem = SpecialFolder.Resource("Chinook_Sqlite.sqlite")

If f.Exists Then
  
  Try
    database = New SQLiteDatabase
    database.DatabaseFile = f
    
    Call database.Connect
  Catch e As DatabaseException
    MessageBox "Error connecting to the database"
  End Try
  
End If

As you can see, it is pretty much the same code we already use when creating SQLiteDatabase instances in our Desktop apps, linking to our SQLite database file and stablishing the connection so we can operate with the database engine from our app.

All the Magic of HandleURL

Xojo Web projects offer a simple way to handle the request received. It is using the HandleURL event. This is the one that fires every time a client app (it may be a Web Browser, desktop or mobile app) connects to the URL associated with the IP address and port combination that is listening for incoming requests.

For example, a valid URL that can be trapped and processed by HandleURL is:

http://www.nice-web-domain.com/getCustomers

Where getCustomers is in this case one of our API methods.

So, with the App object selectd, choose Insert > Event in order to add the HandleURL event.

As we will see, once the event has been added to a web app, it will receive the Request parameter (a WebRequest data type), waiting from us to send back a Boolean value as response: True to process the request or False (the default value) to ignore the response.

Introducing Request, where the information lives!

In fact, we will find in the Request object everything we need to process and (if it is the case) respond to the request from our Web service. For example, through we can get the interesting component from the Path property. If we consider this URL:

http://www.nice-web-domain.com/getCustomers?spain

The Request.Path property will return the getCustomers string; so our web service can process it acordingly from this point on.

Receiving and Sending JSON data

In order to keep this tutorial brief, our web API only has two methods in it: GetAll and AddAlbum. Using the first one, the client app will get the album name in the database wrapped in JSON format. With the second method, our client app will ask the web service to add a new record (a new album) to the right table on our example database.

How can we process the request associated data inside the HandleURL event? Here is where we will find very useful another of the Request object properties. The Body property includes the sent data as part of the request that are not already present in the headers. Generally speaking, it includes additional data via the PUT and POST verbs.

Now we can put the following code into our HandleURL Event Handler:

Select Case Request.Path // What is the method received as part of the request? (URL)
Case "GetAll"
  Var output As JSONItem = GetAllAlbums // Assign the processed data to the output variable, if the received method is 'GetAllAlbums'
  
  Response.Header("charset") = "utf-8"
  Response.MIMEType = "application/json"
  Response.Status = 200
  response.write( output.ToString ) // And send it back to the client that made the request, converting the JSON to a String in first place
  
Case "AddAlbum"
  Var data As String = Request.Body.DefineEncoding(encodings.UTF8) // We have to apply the right encoding to the received data
  Var Input As JSONItem = New JSONItem( data ) // Creating a new JSON object from it
  addNewAlbum( Input.Value("newAlbum") ) // In this case, the request is to add a new Album to the database; passing thus the received data as part of the input
End Select

Return True

The main point here is that we assign the received data to the data variable (if any), and define a known encoding to them so we won’t get into trouble while processing them afterwards. Of course, our example always expects to receive the additional data in JSON format, so this is why we create a new JSON instance from this data.

We use the Select…Case command to decide what method has to execute the web service, and that is based on the component stored in the Path property as you recall. So, if the request uses the GetAll method in the URL, we will call the real method GetAllAlbums in our Xojo code. After processing the information it will return a new JSONItem as the response we will send to the client.

How can we send the response to the request? Really simple: calling the Write method on the Response object, passing as parameter the text we want to send back. In our example, this is the JSONItem referenced by the Output variable. We also use the Response object to set the character encoding to UTF-8 and the MIME type to “Application/json”, in addition of setting the status value to 200 (that is, the request has been successfully handled).

If we receive a request with the AddAlbum method of our API, then we call the real addNewAlbum method in our Xojo code, passing as parameter the JSONItem object in charge of store the received data from the request (this is the one referenced by the input variable). In fact, the record structure is stored inside the newAlbum root node of the JSONItem.

When it comes to the Database

While HandleURL is in charge of processing the received request, we will use a couple of methods in our example app that will act as a link between the API and the database in the backend, both for retrieving and storing the requested information. (In a real world app it is very advisable to introduce checks and data sanitization before dealing with the database!)

Choose the App object again and use the Insert > Method option in order to add the GetAllAlbums method, using the following method signature for that:

• • Method Name: getAllAlbums
  • Return Type: JSONItem
  • Scope: Private

This is the code in charge of generating the JSONitem that we will write as part of the request response, including the node for every expected database record from the Album table in our example database:

Var rc As RowSet = database.SelectSQL("Select * from album order by title asc") // Get the Recordset as result of the SQL selection: all the records
Var item As New JSONItem

If rc.RowCount > 0 Then // We have records on the RecordSet
  
  While Not rc.AfterLastRow // so lets iterate them!
    Var d As New Dictionary // creating a new dictionary for each record, and that we will convert in a node
    d.Value("artistid") = rc.Column("artistid").StringValue // assingning the record ID to the name 'ArtistId' of the JSONItem
    d.Value("title") = rc.Column("title").StringValue // and the Title value to the 'Title' field of the JSONItem
    item.Value(rc.Column("albumid").StringValue) = d // You know you can assign a Dictionary as the value for a JSONItem node. Very useful!
    
    rc.MoveToNextRow
  Wend
  
  rc.Close
  
End If

var output As New JSONItem

output.Value("AllAlbums") = item // Then let's hang all these records form a main Node

Return output // And return it to the caller

Next, create a new method named addNewAlbum. This is the one our web service will use to add a new record to the database, using for that the received data as part of the request. Use the following signature for the method definition:

• • • Method Name: addNewAlbum
    • Paramters: item as JSONItem
    • Scope: Private

And put the following code in the associated Code Editor:

Var title As String = item.Value("Title") // get the data associated to the "Title" field
Var artistid As String = item.Value("ArtistId") // and the 'ArtistID'

database.ExecuteSQL("insert into album(title,artistid) values(?, ?)", title, artistid ) // and insert that data as a new record into the database table

As you can see, the code is very simple: it gets the values for the received keys in the JSONitem nodes and uses them as part of the SQL sentence in order to add a new record to the database.

A Web service… ready to serve!

As you have seen, the code and app structure are really minimal! Of course, this is just a simple example but it gives you a good idea of the kind of possibilities web services offer and how fast you can put it together using Xojo and OOP concepts you already know! Of course, you can run your web app (and services) right from the IDE (just make sure to select 8081 as the Debug Port)… what is probably the recommended way to follow this simple example. For other more complex web apps, remember that you can use the one click solution Xojo Cloud and of course any compatible Linux, Windows or Mac server.

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

*Read this post in Spanish

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

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

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

• Name: Constructor
• Scope: Public

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

Data = New Xojo.Core.Dictionary

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

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

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

data.Value( key ) = value

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

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

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

Retrieving data with Operator_Lookup

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

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

Writing the following code in the associated Code Editor:

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

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

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

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

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

Final Word

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

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

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

*Read this post in Spanish

If you are using Xojo already, or any other programming language, then I’m pretty sure you are using casting without even noticing it. For example, when you use simple types like Double or Integer, or even when assigning a String value to a Text variable. In these cases, everything happens behind the scenes. For example, these could be some type conversions you made in a regular basis:

Dim n as Double = 10.20
Dim i as Integer
i = n // The 'i' variable will have the value 10, losing the decimal part as result of the implicit conversion process

Dim s as String = "Hello World!"
dim t as Text
t = s.ToText // Both variables have the same text using the "ToText" method in order to convert it to the expected type by the target variable.

Both cases shows implicit conversions. This is, these are done without your intervention. However, in other scenarios we need to make these explicit, like when we need to use an object as if it was an instance created by the parent class in the hierarchy, and using it in a later step as a member of its real subclass (child class in the hierarchy), so we can continue using their methods and accesing the properties declared under that class.

Why would you want to do something like this? Well, there are a couple of cases that just jump into my mind:

• When it comes to objects created by classes that are not directly connected through the class hierarchy, but that share one or more common Class Interfaces.
• When these are objects created by several subclasses, descending from a common parent class.

For the first point, it would be the case where we need to maintain a collection of the same kind of objects, probably defined by a Class Interface type, but that in reality are created from several classes. This way, we can put all these objects in the same collection, iterating them and sending to them any of the methods defined by the Class Interface.

Something similar is what happens with the second scenario, where we can access to the common properties and methods offered by the parent class and, thus, shared an availables too in the instances created from their subclasses.

In fact, it is very probable that you are already using this second scenario in your projects as when you iterate all the controls (parent Class Control) put in the layout of a particular Window instance, a WebPage or an iOSView (each platform has its own parent class for controls). Here is a code example (in this case me refers to the Window instance where we put our code):

For n as Integer = 0 to me.ControlCount - 1
  StrBox me.Control(n).Name
Next

Showing this way the name of all the Window controls, no matter if they are TextFields, ListBox, PushButton, etc. After all, these controls classes are inherited from the Control class. Thus, the previous code snippet also could be written like this:

Dim c as Control
For n as Integer = 0 to me.ControlCount - 1
  c = me.Control(n)
  MsgBox c.Name
Next

But, what happens if we just are interested in showing the name of the controls from a specific subclass? For example it could be the case where we just need to show the name of the TextField controls used in the window layout. All the instances maintain internal information about themselves, like their Type, so we can access to that information during the execution of our apps through the introspection mechanisms provided by the Xojo language; but if we just need to check an instance type, then we can simply use the IsA operator. This operator allows us to compare an instance against a Class or Class Interface, returning a boolean value as result of such comparison. Then, we can use this fragment to show the name of the TextField controls used in the window layout:

Dim c as Control
For n as Integer = 0 to me.ControlCount - 1
  c = me.Control(n)
  If c IsA TextField Then
    MsgBox c.Name
  End If
Next

Casting in action

When we work with an instance as if it was an instance from the parent class, or as a member of a Class Interface, then we call it Downcasting; something we could translate as going down in the class hierarchy. For example, this is what we have done in the previous fragments, where we use all the controls of the user interfaces as if they where instances from the Control class.

As we go deeper in the class hierarchy, we reduce the amount of properties, methods and events we can access. I mean, we are limiting ourselves in the functionality achievable by the instances. This is something we will be glad to embrace if we take into account the benefits that this practice gives us in return as flexibility and code cleanness.

Nevertheless, and continuing with the same example, what if we would want to retrieve all the TextField instances, not as Control instances but as their own, original, class type in order to access their defined properties or methods? How can we accomplish that?

Let’s say that we don’t just want to show the TextField instances name, but also change their background color, something that is not implemented under the Control class. That is, we need to use some behaviour specific to the TextField class. Here is where Casting comes into play: the ability to cast or project a class instance as the type we want it to be:

Dim c as Control
dim t as TextField
For n as Integer = 0 to me.ControlCount - 1
  c = me.Control(n)
  If c IsA TextField Then
    MsgBox c.Name
    t = TextField(c) // Casting from the "Control" instance variable as a concrete subclass: "TextField"
    t.TextColor = &cFF0000
  End If
Next

That is, in order to use the Casting feature in Xojo, we need to put between parenthesis the name of the instance we want to convert, preceded by the name of the class we want the instance to be converted to.

Notice that when we use this OOP mechanism, we will not be backed by the usual help provided by the compiler on type checking. This means that if, for example, we cast an instance to a wrong target class for such instance has not internal information (it has not been originally created from that class, subclass or does not implement that class interface), then probably your app will not work as expected and, very probably, will fail or crash during its execution. To prevent this, you need to check for the inner class of any instance using any of the language provided mechanism in order to make sure you’re casting to the right type.

Finally, we could simplify the previous code like this:

For n as Integer = 0 to me.ControlCount - 1
If me.Control(n) IsA TextField Then
  MsgBox me.Control(n).Name
  TextField(me.Control(n)).TextColor = &cff0000
End If
Next

This way will loses some readability (code intention), but results in a more compact code.

Throughout this example we have seen how easy it is to work with instances as if they where more generic, and converting them again to their original type when we need to use their specialized behaviour or access their specific status, using the Casting OOP mechanism for that.

You can watch this video (en español) to see this in action:

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

*Read this post in Spanish

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.