Rapid Application Development – Xojo Programming Blog

Checking Out Xojo Libraries

Paul Lefebvre — Tue, 09 Dec 2025 16:29:31 +0000

The ability to create a compiled Library with Xojo has been a long-requested feature. Starting with 2025 Release 3, Library support is now available as a preview. Here’s more information about what it is and how you can use it.

What is a Library?

A Library is a collection of pre-written, reusable code containing methods, classes and UI. Up until now, the way to distribute a Library for use with Xojo was to create a Plugin or to manually re-use project items across projects. Both have pros and cons.

Plugins are compiled and do not expose source code, but plugins cannot be created using Xojo itself and are typically created using C/C++ along with the Xojo Plugin SDK. Sharing project items is fine for internal projects or open-source projects, but less ideal for commercial libraries. They can be harder to manually add to a project and are recompiled along with the project, slowing the debug process.

With a Xojo Library, you can now create your own compiled Library using Xojo itself. This Library can contain nearly any Xojo project item and can be easily used in other Xojo projects because it is distributed as a single file.

At a high-level, you create your Library in Xojo, add your project items to it and built it into a Library package file. Other projects can then use this Library package, which gives them access to the items you included in the Library.

Creating a Library

Here is a brief overview of how you create a Xojo Library:

In a Desktop, Web, Console or iOS project add a Library by choosing Insert->Library.
Add the project items you want to the Library. Any Xojo project item is supported, except for Worker.
Build the project. It will build the main app (which should serve as a test app for your Library) and a separate Library package file (with extension .xojo_library).
You can put this Library package alongside another project (on the drive) and it will be loaded when that project is opened by Xojo. You can then use the classes, methods and UI contained in the Library within your project. If you instead put the Library in the Plugins folder, then it will be available for all projects.

This is all best demonstrated by a quick example. Go ahead and create a Desktop project and add a Library to it, which adds a Library1 project item to the Navigator. Change its name using the Inspector to LibHello.

While LibHello is selected, choose Insert->Class. This adds Class1 to it. This new class is now part of the Library. With Class1 selected, change its name to StringStuff.

You can now add whatever methods or properties you want to the class. For our example purposes here we will add a simple method that reverses a string.

Public Function ReverseString(s As String) As String
  Var newString As String
  
  For Each c As String In s.Characters
    newString = c + newString
  Next
  
  Return newString
End Function

The Library could contain many other things of course, but to keep things simple this Library will have just the single class with its single method. Here’s what it looks like in the project:

The first thing to do is to test this Library ReverseString method. Add a button to Window1 and have it call the function, verifying the result.

Var stuff As New StringStuff
Var result As String = stuff.ReverseString("Xojo")

MessageBox(result)

When you run, you can see the output:

So far this is all not much different than you would normally be doing with a Xojo project. The next step is to create the Library package for use by other projects.

In the Build Settings area, select Shared. This is where you can enter some information about the Library that can be seen by those that use it.

In the Version field, enter “1.0”.
In the Copyright field, enter “Acme, Inc.”
In the Description field, enter “A Xojo Library test.”

Also in the Build Settings area, check the boxes for the platforms you want the Library to work on. In most situations, you will want to select macOS, Windows and Linux.

Now click Build. This builds the app as usual, but also creates a separate Library package file (LibHello.xojo_library for this example) that can be used with other projects.

Using a Library

Now that you’ve created your Library package, you can use it with other Xojo projects. The Library built above was created within a Desktop project, so it can only be used with other Desktop projects. So the first thing to do is to create a new Desktop project (call it MyTest), save it and close it.

Once it is saved, go to Finder or Explorer and place a copy of the LibHello.xojo_library file (from its build location) alongside this saved project file.

Go back to Xojo and open the MyTest project. The project will open normally, but the Library will also be loaded up as well. You can see this by showing the Xojo About window and going to the Plugins & Libraries tab. There you will see the Library name along with the information you entered about it earlier. (Double-click on the Library row to show the description.)

Going back to the MyTest project, you can now use the Library with it. Add a button to the window and have it call the StringReverse function the same way you did before:

Var stuff As New StringStuff
Var result As String = stuff.ReverseString("Xojo")

MessageBox(result)

Now run the project and it will use the class and its method just as if it is part of the project.

That’s the basics of how to create and use a Library. You can of course include whatever you want in the Library, but as with any library it is usually a good idea to keep things well-organized.

Considerations

A Library package (which uses ZIP) contains compiled code and definitions of the public API in that code.
Only a single Library project item can be added to a project when developing.
A project can use any number of Library packages.
For a built library to work on all OS platforms, then those platforms must be selected before building it.
Libraries only support 64-bit builds.
Library packages are placed alongside the project file and are loaded when the project is loaded.
Library packages can also be placed in the Plugins folder. These libraries will be loaded separately for each project.
If items in your Library have dependencies outside the Library, then the Library package will not be usable in another project without those dependencies. For example, if a Library class method references a class in the main project, then it will build without an error (because the main project is available), but if you use that Library in another project you will get linker errors.

Why a Preview?

We are referring to this initial version of Xojo Libraries as a preview release because it is very new and we want to give more developers a chance to test with it so we can iron out issues. We encourage you to try moving your existing reusable code collections over to a Library to help test, while also improving your workflow. If you have any open-source projects that are essentially a Library, you might try building them into a Xojo Library package as well.

You can make Library packages available publicly, but you should probably tag them as a preview, beta or test version until we remove the preview label.

Read more about Libraries in the Xojo Documentation. Check out these open-source projects on GitHub that have recently been updated for API 2.0 and now have a Library that you can download from the Releases section:

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.

Year of Code 2025: October Project – Multi-Platform Communication

Gabriel Ludosanu — Mon, 13 Oct 2025 19:01:53 +0000

For October’s Xojo Year of Code 2025, I built MPACSocket, a tiny, reusable UDPSocket subclass that enables zero-config, local-network presence and chat across platforms. It wraps binding, broadcast, presence beacons, peer tracking, and JSON parsing into a single class with a clean event-based API. Drop it into Desktop projects and you’ve got instant LAN discovery and messaging.

What this project includes

A self-contained UDPSocket subclass (MPACSocket) that handles bind, presence broadcasting, peer pruning, and chat envelopes with versioned JSON (good for further updates to the protocol).
Simple API: Start(port), Stop(), Rename(name), SendChat(text). Everything else comes through events like Bound, ChatReceived, PeerOnline/PeerOffline, PeerUpdated, StatusChanged, and SocketError.
A sample DesktopWindow (wndMPAC) that wires MPACSocket to a transcript area and peers list.

How to use

Add MPACSocket to your project, drop it onto a DesktopWindow or instantiate in code.
Set DisplayName, call Start(62636), and listen to events to update your UI or console output.
Use SendChat to broadcast a message; presence beacons and peer tracking happen automatically.

Download

You can download the entire Xojo project from GitHub

This project shows how a small, well-scoped class can turn low-level UDP into a friendly, cross-platform building block. Feel free to adapt the events or JSON schema for your own protocols.

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

Year of Code Project

How to Play:

Each month we’ll announce a new theme and share an example project of our own. Share your projects to the Xojo Forum thread for that month via GitHub (all the links you need are posted above ↑ ). Learn how to use Xojo and GitHub.

The Prizes:

Monthly winners get $100 at the Xojo store. Every month you submit a project is another chance to win the grand prize. The grand prize is $250 cash plus a Xojo Pro license and a year of GraffitiSuite and will be announce in December. Learn more about the prizes.

User-Centric Mobile Apps Design Principles for Developers

Gabriel Ludosanu — Thu, 06 Feb 2025 16:00:00 +0000

Ever felt overwhelmed by the sheer complexity of designing a mobile app that not only works but also delights users? As a solo developer, you’re juggling multiple roles—designer, developer, marketer, and more. It’s easy to feel stretched thin, especially when it comes to crafting an intuitive and visually appealing app design. Don’t worry, you’re not alone in this struggle. Many indie developers face the same challenge. The good news? With the right design principles and strategies, you can create mobile apps that look great, function seamlessly, and leave a lasting impact on your users.

In this article, we’ll explore actionable, real-world design principles tailored to the unique needs of solo developers. Whether you’re building your first app or looking to improve your design skills, this guide will give you the tools and confidence to create apps that stand out in today’s crowded market.

Why Design Matters for Solo Developers

Before diving into specific principles, let’s address a fundamental question: Why is design so crucial for solo developers? The answer is simple—Users judge your app within seconds, forming quick impressions that impact their decision to continue using it. A poorly designed app drives users away, no matter how powerful its functionality is. Good design, on the other hand, builds trust, enhances usability, and keeps users coming back.

Start with a minimum viable product (MVP): Focus on the core functionality and get it into users hands quickly.
Gather feedback: Use surveys, app store reviews, or in-app feedback tools to understand what users like and dislike.
Refine based on data: Analyze user behavior (e.g., which features are most used) and improve accordingly.

Example:

When developing a language learning app, you might discover that users struggle with navigation. Based on feedback, simplify the menu structure or add tooltips to guide new users.

Tools to Simplify Design for Solo Developers

As a solo developer, you don’t need to reinvent the wheel. Leverage tools that streamline the design process:

Figma: A powerful design tool for creating wireframes and prototypes.
Xojo: Xojo’s drag-and-drop interface, combined with its easy-to-learn language, makes creating mobile apps across different form factors straightforward.
Canva: Great for creating simple, clean graphics for your app.

Conclusion: You’ve Got This!

Designing a mobile app as a solo developer is no small feat, but by following these principles, you can create apps that are both functional and enjoyable to use. Remember to start with your users in mind, focus on simplicity and clarity, and continuously refine your work based on feedback.

Your Next Step: Take a look at your current project (or start a new one!) and apply at least one of the principles discussed in this article. Need a mobile app development platform? Check out Xojo for an intuitive, developer-friendly way to bring your app ideas to life.

Xojo for 4D Developers

Geoff Perlman — Tue, 10 Dec 2024 23:35:07 +0000

If you are a longtime 4D developer you may recognize my name because I worked for 4D, Inc. (then ACIUS, Inc.) back in the early 1990s, as well as authored a book about 4D. But my experience with 4D goes back even further to 1987 when I began using 4D to build database applications for consulting clients. Over time I found the need to build more general purpose applications. This ultimately resulted in my founding the company that has become Xojo, Inc. and developing and publishing what is now Xojo for the last 28 years. Now, with my credentials out of the way, let’s talk about what Xojo can offer 4D developers.

Like 4D, Xojo has a drag and drop user interface builder, a Code Editor, a Debugger and a Compiler as well as a cross-platform framework. While 4D now has an object-oriented language as an option, Xojo has always been object-oriented. The language is a dot syntax not unlike Javascript. You do not have to become an experienced object-oriented programmer to use Xojo. One of its strengths is that you can learn incrementally.

