Before you can use MobileMapViewer you will need to have a Google Maps account configured so that you can generate an API Key. Instructions for doing this on available from Google: Google Maps Platform, Get Google Maps API Key.

Google Maps is not free to use. Although there is some free usage available for testing your app, your account does get billed based on usage once the small amount of free testing credits are used up.

When you have your API Key, you can add it to your Xojo project using a new App property. Select App in the Navigator and in the Inspector, put the key in the Google Maps API Key field. Note that the key is not saved with text projects and is instead saved as part of the UI state file that is local to the development machine. This prevents the key from being accidently committed to a source code repository.

With the configuration work out of the way, you can now use the control. Drag a MobileMapViewer from the Library onto a screen. When you run the project you’ll see an interactive map that you can swipe, zoom and move around as you like.

This code shows Fenway Park in Boston:

FenwayLocation = New MapLocation("Fenway Park, Boston, MA USA")
FenwayLocation.Title = "Fenway Park"

MapViewer1.ZoomRadius = 5
MapViewer1.GoToLocation(FenwayLocation) // Center map within radius km

MapViewer1.AddLocation(FenwayLocation) // Drop a pin

The MobileMapVIewer API matches what has already been in use for iOS. You can also use the MapLocation class to track specific locations. Although the overall API matches what has been used for iOS, there is one exception: MapLocation.PointsOfInterest() is not yet implemented. Implementing this requires another Google SDK and API Key (the Places API) and is being reviewed for a future release. We may also consider adding alternative mapping engines as well.

Note: You can’t get there from here is an old Maine saying.

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

UserAuthentication works similarly to how it is used on iOS. You can drag the control from the Library onto your layout and then implement the AuthenticationSucceeded event.

To request authentication, call the Request() method with a short string asking the reason why you need authentication.

UserAuthentication1.Request("Authorize me, HAL")

Because this is using system-level APIs, you and your app never know the details about the authentication. You will not know the password, passcode or have any specifics about a fingerprint or face. Instead, if the system determines that the authentication was successful, then the AuthenticationSucceeded event is called.

Here’s a quick video of it in action.

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

You can now use the SetBottomAppBarMenuAlignmentModeXC extension method for MobileScreen to set the alignment of the buttons in your MobileScreen.Toolbar.

Additionally, new declares for MobileMessageBox have been added, allowing you to display an icon next to the title as well as next to individual buttons.

Give it a try! More exciting Android features are coming soon. Stay tuned!

Feel free to take a look at the developer repository, create feature requests, and provide feedback on extending this extension library.

I’m happy to receive any voluntary financial support for the work I’ve done so far, which you are welcome to share here. You can download the project with many examples at https://github.com/XojoGermany/AndroidDesignExtensions.

Happy coding.

Martin T. is a Xojo MVP and has been very involved in testing Android support.

My answer was, of course, “Let me have a look and get back to you.”

I went to my favourite dev tool, Xojo, and went through the process of developing a solution. The connection is a REST API, so I’ll start with a web project and use the HandleURL event. And I’ll use a URLConnection to pass on the request.  Wait … could it be that simple?

Function HandleURL(request As WebRequest, response As WebResponse) Handles HandleURL as Boolean

  // Create the outbound connection
  Var connector As New URLConnection
 
  // Copy the content of the request
  connector.SetRequestContent(request.Body, request.MIMEType)

  // Send the request
  Var result As String
  Try
    result = connector.SendSync("POST", kAddress + request.Path)
  Catch err As RuntimeException
    // Catch DNS, Certificate & Timeout errors
    response.Status = 500
    response.Write(err.Message)
    Return True
  End

  // Return the result of the request
  response.Status = connector.HTTPStatusCode
  response.Write(result)

  Return True

End Function

The answer is, “Yes!”  This is all the code in the entire project.

You will notice that there is no security, but in this instance that is fine as the virtual machine is running this is on the same network as the client server and the firewall is configured to only allow connections from that server.

After processing over 60 thousand requests, memory use is 7.3MB and never exceeded 13MB. CPU usage was at the maximum 1.5%.

Even after using Xojo for 20 years this still blows my mind.

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.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

RESTy uses the URLConnection class to send a request to a web service and get a result. If the result is text (JSON, for example) it displays in the Response tab. Here, I am calling the Eddie’s Electronics web service to return a list of all the customers by specifying the URL and clicking the Fetch button:

For other data (binary data such as pictures) you can use the Fetch to File button to save the request to a file.

The Authentication tab is used to provide Basic Authentication should the web service require it.

The Request Content tab can be used to provide Content data that the request might need. For example, the Eddie’s Electronics web service also lets you request the details for a specific customer by providing simple JSON containing the customer ID. To try this using RESTy app:

1. Click on the Request Content Tab.
2. To indicate the customer you wish to retrieve, enter the following JSON into the field on that tab: {"ID": 10039}
3. Select POST from the Send Method popup menu.
4. In the URL field, enter: https://eews-demos.xojo.com/GetCustomer
5. Press the Fetch button.

If you have entered everything correctly, will see the data for Caleb Horn in JSON format:

And to see the JSON formatted nicely, click the Format JSON button:

This will let you you explore calling various REST API services. You can explore the source code to see how it uses URLConnection to do so.

To be sure, RESTy is very basic, but you have the source code so you and add features to it and modify it for your own testing needs.

With just a few lines of code, you can create a mobile app that shows a new cat picture each time you launch it. I call this app “CatsUp!”. It’s a play on ketchup/catsup, get it?

Set Up The Project

Create a new iOS project called “CatsUp”. Drag an ImageViewer control onto Screen1, make it fill most of the area and change its Name to “CatImage”. Drag a Button to the bottom and change its Caption to “Cat Me!”. Also change the Screen Title to be “CatsUp!”. The result should look something like this:

The Cat API

The Cat API documentation page describes the full API. For access to most features you will want to sign up for a free account and use an API key. For the purposes of this post, I will just use it without an API key. The URL for the method to get a random cat picture is:

https://api.thecatapi.com/v1/images/search

The above URL returns JSON that contains the location of a picture to display. Paste it into a web browser to try it. In my test I got this JSON:

[{"breeds":[],"id":"99v","url":"https://cdn2.thecatapi.com/images/99v.jpg","width":384,"height":384}]

To make CatsUp, we will essentially add some code to 1) send the first request, 2) get the JSON and pull out the picture URL, 3) get the picture and display it.

Add Code

Add the Pressed event to the Button with this code:

CatConnection.Send("GET", "https://api.thecatapi.com/v1/images/search")

This calls the Send() method on a URLConnection object, called CatConnection, to get the JSON with the picture URL.

So now you need to drag a URLConnection object from the Library onto the Screen. Click on this newly added URLConnection1 item in the Tray and in the Inspector change its name to “CatConnection”. Add its ContentReceived event with this code:

Var json As JSONItem = New JSONItem
json.Load(content)

Var catItem As JSONItem
catItem = json.ValueAt(0)

Var picURL As String
picURL = catItem.Value("url").StringValue

ImageDownload.Send("GET", picURL)

The above code loads the JSON into a JSONItem and then fetches the “url” value. It sends this URL to another URLConnection, called ImageDownload, to get the actual picture to display.

Drag a second URLConnection onto the screen and change its name to “ImageDownload”. Add its ContentReceived event with this code:

Var pic As Picture = Picture.FromData(content)
CatImage.Image = pic

Try running the project in the iOS Simulator. Click the button to see a new cat picture.

This is what I see:

Oops, silly me. I actually created this as an Android project and ran it in the Android Emulator. Sorry about that, here is what it looks like as an iOS project running in the iOS Simulator:

