Using a WebPopupMenu with a Keyboard

2024r4 comes with keyboard full support for WebPopupMenu. We’ve been gradually improving this control to allow your users to select a field using the arrow keys, for example. What’s new is being able to go directly to one of the item just by starting to type its name.

Memory Usage Improvements

Everyone does their best to avoid leaking memory but, sometimes, that’s just not enough.

Jérémie Leroy is known for the success of the mobile apps he makes with Xojo. When one of these successful app requires a Web Service, receiving 1000s of requests, it needs to be as lightweight as possible.

Thanks to his reports, the visual controls will be creating Tooltip and WebCSSClasses instances only when being used. For many projects this won’t make a difference, but having a Web project with hundreds of concurrent users will surely lead to less memory pressure, allowing to run Web apps in cheaper servers.

This task never ends. Upcoming releases will continue improving memory usage and performance.

WebMapViewer

The library we use to display maps, MapLibre, has been upgraded from 3.2.0 to 4.7.1, which will make much easier to implement some of the features we want to introduce in upcoming releases. Stay tuned!

This control also received 4 additional bug fixes. One of them was causing the Zoom to be modified, when updating another control property, for example.

Some New Features

While Web received mostly bug fixes this time, it also comes with some hidden gems.

Popover position can be adjusted now when displaying it. The positioning is relative to its parent control. Additionally, you can now use a WebPage as the parent control, instead of one of the page children, to place your Popover exactly where you need.

Last, but not least, my favorite new feature. We’ve added CallLater method to WebTimer. It works exactly the same as Timer.CallLater, but it’s Session aware. This means you will be able to access the Session from its callback, without having to do anything special.

Wrapping Up

We are saying goodbye to a 2024 packed with improvements for the Web target, with a release dedicated (more than usual) to bug fixing and to make everything more stable. Make sure to check Xojo 2024r4 Release Notes, so you don’t miss anything.

Thanks to everyone reporting bugs, making feature requests and collaborating in the forum!

Ricardo has always been curious about how things work. Growing up surrounded by computers he became interested in web technologies in the dial-up connections era. Xojo has been his secret weapon and language of preference since 2018. When he’s not online, chances are he will be scuba diving … or crocheting amigurumis. Find Ricardo on Twitter @piradoiv.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

A Quick Reminder About What Bootstrap Is

As I will be mentioning it during this post, let me take a moment to remind readers what Bootstrap is, and what are we using it for at Xojo.

Bootstrap is the library we use for the visual part of web applications made with Xojo. You can think about it as Gtk on Linux, or UIKit on iOS.

While there is a vast amount of alternative libraries, it’s been probably the most popular framework for the last decade. You can check the Bootstrap website for more information.

ColorGroup Named Colors

Until this release, the Named option when configuring a ColorGroup was not available on web projects. 2024r3 brings the ability to choose from the Web Basic colors, Web Extended colors and, what I find more interesting, Bootstrap colors, which also support dark mode out of the box.

As you can expect, if you drop a custom Bootstrap 5.3 theme with another set of colors, the IDE will automatically update in order to preview them.

Using Named Colors by Code

When a dynamic need arises, it is also possible to use Bootstrap Named colors programmatically, if you find it easier. Here is an example:

Var colorName As String

If paymentCardIsValid Then
  colorName = "success"
Else
  colorName = "danger"
End If

Rectangle1.BackgroundColor = ColorGroup.NamedColor(colorName)

Or in a WebCanvas.Paint event:

Var colorName As String = If(paymentCardIsValid, "success", "danger")
g.DrawingColor = ColorGroup.NamedColor(colorName)
g.FillRectangle(0, 0, g.Width, g.Height)

You can check the list of available colors in the Color section of the official Bootstrap documentation. Basic and Extended Web Colors will work as well.

Using Bootstrap CSS Classes

Bootstrap comes with a set of utility CSS classes for a variety of visual things. You probably won’t need them all, as the Xojo IDE will get you there in most of the cases, and we work hard improving the IDE to make it easier, release by release.

That said, if you are an advanced user, and you have previous experience working with Bootstrap, you may find it useful to add CSS classes directly from the Inspector.

Go to the Advanced tab, add some Bootstrap CSS classes, separated by spaces… and voilà!

Here is a demo:

We have included a new example, called “Applying Bootstrap CSS classes to controls”, that you can find under Platforms > Web. Please give it a try.

CSS Classes are not limited to Bootstrap, if you have added styles in the HTML Header section, you can use them as well.

You can also add and remove them using the new CSSClasses property, which is available in every WebUIControl subclass.

WebRectangle Got Some Love

You won’t need to setup the border color, border thickness or the corner size, for WebRectangle, in the Opening event anymore.

When designing web applications, I found myself using a lot of WebRectangle controls and, by default, they have a rounded border.

The side-effect is subtle, but now that you can control the border radius directly from the Inspector, the IDE preview will be closer to how it will look in the browser. And you are going to avoid writing a few lines of code!

In addition, some Bootstrap themes define a different Corner Size. Setting this property to “-1” will honor that Bootstrap theme’s default border radius.

Conclusion

As always, the release comes with much more than I can tell you about in one blog post. With over 30 Bug fixes and 9 Feature Requests implemented in the Web target alone, make sure to take a look at the Xojo 2024r3 Release Notes to see the whole picture.

Happy coding!

Ricardo has always been curious about how things work. Growing up surrounded by computers he became interested in web technologies in the dial-up connections era. Xojo has been his secret weapon and language of preference since 2018. When he’s not online, chances are he will be scuba diving … or crocheting amigurumis. Find Ricardo on Twitter @piradoiv.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Control Sets

There are cases where you have a bunch of controls with the same functionality. Imagine you are coding a calculator and you’ve just added the WebButtons for each digit. It would be repetitive and error prone to add the same code to Pressed events, on each button when the only thing that changes is the numeric value.

A set of controls can be grouped, so you can think about them like if you were using an array. You can add event handlers to the group itself. Events will be enhanced with an “index” parameter, to help you decide what to do, depending on the element.

Create Tabs and Embed Controls at Runtime in WebTabPanel and WebPagePanel