Xojo supports database application development but there are differences between how it and 4D handles that. 4D has its own database engine and query syntax. Xojo supports SQLite, PostgreSQL, MySQL and ODBC for accessing databases. Unsurprisingly it uses SQL as its query syntax. Because 4D is solely designed for database application development, it ties the user interface you create to tables in the database. Xojo does not. 4D’s model prevents you from having to write code to get data from database records in and out of your user interface. While by default Xojo does not provide this, it provides an add-on called DBKit which assists you in connecting to and interacting with databases.

Xojo supports desktop development for Linux, macOS, Windows and Raspberry Pi (Linux on ARM). It supports web development as well and mobile development for iOS and Android. You can also build console apps which can be handy when you need an app with no user interface to run on a server. Xojo uses native controls and compiles to native machine code for x86 and ARM. Whether you come to Xojo to build desktop, web or mobile apps, you’ll find that 95% of what you learn and the code you write will be applicable to all targets. With the exception of iOS (which because of Apple’s requirements must be built from a Mac) you can build your apps from any platform to any platform. Xojo also includes a Remote Debugger which allows you to build from one operating system and run on another. For example, you might do your development on macOS but want to debug on Windows to track down a Windows-specific issue. With the Remote Debugger, this is quite easy.

Xojo is free to use for development. You only purchase a license when you need to deploy. This is a developer license, not a deployment license. That means that you can deploy as many applications as you like to as many users as you like, without any additional cost. Each developer purchases their own license. A Xojo license comes with 12 months of updates. The new Xojo releases available during your license period continue to be available to you even after your license expires. Renewing your license gets you another 12 months of updates. If you only need to deploy cross-platform desktop applications, the Xojo Desktop license is $399USD. Yearly updates are also $399USD. If you wish to build for any platform we support, the Pro license is $799USD. Yearly updates are also $799USD. Compare licenses and find more pricing details at our webstore.

If you’d like to give Xojo a spin, I recommend starting with the QuickStart and then the full tutorial. After that, check out DBKit, the video and its tutorial which will make it easier to build database-oriented applications. These are the desktop tutorials but there are also tutorials for mobile and web application development. Because Xojo is a general, cross-platform development tool rather than one specifically for database applications, what you build with it is truly limited only by your imagination. If you have any further questions, please reach out to us. Our user forum is also filled with experienced and enthusiastic Xojo users that answer and have answered hundreds of questions. And the Xojo Blog has many posts on database development with Xojo.

Geoff Perlman is the Founder and CEO of Xojo. When he’s not leading the Xojo team he can be found playing drums in Austin, Texas and spending time with his family.

Xojo Web Rescues a .NET Project

Wayne Golding — Wed, 23 Oct 2024 16:40:14 +0000

I had a call recently from a customer whose upstream supplier informed them that they would not be accepting anything less than TLS 1.2 encryption. The customer’s application is written using .NET 1.1 (they are testing a new version but aren’t ready to deploy to production just yet). Their supplier insisted on a 1-week time limit. Can I help?

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.

Spotlight On: LX Aer

Alyssa Foley — Wed, 14 Aug 2024 15:50:42 +0000

Spotlight On posts focus on Xojo community members. We’ll use this space to tell the stories of people using Xojo, share amazing Xojo-made apps and spread awareness of community resources. If you have an app, a project or a person you want to see featured in Spotlight On, tell us about it!

LX Aer is an AI-powered educational platform developed by student-turned-entrepreneur Leo Medvinsky. In 2020 as the pandemic forced schools to begin using remote learning tools, Leo, a student at the time, saw the gaps and the flaws in the tools he was offered and did what so many Xojo developers do, he decided to build something better. A quick view of LX Aer demonstrates it’s the solution someone who actually uses such a system would create. LX Aer is a modern take on the LMS with a user interface that centers the student and teacher. Currently, LX Aer uses Xojo Web for the backend and the project has 30,000 lines of Xojo code and growing.

10 Questions with Leo Medvinsky of LX Aer

Using Xojo Web for just the backend (web services) is somewhat surprising, tell us about that?

The LX Aer web app is designed to be the digital hub for students, teachers, and soon, administrators. The original web app was written in between 2020 and 2021 and used Xojo Web for some web service work but was mainly used the conventional way for Xojo Web pages. To increase speed and reliability as well as to improve performance, the decision was made that our next product (a standalone attendance tracking system) would be written using Xojo Web as a backend, with a Xojo iOS app and a standard HTML/CSS/JS web app to accompany it. We found that Xojo Web was a great way for us to have business logic on the backend, with great performance and amazing ease of management with Tim Parnell’s Lifeboat. When, in 2022, we were unifying this attendance system into the LX Aer suite, it was decided that the LX Aer suite would be combined into the attendance technology stack, rather than the other way around. This was a large time investment as it involved rewriting and rethinking significant portions of the existing product offering but has brought our software to a much stronger position.

What is your experience with Xojo Web performance for larger scale apps like LX Aer?

Up until recently, when we began self-hosting most things, we had two instances of the LX Aer Backend running on a Debian server in AWS with just 2 GB of RAM and performance was very good. We are actively developing solutions to allow for much greater scalability and distribution of load across not just instances (with Lifeboat), but across several different servers. Our database server runs CubeSQL, and Marco and I have been discussing ways to implement database sharding into CubeSQL to allow for greater scalability. While we are a startup without too many users right now, LX Aer needs to be able to support the thousands of users each school brings, along with all of their data requirements.

Can you tell us why Xojo was chosen as the backend and what other options were ruled out?

My first programming language was Visual Basic .NET. The original software I had was a simple quizzing application designed to help the user study for tests, but it could only run on Windows. This was a significant limitation. I (mostly) loved the syntax of VB compared to other languages I’ve worked with (Python, C++, Swift…), so I decided to try Xojo when I came across it in 2020. It was an amazing feeling to be able to write with the syntax I already knew to and make an iOS app, albeit a limited one, the same day I downloaded Xojo. Having experimented with Xojo, I started working on major projects in it very soon, and when a web development need came up, it was my go-to. Over the years, I have considered many alternatives, and many in the developer community (not Xojo’s) have discouraged me from relying on a proprietary language for such critical software, but I have never had any interest in switching. Every step of the way, Xojo has scaled with our needs.

Mac, Windows or Linux?

I flip-flop constantly between my dev machine, a Mac, and my business machine, a Surface. I tried many Linux distros on several occasions and have never been much of a fan of it as a consumer operating system.

What do you wish more people would ask/talk to you about when it comes to LX Aer?

Security. LX Aer’s tagline is “Security, Reliability, Innovation.” Notice how “security” comes first. While the Aer Intelligence platform offers incredible AI tools built into LX Aer to improve educational outcomes, and this is one of the largest attention grabbers, I would argue that security is our most interesting innovation. Having graduated from high school just over a year ago, I recall when I found my student data leaked online after a massive breach of PupilPath, a learning management system that my school used at the time. I also recall the school I transferred to for my senior year and the software they used, Genesis, which allows a user to view their own password in plaintext after logging on. This, among other things, motivated me to always put security first. In 2023, we launched LX SecurShield, which provides encryption for student data WITHOUT storing keys on the server, while still allowing a user to seamlessly log on from any device, without any of the hassle typically associated with client-side encryption. LX SecurShield is truly unique and is something I wish more people took an interest in.

How would you explain your most recent project to a 5-year-old?

LX Aer is creating an AI chatbot that will help teachers teach and students learn!

What’s next on your “Learn Next” list?

Tough question… maybe French?

What programming moments made you think “Wow, I love my job so much”?

I’ve always been technically minded, but I have seen it as a means to an end, rather than the end itself. I never wrote code for the sake of writing code. I always had a long-term project in mind. LX Aer has been a project of mine for over 4.5 years, and has changed immensely from March 2020, when it first began. Consequently, the programming moments that made me think how much I love my job were when I was able to finally push an innovation over the edge into a working state. When I was developing LX SecurShield, it required significant portions of LX Aer to be rewritten to support the new encryption. After developing a proof of concept, I worked almost nonstop for close to a week to develop it into a usable and stable state, with several all-nighters along the way. At the end of it all, I thought, “wow, I love my job so much, even with all the craziness associated with it!”

What is something that has surprised you about coding in the last 10 5 years?

10 years ago, I was 8 and had no experience writing code (though I was still the go-to tech support for my friends/family). This is a tough question, but if I had to pick it would be the difference in writing code for someone else vs. writing code for your own company. Writing code for someone else is 1,000x more difficult than writing code when you’re your own boss. As for something in the industry itself, I am always surprised by the tendency of web developers to jump around from platform to platform… Angular, React, etc. It just fascinates me.

What is a piece of software more people should know about?

To those in the Xojo community writing a web service, I cannot recommend Tim Parnell’s Lifeboat and Marco Bambini’s CubeSQL enough. To anyone working with cryptography, Björn Eiriksson’s Einhugur plugins are just incredible!

To people in general, I think it would be great if more people knew about Proton. They’re a Swiss company that develops mail, cloud storage, calendar, VPN, and password storage software, all of which uses client-side encryption and is easy-to-use. They were my inspiration for LX SecurShield.

What’s something you worked on recently that you are excited about?

It would be somewhat cliché to say that I am excited about AI (Aer Intelligence), but I am. Especially in the EdTech industry, I see so much potential for it to improve educational outcomes and make lives easier for overworked teachers. With our software having won the Pitchfest award at the prestigious Future of Education Technology Conference this year, I believe, largely because of our AI capabilities, I think it isn’t just the LX Aer team that’s excited about AI in education.

Thank you to Leo Medvinsky for answering our questions. If you want to learn more about LX Aer visit https://www.lxaer.com/. To all those in the Xojo community, as a token of gratitude, Leo is offering a free license until December 31^st, 2024. Email sales@lxaer.com and say that you’re part of the Xojo community! “Although I have not been very active in the Xojo community in terms of engagement,” Leo says, “without the exceptionally great resource that is the Xojo Programming Forum, as well as the software and plugins made by those in the community, such as Tim Parnell, Marco Bambini, Christian Schmitz, Björn Eiriksson, and Sam Rowlands, none of this would have been possible.” See the full LX Aer Xojo community credits at https://www.lxaer.com/credits.

How Xojo Simplifies Full-Stack Development for Everyone

Gabriel Ludosanu — Wed, 07 Aug 2024 17:30:00 +0000

The demand for skilled full-stack developers continues to grow in 2024. These developers handle both the frontend and backend of applications, ensuring a smooth user experience from start to finish. As businesses strive to deliver robust, efficient and visually appealing applications, developers and their choice of programming tools can impact the speed, scalability and overall performance of a full software solution.

Presented with choosing what development tool is best for your main, full-stack development needs, let’s discuss the benefits of Xojo development platform for your next web project. With its simplicity, flexibility, and powerful features, Xojo will help you create high-quality web applications quickly and efficiently, with the added bonus of covering backend and frontend development in the same IDE—no more language switching—while also lowering your overall costs.

Overview of Full-Stack Development

Full-stack development covers the entire spectrum of technologies and skills required to create a fully functional web application. This approach involves both the frontend, which users interact with directly, and the backend, which powers the application.