That’s right, the exact same code for this project can be used in both iOS and Android projects! And for another bit of Android news, this CatsUp! app, with a couple minor enhancements, is now available in the Google Play Store:

Have fun with this and may every day be a Caturday!

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

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

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

Download the class with the example project from here.

TextArea Subclass

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

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

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

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

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

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

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

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

Assigning the Cursor Type

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

Me.MouseCursor = System.cursors.standardpointer
RaiseEvent open

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

Matching the Active Words

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

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

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

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

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

RaiseEvent mouseMove(X, Y)

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

Reacting to Active Words

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

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

Return RaiseEvent mousedown(x,y)

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

Registering the Active Words

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

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

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

linkedWords = d

Registering (and Deregistering) Observers

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

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

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

if observer <> nil then observers.add observer

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

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

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

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

Regular Expressions to the Rescue … and Styling!

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

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

And write the following code in the associated Code Editor:

#Pragma Unused RightPosition

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

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

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

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

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

Return nil

Adding Style

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

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

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

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

Var t As StyledText

t = Me.StyledText

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

t.Underline(cstart, cEnd) = mode

Putting it all together!

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

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

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

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

And put the following code in the associated Code Editor:

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

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

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

myURLField.registerObserver WeakAddressOf updateContents

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

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

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

The first beta of Windows 11 is scheduled to be released next week and we will be testing the Xojo Windows framework on it. We will have more blog posts as more information becomes available about the next generation of Windows.

It turns out that adding Gravatars to your application is very simple using the Gravatar API.*

Build a Reusable Gravatar Connection

First, create a new project in Xojo. You can choose any type of project and there are examples available on my GitHub for Desktop, Web and iOS projects.

Click on the Insert button and select Class to add a new class to your project. Call the class “GravatarConnection” and make its super URLConnection.

Next, add a private function to generate the hash required to lookup a Gravatar:

Private Function GenerateGravatarHash(email As String) As String
      // Generate Gravatar Hash
      Var hash As String = Crypto.Hash(email.Lowercase.Trim, Crypto.HashAlgorithms.MD5)
      hash = EncodeHex(hash).Lowercase
      
      Return hash
      
    End Function

As you can see, this function takes the email address, creates an MD5 checksum, encodes that checksum as hex converting it to a lower case string and returning it to the calling method.

Now add a method to get the Profile Data:

Public Sub GetProfile(email As String)
  Me.ClearRequestHeaders
  Me.RequestHeader("User-Agent") = "*"
  Send("GET", "HTTPS://www.gravatar.com/" + GenerateGravatarHash(email) + ".json")
End Sub

Again, this method takes the email address and requests the profile in JSON format from www.gravatar.com.

Next we’ll add three event definitions:

Event Avatar(Value As Picture)
Event Found(FullName As String, Location As String, AvatarURL As String)
Event NotFound()

These events will be raised based on the result of our request.

Now we need to handle the ContentReceived Event with:

Sub ContentReceived(URL As String, HTTPStatus As Integer, content As String) Handles ContentReceived
  If HTTPStatus = 404 Then
    RaiseEvent NotFound
    Return
  End If
  
  If URL.BeginsWith("HTTPS://www.gravatar.com/avatar/") Then
    Var pic As Picture = Picture.FromData(content)
    RaiseEvent Avatar(pic)
  Else
    Var d As Dictionary = ParseJSON(content)
    Var v() As Variant = d.value("entry")
    Var entry As Dictionary = v(0)
    Var names As Dictionary = entry.Value("name")
    v = entry.Value("photos")
    Var Avatar As Dictionary = v(0)
    RaiseEvent Found(names.Lookup("formatted", ""), entry.Lookup("currentLocation", ""), _
      Avatar.Lookup("value", ""))
  End If
End Sub

Here we either raise the NotFound event or either the Gravatar or Found events, depending on the URL.

This class is freely available at https://github.com/axisdirectnz/Gravatar and there are example projects for Desktop, Web & iOS that show how to use the class.

*UPDATE 3/22/21 – Per community feedback, this post has been updated.

Thanks Jeannot and Thom! I would recommend anyone who has downloaded from Git before March 22, 2021, to do so again.

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.

You absolutely can. Xojo creates native apps that are also cross-platform. It can be done. It’s just a matter of choosing the right framework. At Xojo, we didn’t take the easy path of drawing controls ourselves or using HTML5. We didn’t dumb things down to the least common denominator. We did the hard work of creating a framework with an API that manages the nuances, intricacies, and subtle yet important differences between 7 different platforms (macOS, Windows, Linux, web, Raspberry Pi, iOS and soon, Android) and multiple OS versions so you can focus on what makes your application unique. We have been doing it for over 20 years.

When discussing Facebook’s blog post, John Gruber of Daringfireball.net said, “…native apps are smaller, faster, and more reliable.”

Nearly every user interface element in Xojo is native. The one exception is the desktop Listbox because way back when, none of the desktop operating systems provided one. Everyone made their own. Having said that, the Listbox is made up of native controls. The scrollbar is a native scrollbar. If the developer makes the contents editable by their end user, a native TextField control appears. The headers are native controls. The advantages of native controls can’t be overstated, Facebook was right about that. Modern operating systems provide an ever-increasing array of features via their native controls and thus using them gives you immediate and nearly free access to these features. From focus rings to spellchecking to accessibility and more much, using native controls makes the most sense.

Event aesthetics come into play. Because the Xojo framework uses native controls, when Apple and Microsoft make changes to the look and feel of their controls, apps made in Xojo automatically change in appearance and behavior. Most recently, Apple added Dark Mode to both macOS and iOS and for most Xojo developers, adding this support required nothing more than indicating they wanted their apps to support it by clicking a checkbox.

While Xojo provides the developer with an easy drag-and-drop way to create their application’s user interface, it also provides a straightforward API for interacting with controls via code. The TextField control, for example, provides events that tell you when the control has appeared for the first time, when the user has changed the selection or the text itself, and even when they press down on a key or release it. There are properties to change the size, style and behavior of controls. And all of this is a level of abstraction that lets you focus not on the details of the platform but on what makes your application unique.

For example, under the hood for the desktop, Xojo’s TextField uses NSTextField on macOS, EditControl on Windows and GTKEntry on Linux. On iOS it’s the UITextField, on Android it’s EditText and on the web it’s <input type=”text”>. Each of these is very different but Xojo has done the hard work to provide a standard, straight-forward API so that you get the benefit of native controls without needing to learn the thousands of APIs and unique behaviors necessary to create a cross-platform app.

It’s not just controls. The Xojo cross-platform framework includes dialog boxes, menus, access to the file system, printing, sockets, database access and much more.

Native is more than the user interface. It’s also about performance. Xojo compiles to native code for each platform as well. Behind the scenes it uses LLVM, the same optimizing compiler that Apple, Google, Intel, AMD, Nvidia and many others use. Native code means native speed.

Thousands upon thousands of Xojo users have built cross-platform apps. The Xojo IDE itself and much of the Xojo framework are written in Xojo. So yes, we eat our own dog food. Studiometry and Property Me are just two of the many examples of commercial cross-platform apps written in Xojo. There are countless others.

We have also done this in a way that makes it easy for students and hobbyists to learn programming so they can take it into their workplaces and build business applications. In some cases, those citizen developers create something revolutionary and become full-time professional developers. That’s why the Xojo user community is so diverse.

So yes, you can create native applications that are also cross-platform. You just have to choose the right tool.

We did this by creating a sensible set of API naming guidelines and then applying them to our existing APIs. APIs that followed the guidelines were left alone. Those that did not, were changed to meet them. Hindsight, as they say, is 20/20. Looking back, it would have been great had we established these guidelines way back in 1998 before we shipped v1.0 but we didn’t and the fact that we didn’t is no reason to avoid it now. We always plan for a long future ahead of us and thus have to be willing to make changes to make that future possible. That we are still here 20+ years later suggests we are doing something right.