Same as with Control Sets, this is something that was already present in Desktop projects and we wanted to include it for Web. From now on, you will be able to create and remove tabs and pages in WebTabPanel and WebPagePanel controls, respectively. Controls can also be added and removed at runtime, or move controls between tabs or pages whenever you need.

This opens a new world of possibilities for your applications, where you can provide your end users a way to have multiple contexts open at the same time.

WebListBox: Configurable Header and Row Height, Border and Line Style

You will be able to configure the height of WebListBox headers and rows with the same API you are used to using in your Desktop projects. You won’t need to tweak them with CSS anymore.

HasBorder and GridLineStyle has also been added to Web projects, allowing you to remove the outside border, display only vertical lines between the columns… or just remove them.

WebDataSource Interface

Speaking of WebListBox improvements, you’ll find that the WebDataSource is easier to implement. You won’t need to implement SortedPrimaryKeys and UnsortedPrimaryKeys methods anymore.

There are only three methods required now:

• ColumnData: Where you will define the amount of columns, names, and configure if they are sortable
• RowCount: So the control can now the amount of space it will need
• RowData: This is where you return an array of rows

WebListBox lazy load rows, meaning that it will only ask your DataSource for the amount of rows being displayed on screen. It will only fetch more when needed.

WebListBox Improvements When Using a WebDataSource

Using a WebListBox with a DataSource makes it possible to display very large amounts of data. Until now, you were able to display thousands of rows very quickly. This release improves the way Xojo uses your DataSource, without having to change a line of code in your projects.

Scrolling through the data will display the rows much faster than before. Just for comparison, 2024r1.1 was able to display 1 million rows in about 6 seconds in my computer. The same project, using 2024r2, can display them in less than 100ms.

But is not just the speed that has been improved. Its memory footprint has been dramatically reduced as well. Displaying 1 million records in 2024r1.1 used about 1 GB of RAM, where 2024r2 will use just a few MB instead.

I can’t imagine a use case where you need to display millions of rows and scroll through them. But if you find one, you will be able to implement it with Xojo

WebButtons Can be Resized Now

In order to make it easier to migrate your Web 1 projects, you will be able to modify the height of your WebButtons. The web framework will also take care to reduce the font size if needed when the button is smaller.

Individual Indicator for Each Segment of WebSegmentedButton

There are situations where you want to mix different “indicators” (different colors) in a single WebSegmentedButton control. For example, pressing on one of the segments can be a destructive action, so you could use the Danger indicator. By default, segments will use the indicator you set in the Inspector panel, but you will be able now to individually override one of them.

Me.Indicator = WebUIControl.Indicators.Primary
Me.SegmentAt(1).Indicator = WebUIControl.Indicators.Danger
Me.SegmentAt(2).Indicator = WebUIControl.Indicators.Success

Having 4 segments, this will be the result of above example at runtime:

Outlined WebButton and WebSegmentedButton

Some GUIs could become overwhelming, when every button looks like a call to action. The new Outlined property, available in WebButton and WebSegmentedButton controls, can help with heavily loaded interfaces. Here is how it looks like:

Performance, Memory Leaks, Bug Fixes

Last, but not least, 2024r2 comes with great performance improvements. We’ve been improving the web server to handle even more requests per second. If you are using Xojo Web for exposing an API, it will be able to serve more requests in less time. For regular Xojo Web applications, it means it will be able to handle more events and reply to them faster.

Here is a comparison of the same project during the different releases of Xojo:

Latency has also been improved, Xojo is able already to reply in less than 2ms:

If you are still serving Web APIs with Web 1, this is a good opportunity to migrate:

That’s a Wrap!

As usual, I’d like to send a big thank you to everyone taking the time creating bug reports, feature requests and testing beta releases. This wouldn’t be possible without your support.

Ricardo has always been curious about how things work. Growing up surrounded by computers he became interested in web technologies in the dial-up connections era. Xojo has been his secret weapon and language of preference since 2018. When he’s not online, chances are he will be scuba diving … or crocheting amigurumis. Find Ricardo on Twitter @piradoiv.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Popovers

Similar to WebDialogs, popovers give you the opportunity to improve your apps’ UX. They are ephemeral screens where you can place text and controls.

Unlike the WebDialog, which is always centered and prevents the user to interact with other controls, Popovers can be placed on specific controls, where that information matters.

Think about them as enhanced “contextual menus” but, instead of just plain text menus, you can add anything you like. Have you ever dreamed of adding a WebMapViewer into some sort of contextual menu? Now you can!

The API is very simple. Create a container, add some controls and that’s it, really. You will just have to create a new instance of that container and show it as a Popover, specifying the control it should be pointing to.

Let’s say you have a container, called “MyTextFieldContainer”, and you want to display it below a WebLabel called “MyLabel”. Here is the code:

Var c As New MyTextFieldContainer
c.ShowPopover(MyLabel)

By default, it will be shown below the specified control, but if you want to show it in a different place, you can use the new DisplaySides enumeration. As easy as this:

Var c As New TextFieldContainer
c.ShowPopover(MyLabel, WebContainer.DisplaySides.Top)

As you can see, Web Projects’ Popovers are just container instances that you will show dynamically. That gives you the opportunity to raise events, add custom computed properties or implement the Observer interface. If you are already familiar with Containers, you already know how to use Popovers. Learn more about Popovers.

Displaying contextual menus programmatically

Sometimes Popovers could be overkill for the task. If you just want to display a menu with some textual items inside, a contextual menu might be enough.

Imagine you have a WebTextLabel where you want to display the contextual menu whenever the user Presses on it. In its Opening event you could define the ContextualMenu:

Var menu As New WebMenuItem
menu.AddMenuItem("Foo")
menu.AddMenuItem("Bar")
menu.AddMenuItem("Baz")

Me.ContextualMenu = menu

Implement the WebLabel.Pressed event and add this code:

Me.ContextualMenu.PopUp

As easy as that.

New RemoveControl method

WebViews controls, like WebPage and WebContainer, now supports removing controls. This gives you the missing piece to create GUIs programmatically, as AddControl was already supported .