At its core, full-stack development refers to the ability to work on both the client-side and server-side of an application. This means that full-stack developers should be proficient in frontend technologies such as HTML, CSS, JavaScript, as well as backend technologies like Node.js, Python, and frameworks such as React and Django. Full-stack developers possess a broad skill set that includes designing user interfaces, managing databases, and server logic, enabling them to oversee the entire development process.

Usually, a full-stack developer handles:

Frontend Technologies: These consist of HTML for structure, CSS for styling, and JavaScript for interactivity, crucial for crafting engaging user interfaces. Frameworks such as React, Angular, and Vue.js are also typical choices for building dynamic web applications.
Backend Technologies: This segment covers server-side programming languages like Node.js, Python, Ruby, and PHP, coupled with frameworks such as Express, Django, and Ruby on Rails, essential for robust backend development. Databases, both relational (e.g., MySQL, PostgreSQL) and NoSQL (e.g., MongoDB), are also crucial for data management.
APIs (Application Programming Interfaces): APIs enable simple communication between frontend clients and backend applications/servers, facilitating the exchange of data. RESTful APIs and GraphQL are common approaches used in modern web applications.

Advantages in adopting a full-stack approach in software development:

Faster Development Cycles: With a single developer or a small team capable of handling both frontend and backend tasks, projects can progress more quickly, reducing the time to market.
Easy Integration: Full-stack developers have a comprehensive understanding of how the different components of an application interact, leading to better integration and fewer compatibility issues.
Enhanced Problem-Solving: By possessing a complete view of the application, full-stack developers can identify and resolve issues more efficiently, improving overall project quality.

Why choose Xojo as a full-stack development solution?

When it comes to full-stack development, selecting the right programming language(s) or frameworks can significantly impact the efficiency and effectiveness of your projects. Xojo is a powerful choice for anyone seeking a robust, user-friendly and versatile development environment that provides everything needed to transform their ideas into fully fledged, working software products, no matter the platform or environment.

Xojo features ideal for full-stack development:

Built-in Web Server: Xojo has its own built-in web server that allows developers to easily test and deploy web applications (on Linux or Windows servers) without the need for additional software. There is no need to set up complicated web server technologies or deal with compatibility issues and security. Xojo handles all of that for you. In production, you can run a web app built with Xojo as stand-alone or behind Apache or Nginx. You decide what works best for your project.
Visual Development Environment: Xojo offers a visual development environment that allows developers to design user interfaces using drag-and-drop elements. This approach simplifies the process of creating appealing applications, accessible to both novice and experienced developers.
Object-Oriented Programming: Xojo is object-oriented programming (OOP), enabling developers to create modular and reusable code. OOP encourages better organization and maintainability of applications, making it easier to scale projects over time.
Compiled Code: Xojo compiles code into machine code, which results in fast and efficient web applications. In the event that some bad actors gain access to your server, rest assured that Xojo built web apps are more secure than those built with other tools.

In addition to these features, while many programming languages cater to full-stack development by combining and utilizing multiple external solutions, Xojo distinguishes itself as an ideal, singular solution. Compared to languages like JavaScript, Ruby, PHP or Python, Xojo has a gentle learning curve, making it an attractive option for beginners. Its syntax is straightforward and resembles natural language, which helps new developers learn concepts quickly. Xojo’s visual tools and drag-and-drop features enable developers to prototype applications rapidly. This is particularly advantageous for startups and businesses looking to iterate and launch products quickly.

Xojo for Frontend Development

Creating an engaging and user-friendly frontend is crucial for any web application. With Xojo, developers can quickly prototype and design visually appealing interfaces without the need for 3rd party tools or additional frameworks.

Xojo’s visual development environment makes building user interfaces an easy and enjoyable thing. With its drag-and-drop interface, developers can easily design and layout their GUI components- buttons, labels, and text fields- without needing any code at all. This intuitive approach allows developers to focus on the logic of the application rather than getting bogged down by low-level details.

So, what makes Xojo’s frontend capabilities so effective? For starters, it allows frontend developers to quickly:

Prototype and test ideas without writing code;
Easily create complex layouts and designs;
Focus on the logic of the application rather than the UI;
Collaborate more effectively with designers and other team members.

Example: A simple web app frontend built with Xojo

To illustrate the power of Xojo’s visual development environment, let’s take a look at a simple web app frontend built using Xojo. In this example, we’ll create a basic to-do list application with a user-friendly interface without writing any HTML, CSS or JavaScript code.

This ToDo web app design can be quickly prototyped in under 10 minutes with Xojo.

Coding Backend Functionality and Connecting it to the Frontend

While users interact with the frontend of apps, it’s the backend that does the heavy lifting, handling data and core functionality. Xojo makes building these backend systems easier for developers with useful features that create efficient server-side applications without unnecessary complexity. Xojo is a practical choice for developers who want to build solid, functional backends for web (and even desktop or mobile) apps without getting bogged down in overly complicated processes. Here are some notable aspects:

Database Integration: Xojo supports out-of-the box connections to a variety of databases, including MySQL/MariaDB, PostgreSQL, SQLite, and ODBC. Besides the built-in database classes, now there’s also the DBKit project and the new DatabaseConnection project item.
RESTful API Creation: Xojo makes it easy to create RESTful APIs, which are essential for enabling communication between the frontend and backend of a web application. By defining endpoints and handling HTTP requests and responses, developers can facilitate data exchange and enhance the interactivity of their varied applications and clients (web, desktop or mobile).
Session Management: Managing user sessions is crucial for web applications, especially those that require user authentication. Xojo provides built-in support for easy session handling, allowing developers to track user activity and maintain state across different pages, improving the overall user experience.

Integrating the Frontend and Backend

Full-stack development works best when the frontend and backend of an app work well together. Xojo makes this easier by offering a single app development software solution for both parts. Developers can use the same programming language throughout the whole project, which saves time and reduces complications. This approach helps programmers focus on creating a smooth user experience without switching between different tools or languages.

Here are some key points worth taking into account when you want to start building your next successful application:

Unified Language for Development: One of the standout features of Xojo is that it allows developers to work in one programming language, eliminating the need to switch between multiple languages like HTML, CSS, or JavaScript. This means that both the frontend and backend logic can be implemented using Xojo’s straightforward syntax, streamlining the development process, no matter the OS platform they’re building for.
Single Integrated Development Environment (IDE): Xojo’s IDE serves as a centralized hub for managing both frontend design and backend coding. Developers can design user interfaces visually, drag and drop elements, and simultaneously write the corresponding backend code without needing to leave the IDE. This integration enables a more intuitive workflow, reducing the chances of errors and inconsistencies.

As the demand for agile and efficient software development continues to rise, the choice of programming language solutions and frameworks can have a significant impact on both project timelines and budgets. Xojo stands out as a compelling alternative for developers and teams accustomed to traditional stacks like LAMP (Linux, Apache, MySQL, and PHP) or MEAN (MongoDB, Express.js, Angular, and Node.js) or any other.

For organizations and startups already familiar with other development stacks, transitioning to Xojo can lead to significant savings in training costs. Xojo’s intuitive interface and single programming language approach mean that team members can quickly adapt without needing extensive retraining. This is especially beneficial for companies looking to onboard new developers or expand their teams. And as an extra plus, using Xojo, you can expand your application supported platforms to include building native desktop clients (Mac, Windows, Linux) or mobile clients (iOS, Android) , all with just one codebase.

And let’s not forget that managing a full-stack application typically involves maintaining multiple technologies, which can result in higher operational costs. Xojo minimizes the need for additional languages and frameworks, resulting in lower maintenance overhead costs and increased efficiency in full-stack development. Updates, debugging, and scaling become more straightforward, allowing teams to allocate resources more effectively.

Is it fair to call Xojo not just a great full-stack development suite but a full-stack development suite that truly optimizes the entire development process and maximizes productivity?

Download and start using Xojo for free!

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

Tutorial: Create QR Codes with vCard Information

Javier Menendez — Mon, 05 Aug 2024 14:41:37 +0000

It’s the 21st Century and it’s possible to share contacts with other people directly from your mobile phone, but let’s face it, business cards are still a very common way to share personal contact information.

For some years now, it has been common for cards to include a QR code that corresponds to the contact details so that, when scanned, they can be added directly to the Address Book on a device or computer.

This tutorial creates an app that generates QR codes with the embedded information in vCard format. Additionally, learn how to to export that file in vCard format and, if you want, include an image like a contact photograph or logo.

Download Xojo and install it on your computer just as you would do with any other application on your operating system of choice (macOS, Windows or Linux).

Once Xojo is installed, launch it and select Desktop in the Choose a Project window. Enter the desired name for this application, as well as the name of the company, etc. You can leave the values presented as default or change them to those of your choice.

Designing the User Interface

This is the process that will likely take us the longest (with the most steps required). Through this process we will see how to use the Container control to our advantage to compartmentalize different aspects of the UI and also the logic associated with each of these components. Let’s get started!

Personal Data Container

Click the Library button to access the library that displays all of the user interface controls included by default in Xojo for Desktop projects.

Locate the Container control and drag it onto the Project Navigator. This is the vertical area on the left side of the IDE window where all the elements added to the project are displayed.

When you release the control over the Project Navigator you will see that it is added as a new component and the associated Inspector Panel will appear in the right area of the IDE window. Change the following values using the Inspector Panel:

Name: PersonalInfoContainer
Width: 374
Height: 302

With the PersonalInfoContainer control still selected in the Navigator, access the Layout Editor for that control by clicking on the Library icon again. Locate the GroupBox control and double-click on it so it is automatically added to the Layout Editor for the container. Use the following values in the associated Inspector Panel:

Left: 0
Top: 0
Width: 374
Height: 302
Locking: Close the four locks
Caption: Personal Information

Next we will add both the labels and the text fields on the GroupBox1 control so the user can enter the data from which both the vCard and the QR will be created with said information.

Add Label and TextField controls from the library so the user interface looks like this:

Select all the Label items and change the following attribute in the Inspector panel (the change will be applied to all the selection):

Text Alignment: Right

Next, enter the following values for each of the Labels, selecting them one by one from the top to the bottom:

Label1

Name: NameLB
Text: Name:

Label2

Name: SurnameLB
Text: Surname:

Label3

Name: CompanyLB
Text: Company:

Label4

Name: TitleLB
Text: Title:

Label5

Name: PhoneLB
Text: Phone:

Label6

Name: MobileLB
Text: Mobile:

Label7

Name: EmailLB
Text: Email:

Label8

Name: WebLB
Text: Web:

Next, select each of the Textfields, starting from the top, and enter the following values in the inspector panel associated with each of them:

TextField1

Name: NameTF
Locking: Close the left, top and right locks.

TextField2

Name: SurnameTF
Locking: Close the left, top and right locks.

TextField3

Name: CompanyTF
Locking: Close the left, top and right locks.

TextField4

Name: TitleTF
Locking: Close the left, top and right locks.

TextField5

Name: PhoneTF
Locking: Close the left, top and right locks.

TextField6

Name: MobileTF
Locking: Close the left, top and right locks.

TextField7

Name: EmailTF
Locking: Close the left, top and right locks.

TextField8

Name: WebTF
Locking: Close the left, top and right locks.

