With Windows 10 version 1703, Microsoft introduced built-in ICU support, allowing applications to use the system provided ICU instead of bundling their own. By leveraging this, Xojo now benefits from automatic updates, a reduced app footprint, and improved compatibility with the latest Unicode and locale data.

Which parts of the framework use ICU?

One of the main areas where ICU is used is the DateTime class, which includes Locale and TimeZone support. This helps with formatting dates and times and handling timezone differences reliably. ICU is also used for number formatting and string manipulation, particularly when working with characters like emojis and other complex Unicode symbols.

What benefits can be observed?

• Fewer DLLs
• 45MB smaller app sizes
• Faster execution times, i.e. DateTime.Now is roughly 10% faster
• Daylight saving time no longer requires a rebuild of your Xojo app

What are the new requirements?

As mentioned, Windows began including prebuilt ICU libraries starting with Windows 10 version 1703, so your apps won’t run on earlier versions. However, if you’re using Windows Server 2019, you’ll need to be on at least version 1809.

Conclusion

By shifting to Windows’ built-in ICU libraries, Xojo has eliminated the need for manual ICU updates and reducing app file sizes. This change means your apps will always have the latest updates for date/time, locale, and character handling, thanks to Windows updates.

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

Enhanced Emoji Rendering

While Xojo’s Graphics class supported rendering emojis on Windows and Linux, their appearance was less appealing.

Now in Xojo 2024r2, we’ve enhanced emojis with vivid colors!

You’ll notice that other parts of the Xojo framework that utilize the Graphics class, such as the ListBox, have also benefited from this update.

Understanding Emojis at a Deeper Level

Understanding how emojis are encoded is crucial for grasping how Xojo’s String type works and how we interpret them. Any text or emoji displayed on the screen can be considered a Unicode sequence or a series of Unicode sequences. At a deeper level, a single Unicode sequence can be constructed from multiple Unicode code points (i.e., bytes of data). For clarity, we’ll describe one character (whether simple text or an emoji) as being composed of Unicode sequence(s).

To demonstrate, let’s try to understand the woman

This particular woman is not very complex, it is made up of one single Unicode sequence (with corresponding code points). Our String type can easily handle this one Unicode sequence and reports correctly that the Length of the String is 1 (even though the entire emoji is made up of 4 bytes of code points).

Now let’s take a look at a more complicated woman

The only difference visually is that this woman has fiery red hair. This subtle change in appearance means that to construct this emoji requires not 1, not 2, but 3 distinct Unicode sequences (with a grand total of 11 bytes of code points).

Note that the reported length of the String is 3 Unicode sequences, even though we visually see only one character. This distinction is very important in understanding how String functions work. Xojo’s String functions inherently deal with Unicode sequences, not individual characters. When you do need to work with complex emojis like these, you will want to utilize our String.Characters API which effectively manages this complexity.

An Optimized String.Characters

Given the prevalence of emojis in everyday text and messages, properly handling them within Xojo’s String type is crucial. While we initially introduced this feature as String.Characters, it functioned as an iterator until Xojo 2024r2. Now, String.Characters returns a String array, which can still be iterated, ensuring existing code continues to work as before. Additionally, this update offers the added advantage of significantly improved speed, especially on Windows and Linux. Along with this update, we introduced String.CharacterCount, which is useful when you need to know the number of characters in a string without storing them all in an array.

To further understand emojis and their corresponding Unicode sequences, check out this Full Emoji List.

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

For those of you that don’t consider reading through over 220 items as fun as I do, here are a few things I thought I would highlight, in no particular order.

• Desktop projects now save icon resources as compressed PNGs. This can greatly reduce binary/xml project file size and also reduce the .xojoresources file size in text projects. In the case of the Eddie’s Electronics sample project, the binary project dropped from 11MB to 780K, the XML project from 22MB to 1.1MB and the .xojoresources file from 11MB to 388K.

• Need to iterate through a String’s characters in a completely unicode-friendly way (including emojis)? Rather than using the String.Characters iterator, use the new String.Codepoints iterator which returns one value for each unicode scalar.

• You can now install Xojo on Windows ARM 64-bit. Xojo itself remains an Intel x86-64 binary, but Windows ARM has a translation system built-in that will allow Xojo to run. This should allow those of you using ARM Windows in a VM on an Apple Silicon Mac to use Xojo there. If you’re interested in native Xojo support for Windows ARM, subscribe to Feedback Case 62672 so you’ll be notified of updates.

• Auto-complete continues to get smarter and faster. It can’t quite write your code for you, but now it does a better job of substituting text and offering suggestions, among other things.

• The Code Editor has more improvements, particularly in the area of code folding. Another improvement is that you can use Go To Location to jump to a specific line in the code using “#50” (for example) in addition to the previously allowed “50”.

• For use with Declares, there is now an OSHandle class that can handle either an Integer or a Ptr.

• And although we mentioned it in another blog post, I’d still like to remind people that you can again build your Mac apps from Windows and Linux. Improvements in the open-source linker project used by Xojo allowed us to bring this feature back. Of course, please continue to test your Mac apps on an actual Mac before you ship them.

In computer programming, a constant is a value that cannot be altered by the program during normal execution, i.e., the value is constant.

In Xojo we have constants that can be defined in code or added to modules, classes, etc. What you’ll notice about Wikipedia’s definition of “constant” is that it’s a behavior, not a specific type.

There is another way to define a “constant” or “a value that doesn’t change throughout the run of your application”.

A computed property with only the Get method defined that returns the same value every time is also “constant” in that it won’t vary as your program runs. It just happens to be labelled as a “property” and is also referred to as a “read-only” property. But the reality is if you set up a computed property that returns the same value every time you essentially have a “computed constant”.

Consider using one the next time you need something like a String or Text that is a series of Unicode code points since you can’t define one in the Property or Constant Editors without a bit of work (i.e. you can’t just type in &u21BE or a bunch of unicode code points one after the other).

If there are other values that you need to compute at runtime but remain consistent throughout a run of your application this is a decent way to make that happen.

There are some downsides because this is not a constant as far as the language is concerned. You cannot use it in these ways:

• as a compile time check using #if
• as part of another constant expression
• as a default parameter value
• as a default property value
• as a declare library name

There may be other situations as well.

If you truly need an actual constant type, the alternative is to go to unicode.org and copy and paste the symbols into the Constant Editor. This is a little more work but lets you define a true constant that is a bunch of Unicode code points.