If you are one of those long time users who has grown accustomed to the inconstancies that API 2.0 addresses, you might be wondering if there’s any value for you in using it. The answer is absolutely yes! While it will take a little time for you to get used to the new APIs, what you will find is that you become increasingly more productive because they are so consistent. You will find (as I did) that you can guess at what the API is and likely be correct. I personally made 95% of the Language Reference updates for API 2.0. The documentation wiki does not auto-complete so I had to double-check all the code I was updating. In no time I found that I rarely made errors because API 2.0 is so consistent. You will absolutely see productivity gains once you have used it for a short time.

While API 2.0 is a major step forward for Xojo in terms of intuitiveness and consistency, for those of you with large projects you may feel like migrating is a daunting task. Depending on size, there can be anywhere from a handful to thousands of deprecation warnings to deal with, each being a particular change that could be made.

You might be assuming you absolutely must upgrade your projects but that’s not necessarily the case. How much of a project you update and when depends significantly on how important it is for you to update your existing projects to API 2.0.

First, it’s important to understand that most of the deprecated APIs are going be around for a very long time. It’s possible (perhaps even likely) that they could continue to exist for the entire life of your software project. You could decide not to upgrade any portion of your project or only upgrade portions that require it and then only when necessary.

Many deprecated APIs still share their implementation with the API they replace. A good example is RecordSet.MoveNext and RowSet.MoveToNextRow. If a bug is fixed in MoveToNextRow it will also likely be fixed automatically in RecordSet.MoveNext even though that method is deprecated.

Should you find a bug in a deprecated API you are still using, first try the new, replacement API and see if the bug is no longer reproducible. If that’s the case, you have an immediate solution: just upgrade that one usage of the deprecated class to the new one.

If the bug still exists in the new, replacement class, please report the bug using Feedback. Once fixed, there’s a chance that it will be fixed in the deprecated class as well, assuming it still shares its underlying implementation with the old deprecated class which, again, is true in many cases.

When deciding what to do regarding API 2.0 and any particular project, your options are:

1. Not Upgrading – You could choose not to upgrade an existing project to API 2.0. You could then only upgrade portions of it should that become necessary due to a bug fix or the introduction of new features.
2. Upgrade Incrementally – Another option is to upgrade your code incrementally as an extra step before refactoring or adding new code to a particular part of a project. This is the path we have chosen for the Xojo IDE as it’s a very large project that would take many months to upgrade if we did it all at once.
3. Upgrade All At Once – Finally, you may decide to go ahead and upgrade your entire project all at once. This has the advantage of allowing you to focus exclusively on the new APIs and no longer have to switch between the old and the new when going back and forth between older projects and newer ones.

If you’re choosing not to upgrade an older project or do so incrementally and you find seeing the deprecation warnings distracting when you use the Analyze Project feature, you can turn off these warnings by choosing Project > Analysis Warnings.

API 2.0 was introduced with desktop projects but it will be coming to web projects in Web Framework 2.0, for mobile in Android and eventually iOS as well. As a result it will be important to use the new APIs but for many of you, using them only with new projects and/or sporadically with older projects, may make sense.

API 2.0 is a huge change and change can often be difficult. There’s certainly a lot of comfort to be found in the familiar. Still change is sometimes necessary to keep things moving forward. Fortunately, in the case of API 2.0, we have designed it so that you have tremendous flexibility in terms of what options you choose for existing projects.

• Read more blog posts about this transition.
• UserGuide: Moving Forward with API 2.0
• UserGuide: API 2 Guidelines

General Tips

With that said, here are a few things that you may have to update to be able to run your project using 2019r2 and later Xojo releases:

• Some advanced properties on FolderItem have been removed.
• You’ll have to use the Global prefix with the ToolTip class (or switch to new methods).
• You’ll have to add the new EndOfFile method to anything that uses the Readable interface.

Converting Code to Use a New Class

When converting code to use a new class that replaces a deprecated one, there are two different approaches that will help you do so efficiently.

Method 1: Not Familiar with the New Class

When you’re not familiar with the new class, replace class members such as properties and methods first, before replacing the class declaration itself. This will allow you to use auto-complete to see which methods or properties replace the deprecated ones.

Consider the following code example:

Dim rs as RecordSet
rs =db.SQLSelect(“SELECT * FROM Customers”)
If rs <> nil then
While Not rs.EOF
//perform some data processing
  rs.MoveNext
Wend
End If

Deleting EOF and then pressing tab will display the auto-complete menu showing the replacement method, AfterLastRow:

Auto-complete will not replace EOF with AfterLastRow as the variable rs is still a RecordSet. However, you can manually make the change now. Once you have changed all class member references, you can then change the variable itself from RecordSet to RowSet.

Method 2: Familiar with the New Class

If you are familiar with the new class, change the variable (rs in this case). Having done so, you can use auto-complete to change any class members references (properties, methods, etc.) to the new class.

In the beginning the changes in API 2.0 will be unfamiliar so Method 1 above will make sense. Over time you’ll be more familiar with API 2.0 and then Method 2 will work best. The important thing is to remember that you can do this at your own pace. The APIs that have been replaced will continue to be available for a very long time.

Summary

These changes and more are described in detail in the API 2.0 Guidelines topic in the docs. Be sure to give it a quick read to more easily get up and running with 2019r2. For other guidance on moving projects to API 2.0 to take advantage of newer features and improved naming (again, when you’re ready), be sure to read Moving to API 2.0.

API 2.0

You can use this category to show all API 2.0 items across all releases, which is quite useful with the release of 2019r2:

https://documentation.xojo.com/Category:API_2.0

All Deprecated

Use this category to show all deprecated items across all releases:

https://documentation.xojo.com/Category:Deprecated

All Deprecated for a single release

This category to shows all deprecated items for a specific release:

https://documentation.xojo.com/Category:Deprecated2019r2

Change the release value to see other releases.

All New for a single release

Use this category to show all new items for a specific release:

https://documentation.xojo.com/Category:New2019r2

Change the release value to see other releases.

Show All User Guide topics

This category displays all pages that are part of the User Guide:

https://documentation.xojo.com/Category:User_Guide

Show All Categories

There are many more categories. You can use this link to see them all:

https://documentation.xojo.com/Special:Categories

Or as mentioned earlier, at the bottom of each topic page you can view the list of categories to which it belongs. Jumping to other categories can help you find other related information for quickly.

I did some research and found that Amazon provides a service that does exactly what the client was asking for. The service, called Amazon Translate, is available as one of many services that are available through Amazon Web Services.

In this post, I’ll walk you through the process of getting signed up for Amazon Translate, and then share some code that you can use to add language translation to your own Xojo projects. We’ll use the MBS Xojo CURL Plugin, which makes calling the Amazon Translate API easy. But first, let’s learn a little about Amazon Translate.

Amazon Translate

Amazon Translate is an API that can be used to translate text on demand. You send it text in a “source language,” tell the API what that source language is, as well as the “target language” that you want the text translated to. The API responds with the translated text.

Amazon Translate uses machine learning and neural networks that have been designed specifically for language translation. When performing a translation, the service reads the text one sentence at a time, and reads each word individually, to determine the meaning of a sentence. In other words, the service doesn’t just translate words. Instead, it’s acting as an interpreter. This results in translations that are extremely accurate.

In order to use Amazon Translate, you’ll need an AWS account. If you already have an AWS account, log into the account.