When you’re done, the PersonalInfoContainer’s user interface will look like this:

Postal Address Container

We’re done with the design of the container that will be used to enter the personal information data. Now, add a new Container to the Project Navigator and select it to access the associated Layout Editor.

Use the Inspector Panel to change the following values:

Name: PostalContainer
Width: 398
Height: 212

Next, double-click the GroupBox control in the Library to add it to the new container, and change the following values using the associated inspector panel:

Left: 0
Top: 0
Width: 398
Height: 212
Locking: Close the four locks.
Caption: Postal Address:

Like we did in the previous container, this time add a total of five labels and as many text fields. The result should be similar to this:

Align all labels to the right, just like we did with the previous Container. Then, from top to bottom, modify the following properties for each of them:

Label1

Name: StreetLB
Text: Street:

Label2

Name: PostcodeLB
Text: Postcode:

Label3

Name: CityLB
Text: City:

Label4

Name: ProvinceLB
Text: Province:

Label5

Name: CountryLB
Text: Country or Region:

And change the following values in the inspector panel for each of the TextFields, also from top to bottom

TextField1

Name: StreetTF
Locking: Close the left, top and right locks.

TextField2

Name: PostalCodeTF
Locking: Close the left, top and right locks.

TextField3

Name: CityTF
Locking: Close the left, top and right locks.

TextField4

Name: ProvinceTF
Locking: Close the left, top and right locks.

TextField5

Name: CountryTF
Locking: Close the left, top and right locks.

Once completed, the layout for the PostalContainer container will look similar to this:

Completing the UI Design

With the design of the two containers completed, it is time to add them to the main window of the project (Window1), as well as some remaining controls.

Start by selecting the Window1 item in the Navigator to display it in the Layout Editor. Next, drag the PersonalInfoContainer container and drop it onto the top of the right side of the window in the Layout Editor. It should look like this:

With the Window1 item still selected in the Navigator, it is a good time to change some of its properties in the associated Inspector:

Width: 600
Height: 604
Minimum Width: 600
Minimum Height: 604
Maximum Width: 600
Maximum Height: 604
Title: QR From vCard – vCard Export

Now, select the PostalContainer container and drop it just below the PersonalInfoContainer container in the Layout Editor for Window1. The result should look like this:

As you can see, the PostalContainer1 container is slightly wider than the PersonalInfoContainer1 item. Select the latter in the Window1 layout editor and use the left middle handle to drag it to the left until the alignment guide appears. This will mean that both containers are aligned.

Now, continue adding the necessary controls to finish the UI:

An ImageWell control to display the image selected by the user for the vCard.
A button that, when pressed, allows the user to select the image to use in the vCard.
An ImageWell control that displays the preview of the QR generated from the vCard.
A button that, when pressed, allows you to create the QR from the vCard as well as assign the resulting image to the preview control.
A button that, when activated, allows the QR to be exported as an image file in PNG format.
A button that, when pressed, generates the vCard as a file with the selected name and location.
A last button that, when pressed, resets the UI to its default values.

Selecting the Contact Image

The contact image selected by the user will be added as part of the vCard generated as a file but not to the QR code because it does not have enough room to accommodate such a large amount of information.

To do this we need to add two controls to Window1: an ImageWell and a Button. Start by adding an ImageWell control to the top left area of the Window1 window in the Layout Editor:

Use the inspector panel associated with that control to change the following values:

Name: PersonPreview
Left: 20
Top: 20
Width: 150
Height: 150

Next, drop a Button control just below the PersonPreview and use the associated inspector panel to modify the following values:

Name: OpenPictureBT
Left: 20
Top: 182
Width: 150
Height: 20
Caption: Open Picture…

The result should look something like this:

QR Preview and Export

Now, continue with the UI items corresponding to the QR code preview and the buttons to create it, export the QR or export the vCard.

Drop a new ImageWell control from the library onto Window1 in the Layout Editor and modify the following attributes in the associated inspector panel:

Name: QRPreview
Left: 20
Top: 304
Width: 150
Height: 150

Add a button just below QRPreview and use the following values in the associated Inspector Panel:

Name: CreateQRBT
Left: 20
Top: 466
Width: 150
Height: 20
Caption: Create QR

Add a new button under CreateQRBT and modify the following values in the inspector panel:

Name: ExportQRBT
Left: 20
Top: 498
Width: 150
Height: 20
Caption: Export QR
Enabled: Desactivado

Add a new button just below ExportQRBT and modify the following values in the inspector panel:

Name: ExportVCardBT
Left: 20
Top: 530
Width: 150
Height: 20
Caption: Export vCard

Add the last of the required buttons, just below the PostalContainer1 container and use the following values in the inspector panel:

Name: ClearBT
Left: 500
Top: 562
Width: 80
Height: 20
Locking: Close the bottom and right locks.
Caption: Clear

We have completed the UI design! This is how it should look:

Adding Functionality to the PersonalInfoContainer

It’s time to add the code (functionality) to each of the components that need it. Start with PersonalInfoContainer, select it in the Navigator. With PersonalInfoContainer1 selected, choose the Insert > Method menu option and use the following values in the associated inspector panel:

Method Name: GetPersonalInformation
Return Type: String
Scope: Public

Adding the following code in the Code Editor associated with the newly added method:

Var fullName As String = Nametf.Text + " " + SurnameTF.Text

Var returnedValues() As String

If fullname.ReplaceAll(" ", "") <> "" Then returnedValues.Add("FN:" + fullName)
If SurnameTF.Text <> "" Or nametf.Text <> "" Then returnedValues.Add("N:" + SurnameTF.Text + ";" + NameTF.Text + ";;;")
If CompanyTF.Text <> "" Then returnedValues.Add("ORG:" + CompanyTF.Text + ";")
If TitleTF.Text <> "" Then returnedValues.Add("TITLE:" + TitleTF.Text)
If PhoneTF.Text <> "" Then returnedValues.Add("TEL;Type=HOME:" + PhoneTF.Text)
If MobileTF.Text <> "" Then returnedValues.Add("TEL;Type=CELL:" + MobileTF.Text)
If EmailTF.Text <> "" Then returnedValues.Add("EMAIL;Type=INTERNET;type=WORK;type=pref:" + EmailTF.Text)
If WebTF.Text <> "" Then returnedValues.Add("URL:" + WebTF.Text)

Return String.FromArray(returnedValues, EndOfLine)

As you can see, the code for this method is pretty easy to follow. Basically, only the fields in the vCard whose TextField contains values (i.e. are not empty) will be added to the ReturnedValues array. Similarly, and to keep the code as short as possible, this tutorial does not perform any kind of validation on the entered data.

Add a new method to PersonalInfoContainer that will be responsible for cleaning up the UI of that container; use the following values using the Inspector associated with the new method:

Method Name: Clear
Scope: Public

And type the following code in the associated Code Editor for the Clear method:

For Each ctl As DesktopUIControl In Self.Controls
  If ctl IsA DesktopTextField Then
    DesktopTextField(ctl).Text = ""
  End If
Next

As you can see, this code loops through all the controls in the PersonalInfoContainer and uses the IsA keyword to check if the iterated control is a DesktopTextField. If it is, it then casts the iterated control to the DesktopTextField class to access its Text property and assign to it the empty string value (“”).

Add Functionality to the PostalContainer

Select the PostalContainer container in the Project Navigator. You will see that the functionality is very similar to that added in the previous one.

Create a new method and use the associated panel to change the following values:

Method Name: GetPostalInformation
Return Type: String
Scope: Public

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

Var returnedValue As String
Var inputValues() As String

inputValues.Add(StreetTF.Text)
inputValues.Add(CityTF.Text)
inputValues.Add(ProvinceTF.Text)
inputValues.Add(PostalCodeTF.Text)
inputValues.Add(CountryTF.Text)

Var address As String = String.FromArray(inputValues, ";")

If address.ReplaceAll(";","") <> "" Then returnedValue = "ADR;type=WORK:;;" + address

Return returnedValue

As you can see, it is very similar to the one above. The result will be the one corresponding to the “ADR” field of a vCard.

Add a second method with the following values in the inspector panel:

Method Name: Clear
Scope: Public

And write the following code in the associated editor:

For Each ctl As DesktopUIControl In Self.Controls
  If ctl IsA DesktopTextField Then
    DesktopTextField(ctl).Text = ""
  End If
Next

In this case, the code is the same as the one used in the previous container when “resetting” its UI to the initial values.

Add General Functionality to the Window

Select Window1 in the Project Navigator and add a method using the following values using the Inspector Panel:

Method Name: GenerateVCARD
Parameters: forVCardExport as Boolean = False
Return Type: String

And type the following code in the associated Code Editor:

Var vCard() As String
vCard.Add("BEGIN:VCARD")
vCard.Add("VERSION:3.0")
vCard.Add(PersonalInfoContainer1.GetPersonalInformation)
vCard.Add(PostalContainer1.GetPostalInformation)
If PersonPreview.Image <> Nil And forVCardExport Then
  vCard.Add("PHOTO;ENCODING=BASE64;TYPE=JPEG:" + getPersonImage)
End If
vCard.Add("REV:" + GetRevisionTime)
vCard.Add("END:VCARD")

Return String.FromArray(vCard, EndOfLine)

Add a second method with the following values:

Method Name: GetRevisionTime
Return Type: String

And type the following lines of code in the associated code editor:

Var current As DateTime = DateTime.Now
Var currentToUTC As DateTime = New DateTime(current.SecondsFrom1970 - current.Timezone.SecondsFromGMT)

Return currentToUTC.Year.ToString + currentToUTC.Month.ToString + currentToUTC.Day.ToString + "T" + currentToUTC.Hour.ToString + currentToUTC.Minute.ToString + currentToUTC.Second.ToString + "Z"

Add the last of the general methods and use the following values in the Inspector:

Method Name: GetPersonImage
Return Type: String

Next, enter the following code into the associated editor:

Var returnedValue As String

Const kWidth as Double = 120
var pHeight as Double

If PersonPreview.Image <> Nil Then
  
  pHeight = (kWidth * PersonPreview.Image.Height) / PersonPreview.Image.Width
  
  Var tempPic As New Picture(kWidth, pHeight)
  tempPic.Graphics.DrawPicture(PersonPreview.Image, 0, 0, kWidth, pHeight, 0, 0, PersonPreview.Image.Width, PersonPreview.Image.Height)
  
  Var mb As MemoryBlock = TempPic.ToData(Picture.Formats.JPEG)
  
  returnedValue = EncodeBase64(mb)
  returnedValue = returnedValue.ReplaceLineEndings("")
End If

Return returnedValue

Adding Specific Functionality to Controls

We just need to add the functionality that will be executed when the different buttons are pressed. Start by selecting ClearBT in the Project Navigator then select the “Add to ‘ClearBT’ > Event Handler…” option in the context menu. Choose the Pressed event in the resulting window and confirm the selection so that this event is added to the control.

Now, enter the following code in the code editor associated with the Pressed event of the ClearBT control:

PersonPreview.Image = Nil
QRPreview.Image = Nil
ExportQRBT.Enabled = False