This can be useful when you are presenting a form to your end user with an unknown amount of fields.

For example, your user is filling the profile and you want to support having multiple contact fields. Some users will want to add 1 phone, others 2, and others would prefer to be contacted just by email.

Adding and removing controls dynamically gives you the opportunity to build this kind of features. Instead of adding a fixed amount of contact methods, you can adapt your app to what your user really needs.

Performance and memory usage improvements

We’re landing at my favorite part, improvements that nobody will see… unless you want to share your server monitoring stats, which is cool.

2024r1 comes with less Disk I/O usage. In my own benchmarks, Xojo Web is now able to serve about 1200 requests per second via the WebApplication.HandleURL event. That’s around a nice 20% more, compared to the previous version.

Also, thanks to Jeremie Leroy (one of our Xojo MVPs) and Bruno Fréchette, we’ve managed to identify and fix some memory leaks. In 2024r1, your web application will be doing a better job at cleaning up after processing requests.

Bug fixes

The list of fixes is big, you can inspect the whole list in the 2024r1 Release Notes page.

Web fixes by category:

• Compiler: 1
• IDE: 7
• Framework: 40

18 extra regressions were reported and fixed during the beta period. A huge thank you to everyone taking the time to test our releases and reporting issues before the final release becomes available.

Conclusion

We hope you are as excited as we are for this release. I’m personally looking forward to see what you’re building, please remember to mention us on your favorite social network so we all can see what you’re working on.

In the meantime, we are already working hard preparing our next release, 2024r2. Spoilers: You will love it!

Happy coding!

Ricardo has always been curious about how things work. Growing up surrounded by computers he became interested in web technologies in the dial-up connections era. Xojo has been his secret weapon and language of preference since 2018. When he’s not online, chances are he will be scuba diving … or crocheting amigurumis. Find Ricardo on Twitter @piradoiv.

Faster HandleURL Responses

With Xojo Web you can create APIs backing your Mobile or Desktop applications. Just by updating to Xojo 2023r4, your web services will get the benefit of much faster responses and the ability to handle many more requests per second.

Just to compare between different Xojo versions, we’ve created some benchmarks using Xojo Web 1 (with Xojo 2019r3.2) and some Xojo Web 2 releases, 2023r3.1 and the latest one, 2023r4.

Here are the results, returning plain text:

And the same test, but this time returning a string generated by JSONItem:

Xojo 2023r4 is capable of serving around 20x more requests per second compared to Web 1, and around 4x compared to Xojo 2023r3.1. And thanks to the reduced latency time, your API will return the contents much faster.

Faster Transfer Rates in Windows and Linux

While working on performance, we’ve found that applications deployed on Windows and Linux were serving large files much slower than those deployed on macOS servers.

William improved the low level code for sockets on those targets, allowing the server to transfer large files at a much faster speed. During my tests, I’ve seen 10x faster transfer rates.

But this doesn’t affect only our Web target! If you are using a ServerSocket with TCPSocket classes, your Console and Desktop applications will also benefit from these improved transfer rates.

Static Assets Cache Control

In this release, we’ve also improved how the framework interacts with the browser. When your user visits your web application for the first time, it will store all of the required JavaScript and CSS files.

This was already happening in previous releases but with a subtle difference. From now on, the browser won’t even need to check with the server if the file has changed since the last visit. This translates to faster load times for your users and less server load for you since the server won’t need to handle all those requests anymore.

Improved Compile Time

In this release, Xojo Web will compile your projects a few seconds faster. The first time you compile your project, it will cache the result of some processes that are only changing between Xojo releases.

Here is a comparison between 2023r3.1 and 2023r4, both are running a debug session of a blank project:

That’s around 3-4 seconds faster every time a project compiles.

Events Improvements

Some web controls were sending information from the browser to the server more frequently than needed. For example, a WebContainer.Scrolled event was being sent for every scrolled pixel, causing unnecessary server load.

We’ve been reviewing these controls and have made some improvements:

• WebCombobox
• WebContainer
• WebSearchField
• WebTextArea
• WebTextField
• WebUploader

All of them will continue communicating their state updates, but the framework will focus on delivering the latest value available.

For example, in a WebSearchField, if the user writes “hello”, the framework will send the first key press (“h”) as soon as it happens. The next event it will send will depend on how fast the user types, so it can be either “hel” or maybe directly “hello”. What is guaranteed is the TextChanged event will be fired for the final value (“hello” in this example).

New Experimental Option

WebSession has a new experimental option available, disabled by default. “Send Events in Batches”:

Turning it on will make our JavaScript framework group different event notifications in a single request. Projects that contain complex layouts that show and hide several controls at once may benefit from snappier GUIs.

As a side effect, it will also ensure the events arrive to the server in the correct order. Think about a login screen where the user has an email field, a password and a “Login” button with the Default setting turned on (to allow the user to trigger the Pressed event by pressing the Enter key). When sending the events in different requests, because of network latencies, the WebButton.Pressed event could arrive at the server before the last WebTextField.TextChanged.

We would love to hear your experiences when turning on this experimental option. If you find an issue, please report it.

Wrapping Up

As always, while Xojo 2023r4 comes with a lot of performance improvements, it also comes with bug fixes and feature requests. I want to again thank everyone who took the time to create new Bug reports and Feature Requests, and tested the pre-releases.

We’re looking forward to see what you build with it!

Ricardo has always been curious about how things work. Growing up surrounded by computers he became interested in web technologies in the dial-up connections era. Xojo has been his secret weapon and language of preference since 2018. When he’s not online, chances are he will be scuba diving … or crocheting amigurumis. Find Ricardo on Twitter @piradoiv.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Optimizing the Navigator

In Xojo 2023r4 we tackled a performance issue impacting the navigator’s speed, particularly during scrolling. Upon closer examination, we identified that the substantial consumption of resources and time was attributed to the rendering of these basic and compact navigator icons.

What was initially intended as a straightforward drawing of an icon, ended up becoming a needlessly intricate element that significantly impeded overall speed.

The Before and After

