⚠️ This blog post was created with AI assistance to help explain Uniface 10.4 concepts.

If you’re working with Uniface 10.4, you’ll want to understand Global Objects. They’re powerful tools that make your code more reusable and easier to maintain. Let me break it down in simple terms! 💡

📦 What Are Global Objects?

Global Objects are reusable pieces of code and resources that you can use anywhere in your Uniface application. Think of them as shared tools in a toolbox - once you create them, every component in your application can access them without duplicating code.

The best part? They’re stored in runtime libraries and loaded dynamically when needed. This means you can update a Global Object without recompiling every component that uses it. That’s a huge time-saver! ⏱️

🎯 Types of Global Objects

Uniface 10.4 offers several types of Global Objects, each serving a specific purpose:

1. Global Constants 🔢

These are fixed values you define once and use throughout your application. They’re defined in a special IncludeScript called DEFPARAM.

Example: Instead of writing the number 100 everywhere, you could define a global constant called MAX_RECORDS with the value 100. Now if you need to change it to 200, you only change it in one place!

2. Global Variables 📊

These are typed variables that all your ProcScript code can access. Perfect for storing application-wide settings or state information.

Example: You might have a global variable called CURRENT_USER that stores the logged-in username. Any component can check this variable to see who’s using the application.

3. Global ProcScripts 🖊️

These are reusable code modules that any ProcScript in your application can call. This is where the real power of code reuse shines!

Example: Create a global ProcScript function called CalculateTax that takes an amount and returns the tax. Now every component that needs to calculate tax can simply call this function instead of writing the calculation logic repeatedly.

4. Messages 💬

Language-specific text that can be used for labels, help text, prompts, and error messages. These are especially useful for international applications.

Example: Instead of hardcoding “Save successful” in your code, you reference a message object. If you need to support German users, you just add the German translation “Speichern erfolgreich” to the message library.

5. Menu Objects 🍔

Definitions for menu bars and popup menus in desktop applications. These are also language-specific.

6. Panels 🎨

Toolbars with buttons for executing operations in desktop applications.

7. Drag-and-Drop Formats 🖱️

Definitions for drag-and-drop behavior in your widgets, including icons and default actions.

8. Glyphs 🖼️

Images in Uniface format that you can use as background images, icons in widgets, panel buttons, and menus.

✨ Why Use Global Objects?

Reusability 🔄

Write once, use everywhere. No more copy-pasting the same code across multiple components.

Easy Maintenance 🔧

Need to fix a bug or add a feature? Update the Global Object once, and the change applies everywhere it’s used - no recompilation needed!

Technology Independence 🌐

Global Objects work regardless of your deployment environment. Whether you’re running on desktop, web, or mobile, the same Global Objects work.

Language Support 🌍

For text-based objects like messages and menus, Uniface automatically selects the right language version at runtime based on the user’s environment.

🔍 How Global Objects Work

When your component needs a Global Object, Uniface doesn’t look for it in the component itself. Instead, it searches through runtime libraries at runtime and resolves the reference dynamically. This is called late binding.

Here’s the process:

1. Your component references a Global Object (like calling a global ProcScript function)
2. Uniface searches the appropriate runtime library
3. It finds and loads the Global Object
4. Your component uses it The library and language settings are determined when the application starts, making this process seamless for the developer. 🎯

💪 Global Objects Can Use Other Global Objects

Here’s something cool: Global Objects can reference other Global Objects. For example, a component can call a global ProcScript function that displays global messages. This creates a powerful ecosystem of reusable code!

Example scenario: Your CalculateTax global ProcScript might use a global message to display an error if the input is invalid. Both the function and the message are global objects working together.

🎓 Best Practices

• Plan your Global Objects: Think about what code you’ll need across multiple components before you start building.
• Use meaningful names: Clear names make your Global Objects easier to find and use.
• Document your Global Objects: Add comments explaining what each Global Object does and how to use it.
• Keep them focused: Each Global Object should do one thing well.
• Test thoroughly: Since Global Objects are used everywhere, bugs can have wide-reaching effects.

🎉 Conclusion

Global Objects in Uniface 10.4 are essential for building maintainable, scalable applications. They promote code reuse, simplify maintenance, and support international development - all while keeping your deployment flexible. Whether you’re building desktop, web, or mobile applications, Global Objects help you write better code faster! 🚀

Start identifying repeatable patterns in your code today and turn them into Global Objects. Your future self will thank you! 😊