PersonalInfoContainer1.Clear
PostalContainer1.Clear

Add the Pressed event to the CreateQRBT control and type the following code in the associated code editor:

QRPreview.Image = Nil

Var theCard As String = GenerateVCARD

Try
  Var p As Picture = Barcode.Image(theCard, 600, 600)
  
  If p <> Nil Then
    QRPreview.Image = p
    ExportQRBT.Enabled = True
  Else
    ExportQRBT.Enabled = False
  End If
  
Catch e As UnsupportedOperationException
  
  MessageBox("Unable to Create QR" + EndOfLine + EndOfLine + "Probably the provided data exceeds the available room for a QR.")
  
End Try

Add the Pressed event to the ExportQRBT control and enter the following code in the associated code editor:

If QRPreview.Image <> Nil Then
  
  Var f As FolderItem = FolderItem.ShowSaveFileDialog("", "ExportedQR.PNG")
  
  If f <> Nil Then
    
    QRPreview.Image.Save(f, Picture.Formats.PNG)
    
  End If
  
End If

Add the Pressed event to the ExportVCardBT control and enter the following code in the associated Code Editor:

Var theCard As String = GenerateVCARD(True)

Var f As FolderItem = FolderItem.ShowSaveFileDialog("", "Exported.vCard")

If f <> Nil Then
  Var tos As TextOutputStream = TextOutputStream.Create(f)
  
  tos.Write(theCard)
  tos.Flush
  tos.Close
End If

Add the Pressed event to the OpenPictureBT control and type the following code using the associated Code Editor:

PersonPreview.Image = Nil

Var f As FolderItem = FolderItem.ShowOpenFileDialog(SupportedImageFormats.All)

If f <> Nil Then
  PersonPreview.Image = Picture.Open(f)
End If

Files Filtering

As you can see, in the second line of the above code we reference the SupportedImageFormats.All object as a parameter to filter the type of files that the user can select.

To do this, add a new File Type Group from Insert > File Type Group. With the newly added item in the Project Navigator selected, click the leftmost button in the toolbar to add the “image/jpeg” entry. Repeat this to add “image/png” as well.

Finally, in the inspector panel change the name of the item to SupportedImageFormats. Once finished, it should look like this:

Let’s Go!

Now the design and the functionality of our app are both completed! Let’s run it and do some tests. Try selecting a contact image (or not), filling in any of the fields, generating the associated QR and exporting it … or exporting the vCard file directly so that you can import it from any compatible application (for example, Contacts on macOS).

Of course, you can expand and complete this small example: from introducing validations for the fields that require it, increasing the number of fields so that the vCard also includes any other fields supported by the standard, etc.

Conclusion

As you have seen, generating both the vCard and the QR that contains contact information does not require a large amount of code. Best of all, with Xojo, you can check a box and cross-compile your app for macOS, Windows and Linux.

Happy Xojo Coding!

Javier Menendez is an engineer at Xojo and has been using Xojo since 1998. He lives in Castellón, Spain and hosts regular Xojo hangouts en español. Ask Javier questions on Twitter at @XojoES or on the Xojo Forum.

New Database Connections

William Yu — Wed, 26 Jun 2024 15:00:00 +0000

While Xojo has always supported adding database connections, the old method was far from ideal. Let’s delve into the improved approach using the new Database Connection project items and explore some recent additions to our database API.

Out With The Old

The old database connections were quite limiting, requiring you to create a new connection and re-enter all the parameters whenever one changed. With our new Database Connection items, you can now easily update specific connection parameters directly in the inspector.

Additionally, you can now choose whether the item will auto-connect or if you prefer to connect to it later in your code.

Connecting to a Specific Database

There are times when you need to connect to a database for debugging and testing, but for the final builds, you want to connect to your production database/server. Setting this up correctly with the old database connection method required creating two separate connection items—one for debug and one for release. With the new Database Connection items, this process is much simpler and fits more easily into the build process. You now have several new Database Connection subitems that can be customized based on the stage of your build. These subitems are linked to the Stage Code in your Shared Build Settings, ensuring that when you build a final release, your database connection uses the correct settings automatically.

Additional Database Features

In addition to this change, there are two new database APIs that may be useful to you:

A new method, IsConnected, has been added to the SQLiteDatabase, ODBCDatabase, PostgreSQLDatabase, and MySQLCommunityServer classes. This method returns true if the connection is still active, and false if it is not.
We’ve enhanced Database.AddRow with a new signature that returns the unique ID of the newly inserted row. This feature is supported for SQLiteDatabase, ODBCDatabase, PostgreSQLDatabase, and MySQLCommunityServer classes. It is recommended to use this new API instead of the deprecated SQLiteDatabase.LastRowID and MySQLCommunityServer.LastInsertedRowID

Let’s explore how the new Database.AddRow feature can assist you. Previously, only SQLiteDatabase and MySQLCommunityServer had APIs to retrieve the unique ID of the last inserted row. Now, PostgreSQLDatabase and ODBCDatabase also have this capability by using the new Database.AddRow(tableName As String, row As DatabaseRow, idColumnName As String = "") As Integer

The new aspect of this signature is the idColumnName parameter and the return value. For databases that support the SQL RETURNING clause, the idColumnName specifies the column whose value will be returned. For databases that do not support the RETURNING clause, we will use the suitable method for each specific database to return a unique value.

We recognize the significance of databases in your Xojo apps. So with these updates to database connectivity for your desktop, web and console apps, and the addition of new features, we aim to make your database programming easier and more efficient.

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.

A Beginner’s Guide to Handling Text Files in Xojo

Gabriel Ludosanu — Wed, 29 May 2024 15:33:40 +0000

As developers, we often need to work with text files. This could be for reading configuration settings, parsing log files, or generating reports. Text files are a common part of software development, and knowing how to access and manipulate them is important for building strong and flexible Xojo applications.

In this article, we will make use of the key Xojo classes and techniques for working with text files. We will start by looking at how to read the contents of text files using the TextInputStream class. You will learn how to read an entire file into a string and how to process the file line-by-line.

Next, we will cover writing to text files using the TextOutputStream class. You will see examples of how to write a complete string to a file and how to write individual lines one-by-one, useful when logging information or saving user preferences.

By the end of this post, you will understand the core techniques for accessing, reading, and writing text files in your Xojo applications. These skills will help you build more robust and flexible software that can work with a wide range of data sources and formats.

Reading Text Files

When it comes to reading the contents of text files in Xojo, the TextInputStream class is the primary tool you’ll use. This class provides methods for both reading the entire file at once, as well as reading it line-by-line.

Using TextInputStream to Open and Read Text Files

Here is an example that demonstrates how to read an entire file into a string:

// Step 1: Open the File
Var file As FolderItem
file = FolderItem.ShowOpenFileDialog("text/plain") // Show an open file dialog to select the file

If file <> Nil Then
  // Step 2: Create a TextInputStream
  Var inputStream As TextInputStream
  inputStream = TextInputStream.Open(file)
  
  // Step 3: Read the File
  Var fileContents As String
  fileContents = inputStream.ReadAll
  
  // Step 4: Close the Stream
  inputStream.Close
  
  // Output the file contents (for demonstration purposes)
  MessageBox(fileContents)
Else
  MessageBox("No file selected.")
End If

In this example:

The FolderItem.ShowOpenFileDialog method is used to display a file dialog, allowing the user to select a text file.
The TextInputStream.Open method opens the selected file for reading.
The ReadAll method reads the entire contents of the file into the fileContents string.
The Close method closes the TextInputStream.

This approach is useful when you need to process the entire contents of a text file at once. However, for larger files, you may want to read the file line-by-line to manage memory usage more efficiently, which we will cover in the next section.

Using TextInputStream to Read Line-by-Line

Reading a file line-by-line is often more efficient, especially for large files. This method allows you to process each line individually, reducing memory usage and enabling you to handle large datasets more effectively.

Here is an example that demonstrates how to read a file line-by-line in Xojo:

// Step 1: Open the File
Var file As FolderItem
file = FolderItem.ShowOpenFileDialog("text/plain") // Show an open file dialog to select the file

If file <> Nil Then
  // Step 2: Create a TextInputStream
  Var inputStream As TextInputStream
  inputStream = TextInputStream.Open(file)
  
  // Step 3: Read Each Line
  Var line As String
  While Not inputStream.EndOfFile
    line = inputStream.ReadLine
    // Process each line (for demonstration purposes, we'll just output each line in a MessageBox)
    MessageBox(line)
  Wend
  
  // Step 4: Close the Stream
  inputStream.Close
Else
  MessageBox("No file selected.")
End If

This approach is particularly useful when you need to process or analyze each line of a text file individually, such as when parsing log files or reading configuration settings.

Writing Text Files

Writing text files in Xojo is just as straightforward as reading them. The TextOutputStream class allows you to write data to text files, either all at once or line-by-line and it’s quite easy.

Using TextOutputStream to Write Entire Files

To write an entire string to a file, follow these steps:

// Step 1: Allow the user to set the path and name of the text file we are about to create
Var file As FolderItem
file = FolderItem.ShowSaveFileDialog("text/plain", "example.txt") // Show a save file dialog to specify the file

If file <> Nil Then
  // Step 2: Create a TextOutputStream
  Var outputStream As TextOutputStream
  outputStream = TextOutputStream.Create(file)
  
  // Step 3: Write to the File
  Var fileContents As String = "Hello, Xojo!"
  outputStream.Write(fileContents)
  
  // Step 4: Close the Stream
  outputStream.Close
  
  MessageBox("File written successfully.")
Else
  MessageBox("No file specified.")
End If

In this example:

The FolderItem.ShowSaveFileDialog method is used to display a save file dialog, allowing the user to specify the file name and location.
The TextOutputStream.Create method creates a new file or overwrites an existing file.
The Write method writes the fileContents string to the file.
The Close method closes the TextOutputStream.

Using TextOutputStream to Write Line-by-Line

Writing a file line-by-line is useful when you need to write data incrementally or when dealing with large datasets.

To write a file line-by-line, follow these steps:

// Step 1: Allow the user to set the path and name of the text file we are about to create
Var file As FolderItem
file = FolderItem.ShowSaveFileDialog("text/plain", "example.txt") // Show a save file dialog to specify the file

If file <> Nil Then
  // Step 2: Create a TextOutputStream
  Var outputStream As TextOutputStream
  outputStream = TextOutputStream.Create(file)
  
  // Step 3: Write Each Line
  Var lines() As String = Array("Line 1", "Line 2", "Line 3")
  For Each line As String In lines
    outputStream.WriteLine(line)
  Next
  
  // Step 4: Close the Stream
  outputStream.Close
  
  MessageBox("File written successfully.")
Else
  MessageBox("No file specified.")
End If

In this example:

The FolderItem.ShowSaveFileDialog method is used to display a save file dialog, allowing the user to specify the file.
The TextOutputStream.Create method creates a new file or overwrites an existing file.
The WriteLine method writes each line from the lines array to the file.
The Close method closes the TextOutputStream.