In 2023r3, a noticeable lag occurs during scrolling, with the thumbtrack failing to keep pace with the mouse movement.

In 2023r4, scrolling has been significantly improved and the thumbtrack now maintains synchronization with the mouse movement, resulting in a smoother experience.

What other benefits does this change offer?

Having pinpointed the root cause of this issue, we proceeded to implement updates across various instances where the needless drawing persisted. We identified a similar occurrence when rendering command bar icons affecting every keystroke in the code editor and movement in the layout editor. Refactoring this aspect is expected to enhance performance in these specific areas of the IDE. We trust that you will find the IDE more enjoyable following these small and simple changes.

William Yu grew up in Canada learning to program BASIC on a Vic-20. He is Xojo’s resident Windows and Linux engineer, among his many other skills. Some may say he has joined the dark side here in the USA, but he will always be a Canadian at heart.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Dark Mode Support and Bootstrap 5

You can now create web applications with Xojo that respects users’ Dark Mode preference with Bootstrap 5.

There is a new WebSession.ColorMode property you can use. It will be set as Auto by default, meaning it will match the user’s OS appearance preference, but it can also be forced to Light or Dark. It can be changed at runtime and per session.

While not everyone likes Dark Mode, some of your end users will appreciate this. Due to medical circumstances, they might actually need it, so please consider adding support even if you don’t like dark interfaces.

If you want to enable Dark Mode in your previous projects, you will have to manually enable the setting in the Shared Build Settings section (which is turned on by default on new projects):

Color Groups can also be used nearly everywhere, and they will be used in the IDE preview when you toggle between Light and Dark Mode:

In order get Dark Mode support ready for Web, we had to upgrade our internal Bootstrap dependency from v4.6.1 to v5.3.0, which is a huge leap by itself. Bootstrap 5 comes with a refreshed color palette, new components, modernized existing controls and bug fixes. Please check our previous Bootstrap 5 is Coming to the Xojo Web Framework blog post.

If your application wasn’t using a custom Bootstrap Theme (bootstrap.min.css), everything should look more or less the same except for the subtle color palette differences and rounder buttons. Bootstrap 4 themes aren’t supported in Bootstrap 5, please replace it with a v5 theme if needed. Not every theme supports Dark Mode, but the one included in Xojo does.

If you are a theme builder, please check the Bootstrap’s Color Modes documentation. You can also find free Bootstrap 5 themes available at Bootswatch.

We also want to send a big thank you to our third party developers for their effort adapting their Open Source and Commercial plugins and controls to Bootstrap 5. You can learn about what they offer at the Xojo Extras Store and in the Open Source Projects page in the Xojo Documentation.

Accessibility

Navigating and using web applications with the keyboard makes everyone’s life easier. In Xojo 2023r2 we’ve upgraded WebPagination and WebBreadcrumb controls, which are composed of more than one focusable item. Your users will be able to properly use the tab key to go through them.

We plan to continue working on improving Accessibility. Please open a new Issue if you find anything that can help you and your end users.

WebListBox

DataTables, the internal dependency we use for bringing your tables to life, has been upgraded from v1.10.20 to v1.13.4. This recent version includes support for Bootstrap 5 and a few bug fixes that some users were facing in their web projects.

You can now disable your WebListBox by setting its Enabled property to False so your users won’t be able to interact with it. And also, if you were missing this feature that’s in the DesktopListBox, you can now add Variant tags to your columns, using the new WebListBox.ColumnTagAt.

Last but not least, this control comes with a visual Inline Editor, like in its Desktop counterpart:

WebChart

Chart.js, the underlying library we use for WebChart, has been upgraded from v2.9.3 to v4.2.1. Again, we’ve done everything we could on our side so you don’t have to do anything.

The only exception is with the WebChart.OverrideOptions event. If you are currently using it, you’ll have to check the library documentation as the internal options JSON has changed.

You can expect the new DesktopChart features to be working on WebChart, like configuring how the lines look like (including the endpoints), background images or prefix and suffixes. Read New Additions to DesktopChart, MobileChart and WebChart to learn more.

Web SDK

If you are using third party controls, you will notice some of them now have a custom icon in the IDE Library. But even more important, they will use less memory at runtime.

Are you developing Open Source or Commercial Web SDK controls? Remember there is a dedicated Web SDK forum where you can ask any questions you may have.

IDE Performance and Improved CSS Support

Bootstrap 5 makes use of the latest CSS features. We took the opportunity to rethink our CSS parser and improve its performance at the same time. As a result, the IDE preview looks even closer to what you see in the browser, and we render everything faster.

Wrapping Up

Over 50 bug fixes and features were included just for Xojo Web in Xojo 2023r2. Please find a full list in the Release Notes. read more about Bootstrap 5 and updates to WebChart on the Xojo Programming Blog. We are looking forward to hearing your thoughts and seeing what you’re building with Xojo! See you in the forum!

Ricardo has always been curious about how things work. Growing up surrounded by computers he became interested in web technologies in the dial-up connections era. Xojo has been his secret weapon and language of preference since 2018. When he’s not online, chances are he will be scuba diving … or crocheting amigurumis. Find Ricardo on Twitter @piradoiv.

Both server and frontend will have less memory footprint now. The team has been working on finding and fixing memory leaks, and optimizing how the framework cleans up the controls, when pages aren’t visible anymore.

Paul and Travis made IDE improvements to load projects much faster. If you have a large Web project, you will surely notice the difference.

The WebListBox component got most of the improvements. Visually, you will notice less flickering. Internally, it will make less requests to the web server to display its data. We will continue optimizing its performance release after release. Interacting with this control is now more natural and accessible, as we’ve made it more compatible with the different OSs and devices. And just like WebListBox, almost every other control received one or more bug fixes. Check the Release Notes for a detailed list.

I would like to finish this post with a huge thank you to every user that has helped directly or indirectly creating Issues, attaching a sample project, posting on the Forum and testing the beta releases.

The community is the best feature of Xojo

Ricardo has always been curious about how things work. Growing up surrounded by computers and became interested in web technologies since the dial-up connections era. Xojo has been his secret weapon and language of preference since 2018. When he’s not online, chances are he will be scuba diving … or crocheting amigurumis. Find Ricardo on Twitter @piradoiv.