Next, you’ll need to create an “Identity and Access Management” (IAM) user. To do so, under Services, select “IAM” (which can be found in the “Security, Identity, & Compliance” category). This will present you with the IAM Dashboard.

Under Groups, create a new group and give it a recognizable name. For example, you might call the group “translate.” As you are creating the group, give it the “TranslateFullAccess” permission.

Next, create an IAM user. Under Users, click the “Add user” button. Give the user a name such as “XojoTranslater.” For the “AWS access type” be sure to select “Programmatic access.” Add the user to the “translate” group that you created above. There’s no need to assign any tags to the user, so you can skip that step.

And finally, create an Access key for the user. Be sure to make note of both the “Access key ID” and “Secret access key” values that are automatically assigned. You’ll need these in order to make API calls.

The MBS Xojo CURL Plugin

If you don’t already have the MBS Xojo CURL Plugin, download it and install it. To install the plugin, simply drag it into the Xojo “Plugins” folder.

The project will work with an unlicensed version of the MBS Xojo CURL Plugin. In this case, you’ll occasionally see a popup message reminding you to purchase a license. However, I highly encourage you to purchase a license. You can license the plugin individually, or as part of the MBS Complete plugin bundle.

The Xojo Example Project

To demonstrate the Amazon Translate service, I’ve put together an example Xojo desktop project (project file). Before running the application, be sure to set the three App-level properties: AWSAccessKeyId, AWSSecretAccessKey, and the AWSRegion. For the AWSAccessKeyId and AWSSecretAccessKey properties, use the values that you set when you created the Access key for the user. For the AWSRegion, refer to this and use the value that makes the most sense for you.

Once you’ve configured the app, run it, and it will look something like this.

The Xojo Code

Let’s take a look at some of the code.

The AWSTranslator class is a subclass of the CURLSMBS class. The class does two important things: It provides access to a list of the languages that are supported, and provides a method for calling the Amazon Translate API.

The “Languages” property is a dictionary that you can use to get the names of the languages that Amazon Translate supports and the corresponding language codes. The example app uses this dictionary to populate the “Translate From” (SourcePopupMenu) and “Translate To” (TargetPopupMenu) popup menus.

The Translate method creates the payload that gets sent to the Amazon Translate API, and sets special HTTP headers that are needed in order to call the API. But most importantly, it uses the CURLSMBS class’s “SetupAWS” method to configure the CURL instance so that all of the steps that are required to “sign” the API request are done automatically. This is an amazingly convenient function of the MBS Xojo CURL Plugin. You can get a sense of what’s involved in signing the request here.

To translate text using the AWSTranslator class, you create an instance, configure it with your IAM credentials and AWS region, pass it the source language text, the source language code, and the target language code. In the example app, this all handled in the Window1.Translate method. The values are pulled from the App-level properties, as well as the various window controls. Finally, you call the AWSTranslator instance’s Translate method. If the translation is successful, the translated text will be available via the TranslatedText property. If any errors occur, the ErrorType and ErrorMessage properties will be set.

The “Estimated Translation Cost” is calculated whenever the Source Text changes. The value is calculated by taking the length (number of characters) of the Source Text and multiplying it by 0.000015 (the average cost for translating a single character).

Wrapping Up

I’ve been amazed at the speed and accuracy of the Amazon Translate service. And after developing the AWSTranslator class, I was able to quickly and easily add language translation to my client’s middleware app.

I hope you’re equally impressed by the Amazon Translate service, and that you find the AWSTranslator class to be helpful in your own Xojo projects.

Tim Dietrich is a custom software developer based in Richmond, Virginia. To learn more, visit: https://timdietrich.me

After a brief introduction welcoming attendees from 11 different countries, Geoff began the keynote by sharing some graphs showing how the Xojo community has been changing.

Along with a growing interest in Xojo, account creation is up 200%, we’ve seen a change in the demographics of our users. In 2017 only 22% of Xojo users were women. This year, that number has nearly doubled to 41%!

A few years ago, just under half of Xojo users were under 35. Now in 2019, 61% of our users are under 35.

This broader change is partially the result of current Xojo community members who evangelize Xojo on social media, blogs or simply in speaking with friends and colleagues. We know that word of mouth recommendations always carry more weight than any advertisement. Geoff took some time to recognize a few members of the Xojo community that have gone the extra mile to build this community. Hal Gumbert and Tim Dietrich, both Xojo developers from the FileMaker community, regularly blog and share on social media their experiences with Xojo. Also thanks is due to Thomas Templemann whose rally cry on the forum encouraged users to review Xojo on slant.co. What may appear to be small single actions all add up to make a difference. The stronger our community is, the better Xojo will be.

Next Geoff announced the winners of the Xojo Design Awards 2019, learn more more about these stellar examples of what has been done with Xojo!

Our team has been very busy over the last 12 months. Xojo has introduced 48 new features, made 75 changes and fixed 465 bugs. To name a few: we added Dark Mode for macOS, native labels in Windows, iOS Table pull to refresh and variable row heights, better text rendering on Windows, URLConnection in API 2.0, incremental compilation for 64-bit and ARM and significantly sped up the layout editor.

But we’ve also spent a lot of time working on some big, multiyear features so let’s take a look at where Xojo is going.

Xojo Cloud

Xojo Cloud is moving to 64-bit because the modern Linux distros are all 64-bit. Going forward, Named Hosts will allow you to point a domain at a specific app. We will be switching from CGIs to stand-alone apps to utilize modern web protocols and we are putting a load balancer in front of each app so you can easily handle more concurrent users.

Interops

If you don’t already know, Interops are basically a better way to make calls into OS APIs than declares. Interops require less code, remove the need to convert data between OS and Xojo types and are far easier to write. A quick example:

These four lines of declares connect to the EventStore database on your iOS device:

Just to connect to the eventstore, you’re dealing with a lot of very unfriendly stuff. However, with Interops this is reduced to one simple line that is friendly Xojo code:

Interops are already a real thing. We are using them internally in the iOS XDC app for both for calendar events and local notifications as well. We are also using them to build the Android framework.

IDE Update

We’ve been doing a lot of work behind the scenes on IDE improvements. You’ve seen some of this in 2019r1 with the layout editor.

With that completed, we’ve now reached the point where the new Home screen and improved workflow are coming soon.

API 2.0

API 2.0, is a set of APIs that will replace many of the existing ones, they will provide better consistency in naming, offsets and error handling. In some cases, we are taking the opportunity to modernize the implementation as well. You already saw this with URLConnection introduced in 2018r4. URLConnection replaced the old HTTPSocket that used a library that had to be updated. URLConnnection uses the underlying OSs’ library, so as those OSs get updated in order to provide better HTTP connections, your apps will automatically benefit. To name a couple more, API 2.0 supports Bezier Curves for all platforms, not just iOS. And the Date class has all the features we added to xojo.core.date, including: Locale support, DateInterval support and TimeZone support.

In most cases the APIs have not changed and not everything will be replaced. Those that are replaced will remain for many years so you don’t need to worry about rewriting your code right away. This change has gone faster than expected (yay, it does happen!) and we plan to be in beta after just a few more updates are made.

Web Framework 2.0

Last year we talked a lot about the design of Web 2.0, this year Geoff focused on implementation and the great progress made so far. As a way of testing out Web Framework 2.0, we decided to port something to the web using it. Since so many have asked for it over the years, we’re working on a web version of Feedback. It’s in the early stages and Greg will be demonstrating the web version in his XDC session. While there’s still more implementation to do, the fact that we are using it for internally tells you how far we have come. Once the implementation is complete, we will begin beta testing.

Android