By understanding these methods, you can choose the one that best fits your needs. Writing the entire file at once is useful for smaller datasets or when you need to write all data simultaneously. Writing line-by-line is more efficient for larger datasets or when you need to write data incrementally.

Conclusion

This article has provided you with the skills to handle text files in Xojo using the TextInputStream and TextOutputStream classes. We covered the following essential techniques:

Reading Text Files:

Reading entire files into a string using TextInputStream.ReadAll
Reading files line-by-line using TextInputStream.ReadLine

Writing Text Files:

Writing entire strings to a file using TextOutputStream.Write
Writing lines to a file using TextOutputStream.WriteLine

Try applying these techniques in your own projects. Experiment with different methods to see how they can help you manage text files more effectively. The official Xojo documentation on working with text files is a great resource for further reading.

Ready to get started? Download Xojo for free and begin building your applications today!

Happy coding!

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

The One Person Framework for the Rest of Us

Paul Lefebvre — Thu, 02 May 2024 14:00:00 +0000

The technology and development world is always changing. First released in 1998, Xojo’s longevity is a testament to its ability and willingness to adapt from the early days of desktop apps, to web apps and on to mobile apps.

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

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

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

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

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

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

Desktop Apps

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

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

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

Web Apps

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

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

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

Mobile Apps

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

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

Console Apps

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

Xojo Framework

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

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

Could Xojo Work For You?

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

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

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

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

Free Xojo Linux and Raspberry Pi for Everyone

Xojo — Tue, 26 Mar 2024 15:26:18 +0000

Beginning with Xojo 2024r1 you can use Xojo’s free IDE to build Linux desktop and console apps from Linux, macOS, or Windows, no license required.

Xojo Linux is Free

We have made building for Linux free and included in the Xojo IDE! This means that on Linux you get a version control ready IDE, along with the ability to build desktop and console Linux apps (including Raspberry Pi), all for free. Launch Xojo 2024r1 (or any later release of Xojo) and open any desktop or console project, go to Build Settings, select Linux and in the Inspector choose the appropriate Architecture that matches the Linux OS you want your app to work on, either ARM or x86. Click Build to compile your project to a standalone app that you can then run on Linux – no license required.

Wrapping Up

All these changes were made based on feedback from the Xojo community and to better match the changing ways that people develop and share software projects. With this change Xojo continues its dedication to supporting Linux.

Download Xojo to get started.

Edited 07/2025 to reflect changes to licensing.

Webinar Follow-Up: Using Xojo to Develop NetSuite Web Apps

Tim Dietrich — Wed, 28 Feb 2024 21:53:39 +0000

Last week, I presented the third in a series of Xojo / NetSuite webinars. The latest webinar was “Using Xojo to Develop NetSuite Web Apps” webinar, and it follows “Using Xojo to Develop NetSuite iOS Apps” (from January) and “Using Xojo to Develop NetSuite Android Apps” (from last December). This blog post is a follow-up to last week’s “Web” webinar – “Using Xojo to Develop NetSuite Web Apps” – a recording of that webinar is available here.

Downloading the Xojo Project

The Xojo project that we developed during the webinar is available for download here:

https://tdietrich-opensource.s3.amazonaws.com/Xojo/Xojo%20NetSuite%20Web%20Demo%20-%2020240222.01.zip

In the zip file, you’ll find the project and a “Readme” file that includes instructions on how to set things up (including SuiteTalk REST, a custom NetSuite role, an integration record, etc).

I suggest downloading the project, setting up NetSuite, and running the project. Then look at how the project was built during the webinar – the objects, methods, and constants that I added, and so on. After you’re familiar with the project file, experiment with it. Maybe try modifying the project so that instead of providing access to Order Status information, it provides access to Item information instead (quantity available, pricing, etc).

If you run into any problems, or have questions, please feel free to email me (timdietrich@me.com). Another resource for more general Xojo questions is the Xojo Programming Forum.

I want to thank everyone that attended the webinar, as well as Geoff and the Xojo team for the opportunity to present. I hope that the webinars have increased your awareness of and interest in Xojo, and especially in using Xojo to develop apps that integrate with NetSuite.

Tim Dietrich develops custom software for businesses that are running on NetSuite. He makes extensive use of Xojo to develop mobile, desktop, Web apps, and more – all of which integrate seamlessly with NetSuite. To learn more, visit: https://timdietrich.me

Webinar Follow-Up: Using Xojo to Develop NetSuite iOS Apps

Tim Dietrich — Mon, 29 Jan 2024 16:00:00 +0000

Last week, I presented the second in a series of Xojo / NetSuite webinars, Using Xojo to Develop NetSuite iOS Apps. You can watch that webinar here. During the webinar, I demonstrated a Xojo-based iOS mobile app that integrates with NetSuite. This blog post is a follow-up to the webinar.

Downloading the Xojo Project

The Xojo project that I demonstrated can be downloaded here. In the zip file, you’ll find the Xojo project file and a “Readme” file. The Readme file includes step-by-step instructions on setting up SuiteTalk REST, a custom NetSuite role, an integration record, and more.

The SuiteQL Query

During the webinar, I spent some time discussing the SuiteQL query that’s used to lookup items based on the keywords that a user enters. I mentioned that there’s a lot of variation between NetSuite instances, both in terms of how they’re configured and customized. That makes NetSuite development both challenging and interesting.

As a result of the variation between NetSuite instances, you may need to modify the SuiteQL query based on how your NetSuite instance is configured. In the Xojo project, you’ll find that the query is stored as a constant named “SuiteQLQuery,” and it’s an attribute of the ListView screen.

The query uses the REGEXP_LIKE condition, which I discussed recently in this blog post. If you’re not already familiar with REGEXP_LIKE, then you might want to read up on it. Also, in the query I’m using the TO_CHAR function to format the “first column Base Price” as currency. Specifically, in the query, you’ll see this: TO_CHAR ( COALESCE( MAX( Price ), 0 ), ‘fmL99G999D00’ ). If you’d like to learn more about the TO_CHAR function and the format model modifiers that it supports, visit: https://docs.oracle.com/cd/B19306_01/server.102/b14200/sql_elements004.htm#SQLRF00216

Our Next Webinar

Our next Xojo / NetSuite webinar will be held on Thursday, February 22nd at 1PM CT (US). I’ll demonstrate how you can use Xojo to develop a Web app that integrates with NetSuite. To signup, please visit Xojo’s Webinar page. And finally, I want to thank everyone that attended the webinar, as well as Geoff and the entire Xojo team for the opportunity to present.

Xojo for Students

Xojo — Thu, 25 Jan 2024 13:00:00 +0000

Xojo is a programming language and development environment for creating cross-platform applications for macOS, Windows and Linux from whatever computer you use – Mac, Windows or Linux. You can also create web, iOS, Android and Raspberry Pi apps with Xojo. To empower students, Xojo has partnered with GitHub to offer Xojo Pro to all students in the GitHub Student Developer Pack. In addition to Xojo, the Pack includes tons of free tools to help students expand their technical knowledge and learn new skills.

Students looking to begin their journey into programming choose Xojo for its ease of use and dedication to cross-platform development. Plus, Xojo is true rapid app development and is ideal for building prototypes and mockups really fast. All of these features benefit from Xojo’s OOP-focus. Xojo also has an active and helpful community and years worth of free, on-line resources.

Ease of Use from App Design to Build

Xojo is known for its user-friendly and visual development environment. It employs a drag-and-drop interface, which can be helpful for students who are new to programming and those who want to rapidly prototype software without delving into complex coding. Xojo is efficient, featuring a streamlined development process and extensive feature set, you can create applications fast without sacrificing quality or functionality. Xojo is based on object-oriented programming principles. Learning OOP through Xojo can provide students with a solid foundation in programming concepts that are widely applicable in the software development industry.

Multiplatform Development for Windows, macOS, Linux, mobile, & web

Xojo is incredibly versatile. Whether you’re interested in desktop, mobile, or web application development, you can built it with Xojo. With its cross-platform capabilities, you can even build applications that run on multiple platforms from a single code-base. This can be particularly valuable for students working on a MacBook but needing app for a Windows machine or vice-versa. Write your app once and compile it for macOS, Windows and Linux.

Rapid Application Development for Prototypes and Mockups

Xojo is designed for rapid application development (RAD), making it an ideal choice for students who need to create functional applications quickly. Students can use Xojo to build practical, real-world applications. This hands-on experience can be valuable for learning and demonstrating software development skills, especially for those working on the design and usability aspects of software development.

Community and Resources

Xojo has an active community and offers resources, including documentation, tutorials, and forums. Students can benefit from this support when learning and troubleshooting. With an active and friendly community of developers, top-notch support team and extensive documentation and tutorials, you’ll always have the help and resources you need to succeed. Learn at your own pace, and have access to the support you need to overcome challenges along the way.

No matter why you choose Xojo, whether for its simplicity, cross-platform capabilities, rapid development or community and resources, Xojo is a valuable tool for learning programming and software development concepts. Xojo is a great place to start when building or looking to expand your development toolkit.

Download Xojo

Remote Debugger: How to debug your app on any computer

Geoff Perlman — Fri, 19 Jan 2024 13:00:00 +0000

At one time or another we all experienced it. The app you created works beautifully and your users heap praise upon it. Then, a particular user reports that some part of the app (or the entire app) doesn’t work on their computer. Other users with the same type of computer, same OS version, etc., do not experience the same issue. After scratching your head and thinking to yourself that the fault perhaps lies with the user, you create a special version of your app just for that user with MessageBox commands and/or various points in the code logged to a text file. This will give you the answer as to why your app is failing just for that one user. Alas, your digital spelunking reveals nothing. If only you could run your app in debug mode on their computer.

Remote Debugger

With Xojo, you can. Let’s talk about Xojo’s aptly named Remote Debugger. In the instance above, that particular user can install Xojo’s Remote Debugger app on their computer. You and your users can find the app included in the Extras folder of the Xojo download. After your user installs, launches and sets the Options in the Remote Debugger app, you can connect to that user’s computer by adding a connection to it in the Debugging pane of the Settings dialog box in the Xojo IDE on your computer.

Press the Add button, choose a name, add the user’s IP address and the password they created for the Remote Debugger app. If the user is just barely remote (on your local network for example), the Add dialog that appears will show local Remote Debuggers, making the process even easier. If this is the case, you can click on the user’s machine from the list without having to ask them for the their IP address.

It gets a bit complicated if you and the user are not on the same network. That’s because their router has to be configured to allow the connection to get through to their computer. That can be complex and potentially not allowed by their network administrator. The easiest solution in these cases is to use a service such as ZeroTier or Tailscale that creates a secure, private network which effectively puts you both on the same network making it a breeze to connect. (Both of ZeroTier and Tailscale have a service tier that is free.)

Once you’ve added the remote debug host, you can choose Project > Run Remotely and then choose that host to begin the connection. When you do this, your computer will compile a debug version for the computer and OS running on that remote user’s computer. It will then send that build to their computer and launch it. The app will then connect back to your Xojo IDE’s Debugger! You can then debug just as you normally would. Have the user try various functions as you watch what they are doing using screen sharing of some kind. When it drops in to the Debugger, you can step through the code, look at the values of variables and properties, etc., just as you do when debugging on your local computer. In cases like this, it can take a frustrating, painful debugging experience and make it nearly stress-free. In minutes you’ll be staring at the line of code that just wasn’t expecting the user to do what they did.