Line Numbering and the Gutter

Code Editor Line Numbering is now an IDE preference instead of a per-Code Editor preference. In the Preference (or Options) window, choose Coding and then turn on “Show line numbers in gutter” to enable line numbering on all Code Editors.

With Line Numbering enabled, the gutter area is a bit wider to show the line number. As you move the cursor around in the Code Editor, notice that the gutter highlights to indicate the line you are on. This can be very handy to help find where the cursor is in a busy method.

You can also now click on a line number in the gutter to select the entire line. This is helpful if you want to copy the entire line, but it is also a great way to make it a bit easier to study a particular line of code more carefully.

Code Folding

If you’ve not used it before, Code Folding allows you to collapse (or fold) code to help reduce clutter in the Code Editor. You do this by clicking on the small “-” indicator that appears to the left of a code block. When code is folded that indicator changes to a “+”, which you can click to make the code visible again. Folded code is never removed, it is just temporarily hidden.

In this release, we improved the “-“ and “+” indicators so that they show with a rounded rectangle to be a bit friendlier. The code folding line highlights are also now slightly less distracting.

Super Return

When you are on an incomplete line of code, you can press Shift-Return (also known as Super Return) to automatically provide some assistance. For example, start typing an If statement like this:

If True

and press Shift-Return after typing True. The Code Editor will fill in the “Then” and “End If” and put the cursor between them:

If True Then
  <-- Cursor here
End If

When you press Super Return with a For loop, not only is the Next added as it always was, but if you have an inline loop variable, then it is added to the Next as well. This can make it easier to match nested loops.

Although this was added in 2021 Release 1, you may also find this tip useful: Press Super Return on a comment line to start a new line with a comment.

Related to Super Return is Option Return or Control-Alt Return on Windows/Linux. When you press Option Return on a line, a new line is added with the code continuation character placed at the end of the current line.

In 2021 Release 2, when you press Option Return when inside quotes for a String, the string is completed and things are extended to the next line.

Other Improvements

The Project -> Go To Location feature lets you jump to a specific method in your project by typing the class and name, for example: CustomerDetailsWindow.LoadCustomers

In 2021 Release 2 you can now also add a line number to jump to a specific part of the code. This is great when asking someone else on the team to look at some code, especially in a lengthy method. You can do this by putting a “#” followed by the line number like this: CustomerDetailsWindow.LoadCustomers#15

Sometimes you want to get the text for a method signature, but don’t want to copy the entire method and all its code (which was what you previously got when you select a method in the Navigator and choose Copy). Now you can right-click on the method signature in the header of the Code Editor and choose “Copy signature” to copy the signature to the clipboard.

As usual, be sure to check out the full release notes for 2021 Release 2 as there are other cool things to find or download 2021 Release 2 and try it yourself!

What you now know as Xojo came along about 18 months later. As we prepared v1.0 to ship, we wound down the custom software development part of the business. We’ve been a development tools company ever since.

It’s truly amazing to me how quickly the past 25 years have gone by. It certainly doesn’t seem like 25 years. I consider myself quite fortunate that 25 years later, I still get to do what I love. The big factor for us has been adapting to change and learning from our mistakes. In his book, “A Short History of Nearly Everything”, Bill Bryson explains what lifeforms must do to survive. He says, “You must be prepared to change everything about yourself-shape, size, color, species affiliation, everything-and do so repeatedly.” This is also true in business. I didn’t start this company to provide development tools but when the opportunity presented itself, I grabbed it. When we shipped v1.0 on July 4th, 1998 it only built desktop apps, only for what is now referred to as Classic MacOS and only for the Motorola 68000 and PowerPC processors. Today we support MacOS (that shares almost nothing with its predecessor), Windows, Linux, the web, iOS (soon Android) and Raspberry Pi. In fact, other than desktop apps as a type, we don’t support anything we supported in 1998. And despite the fact that everyone on the team has been with us for many years, the team is nearly completely different from what it was back then.

Over the last 25 years we have done what Bill Bryson said must be done – we changed nearly everything about ourselves. We have added new operating systems, new processors, new capabilities, as well as rewritten the compiler and the IDE from scratch. We have had false starts on projects but we have followed the mantra of the US Navy Seals:

“I will never quit. I persevere and thrive on adversity… If knocked down, I will get back up, every time.”

These are the reasons we are still here after 25 years. We learn, we adapt and we never give up.

As the founder and CEO, I set that tone but a company is only as good as its team. It is the people that show up every day, sometimes in the middle of the night or on a Sunday afternoon, to bring their passion, talent and experience, from customer service and marketing to tech support and engineering, in order to create and support Xojo and enable each of you to create things that perhaps might have not otherwise existed.

That’s what has made this past 25 years the best of my life and I can speak for the rest of the team when I say that we look forward to many more challenging, inspiring and rewarding years ahead.

To you who have used the fruit of our labors to create your own for so many years, we are thankful and grateful for your past and continued support. You allow us to spend each and every day doing something we love. Who could ask for more than that?

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.

At that time, Xojo did not have this feature, but I did say that I thought it sounded pretty useful.

I’m happy to let you know that as of 2019r2, Xojo now has this feature. We call it Ignore All Breakpoints and you can turn it on or off from the Project -> Breakpoint -> Ignore All menu. A checkmark appears next to this menu when Ignore breakpoints is active. And when active, Xojo will not stop at any of your breakpoints. You can turn it on or off during the debug run as needed.

2019r2 also has a couple other improvements to the debugger as well:

• The debugger no longer stops at breakpoints within encrypted classes. This was not helpful and actually rather confusing since you couldn’t see the code.
• Breakpoints set within a Module Class Method during a debugging session now properly break in the debugger.

Xojo 2019 Release 2 has lots of new features and improvements, so be sure to download it today and review the full Release Notes.

Improved Overall Speed
One of the most obvious areas that hurt people with large projects is the speed of the IDE itself. We worked on a number of pain points to improve the overall IDE experience. Specifically, we were looking for things which by themselves were not too bad, but in a cumulative effect they could take large chunks out of your day.