As you may remember we showed you a Hello World on Android back in 2018. Since then we’ve got IDE integration, apps running on simulator and apps running on actual hardware. We’re also building Android apps internally. In fact, we have put together an Android version of the XDC app! You can go to the Play Store and download it right now. This is a simple app, basically the HTMLViewer. However, the app is native and was built the same way you will be building native apps in Xojo. Travis will show you more controls and have lots of details and demos in his XDC session.

So what’s left before Android is in your hands? In this as well, a lot of the “heavy lifting” has been done, we need to finish implementing the framework and port the debugger and then we will begin pre-release testing Xojo Android.

As you can see, Xojo has made significant progress towards these many large, multiyear projects. An additional note, currently work on Plugins in Xojo is paused to allow us to focus on Android. We’ll do our best to keep you updated via Twitter and Facebook throughout the conference. Please use hashtag #XDC2019 online to search or share your own thoughts. Even if you aren’t here, we’ll do our best to reduce the Xojo FOMO! The XDC Video set is now available for sale.

Speaking of great conferences, the MBS Software conference will be in Cologne, Germany on October 24th and 25th of this year. There are already 40 people coming from 10 different countries, including Geoff Perlman!

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

If you were at XDC 2018 maybe you caught my iOS session where I showed how to send an update to the App Store. The app I updated was Cats Up!, a simple iOS app that display cat pictures. Dogs Up! is the dog version and it uses the Dog API.

To make this app, I made a copy of the Cats Up! project and then started changing the parts necessary to hook it up to the Dog API. Changing existing projects is a great way to learn and one of the reasons we are doing the Just Code Challenge.

The Cats Up! project used a single HTTPSocket to connect to its web service for the cat pictures. The Dog API required two HTTPSockets: one to request a URL to a dog picture and another to download the picture itself.

Once these steps were done, I just needed to update the JSON file with dog facts (instead of cat facts), find something to use for the dog icon and get a recording of a dog bark to use when a new picture is displayed.

Download the Dogs Up! project.

Download and check out earlier projects:

• Week 2: Password Generator
• Week 1: Color Picker

I’m going to show you how to connect to IBM’s Watson services with REST APIs and how to use them with Xojo projects to identify images. This is just one example, of course, of the many ways to utilize Watson and AI in your Xojo apps.

IBM Watson

IBM’s Watson services have been online for several years and are continuously updated. They are paid services but you can create a Lite user to test and evaluate them. The documentation and variety of services are huge and includes (among other things) image identification services.

Identify images with Watson

This service mainly offers two possibilities: identifying the faces in an image (returning the position, the probable gender of the subject and the probable age range) and the classification (i.e. the recognition of possible tags that can be associated with the image).

Watson’s Natural Language Classifier, is a service that “applies cognitive computing techniques to return best matching predefined classes for short text inputs, such as a sentence or phrase”. It is really large (and the definitions are localized in many languages); moreover you can create your own classifiers specific to projects. The Lite user can create only one classifier at a time that is replaceable but not updatable. Another limit is the number and total size of the images that you can use to address your classifier.

Watson’s documentation is complete and easy to use. After creating the service in your account, you can start using them with the terminal or through the web page relative to the selected service.

How to use Watson with Xojo

The services use a REST API so you’ll use Xojo.Net.HTTPSocket as the base class to create the object that will consume these services. To learn more about using Xojo with a REST API, you should read up on that before continuing: Cats Up: Using the HTTPSocket with the Cat REST API, PDF File Generation? There is an API for that and Web Services Video Playlist.

In this example, the base class is called “WatsonAPI”. This class will deal with the communication with the API (sending and initial interpretation of the answer) and will have some common features (such as zipping several images so they can be sent all at once). Moreover, since the interaction with the service is asynchronous, the class will have to manage the serialization of the different requests and take care to return the result to the correct call.

Next, you’ll define a delegate who will have as an argument the answer (positive, negative or error) that will have as its signature a Xojo.Core.Dictionary:

WatsonReplyFunction(reply as Xojo.Core.Dictionary)

Now you’ll define two private properties: id and callback. You’ll use id to distinguish the various call, and callback will be the function to call when there’s a the result.

Private Property id as Text
Private Property callback as WatsonReplyFunction

The constructor (protected because the subclasses will call it) can be of this kind:

Protected Sub Constructor( cb as WatsonAPI.WatsonReplyFunction)
  // Register the callback
  callback=cb
  Super.Constructor
  register Me
End Sub

Register is a private shared function that assigns the identifier to the object and saves the pair id, object in a shared dictionary. There’s also a deRegister function that will delete the object whose identifier is passed.

As noted before, you’ll use a dictionary to represent the API result because it’s the format used for positive or negative API replies. Moreover, we can use the same format for network error replies. The dictionary will contain at least 3 values: success as boolean for a positive or negative reply, status as integer for the reply http status and result as text or dictionary to represent the current reply. Since it’s a dictionary, we can easly add more information as needed. Subclasses or consumer classes can transform this data structure in a more specific way (class, record or whatever).

Now you will implement the major events:

Sub Error(err as RuntimeException) Handles Error
  //All replies will have the same structure
  //In the event of an error, the returned dictionary must be structured as correct one
  Dim d As New Xojo.Core.Dictionary
  d.Value("success")=False
  d.Value("status")=0
  d.Value("result")=err.Reason
  //Delete the object from the dictionary
  deRegister(Me)
  //return the reply
  callback.Invoke(d)
End Sub


Sub PageReceived(URL as Text, HTTPStatus as Integer, Content as Xojo.Core.MemoryBlock>) Handles PageReceived
  #Pragma Unused url

  //evaluate the reply
  Dim d As Xojo.Core.Dictionary
  Dim t As Text
  Try
    t=Xojo.Core.TextEncoding.UTF8.ConvertDataToText(Content)
  Catch
    t=""
  End Try
  If Not t.Empty Then
    Try
      d=Xojo.Data.ParseJSON(t)
    Catch
      d=Nil
    End Try
  End If
  Dim reply As New Xojo.Core.Dictionary
  reply.Value("success")=HTTPStatus=200 And d<>Nil
  reply.Value("status")=HTTPStatus
  If d=Nil Then
    reply.Value("result")=t
  Else
    reply.Value("result")=d
  End If
  //Delete the object from the dictionary
  deRegister(Me)
  //return the reply
  callback.Invoke(reply)
End Sub

Now you can create a subclass to classify the images: WatsonVisualRecognition as subclass of WastonAPI.

For the image classification you can use one or more of the classifiers and/or the default one or even those in beta (currently Food and Explicit). So let’s define the constants related to these classifiers:

Public Const IBMDefault as Text =default
Public Const IBMExplicit as Text = explicit
Public Const IBMFood As Text = food

… and the ones related to the services:

//The current version of the service
Private Const version As Text = 2016-05-20

//The address actually depends on the user settings
Private Const kBaseUrl As Text = https://gateway.watsonplatform.net/visual-recognition/api/v3/

//The key to use the service
Private Const keyVision As Text = •••••••

You can now define a public shared method for analyzing an image on the web:

Public Shared Sub classifyImage(cb As WastonAPI.WatsonReplyFunction, imageUrl As Text, threshold As Single=0.5, paramArray classifiers As Text)
  //The method requires a method to be called to return the results,
  // the address of the image to be analyzed
  // the minimum value to be considered for recognition
  // a list of classifiers to use

  //Let's create the instance linking it to the callback
  Dim w As New WatsonVisualRecognition(cb)

  //threshold is the minimum acceptable value for classification
  //  must be between 0 and 1
  If threshold<0.0 Then threshold=0.0
  If threshold>1.0 Then threshold=1.0

  //For classifiers I can use both the ones provided and mine
  //none means the default one
  Dim useIBM As Boolean
  Dim usePersonal As Boolean
  Dim usedClassifiers() As Text
  For i As Integer=0 To classifiers.Ubound
    Select Case classifiers(i)
    Case IBMDefault
      useIBM=True
    Case IBMExplicit, IBMFood
      useIBM=True
      //These classifiers are in English only 
      w.RequestHeader("Accept-Language")="en"
    Else
      usePersonal=True
    End Select
    If usedClassifiers.IndexOf(classifiers(i))=-11 Then usedClassifiers.Append  classifiers(i)
  Next
  Dim classifierIds As Text=Text.Join(usedClassifiers, ",")

  //Set the kind of the classifiers used
  Dim usedOwners() As Text
  If useIBM Then usedOwners.Append "IBM"
  If usePersonal Then usedOwners.Append "me"
  Dim owners As Text=Text.Join(usedOwners, ",")

  //Create the URL to be called
  Dim url As Text=kBaseUrl+"classify"

  //I create the list of arguments
  Dim args() As Text
  args.Append "api_key="+keyVision
  args.Append "version="+version
  args.Append "url="+imageUrl
  If Not owners.Empty Then args.Append "owners="+owners
  If Not classifierIds.Empty Then args.Append "classifier_ids="+classifierIds
  If threshold>0 Then args.Append "threshold="+threshold.ToText
  Dim parameters As Text=Text.>Join(args, "&")

  w.Send "GET", url+If(parameters.Empty, "", "?"+parameters)
End Sub

Finally, you can request the classification of an image. For example, put a button in a Window and in the Action event put the following code:

WatsonVisualRecognition.classifyImage(WeakAddressOf analyzeResponse, "https://watson-developer-cloud.github.io/doc-tutorial-downloads/visual-recognition/fruitbowl.jpg", .3)

Where analyzeResponse is the method that will read the results translating the Dictionary into something useful like actions for a database, a textual list or a simple text message.

Starting from this simple method, it is possible to create all the others, adding a bit of utility functions to the WatsonAPI base class.

As an example, it is possible to obtain the basic information about the people in this image and display it as an overlay:

Or update a database of images with classifications to then find the images of a specific type:

Create your own classifiers

Starting from this object it is easy to create an application to generate, update, and verify a classifier that is specific to this solution. While you can do it with the provided web interface, you can create a Xojo app that can return the feedback in a much easier and manageable way; and you can add some methods to automate the process of automatically discarding bad images and adding new ones in order to refine your classifier better.

Conclusions

Watson’s API services allow you to add a bit of artificial intelligence to your Xojo projects. The simplicity of the classes required to do this are clear proof of Xojo’s versatility.

It’s important to keep in mind that this service is not instantaneous. This is due in large part to network traffic; generally for sending the data and receiving the answer.

A really interesting option if you develop for MacOS would be to download your classifier in CoreML format and use it offline with MBS Core ML plugin.

Antonio Rinaldi is a professional engineer, Xojo developer for almost twenty years, Xojo evangelist for Italy since 2014, consultant and teacher. He develops extensions for Xojo iOS that you can find in the Xojo Store, and manages XojoItaliaBlog.com. Musician, composer, lover of good food, traveler and constantly curious, he is always looking for new ideas to expand his knowledge.

The Linux API is largely based on the C/C++ programming language and makes heavy use of structures.

As a simple example, the gtk_widget_set_opacity method in libgtk-3 can be used to change the window opacity so that it appears more transparent. This is what the method declaration looks like in the Gnome docs:

void
gtk_widget_set_opacity (GtkWidget *widget,
 double opacity);

This tells you it is a method (sub) because the “void” at the beginning indicates it does not return a value. The first parameter is a pointer to a GtkWidget, which in this case is the handle to the Xojo window. The opacity is a Double in the range of 0 to 1.

So the above method call translates to a Declare that looks like this:

Declare Sub gtk_widget_set_opacity Lib "libgtk-3" (handle As Integer, opacity As Double)

To set the window to 75% opacity you can call it like this:

gtk_widget_set_opacity(Self.Handle, 0.75)

Because this method is called for a window, you can put it in a Xojo Extension Method to make it easier to call. To do this, create a global method on a module like this:

Public Sub Opacity(Extends w As Window, value As Double)
  #If TargetLinux Then
    Declare Sub gtk_widget_set_opacity Lib "libgtk-3" (handle As Integer, opacity As Double)
     gtk_widget_set_opacity(w, value)
  #EndIf
End Sub

Note the use of the “#If TargetLinux” line. This prevents this code from being compiled into Windows or macOS builds of your app where the code could possible crash your app.

This now allows you to have code like this on a window’s Open event to center the window:

Self.Opacity(0.75)

To learn more in the Xojo Documentation:

• Calling Native Linux APIs

If there are Linux-related or other topics, regarding Xojo Programming or general technology, you are interested in reading about on the Xojo Blog about please let us know!

So I have a challenge for you, you can download the already canned Xojo class ready to use … or you can continue reading and discover how easy is to use Xojo to generate your PDF files!

The service we are going to use is the OpenSource software Docverter, able to convert any plain, HTML, Markdown or LaTeX file to PDF, Docx, RTF or ePub using a simple HTTP API. In my tests it worked like a charm from the HTML + CSS returned from Markdown Parser class of my own.

In fact it is possible to use this service stright from a Shell class instance, but I’ve found it more portable and multiplatform to wrap it in a Class so you can simply drop it in your project, passing the file or files you want, and specifying the conversion you want to get back; as simple as that!

For that API wrapper we are going to create a new class derived from HTTPSocket. Let’s name it HTTPDocConverter and put as the next step these String constants that will ease its use:

• kDOCX As String = "docx"; scope: public.
• kePUB As String = "ePub"; scope: public.
• kMOBI As String = "mobi"; scope: public.
• kRTF As String = "rtf"; scope: public.
• kRemoteAPI As String = "http://c.docverter.com/convert"; scope: private.

I think that is a good habit to get accustomed to constants wherever Strings or other frozen values are involved in order to minimize possible minor bugs in the code.

Now it is time to implement the class Constructor passing along three parameters that will simplify its use:

• convertDataTo As String. This is the text that identifies the format we want our document converted to and that is why we defined the Constants in the previous step.
• inputFile As folderItem. A valid FolderItem file pointing to the file we want to use as the source for the conversion process.
• notification as callback. This is new Delegate Type we will define in the next step, and that will be used by the class to, well, notify of the process completion. This way, your code and UI will not be locked.

So our class Constructor will have the following signature:

Constructor( convertDataTo As String, inputFile As FolderItem, notification as callback )

Once we add the Constructor method, the Xojo IDE will put the right class initialization here, and we will complete the code with the following sentences:

Super.Constructor
registeredCallback = notification
encodeRequest( inputFile, convertDataTo )

Time to add to the class a new Delegate Type (Insert > Delegate), using the following signature in the Inspector Panel:

• Delegate Name: callback
• Parameters: content As String, documentType As String
• Scope: Private.

That is: our class will accept as a callback Delegate any method that accepts two strings. In fact our class will return the already converted data into the argument content, and also the document type used for the conversion into the documentType argument.

With our Delegate already set, it’s time to add the registeredCallback Property to the class, and that will be responsible to point to the Delegated method passed to the class instance throught the Constructor:

• Name: registeredCallback
• Type: callback
• Scope: Private

In fact, let’s add two more Properties:

• Name: convertedToType. This one will contain the conversion format.
• Type: String
• Scope: Private

• Name: receivedData. This property will contain the converted data received from the remote service.
• Type: String
• Scope: Private

Encoding the Post Request … the right way

With all our properties set, it is time to add the Method encodeRequest. Here is where we will take care of constructing our Post Header request including the data for the source file we have to send to the remote URL, along all the required stuff. Create the Method with the following signature:

• Method Name: encodeRequest
• Parameters: inputFile As Folderitem, convertdataTo as String

And write the following snippet of code in the resulting Code Editor:

Dim formData As New Dictionary
formData.Value("input_files[]") = inputFile
formData.value("from") = "html"
formData.value("to") = convertDataTo
convertedToType = convertDataTo
Dim boundary As String = ""
Boundary = "--" + Right(EncodeHex(MD5(Str(Microseconds))), 24) + "-reQLimIT"
Static CRLF As String = EndOfLine.Windows
Dim data As New MemoryBlock(0)
Dim out As New BinaryStream(data)
For Each key As String In FormData.Keys
  out.Write("--" + Boundary + CRLF)
  If VarType(FormData.Value(Key)) = Variant.TypeString Then
    out.Write("Content-Disposition: form-data; name=""" + key + """" + CRLF + CRLF)
    out.Write(FormData.Value(key) + CRLF)
  Elseif FormData.Value(Key) IsA FolderItem Then
    Dim file As FolderItem = FormData.Value(key)
    out.Write("Content-Disposition: form-data; name=""" + key + """" + "; filename="""+inputFile.Name+""""+ CRLF)
    out.Write("Content-Type: text/html" + CRLF + CRLF)
    Dim bs As BinaryStream = BinaryStream.Open(File)
    out.Write(bs.Read(bs.Length) + CRLF)
    bs.Close
  End If
Next
out.Write("--" + Boundary + "--" + CRLF)
out.Close
Super.SetRequestContent(data, "multipart/form-data; boundary=" + Boundary)

Calling the remote API

Now that the hard part is complete, we are going to add the Method getConvertedFile, in charge of call the remote API:

• Method Name: getConvertedFile
• Scope: Public

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

Super.post( kRemoteAPI )

This single line fires all the magic behind the scenes, now in order to get our response we need to add the Event PageReceived to our class, writing the following code in the resulting Code Editor:

If registeredCallback <> Nil Then
  registeredCallback.Invoke content, convertedToType
End If

If you want, you can also add the Error Event, so you can raise or inform about any error during the process.

Testing our class!

In order to test the class, and convert some documents along the way, add a new Method to the project Window (let’s assume its a Xojo Desktop Project). This is the one we will use as Delegate for the callback once we receive the converted data:

• Method Name: conversionCompleted
• Parameters: convertedData As String, documentType as String
• Scope: Public

And write the following code in the resulting Code Editor for the Method:

Dim f As FolderItem = GetSaveFolderItem("", "ConvertedFile." + documentType)
If f <> Nil Then
  Dim tof As TextOutputStream = TextOutputStream.Create(f)
  If tof <> Nil Then
    tof.Write convertedData
    tof.Flush
    tof.Close
  End If
End If

Add now the Open Event to the same Window and write the following code, this is the one in charge of creating our class instance and firing the conversion process. In this example converting the source file to a PDF file (you only need to change the file format constant to get other kind of documents as result):

Dim f As FolderItem = GetOpenFolderItem("")
If f <> Nil Then
  Dim post As New HTTPDocConverter(HTTPDocConverter.kPDF,f, AddressOf conversioncompleted)
  post.getConvertedFile
End If

Creating PDF Files without Internet connection

What if you need to generate PDF files without having an active Internet connection or because you handle confidential information? Well, in these cases I’m sure you’ll find of interest the wkhtmltopdf tool/library.

Add it to your product bundle/folder or directory during the compilation process and you’re set!

In this case, you have to invoke it from a Shell instance passing HTML as the source file and getting the PDF as result. The downside is that the distributable product will be weighter (47 Megabytes)! Not a big problem these days, anyway.

The Last Word

As you have seen, with a couple of methods and Events we were able to create a multiplatform Class that works in 32-bit and 64-bit targets for Desktop, Console, web and Raspberry Pi deployments. I’ve been able to create PDF, DOCX, RTF and even MOBI files in no time!

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 and the Snippery app, among others

*Read this post in Spanish

WFS is still available on GitHub, but it has languished over the years. For example, it has lots of legacy code in it for older versions of Windows that is no longer needed since Xojo only supports Windows 7 and later. WFS is also not really compatible with 64-bit projects since the Declares mostly assume 32-bit or bust.

To that end, I’ve started a new open-source project called WinAPILib that is now available on GitHub.

This project is the start of an attempt to collect useful Windows Declares (from WFS and elsewhere) and make sure they are updated to work with 64-bit and newer versions of Windows.

Why is it called WinAPILib? First, Microsoft no longer uses the term Win32 for their desktop framework since the API also works with 64-bit apps. It would be confusing to say you are using the Win32 framework for 64-bit apps, so Microsoft has switched to mostly using “Windows API”:

The Windows API was formerly called the Win32 API. The name Windows API more accurately reflects its roots in 16-bit Windows and its support on 64-bit Windows. The name Windows API is used in this volume except when comparing 32-bit Windows programming with 64-bit Windows programming. They are then referred to as Win32 and Win64 APIs, respectively.

This is informally just shortend to “WinAPI”. Combined with the popular macOS Declare project on GitHub called macoslib, I figured WinAPILib would be a consistent, familiar name.

I’ve started small with WinAPILib. Right now it just has a few classes for some system declares and other things. More will be added over time by me and hopefully by others sending pull requests up to GitHub.

To get WinAPILib, go to the GitHub page and click the green “Clone or download” button. Use the clone URL with your favorite GitHub client (I use SourceTree) or just download the Zip if you’re Git-shy.

WinAPILib on GitHub

For some tips on writing Windows Declares, visit Calling Native Windows APIs in the User Guide.

I hope you find this helpful and please share your useful Windows Declares!

This post was updated in 2021 to using Xojo’s API 2.0.

There are plenty of times when your Xojo apps might need to know what the public or external IP address in use is, and for that there are a lot of web sites or services that you can use from Xojo. Nevertheless, I found ipify to be the simplest and easiest to use, plus it is highly available due to being hosted by Heroku. That means, for example, that if half the Internet is down…you still can be confident to reach the ipify service in order to get the information.

Using ipify from a Xojo desktop apps is as simple as using this code:

Dim request as New HTTPSSocket
Dim s as String = request.get("https://api.ipify.org",10)

But sometimes we need additional information, for example knowing if the IP address has changed over time, or simply checking periodically for IP address changes. And that is something that you can find in the OpenSource project ipify for Xojo available in this repository from GitHub.

ipify for Xojo is designed as a Singleton class, what means that you even don’t need to instatiate it in order to get the current IP address, know if the IP has changed over time, or even instruct the class to periodically check for the IP address, notifying the registered object every time with the current IP address in use and if it is the same or has changed from the last checking.

Download IPify for Xojo from GitHub

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 and the Snippery app, among others.

*Read this post in Spanish

Xojo is a powerful, full-featured development tool and as far as professional development tools go, Xojo is amazingly easy to use. For people with programming experience or those that want to learn, Xojo is a great choice for creating powerful apps to meet any business need – from cross-platform desktop apps, web apps, mobile and iOT apps.

Free, On-Demad Webinars

First, we did a couple webinars with FileMaker experts. The first webinar shows you how to create a Xojo iOS app that communicates with a FileMaker database:

• Develop iOS Apps that Integrate with FileMaker

To learn what FileMaker developers were concerned about and how Xojo could help, we did a Question & Answer webinar with FileMaker developers considering Xojo:

• Q&A Xojo for FileMaker Developers

Aloe is a new open source module that enhances Xojo’s Web framework. With Aloe, you can develop powerful, secure, and scalable websites, apps, and APIs. This demo shows you how to use Aloe and Xojo to quickly and easily create a website whose content is dynamically generated using data that’s stored in FileMaker databases:

• FileMaker Web Publishing With Xojo and Aloe

Projects

In conjunction with this, we released to GitHub a project called Xojo.FM which maps many commonly used FileMaker functions to make using Xojo a bit more familiar to you:

• Xojo.FM

Tim Dietrich, an experienced FileMaker and Xojo developer, introduces FMLuna and the opportunities that it presents to both Xojo and FileMaker developers. See some of FMLuna’s features in action as Tim builds a basic FileMaker API:

• Integrate with FileMaker Databases using FMLuna

After you have checked out all those resources and you’re ready to begin development, visit the Migrating from FileMaker page in the Xojo Dev Center for tips on how to best migrate your FileMaker apps. You’ll quickly see how simple it can be to jump from FileMaker to Xojo, grow you client base and open up new opportunities in the mobile market.

Xojo is free for development and testing and has a 90-day return policy. Give it a try to see how you can start making better, more powerful apps.

1. Create a new desktop app
2. Add a new window and set its frame type to “movable modal” name it “myDialog”
3. Add two Buttons one with the caption “cancel” and one with “close”
4. Add a property “cancelled as boolean” and make sure its scope is public
5. Add the action event to the cancel button and add this code:

cancelled = true
self.close

1. Add a textfield name “userText” (so the user can enter something and we can send it back to the caller just to illustrate)
2. Add another property “userEnteredText as string”
3. In the “close” button add this code to its action event:

userEnteredText = userText.text
self.close

Lastly, turn OFF implicit instance for the myDialog window.

With this technique Cancelled and userEnteredText are the “API” portion of this dialog that the rest of your app uses and cares about. In a more complex example you might return many values or a class instance but the principles are not radically different.

To use this in your code:

1. On Window1 add a button and a text field – name the text field “fromDialog”
2. Add the action event to the button
3. In the action event put this code:

       dim dlg as new myDialog

       dlg.ShowModal

       if not dlg.Cancelled then
              fromDialog.text = dlg.userEnteredText
       end if

Run the project to try it out.

You’ve now successfully made an API so whatever is using this dialog doesn’t need to know how things work, such as how the dialog presents and stores information. All you need to know is that you create one, tell it to “run” (the ShowModal call) and when it’s done you can ask it for “did the user cancel” and if they didn’t you can ask the dialog for “what did that user enter?” and get a reply.

Beyond that you don’t need to know the names of controls or anything else that dialog doesn’t want you to know about. Next time you need to do something along these lines now you know how to “make an API” you can use and save yourself a lot of headaches down the road.

For another way to make an input window like this, check out the example that is included with Xojo: Examples/Desktop/Windows/InputWindow.

If you missed it, the recording of the presentation is available in the Dev Center: What is Xojo?

Q: I would use Microsoft SQL Server Express with Xojo Lite. Is this possible?

A: You can certainly use Microsoft SQL Server with Xojo, but you will need to upgrade to a Desktop, Web or Xojo Pro license. Contact customer support to get a quote.

Q: Will Xojo be supporting build apps for Android?

A: Yes! We announced plans for Xojo to be able to create Android apps at the Xojo Developer Conference in October 2016. We will post milestones as we reach them on the Xojo blog.

Q: Is it possible to deploy an iOS app to my own iPad?

A: Yes, absolutely. If you don’t have an Apple Developer account, you can follow these steps to get your free Provisioning Profile from Apple. If you do have an Apple Developer account, the steps are much easier: Deploying to Device.

Q: Is there a way to show the Library and Inspector at same time?

A: Yes! Xojo has a preference to change the Library and Inspector to display as floating palettes. When you do this you can have both open at the same time and can even position them on a second display.

Q: Can iOS apps make use of low-level APIs?

A: You can use the Declare command to directly access iOS APIs. Some examples are also included with Xojo. The open-source iOSKit library provides access to many additional iOS features as well.

Q: How do you connect to database(s)?

A: Xojo has built-in support for SQLite, MySQL, PostgreSQL, Microsoft SQL Server and Oracle. In addition you can use ODBC to connect to any other database (as long as you have a driver).

Q: How easy is it to access the hardware features of apple devices, such as the GPS or its movements?

A: Xojo has a built-in class for accessing location/GPS information: iOSLocation. The iOSMotion class gives you access to information about device movement from the accelerometer and gyroscope.

Q: How do you create apps that work on both iPhone and iPad, switch screens as appropriate?

A: You can specify different views that are used for iPhone and iPads by setting the Screens. Also, the Split Screen topic in the User Guide shows how iPad apps can have two views displayed at once. There are a few example projects that show this as well:

• Examples/iOS/Apps/XojoNotes
• Examples/iOS/Navigation/SplitViewExample

Q: Where can I find Xojo training materials?

A: You can access our vast library of online learning materials at the Xojo Dev Center. There you will find Quick Starts, Tutorials, User Guide, Reference Guide, Videos and much more. From our Resources page you can access our free textbook, Introduction to Programming with Xojo, and our Teacher’s Guide. Join us for free webinars and virtual events, or watch on-demand webinars and video tutorials covering all kinds of topics. If you are interested in training, Xojo offers training and there are other options in our Add-On Store.

Q: How would I transition a desktop Xojo app to a web service + custom web UI?

A: You can move your desktop app’s business logic to a web app that functions as a web service. More information about that is in the Web Services topic, which has links to many videos on this topic. Another option to help with this is the Luna open-source framework. Once you have your web service set up, you can use the HTTPSocket in desktop, web or iOS apps to connect and use the web service.

Q: As a Filemaker developer, can Xojo display/play photos,video, mp3 files?

A: Yes, Xojo has built-in controls to display pictures, play video and mp3 files. Some of them include: ImageWell, WebImageView, iOSImageView, MoviePlayer, WebMoviePlayer. Also there is a web project that shows how to play audio using HTML5: Examples/Web/Controls/AudioPlayer.

Q: How do I convert my FileMaker Apps (desktop and mobile apps) to Xojo?

A: You’ll find some ideas at the Migrating from FileMaker topic at the Dev Center.

Q: Where can I find examples for developing Xojo plugins?

A: Included in your Xojo download (in the Extras folder) is the PluginsSDK, which has documentation and examples on how to create your own plugins.

Q: Can you say a bit about reports?

A: Xojo desktop projects can use the Report Layout Editor to design reports that can be printed or displayed on the screen. There are also several 3rd-party reporting products available.

Q: Info about Raspberry Pi and for Apple TV?

A: Xojo can create desktop, web and console apps that run on Raspberry Pi 2 and 3. You can find more information, with some example hardware projects here: Raspberry Pi. Xojo cannot directly create Apple TV apps, but you can use a Xojo web app as a web service to send content to Apple TV TVML apps using the open-source Viewpoint project shown by Tim Dietrich in the most recent Virtual Xojo User Group meeting.

Q: What happens with my Xojo Apps when the user updates their Operating System? Will I have to make an update for the Apps?

A: Your Xojo apps are generally not affected by OS updates. Of course, you’ll want to use the latest version of Xojo to ensure you have the most recent support for the latest operating systems.

Q: How active is the referral forum for the Pro users, specifically from the freelance developer perspective?

A: This varies greatly, but currently there are about 2 posts per week on average with about 28 items currently listed.

Thanks!

Thanks to all the attendees for the great questions! Be sure to give Xojo a try today. It’s free! You’ll soon be making apps faster than you ever thought possible. Additional “What is Xojo?” webinars are scheduled for February and March. Be sure to join so you can ask your own questions. For more casual conversations, join our Lunch with Xojo hangouts in February and March.