Also, the remote computer doesn’t have to actually be remote. For example, the Remote Debugger is handy for debugging on local virtual machines or other computers on your desk. It lets you keep your project where it belongs (where you keep it on your computer) while debugging in an OS running somewhere else.

So the next time you wish you could just debug on another computer or virtual machine, remember Xojo’s Remote Debugger! Watch a 13 minute video on Xojo’s Remote Debugger to learn more.

Learn more in the Xojo Docs

Webinar Follow-Up: Using Xojo to Develop NetSuite Android Apps

Tim Dietrich — Tue, 19 Dec 2023 22:06:09 +0000

Last week I was thrilled to present Xojo’s “Using Xojo to Develop NetSuite Android Apps” webinar (watch the webinar). I want to thank everyone who attended, as well as Geoff and the entire Xojo team for the opportunity. It’s always nice to be able to introduce new developers to the Xojo platform.

This blog post is intended as a follow-up to that webinar. In it, I hope to provide some additional information that we didn’t have time to cover, answer some of the questions that came up during and after the webinar, and also provide a link to the Xojo project that we created during the webinar.

Downloading the Xojo Project

The Xojo project that we developed during the webinar is available for download here. In the zip file, you’ll find the project and a “Readme” file that includes instructions on how to set things up (including SuiteTalk REST, a custom NetSuite role, an integration record, etc).

My advice is to download the project, setup NetSuite, and run the project. Then look at how the project was built -the screens, methods, and so on. After you’re familiar with the project file, experiment with it. Perhaps try modifying the project so that instead of providing access to Items it provides access to Employees instead.

If you run into any problems, or have questions, please feel free to email me (timdietrich@me.com). Another great resource for your general Xojo questions is the Xojo Programming Forum.

Have fun!

Questions & Answers

Do you prefer to use RESTlets instead of SuiteTalk REST? If so, why?

Yes, I much prefer using RESTlets in all of my NetSuite integration projects. With RESTlets I have more control over the functionality that the API provides, and more control over how the responses are formatted. Also, my experience has been that RESTlets are slightly faster than SuiteTalk REST.

That being said, SuiteTalk REST does have some advantages over RESTlets. For example, SuiteTalk REST provides endpoints that you can use to get metadata, which is something that is often difficult to do with a RESTlet. But perhaps the biggest advantage of SuiteTalk REST is that, unlike RESTlets, there is nothing extra that needs to be installed in your NetSuite account. It’s simply a matter of enabling it.

You mentioned some NetSuite customer statistics in your presentation. Can you repeat those?

Sure. During his SuiteWorld keynote presentation this year, Gary Wiessinger (SVP of NetSuite Application Development) mentioned NetSuite’s growth in terms of the number of customers that are using NetSuite. So as of October 2023, 37,000 customers are using NetSuite, and that represents 324,000 organizations. And those customers are located in 219 countries and territories.

As a Xojo developer, how can I get started with NetSuite?

You should first try to get access to a NetSuite account that you can experiment with. Unfortunately, that’s not as easy as it is with other platforms (such as Salesforce or ServiceNow), where they provide developers with test accounts. My advice would be to reach out to a local NetSuite partner, and see if you can build a relationship with them, and try to get their help in getting started.

After the demo, you mentioned another Xojo project that extends the Android functionality. What was that?

It’s called Android Design Extensions, and there’s a great blog post about it here. Read multiple posts about Android Design Extensions on the Xojo Blog.

Wrapping Up

Thanks again for your interest in Xojo and in using it to develop apps that integrate with NetSuite. I hope you’ve found the webinar and the Xojo project to be helpful.

Happy holidays!

Android Design Extensions 2.0 for Xojo 2023r3 and Later

Martin T. — Tue, 12 Dec 2023 14:30:00 +0000

Half a year has passed since the introduction of Android as a new target in Xojo 2023r2 and hundreds of framework and compiler bugs have been fixed and new features introduced. This is also the case in the latest Xojo release 2023r4. So it’s time to take the Android Design Extensions to a new level and release version 2.0 with over 80 new extensions. This version works with Xojo 2023r3 and late releases.

Highlights and New Features in Android Design Extensions 2.0.

Buttons can now have borders in different thicknesses and colors. Use the SetStrokeColorXC and SetStrokeWidthXC extension methods for this. You can also use the same properties for the Android MobileDateTimePicker. You can also set the color of the button when it is clicked: SetRippleColorXC .

The colors of sliders and progress bars can now be set dynamically via the extension methods SetProgressBackgroundTintListXC and SetProgressTintListXC.

Would you like to display the top bar of an app, where the time and battery status are displayed, in a dark color instead of white? No problem. The MobileScreen method SetSystemBarsAppearanceXC will help you. The Android Design Extensions sample app shows you how to use it.

The background color of individual segments of a MobileSegmentedButton can now also be set dynamically with SetBackgroundColorAtXC.

MobileTabPanel now supports the display of badges. You can set the color, position, and number of a badge individually.

Would you like a little more for the MobileTextArea? With the SetTextFromHtmlXC method, you can output formatted HTML content in the MobileTextArea.

MobileTextFields also experience a push forward with the latest Android Design Extensions. You can now show a clear button or, if it is a password field, show and hide the password. The name of the helper here is SetEndIconModeXC. You can also set the border color and border thickness of text fields. SetBoxStrokeWidthXC, SetBoxStrokeColorXC, and SetBoxBackgroundColorXC are the methods to be used.

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 here.

Happy Coding.

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

Simplicity and Security, Xojo Cloud is Ideal Hosting for Xojo Web Apps

Xojo — Mon, 30 Oct 2023 16:00:00 +0000

Xojo Cloud is the premier hosting solution for developers looking for a reliable, secure and high-performance hosting environment for Xojo web applications. Xojo Cloud is developed specifically for Xojo web applications and offers a range of benefits for you and your applications that make it worth the investment.

Xojo Cloud is optimized for Xojo applications. It is specifically designed to provide the best possible performance and stability for Xojo web applications. We optimize Xojo Cloud for performance, so your web apps will run smoothly and seamlessly. You can even monitor server stats from within the Xojo IDE.

Xojo Cloud is focused on simplicity and ease of use and requires zero configuration. Designed with the Xojo developer in mind, Xojo Cloud’s Control Panel makes it easy to deploy and manage web applications. Purchase a server, open a web project in Xojo and click Deploy to upload and install to Xojo Cloud. Not just for web apps, Xojo Cloud includes Apple Push Notification server (APNs) support for your iOS apps. Set up SSL, PostrgeSQL, MySQL, SFTP and a SSH Tunnel with a click in the Xojo Cloud Control Panel (the Control Panel itself is a Xojo web app). The administration of a web server is a significant and constant task; Xojo Cloud allows you to leave that behind and focus on your projects.

We take security very seriously. Xojo Cloud offers advanced security features to protect your data from cyberthreats, including a smart firewall, intrusion and hacking detection and Security-Enhanced Linux. Unlike most hosting solutions that provide little to no security, each Xojo Cloud server is built with our state-of-the-art, industrial-strength, multi-tiered security system woven into its very core.

Additional features and benefits include daily automatic backups, load balancing and support from the Xojo team. With nine global hosting locations, you are able to host your Xojo web applications close to your users, for speed and an ideal overall experience.

In addition to the standard options, Xojo Cloud servers with more RAM, storage and Virtual CPUs are available. Contact customer support for details about personalized plans.

Whether you are a seasoned Xojo developer or just getting started, Xojo Cloud provides an intuitive and user-friendly hosting solution for Xojo web applications. Today is a good day to start using Xojo Cloud, visit our website to learn more or see the Xojo Store to pick your package and location.

Android Improvements in Xojo 2023r3

Paul Lefebvre — Tue, 10 Oct 2023 13:30:44 +0000

Android remains in Beta, but there have been many fixes and improvements in Xojo 2023r3 and I’d like to highlight a few including: more support for dark mode, additions to MobileTextField, a Destination property, a HasBackButton property, MobilePopupMenu, enhancements to MobileHTMLViewer, support for running JavaScript, the new Kotlin Declare and more.

Although Xojo for Android does not yet have full dark mode support, things continue to head in that direction. Previously your app would adjust its UI for light/dark if the Support Dark Mode property was turned on in the Android Build Settings. Starting in Xojo 2023r3, Color.TextColor and Color.FillColor also adjust their values when run in light mode or dark mode, making it easier for your custom drawing to also adapt.

MobileTextField gets a couple new additions. The ReturnPressed event is now called when, as the name suggests, return is pressed. The AllowSpellChecking property is now also available for MobileTextField and MobileTextArea.

In the Shared Build Settings Inspector there is now a Destination property as there is with other platforms.

Many Android devices have physical back buttons and all let you turn on global software controls that have a back button, but sometimes you want to have the back button clearly shown on the navigation toolbar. With Xojo 2023r3, the new HasBackButton property of MobileScreen can show a back button on the navigation toolbar.

To make it easier to write code that is applicable to both iOS and Android, but not other platforms, there is a new TargetMobile constant available for conditional compilation.

MobilePopupMenu is an all-new control for Android that makes it possible to simplify some of your user interfaces. It works similarly to a PopupMenu on Desktop or Web: when the user taps this control a list of items appears and they can choose one.

On the Advanced tab of the Android Build Settings there is a new Manifest section with a Permissions property. Here you can specify the names of Android permission constants that are needed by Declares or libraries. They are added to the AndroidManifest.xml file when the app is run/built.

MobileHTMLViewer got several enhancements. It now has various processing events, including: DocumentBegin, DocumentComplete, CancelLoad, Error, NewWindow, DocumentProgressChanged and TitleChanged.

And there is now support for running JavaScript using the ExecuteJavaScript method along with the JavaScriptResult and JavaScriptRequest events. ExecuteJavaScript is asynchronous and results appear in the JavaScriptResult event. To call the JavaScriptRequest event, use xojo.execute() in the JavaScript code. A method name and up to 5 parameters can be passed back to Xojo. Learn more in the Xojo Programming Documentation.

The last thing I want to highlight is the new Kotlin Declare. For advanced users, this adds the ability to create Android declares that can pass untouched calls via Alias (with the exception of required type/object handling) to the Kotlin compilation step. This is done by specifying Lib “Kotlin” or adding “:Kotlin” to the end of Lib. Here are a couple examples of what this can look like:

Declare Function AndroidVersion Lib "Kotlin" Alias "android.os.Build.VERSION.RELEASE" As CString

Declare Sub findAllAsync Lib "Object:ctrl:MobileHTMLViewer:Kotlin" Alias "findAllAsync(myfind.toString())" (myFind As CString)

Of course there were many bug fixes as well. Be sure to check out the full release notes for all the details.

Using the Zip & Unzip Feature

William Yu — Tue, 10 Oct 2023 13:30:08 +0000