One such area was in saving text projects. Now you wouldn’t think that there was much room for improvement here, since it’s just File I/O right? We found an optimization point in the way we save Bookmarks and Breakpoints, which in the IDE project represents a huge savings when making lots of changes. In our case, we went from 30 seconds down to 1, and for someone who insists on saving before every run, it makes a huge difference.

We also optimized drawing in the Navigator, and that change resulted in huge overall speed increases in many parts of the IDE, from selecting large number of items in the Navigator itself, making changes to multiple items, to even just typing code in the code editor.

Improved Tab Management
Tabs have been broken in one way or another for a long time. They finally got some TLC this cycle and we think you’re going to be much happier with the way they work now. We’ve rewritten the logic surrounding how tabs are chosen when you take an action which results in a new location request and made the behavior consistent, no matter where that request comes from. Whether that’s a Go To Location request or a search or clicking on an error result. The rules are applied in the following order:

1. If there is at least one locked tab which matches the Go To target, the first one will be used (left to right).
2. If there is at least one unlocked tab which matches the Go To target, the first one will be replaced.
3. If the current tab is unlocked, it will be replaced with the new location.
4. If there are any unlocked tabs, the first one will be replaced.
5. If none of the above conditions are met, a new tab will be created for the target location.

NOTE: Debugger Tabs are never eligible as a Go To target. This may seem obvious, but it wasn’t always true before. Now it is. Debugger tabs are also locked by default and cannot be unlocked.

The only exceptions to these rules are the Open In New Tab rules. That is, if you right-click on an item and select Open In New Tab or you double-click on an item with the “Double-click opens item in new tab” preference set, they will always open a new tab for you.

Once you start using the new logic, I think you’ll agree that it’s much more intuitive and you won’t feel like the IDE is constantly switching contexts on you. Personally I find that I’m using fewer tabs than in previous versions because I’m more confident that the objects I opened will still be there when I get back.

MacOS Dark Mode Layout Editor Toggling
On macOS 10.14 and above we’ve added a new toolbar button which allows you to quickly switch the Window you are editing between light and dark mode. No more switching your entire OS just to see how your app will look in the other mode.

Navigator Contextual Menu
We’ve done some cleanup work here to make it more obvious what you can and can’t do with objects in the Navigator. Gone are all of the disabled items that were not “in-context” for the currently selected item because, well duh, they’re not “in-context”. We’ve also enhanced the Edit Superclass and Edit Subclass menus. Edit Superclass now shows the entire superclass hierarchy, including things that you can’t edit (disabled of course) so you can track down common parentage. The Edit Subclass menu has been alphabetized so you don’t have to read the entire list just to find all of the items that begin with “c”.

Code Editor Contextual Menu
This menu has also gotten some love and attention. First of all, the menu has been reorganized so that the menu groups are based on the context of the thing that you’ve clicked on and the object where the code itself lives.

Group 1: Just like previous versions of the IDE, Cut, Copy, Paste, Delete and Select All are still at the top of the menu. They’re a common thing for mouse oriented users and we don’t want to hurt that functionality.

Group 2: The next group is for things that are for accessing or modifying the object that you’re currently editing. This is where you’ll find the Switch To menu for directly accessing the other code items within the current item.

We’ve also added two new submenus to this section that are specifically for copying the event and delegate signatures of the thing you’ve clicked on. For example if your code refers to a URLConnection object, you can now right-click on URLConnection and select Add Method > From Event > ContentReceived and the IDE will automatically add a method to the current object with the same signature including the object itself for use with AddHandler! In this case, you’d end up with a method that looks like this:

URLConnection_ContentReceived(obj As URLConnection, URL As String, HTTPStatus As Integer, content As String)

Then you could type something like:

AddHandler h.ContentReceived, AddressOf URLConnection_ContentReceived

Delegates work the same way, albeit without including the object reference in the method signature. No more flipping back and forth between your current code and the target object or Language Reference to copy the signatures!

Group 3: If it exists, this group is for things that are specific to the object or instance of the object that you clicked on in the code editor. This is where you’ll see the “Find” and “Go To” menu items for finding other uses of or going to the definition of an item, respectively.

Group 4: This group is for selection and code-specific tools including the Insert Color command, Standardize Format and the Wrap In menus for wrapping the current selection if an #If #EndIf or While/Wend block. This section also sports the menu for converting the current selection to a Constant or a Method.

Group 5: From here you can toggle Breakpoints and Bookmarks

Group 6: Help and Language Reference access.

For more information about the changes in 2019r2, read the full Release Notes.

In order for these to work, you must have focus in the Navigator, which means that the row selection is blue.

• Home: Move selection to first row, scrolling if necessary.
• End: Move selection to last row, scrolling if necessary.
• Right Arrow: Expand currently selected row.
• Left Arrow: Collapse currently selected row.
• Up Arrow: Move selection to previous row. If you are now selecting a code item, then focus moves to the Code Editor.
• Down Arrow: Move selection to next row. If you are now selecting a code item, then focus moves to the Code Editor.
• Page Up: Move selection up by one page, scrolling if necessary.
• Page Down: Move selection down by one page, scrolling if necessary.
• Shift + Up/Down Arrows: Select multiple rows.

Learn more about the Navigator here: https://documentation.xojo.com/getting_started/using_the_ide/navigator.html

There’s an advanced feature in Xojo called Compiler Directives which allows you to direct the compiler to conditionally compile a block of code based on a boolean comparison. For instance, if you wanted to temporarily disable a block of code (as opposed to commenting it out) you could wrap your code like this:

#If False
  // Code that you don't want to compile
#EndIf

You can also use constants with the #if directive, so if you created a module called “Switches” and it contained a Public or Protected constant named “EnableDeepLearning” with a value of True or False you could write code like this:

#If Switches.EnableDeepLearning
  // Code for your deep learning feature goes here
  // This code will only be included in your app if EnableNewFeature is set to True
#EndIf

There are also some built-in constants for you to use. For instance, there are two constants that tell you which version of the IDE is running, one is a Double, the other is a String. Here’s an example which allows you to use the new Dark Mode capability depending on whether you’re running 2018r3 or something earlier:

#If XojoVersion < 2018.03
  Var myTextColor As Color = &c000000
#Else
  Var myTextColor As Color = &c1C1C1C
  If IsDarkMode Then
    myTextColor = &cFEFEFE
  End If
#EndIf

There are also build-in constants per platform and processor type:

#If TargetMacOS
  // macOS Specific Code
#ElseIf TargetWindows
  // Windows Specific Code
#ElseIf TargetLinux
  // Linux Specific Code
#ElseIf TargetIOS
  // iOS Specific Code
#EndIf

#If Target32Bit
  // Code for 32-Bit Processors
#ElseIf Target64Bit
  // Code for 64-Bit Processors
#ElseIf TargetARM
  // Code for ARM Processors
#EndIf

For more information on Compiler Directives, see https://documentation.xojo.com/＃If…＃Endif

In addition to code for specific platforms, sometimes you need to know the specific version of the OS that the user is running. In 2019r3 we added the System.Version method specifically for this purpose:

#If TargetMacOS
  If System.Version = "10.15" Then
    // Code that works exclusively on 10.15
  ElseIf System.Version >= "10.15.1"
    // Code that only works on 10.15.1 and above
  End If
#EndIf

If you’re working with Windows, keep in mind that System.Version returns NT System Versions, so you’ll need to compare to these values instead:

• Windows 10 = NT 10
• Windows 8.1 = NT 6.3
• Windows 8 = NT 6.2
• Windows 7 = NT 6.1
• Windows Vista = NT 6.0

For more information about System.Version, See http://documentation.xojo.com/api/os/system.html#system-version.

Each year for Hour of Code, I volunteer at the local Middle School to talk to the students about what it is like to be a programmer and do a little bit of programming. This year I plan to demonstrate Xojo Dojo with a Raspberry Pi and show the kids how much fun coding and Xojo programming can be.

My wife teaches 7th grade math so I have a somewhat receptive audience, at least when it comes to middle school students. Of course, I’ll be sure to show off a few games made with Xojo. Asteroid Run was popular last year.

As Xojo developers you have a great perspective on coding, which would be wonderful to share with the youth of today. Most schools would absolutely welcome a guest speaker for a day so if you have a child in school or know someone that works at a school, I encourage you to see if you can help out by volunteering.

Looking for ideas? Here’s what we’ve done for the Hour of Code in past years:

• Hour of Code 2013: Math Facts
• Hour of Code 2013: Spelling Test
• Hour of Code 2013: Recap
• Hour of Code 2014: iOS Doodle
• Hour of Code 2014 Recap
• Hour of Code 2015: Cat Pictures
• Hour of Code 2017: Asteroid Run

Update (Dec 5, 2018):

Finished hour of code with 7th Grade students. They were very excited to learn a bit about coding and see some Xojo-made games.

Also, Xojo Dojo is now available for Mac and Windows. Download either of these from the main Xojo Dojo page.

So this Thanksgiving we wish to give thanks to all of you who use Xojo. You make our work possible.

To activate dark mode in Mojave, go to System Preferences, click General and select the “dark” appearance. The entire UI will switch to a darker, more muted color scheme which can be easier on the eyes, especially at night.

Here is what the Xojo IDE looks like in dark mode:

In order for your apps to support dark mode you’ll have to rebuild them with Xojo 2018r3 with its support for dark mode. Once you open your project in 2018r3 go to Shared Build Settings and turn on the Supports Dark Mode property:

Note: This property defaults to OFF for existing projects and ON for new projects.

This will automatically cause the Xojo built-in controls to switch to dark mode when you run your app in dark mode on Mojave. Here is Eddie’s Electronics running in dark mode:

For your own graphics and custom controls you may need to update your drawing code so that you use darker colors and icons when in dark mode. There is now a new IsDarkMode global method that you can check to see if your app is running in dark mode so that you can choose a different color or image.

The App.AppearanceChanged event is called when the user switches between light and dark modes or when the accent color changes. You can use this to tell your UI to update or redraw as necessary.

Read more about this change and others coming to Xojo graphics and the IDE in this post. To learn how you can update your apps to work in dark mode, refer to the Dark Mode topic in the documentation.

With Apple’s announcements at WWDC 2018 and the introduction of dark mode it was time to revisit our graphics and the overall appearance of the IDE again. Here are some things which contribute to the changes that have been made and ones that you will see in the coming months.

Dropping macOS 10.9

Xojo 2018r3 drops support for macOS 10.9 and as the last version which had the skeuomorphic design elements all of our supported OS’s now have the flatter modern design. It’s not that this has held anything up per se, but it’s a good reminder that “it’s time”. 

To that end, we have taken that opportunity to remove some of the graphics that make the IDE look out of place and doing so subtly lowers the memory footprint and accelerates drawing of the IDE itself across all platforms. We’re also using a variation of Apple’s image templates which has somewhat reduced the on-disk footprint of the IDE itself.

macOS Dark Mode

Apple’s addition of a darker variant of the visual “Aqua” theme in macOS means that we needed to do an audit and update of several of our base framework controls so that your apps would render correctly as well as ours. 

Events

While it probably won’t be used very often (how often does one change themes while running a piece of software, besides the novelty of seeing it happen), we added an event to the App class named AppearanceChanged to notify you when the user changes from light to dark or changes their accent color. This is a good place to clear any graphic or color caches which contain theme specific UI graphics. 

Methods

There is also a new global method called IsDarkMode(Boolean) which will return True if your app is running with the Dark Mode theme on macOS 10.14 or higher. If your app is running on 10.13 or lower or in light mode on 10.14, IsDarkMode will return False.

Build Settings

Enabling Dark Mode in your apps is as easy as flipping a switch in the Shared Build Settings. Unfortunately, because Apple made the assumption that most apps would “just work” versions of your apps compiled with older versions of Xojo will either need to be recompiled with Xojo 2018r3 or you’ll need to push out a new version with a plist entry to prevent macOS 10.14 from showing your app dark in Dark Mode. 