FolderItem has been extended with new methods to Zip and Unzip files and folders in Xojo 2023 Release 3. Take a peek as we look at how easy it is to use this new feature.

What is New?

Xojo 2023r3 adds new FolderItem.Zip and FolderItem.Unzip methods with support for the most widely used DEFLATE compression format.

Zip(destination As FolderItem, contentsOnly As Boolean = False, compression As ZipCompressions = ZipCompressions.Normal) As FolderItem

Zip(contentsOnly As Boolean = False, compression As ZipCompressions = ZipCompressions.Normal) As FolderItem

Unzip()

Unzip(destinationFolder As FolderItem)

How to Zip

Here’s an example of zipping SomeFolder on your Desktop:

Var someFolder As FolderItem = SpecialFolder.Desktop.Child("SomeFolder")
Var outputFile As FolderItem = someFolder.Zip

The outputFile will be created on your Desktop with the name “SomeFolder.zip”.
This zip file will contain a single folder called SomeFolder, along with the contents of that folder.

+- SomeFolder.zip
  +- SomeFolder
    +- File1.ext
    +- File2.ext
    +- etc.

If you’d rather just zip up the contents of SomeFolder then you can pass True to the contentsOnly parameter.

Var outputFile As FolderItem = myFolder.Zip(True)

Now the zip file only contains the contents of the SomeFolder folder.

+- SomeFolder.zip
  +- File1.ext
  +- File2.ext
  +- etc.

Note: on macOS, when the OS unzips this kind of zip folder hierarchy, it will automatically create a folder with the contents, regardless of what the actual zip hierarchy looks like. However, this does not affect our own FolderItem.Unzip method.

With the overloaded Zip method that takes a destination FolderItem, you can use this to specify where the zip file is created.

Var destinationFolder As FolderItem = SpecialFolder.Documents
Var outputFile As FolderItem = myFolder.Zip(destinationFolder)

In this case the outputFile is created in the user’s Documents folder. If you wanted to rename it to something other than the default name with a “.zip” appended to it, you can also use this syntax to pass a destination file instead of a destination folder.

Var destinationFile As FolderItem = SpecialFolder.Desktop.Child("MyZipFile.zext")
Var outputFile As FolderItem = myFolder.Zip(destinationFile)

While we only demonstrated how to zip a folder in these examples, the exact same syntax applies for zipping a single FolderItem file too.

How to Unzip

Conversely, if you wanted to unzip a file, this is a simple call to FolderItem.Unzip

outputFile.Unzip

This unzips the outputFile contents to the same directory that the outputFile resides in. If you wanted to unzip the contents to a different location, pass in a destination folder instead:

outputFile.Unzip(SpecialFolder.Temporary)

This feature is not yet supported in Android. In conclusion, Zipping/Unzipping has never been easier! Learn more in the Xojo Programming Documentation – Zip and UnZip. (Thanks in part to zlib)

Get Set

Paul Lefebvre — Tue, 10 Oct 2023 13:30:01 +0000

If you need to work with sets, you may find Xojo’s new Set class useful.

A set is a group of items, not unlike a Dictionary. You can add or remove items from the set, as you might expect, but some of its more unique capabilities let you do a difference, intersection and union of two sets.

Difference returns a new Set with members that are unique to each Set. This is essentially the items in the first set that are not in the second set.

Intersection returns a new Set with members that are common to both Sets.

Union returns a new Set that contain the members of both Sets.

There are also methods to populate a set from an array or a Dictionary. Learn more about using the Set class in the Xojo Programming Documentation.

Set is based on code written by Xojo MVP Kem Tekinay and works on all platforms.

Kem Tekinay is a consultant and developer based in Connecticut. A Xojo MVP, Kem has been an avid Xojo user since the early days and is a world-renowned thinker and philosopher, at least in his own mind. You can find him and his work at MacTechnologies Consulting.

The XAML Control’s New Playground

William Yu — Tue, 10 Oct 2023 13:30:00 +0000

With the new XAML Control chooser window that is available in Xojo 2023r3 for Windows you can now play/experiment with XAML like never before, right in the IDE.

A Playground Built-In to the IDE

For those that have already tried the XAML Gallery example project, you may be familiar with one particular part of the demo which allows you to experiment with XAML in what we call the Playground:

This Playground has now been integrated into the Windows IDE in Xojo 2023 Release 3.

The New XAML Control Chooser Window

In Xojo 2023r2 we introduced DesktopXAMLContainer. Dragging one onto your layout and clicking on the edit icon allowed you to pick a pre-defined XAML control via our XAML Control Chooser Window. This XAML Control Chooser Window has now been updated in Xojo 2023r3 to include additional features that mimic what the XAML Gallery example project already provided, and that’s the Playground.

Experimenting in the New Playground

Just like in the XAML Gallery project, you can now enter your own custom XAML code and “run” it (using that play looking button next to the XAML editor).

When you are satisfied with how your XAML looks, just click Add to insert it into the DesktopXAMLContainer.

Et voilà! The new XAML Control Chooser Window provides a unique WYSIWYG interface that you can use to edit your XAML code and to experiment with XAML, now go out and play! Learn more about the the DesktopXAMLContainer in the Xojo Programming Documentation.

iOS: Visits and GeoFencing For MobileLocation

Javier Menendez — Tue, 10 Oct 2023 13:30:00 +0000

Starting with Xojo 2023r3 there are two new features in the iOS MobileLocation control: Visits and GeoFencing. Visits allows the operating system to notify an app when a device stays near a given place for some time. GeoFencing can notify an app when the user enters and/or leaves a previously registered region.

As for any other features involving the MobileLocation control on iOS, the same rules apply when enabling the required capabilities (from the Attributes section in the Inspector Panel with the iOS item selected in the Navigator), and also when requesting the user’s permission to use location services. In fact, it is advisable to enable the Background Modes > Location capability so your app still gets notified both when using Visits or GeoFencing and the app itself is running in the background.

Because we want to receive these events even when the app is not in use, you will want to use the MobileLocationUsageTypes.Always value for the request:

location1.RequestUsageAuthorization(MobileLocation.UsageTypes.Always)

Have a Nice Visit!

From the device point of view (iPhone or iPad), Visits are the most power-consumption effective way to track the user location involving almost no code. The downside is that the operating system does not guarantee the immediate sending of the generated events to the running app.

In order to get this to work in your Xojo iOS app all you need to do is set the VisitAwareness property on the MobileLocation instance of the app to True. Setting the instance to True starts tracking the device location and setting it to False stops tracking and raising Visits based events in the app.

Then, when implementing the VisitChanged Event Handler in the MobileLocation instance of the app, it will receive the following parameters when a new Visit event is raised by the operating system:

latitude As Double
longitude As Double
accuracy As Double
arrival As DateTime
departure As DateTime

So, for example, it will be really easy to automatically add new MapLocation instances to a MobileMap in the app based on the information received. The following snippet of code added to the VisitChanged event shows how to do that on a MobileMap control instance named VisitsMap that has been added to the Screen of the iOS app:

Var arrivalDate As String = If(arrival <> Nil, arrival.ToString, "")
Var departureDate As String = If(departure <> Nil, departure.ToString, "")

Var lc As New MapLocation(latitude, longitude, "Arrival: " + arrivalDate + EndOfLine + "Departure: " + departureDate)
VisitsMap.AddLocation(lc)

It is worth mentioning the checks on the arrival and departure DateTime objects against Nil, iOS does not guarantee to always fulfill this information on the generated Visit events. That means, you may just receive the arrival date and time or the departure date and time, or both of them.

Lastly, the Visits feature will not work when the app is run in the Simulator so you will need to build the app and copy it to the device itself (using Xcode > Devices and Simulators window). You can find an example project for the Visits feature in the Examples folder in the Xojo download,

The screenshot above shows what it looks like after using the app (in the background) for about one hour. As you can see, several MapLocation items have been added to the map tracking the places visited by the user.

GeoFencing on iOS

GeoFencing allows the operating system to notify the app when the device enters and/or exists a previously registered region. These regions are created by providing latitude, longitude and radius (in meters) values along with a String value that uniquely identifies the region. These regions persist even after exiting the app or restarting the device. The main limitation is that a maximum of 20 regions can be registered by an app.

The way to create such regions is through the new MobileCircularRegion class; for example:

Var EiffelTowerRegion As New MobileCircularRegion(48.858093, 2.294694, 20.0, "EiffelTowerExample")

By default it is set to notify when the device enters and leaves the region, this can be changed using the available class properties.

Once the region instance has been created, it needs to be added to the MobileLocation instance of your app using the AddRegion method:

MyLocationInstance.AddRegion(EiffelTowerRegion)

Lastly, and in order to receive GeoFencing events, add the RegionEntered and/or RegionExited Event Handlers to the MobileLocation instance in your app. Both of these will provide the associated MobileCircularRegion instance as the parameter, so the logic of your app can take the required path based on that.

Also, while the Visits feature can only be tested on a physical device, the GeoFencing feature can be tested in the Simulator.

You will also find other new methods in MobileLocation in order to remove a previously added Region or retrieve all the registered Regions in addition to adding them as we did in the earlier code example above.

As with the Visits, you can find a project in the Examples folder to test GeoFencing on iOS.

In Summary

Both Visits and GeoFencing provide to you new ways of retrieving the user location that can be more suitable for the purposes of the iOS apps you develop with Xojo, and because these are based in events managed by the operating system itself, they have less impact in the iPhone/iPad battery.

Android Design Extensions 1.5 for Xojo 2023r3

Martin T. — Tue, 10 Oct 2023 13:30:00 +0000

The Android Design Extensions 1.5 are now available. This version works with Xojo 2023r3 and brings about 90 new extensions:

Declares for the new MobilePopupMenu
Declares for MobileMoviePlayer
Extensions for all MobileUIControl subclasses
New extensions for AndroidMobileTable
New extensions for MobileScrollableArea
New extensions for MobileSwitch
New extensions for MobileTabPanel
New extensions for MobileTextArea
New extensions for MobileTextField

Use MobilePopupMenu to Display it in Other Controls

The new MobilePopupMenu is a nice new addition to Xojo’s Android control library. Wouldn’t it be nice to display the popup menu when clicking on a Button or Canvas as well? With the Android Design Extensions you can achieve this.

Create a new Android project
Import the Android Design Extension folder into your project
Add a MobilePopupMenu (PopupMenu1) from the library to Screen1
Add some entries to the PopupMenu1 in the Inspector in the InitialValue section (say “Apple”, “Banana”, “Peach”)
Set the Visible property of the PopupMenu1 to False
Add a MobileButton (Button1) from the library to Screen1 and place it over the “invisible” PopupMenu1
Add the Pressed-Event to Button1 with the following code:

Call PopupMenu1.PerformClickXC

8. Add the SelectionChanged-Event to the PopupMenu1 with the following code:

Button1.Caption = Me.SelectedRowText

9. Run your project by clicking Run.

You can use this technique with any control that you want to have a popup menu. For example, in a Canvas you would use the PointerDown-Event.

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 here.

Happy Coding.

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