Testing

When testing apps for use with Mojave’s dark mode, I seriously suggest that you test on a system that allows you to see the translucency effects of dark mode. Virtual Machines are usually really handy for testing, but in this case, Parallels Desktop 14, VirtualBox 5.2 and VMWare Fusion 11 do not show the subtleties of dark mode.

Colors

One of our goals at Xojo is to remove some of the headaches involved with the minutiae of each OS that you deploy for and to that end, we wanted to make drawing custom controls easier too. What this means is that the built-in global colors are largely theme aware now and will change depending on whether your app is running in light or dark mode on macOS. This affects things like TextColor, FillColor, FrameColor, HighlightColor, etc, so if you use those methods when drawing in pictures and canvases, you will want to audit that code. If you want a specific color, you should use a color constant. For instance, use &c000000 if you want black because TextColor will now return white in Dark Mode. 

In terms of the framework controls themselves, we are taking this opportunity to make some changes to make your apps appear better in the macOS 10.10+ ecosystem. Ever notice that a Label control and the text portion of a CheckBox or RadioButton control are not exactly the same color? Going forward, the default colors of controls which should automatically change between Light and Dark modes will do that. So if you have a Label using the default color of &c00000000 (Black with Transparency = 0), the color that is actually used is what Apple calls labelColor. It’s still black, but is a tiny bit translucent. TextFields and TextAreas will automatically change text, placeholder, selection and background colors to match the Apple prescribed colors for automatic Light/Dark compatibly. We think you’ll find that building your apps with 2018r3 will largely make them just behave and appear the way you expected them to.

IMPORTANT NOTE: These color and framework changes affect how your apps draw on all versions of macOS, so make sure you try them out on your 10.10 through 10.14 VMs before shipping!

Eating our own dog food

One thing we hear from users every so often is the desire for Xojo to use our own products for building apps. As most of you know the IDE itself is written in Xojo, but we also have several other apps (big and small) that are written in Xojo.

• Feedback – Our bug reporting system
• Xorders – Our internal order system
• Lingua – The Xojo localization app
• Remote Debugger – The remote debugger stubs for desktop and console

While the 2018r3 cycle was in progress, all four of these projects got updated for Mojave’s Dark Mode and definitely helped us find framework rendering bugs early on in the pre-release process.

What about Windows and Linux?

The TL;DR version is that we’re still looking into it. 

Currently there are several different ways to change Windows 7, 8 and 10 to use a dark interface, not all of which are compatible with the Xojo Framework controls and the Windows 10 2018 Fall Update promised yet another way but that ended up only being for UWP. We are looking into which method gets you the most “bang for the buck” so to speak. 

Learn to code using Xojo and you can build apps for Mac, Windows and Linux, web apps, iOS apps and Raspberry Pi apps (and Android- it’s coming!). With the exception of iOS which requires a Mac, you can build for any platform we support from any platform we support. Want to build Windows apps for your friends from your Mac? That’s what Xojo is great at! Want to make your work day easier with a database app to track your inventory? Xojo’s great at that too!

One Thing to Learn

Xojo is a fully integrated development environment (IDE) – that means your code editor, build tools and debugger are all in Xojo. Learning to code can be challenging enough, you don’t need to also learn how to install and configure a bunch of tools before you even get started. In fact, customers have told us they were able to create their first Xojo app before the other development tools they were testing finished installing!

Free Introduction to Programming Book

Xojo has a free book, Introduction to Programming with Xojo, and it is a great way to start learning. The book walks you through programming and general concepts in a way that is easy to understand. You can download it in PDF or for iBooks. Plus there’s an iOS Addendum, a Raspberry Pi Book and a Teacher’s Guide.

Apply Your New Skills to Other Languages

The Xojo programming language is similar to other languages, such as Visual Basic or Java. Because Xojo is object-oriented, the skills you learn with Xojo are directly applicable to other languages, including Visual Basic, Java, C# and more.

Videos and Webinars

For those that learn visually, attend the Xojo webinars, hosted by Xojo Developer Evangelist Paul Lefebvre. The webinars cover a wide variety of topics, from beginner to advanced. Plus all the webinars are recorded for on-demand viewing anytime.

Be sure to check out the Getting Started playlist on the Xojo YouTube channel with videos such as:

• An Introduction to Developing with Xojo
• Introduction to Xojo and Xojo Cloud
• Creating a Desktop App Tutorial
• Creating a Web App Tutorial
• Creating a Desktop App using Xojo
• Creating a Web App using Xojo
• Introduction to Programming 101
• Introduction to Programming 201

Comprehensive Documentation

In addition to Xojo’s books, webinars and video library, we’ve got QuickStart Guides, Tutorials and a User Guide totalling over 900 pages. Divided into four parts to help simplify the learning process, the Xojo User Guide is a great resource for learning.

Still not sure where to start? Our How to Get Started with Xojo page can point you in the right direction.

Wonderful Community

Xojo is known for its friendly and approachable user community. The Xojo Forum is vibrant and active, and includes a Getting Started channel with lots of fellow Xojo Developers available to help answer questions along the way – though we recommend you take a moment to search to see if your question has already been answered first!

Free to Develop

Xojo is free for learning and development. Just create an account, download Xojo and use the resources listed above to start developing your app.

You can develop, run, test and debug all for free. When you are ready to compile your app, you can buy the right Xojo license for you.

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.

We’d love if you showed up ready to have some fun and learn something new at your local Code Day event with your new Xojo license! Starting Monday, May 19th and running through Sunday May 25th we’re offering students and teachers 30% off new Xojo licenses! Simply send me an email at custserv@xojo.com using your academic email address or include a picture of your current student ID and I’ll send you a coupon code for 30% off any new Xojo license! And don’t forget about Xojo’s free Introduction to Programming textbook and our new Teacher’s Guide!

Code Day is a special event, and this is the first time it will be celebrated across the United States. Please share this post and help spread the word about #CodeDay and codeday.org, let’s grow the Xojo community and encourage more coding across the world! Like they say at code.org, “Build something awesome in 24 hours!”