Hot Use Case: Mobile App Integration

 

Hot Use Case:

Mobile App Integration

Merit Service Solutions

Merit Service Solutions needed a mobile app to help direct snow removal providers to the parking lots that needed clearing. Clients like Walmart, Target and other major retailers needed fast deployment and "proof of delivery."

Merit Service Solutions used Magic xpi and Magic xpa to deploy a fully integrated mobile app. “We manage approximately 2000 customer sites and wanted a way to take advantage of today’s digital and mobile capabilities to streamline processes, and provide the best experience to our customers and our service providers. I am happy to report that Magic’s unique solution, combining both mobile and back-end integration under one technology stack, not only provided all the capabilities we demanded, it has also passed the test of an epic blizzard, enabling us to provide our customers with the timely services they expect, even under the most demanding circumstances.”

The app created included ability to find the lot to be serviced, log time, and record snow levels before and after service. This approach removed the guesswork in customer invoices and virtually eliminated  disputed invoices. 

The Select Window Component: Addressing the Difference Between Desktop and Mobile Contexts

As is often the case with new technology, we mimic old ways of doing things until we figure out that the new technology is best suited to new ways of working. Case in point, I am writing a blog to communicate with you now when a video would be more effective.

Experienced developers sometimes suffer a disadvantage because these old ways of doing things creep up in new paradigms as old and freshly irrelevant patterns. Such is the case in the numerous differences in best practice between mobile user interfaces and the traditional GUI interaction in desktop software.

With the announcement of Magic xpa Application Platform 2.5, a new Mobile Application Framework was introduced by Magic Software. Let’s take a look at the Select Window Component to see how different mobile GUIs ought to be from traditional applications.

Our example app is a Time Sheet application. In a traditional application where I want to find a particular timesheet, criteria would normally be entered in a multi-field search form, a “Search” button would be pressed and the match or matches would be displayed in a list. In a large screen format this allows me to use human memory to search very specifically. When my memory is faulty, I can search more broadly and then gradually filter the results to get down the actual time sheet I want to see.

A mobile approach will be quite different. My main screen will call out the two categories that I am most likely to use to find a specific project – wither the “Customer” name or the “Project” name. So I might design an interface with just these two menu options. Each will raise an event that gives me more choices.

If I select Customers, I get a list of my Local Customers.

If I select Projects, I get a list of Local Projects.

But if I select customer, and then click on the customer name in the list. I automatically get a list of that Local Customer’s Local projects.

In this example, the projects are simply named by month. Selecting a specific project will then show me the Customer Name, Project Name and my Time Sheets for that project.

To edit a given time sheet, once again I simply select it (by sliding or touching). Setting the time in the report uses features that are “native” or normal for my type of device (Android, Apple, Windows Mobile, etc.) 

The result of setting the new time is a corrected or updated Time Sheet as seen below.

So the flow of the app is something like this:

That is not to say that the old approach wouldn’t work. But good mobile apps strive to leverage the users time and limit typing and button pressing as much as possible. What the user sacrifices in flexibility, they gain ten times in efficiency and overall ease-of-use. 

Magic Software Named to the SD Times 100 Five Years Running

Magic Software has been named to the SD Times 100 for the fifth year in a row. As stated on the awards page: “Each year the SD Times 100 recognizes companies, non-commercial organizations, open source projects and other initiatives for their innovation and leadership. It is not a product award. Judged by the editors of SD Times, the SD Times 100 recognizes the top innovators and leaders in multiple software development industry areas.”

“When choosing the SD Times 100, we carefully considered each company’s offerings and reputation. We also listened for the “buzz”—how much attention and conversation we’ve heard around the company and its products and technologies—as a sign of leadership within the industry,” wrote David Rubinstein when the awards debuted in 2003.

“The SD Times 100 looked for companies that have determined a direction that developers followed,” Rubinstein added as he expanded on the criteria. “Did the company set the industry agenda? Did its products and services advance the software development art? Were its competitors nervously tracking its moves? Were programmers anxiously awaiting its developments? Those qualities mark a leader.”

We will never know for certain what qualities and characteristics of the Magic Software offering entered into the judges decision these last five years. Nevertheless, I have identified here what I believe to be some of the key developments that the judges could have looked at in making their decision.

In 2010, Magic Software was recognized in the SOA & Middleware category. Not surprisingly, in the prior year Gartner and Forrester had both recognized Magic Software as a Visionary and Top Performer in their respective quadrants and waves related to integration and Service-Oriented Architecture.  

Leading up to that time, Magic Software had innovated its application and integration platforms with features such as Web services wizards; SOAP, UDDI, and WSDL automation; RESTful Web Services; Service Oriented Architecture (SOA); and  Event Driven Architecture. While Magic’s support for these technologies had their roots all the way back to 2001, support for Web Services in 2001 and the release of the Magic integration platform in 2003 had clearly become mainstream by 2010.

Magic Software was recognized in the SD Times 100 2011 Database & Integration category. While the grouping of Database and Integration may have seemed like an odd pairing by the editors, it was appropriate enough in Magic Software’s case.  

Our platforms had long included high-speed Native Database Gateways which were particularly important in the pre-in-memory computing era. The diversity of our database, file and variable support also shined through in the Magic xpi Data Mapper, which has a connection to those databases. On the integration side, platform-level features for drag, drop and configure visual integration flows, process flow automation and business process orchestration were also well established and gaining in market adoption and awareness by that time.

In 2012, Magic Software was named to the SD Times 100 in the APIs & Integration category. One of the uniquenesses of the SD Times 100 program has been that the categories have changed over the years. The topic of API integration started to reach a peak that year and the Magic xpi Integration Platform clearly contained rich API handling capabilities that simplified integration for thousands of medium and large sized enterprises. The API library in the Magic xpi Integration Platform included an Application Adapter Library; Technical Component Library; Message Queue Adapters; Composite Object Mashups and Communication Protocol Adapters.  

By 2013, Magic Software’s Rich Internet Application (RIA) technology had come into widespread adoption. So it is no surprise that we were named to the 2013 SD Times 100 in the category of User Experience. Magic Software had introduced desktop Rich Internet Applications (RIA) within the Magic xpa Application Platform’s unitary development and deployment architecture. At the same time as the RIA introduction, Magic’s technology became fully .NET compliant, providing the end user a rich .NET user experience while affording the developer a simplified environment for development of .NET applications.

For the first time in the history of the SD Times 100, Magic Software repeated in the same category in the 2014 SD Times 100. Once again, Magic Software was recognized in the User Experience category. If Magic Software’s desktop RIA was obvious to the market in 2013, it was likely not until 2014 that the editors would have noticed our Mobile RIA capabilities. Magic’s single development environment for both Mobile Client and Server coupled with its deploy anywhere support for iOS, Android, Windows, and RIM is further enhanced by providing users with a native look and feel in both online and offline mode.

Are these the precise reasons that Magic Software has been recognized as a leader in the industry year-after-year? Perhaps the editors would have cited other innovative factors. But one thing is clear, Magic Software is widely and consistently recognized for innovation and leadership in the software development industry.

Offline Apps: Don’t Forget the Security

Often when discussing the challenge of creating offline mobile apps we jump right to the issue of the synchronization business logic. Let today’s discussion serve as a reminder that offline mode presents important security considerations that must be planned for by the developer as well.

The Magic xpa Application Platform is among the elite class of application platforms that now provides capabilities for offline applications. 

Nevertheless, intentional effort is required to assure that proper and unique security measures are taken to protect offline apps and their data.  Offline security requires technical implementation measures, but beyond this it requires that developers apply business logic to the architecture and workflow of an application to make it secure. Even the most secure application platform can be misused to create insecure apps, so be careful to approach offline business app logic very carefully. 

Security may indeed be the most significant challenge for offline access to web services as opposed to using pure cloud services, because while the same network, server and application security concerns apply, offline access also requires storage on the device.  Therefore, malware, lost and stolen devices, and BYOD can all put your organization at risk of losing data held offline. Malware could access the local storage, lost or stolen devices could fall into the hands of data thieves, and a disgruntled user with their own device could seek to divulge the contents of their local storage after leaving the organization.

As with any mobile security challenge, this requires security to be built in to the business processes on several layers, from the device to the application and the user, as appropriate for the data being stored.  Securing devices is typically achieved through software measures such as user authentication and encryption while modern mobile device management (MDM) vendors provide tools external to the apps themselves like geofencing, remote wiping and device tracking to provide extra security and control over the device.Magic Software now offers a Mobile Device Management (MDM) platform to accompany its well known Magic xpa Application Platform and Magic xpi Integration Platform.

MDM and mobile application management (MAM) tools as well as modern application platforms help secure the applications, in particular providing the organization with the ability to view and manage who can access which applications, where, when and on which devices.  Finally, the data itself can be secured by requiring user authentication.  A combination of these layers should be used according to the data being stored.

For Magic xpa applications that require user authentication, user credentials should be securely stored on the client, to allow for operation without server authentication. To ensure validity, such credentials should be re-checked when connected.

When using integrated security with Magic xpa Application Platform, the user logon details and security credentials are automatically kept encrypted in the client cache. When running the application without connecting to the server, the last logon details (including rights) are used. Note that when running the application without connecting to the server, the logon dialog box will not appear. The logon credentials will be automatically synchronized on initial connection and on subsequent connected application startups.

Developers of offline apps have the tools they need, so don’t forget the security.

Mobile Saturday

In this demo, Magic demonstrates how you can easily develop applications that deploy natively on all mobile devices. The sample app is sort of silly, an "asset management" app for families in which family members set meetings like "portfolio management review." That made me laugh, but then the video gets into the Magic xpa Studio and shows how-to add form controls, bind variables, set data sources for drop-down lists, and so on. Not bad!

One nice aspect is that the new application does not have to be redistributed to users. The next time they run the app, it is simply the new and enhanced version that executes. In this sense, RIA apps, are a lot like SaaS or web-based apps. 

With the Magic xpa Application Platform, a single development effort can create apps that run on multiple devices such as the Android example in the demo. 

Be sure to register for the Magic Software Users Conference 2013. 

XML Programming Basics with the Magic XPA Application Platform

XML is so commonplace today, that we may tend to forget what it really is and what it really does or does not do. First off, XML stands for Extensible Markup Language.  XML uses a flexible standards-based format, which enables you to easily share data. Unlike HTML whose purpose is to display data, XML’s purpose is simply to provide a format by which one can store and transport data. Unlike HTML, there are no predefined tags.

I made up my own tags for this example:

<blogger>
  <first_name>Glenn</first_name>
  <last_name>Johnson</last_name>

  <blog_name>Magic Application Platform</blog_name>

  <url>www.magicapplicationplatform.blogspot.com</url>
</blogger>

XML doesn’t do anything by itself, it is simply formatted data. Someone must write software to send, receive or display  XML. That’s where the Magic xpa Application Platform comes into the picture.

Magic xpa provides you with the ability to use XML documents as a standard data source in your applications. You can define an XML data source (XML view) in the Data repository and define a task to manipulate and handle the XML data.  

When using an XML data source, you can create Magic xpa tasks (Batch, Rich Client and Online) that read and manipulate XML documents using XML views. The XML views can be defined in tasks either as a main source or as a linked source.

You can also verify the validity of XML documents using the XMLValidate and XMLValidationError functions. XML schema namespaces are automatically handled by Magic xpa. XML and XSD files that use namespaces do not require any applicative translation between aliases and URIs.  

Earlier versions provided functions for working with XML, but XML manipulation is even easier with Magic xpa today. Now you can work with XML using the XML data source.

The following are provided by Magic xpa to enable you to work with XML data sources:

1. The XML File entry in the DBMS repository
2. The XML Defaults tab in the DBMS Properties dialog box
3. The Temporary Data Source property in the Database Properties dialog box
4. The XSD section in the Column Properties sheet
    

Defining an XML data source is done by loading definitions from an XML schema (XSD). If you do not  have a schema that describes the XML document structure that you want to work with, you should use an external tool, such as XMLSpy®, to generate the XML schema.

When parked on a line in the Data repository, you can define a single view for a specific XML schema.

When parked on top of the Data repository (# column), this utility will generate all required views for the XML schema and optionally will generate programs for reading and writing XML documents that are based on this schema. This method lets us reload schemas in order to update existing views.

If the schema file that you selected has several global elements (roots), the Root Selection list will appear. Select one of the roots in order to load it. For schemas with defined namespaces, the namespace URI will be displayed next to the global element name.

When you get the definition of an XML schema, and the Name column has no value, the column will be assigned with a default value: <schema file name with the suffix>.<root element name>. For example: If you use a file called "po.xsd", the name that will appear in the Name column will be "po.purchaseOrder".

Similarly, if the Data source name column has no value, the column will be assigned with a default value: <root element name>.xml . For example: If you use a file called "po.xsd", the name that will appear in the Data source namecolumn will be "purchaseOrder.xml".

To restrict the number of complex elements parsed from a schema (XML views), use the SpecialSchemaSizeLimit setting.

In our next entry, XML Deep Dive with the Magic xpa Application Platform, we’ll more fully explore the detailed usage of XML in Magic xpa. For a detailed look at XML Handling or XSLT for XML Transformations in the Magic xpi Integration Platform see the Integrate My JDE blog which covers JD Edwards ERP integration and a very wide array of related topics. 

Are you falling behind the times?

Trying to read documentation and get updated on your own can be tough. That's why we make it easy to learn how to migrate your applications from either eDeveloper 9.4  or uniPaaS 1.x to Magic xpa. I invite you all to Come to sunny Southern California the week of August 27 for Magic University training. The course schedule breaks down like this:

August 27-29  Migration from eDeveloper V9.4 to Magic xpa Enterprise Client

August 30        Migration from uniPaaS V1.x to Magic xpa V2.x

August 31            RIA Programming for Magic xpa Developers

Basically, the first four days are one course if you are migrating from 9.4 (or earlier). If you are already on uniPaaS V1.x, then you could just come for the last day, Thursday, although I think most will benefit from the entire four days. In the first three days of the course, August 27-29, you will learn about: The Magic xpa project paradigm; Magic xpa studio enhancements and features; data repository; task editors; expression editors; event-based logic; user-defined functions;GUI enhancements; subform controls; application migration; xml handling; use of external version control systems; and rich client applications.

On August 30, the focus will be on migrating to Magic xpa 2.x, additional GUI enhancements; GUI Frames; MDI; and the new open source end user functionality.

August 31 is the optional RIA day. This course will detail the RIA concept and architecture; explain the differences between client-server and RIA applications, detail the development, optimization, deployment and monitoring of RIA apps; provide guidelines for converting existing apps to RIA apps.

The optional RIA class day is $699. The main course from the 27-30 is free if you have a current M&S contract on an Enterprise Studio. The cost is $2,000 if you don’t. Please call your representative to make arrangements for the course. (949) 250-1718. 

Magic xpa Application Platform and Team Foundation Server

By now, most of you know that Microsoft replaced the old Visual SourceSafe with a new product called Team Foundation Server (TFS) for Application Lifecycle Management (ALM) and source control.  

The Magic xpa Application Platform requires that a Source Code Control tool be SCC compliant and Team Foundation Server meets this criteria. Using Team Foundation Server as the SCC for Magic xpa requires additional software, however.

To get Magic xpa to work with TFS you need to install MS TeamExplorer which will manage your TFS workspace. You should also install the MSSCCI provider. The provider is downloadable from  MSDN at no cost.

The new version of  TFS is Team Foundation Server 2012 and it is an evolution of Microsoft Application Lifecycle Management tools.  TFS 2012 improves the project manager experience by using a new web interface to show product backlog and iteration backlog.  The Team Explorer has changed to improve workflow efficiency. New Feedback Manager and storyboard features enable better development team communication.

You will recall that TFS 2010 allowed for product backlog and iteration backlog worksheets in the Agile Team Project template. TFS 2012 replaces the worksheets feature and and moves it to the Team Web Access interface. Each project can now be managed in a web app. Also available is the SharePoint portal as in the previous version of TFS. The Team Web Access interface allows  project managers to view and manage each project, iteration,  work area, and team member. It also enables access to reports.

The Team Web Access interface uses Microsoft’s new “Metro” UI look and feel as you can see in the home page below. (Are we allowed to call it Metro anymore?)


From the home page you can see KPI information about the current sprint or iteration such as hours remaining in the iteration, capacity, backlog items in progress, and the sprint start date and end date. A new feature allows you to assign dates to a sprint. The home page includes a burndown chart and Team Favorites, which provides a customized dashboard view for queries, recent source changes and history.

The team concept has also been improved. You can create separate teams within a single project with their own product backlog, sprints, members, and other tracking information uniquely for that team. Because a team is assigned a parent iteration, reports can be run just for a specific team using the iteration filter found on the reports. Each team has its own  product backlog iteration where work items are shown.

A sprint backlog has two tabs, one that contains the product backlog items assigned to the sprint as well as the sub tasks associated to it as well as a view of team member capacity. From the capacity tab itself you can execute capacity planning tasks.

For teams running Scrum and Agile development, TFS just got a whole lot better. Please let us know if you have any experience with TFS and Magic xpa Application Platform.

Wizards and Builders: A Smarter Way to Work Your Magic

Wizards and Builders: A Smarter Way to Work Your Magic

When a programming task is comprised of a series of atomic but interrelated steps, a wizard is a useful way to build the functionality needed without having to memorize the order of the steps needed to accomplish your objective. While many 3GLs simply expect you to write a series of lines of code that execute functionality in a prescribed order, Magic simplifies this process by eliminating the need to remember the syntax of each step and by eliminating the need to remember the needed steps themselves and their orders. To accomplish this, the Magic xpa Studio includes a number of wizards and builders for creating components and other resources that run on the Magic xpa Application Platform.

A component acts as a building block of an application. They are generally stateless, meaning that each instance of the component can be executed independently of every other instance of that same component. Magic allows you to define project objects as components and export them to share resources among Magic xpa projects and facilitate distribution of revisions. When you make changes to a component, the revisions are inherited by any programs that call the component.

With Magic xpa Studio wizards, you can readily create components, such as Web Services and SQL Stored Procedures. And with the component interface builder, you can even package your own components for use by others. Your components are maintained in the Composite Resource Repository (CRR). Your programs may be highly atomic or they can contain entire programs. The CRR provides repositories that allow you to easily access and maintain models, data sources, programs, helps, rights, menus, events, functions, handlers and environment settings.

The Magic xpa Application Platform Resource Repository

Models Repository. Models are useful objects to expose in components as they provide a way to create programming standards, design standards and so on that you can use throughout your program or across a number of different applications. To expose a model for use by others, you simply give it a Public Name.

Data Sources Repository. In the data sources repository, you should store data objects that will be used in your application. In a world where agile concepts often lead to changing requirements in the middle of a project, you never know when a resource may be needed again elsewhere in your project. So it is a good practice to define all of your data sources in the CRR data sources repository. Whether or not to expose the data sources with a Public Name, however, is a very different question. I recommend giving a Public Name only when a definite need has been defined to share the data model outside your application by a host application.

Programs Repository. In the Magic xpa Application Program, an application program is composed of numerous discrete programs. The CRR provides a repository for all of the programs that make up your overall business application. The ability to provide a Public Name and designate these programs as external means that Magic gives you Service Oriented Architecture capabilities. In addition, of course you can and often will publish your Magic programs as Web Services that can be more easily discovered through UDDI and described via WSDL for full SOA compliance.

Rights, Menus and Helps. Three additional repositories are provided for managing the rights, menus and helps in your applications.

·         Helps – You expose Help objects similarly to models and data sources: just give each object you wish to expose a Public Name.

·         Rights – You expose Rights similarly to models and data sources: just give each object you wish to expose a Public Name.

·         Menus – You expose Menus similarly to models and data sources: just give each object you wish to expose a Public Name.

Events.  In each task you can define user-defined events to be handled in your project whenever these events are raised or triggered.

A user-defined event is a logical definition of an occurrence. For example, you can define an event called ‘Add Customer’. The event definition by itself will not affect the project. This logical definition allows you to define the handling for such a logical occurrence. You expose events as components by giving them a Public Name and selecting the Expose check box.

Functions and handlers. Developer functions set in the Main Program can be published as part of a Magic xpa component by setting the Scope option to Global.

Environment settings.

The loaded component is integrated into another project and appears in the Composite Resource Repository. Any component object can be selected from the Object list. The environment settings selected for a component are accessed for any component object that the end user opens in the project. The environment settings for a component appear in the Environment repository, which is reached by clicking the Environment button in the Magic xpa Component Items repository.

All environment variables not specified for a component are inherited from the environment settings of the project. 

Runtime Expression Editor: It’s Magic, You Know!

Last month, I was singing “Oh, oh, oh it’s Magic, you know! Never believe it’s not so!” with 250 of my colleagues in Jaffa, one of the oldest port cities in the world. Why?

Because it is Magic! When I first got involved with the Magic Application Platform twelve years ago there was a lot of talk in the industry about rules engines, business rules editors, and the like. Today, you’re more likely to hear people discuss cloud computing or service-oriented architecture than business rules engines. But one of the features that puts the “Magic” in the Magic xpa Application Platform is the Runtime Expression Editor. One of the reasons Magic employees believe so passionately in the solutions we bring to market is because we know that the productivity features offered are unparalleled. The Runtime Expression Editor is a great example of how our smarter technology works to help accelerate business performance.

When running an application of the Magic xpa Application Platform, the end user can “zoom in” on a range field by pressing the F5 function key, for example. This will reveal the expression that is being used to determine what is being displayed in the view for that range field. Using the pulldown and context menus an end user can edit the expression on the fly. The Runtime Expression Editor can use numeric, string, “basic,” date & time, and variable functions (see the partial lists below from the Magic xpi reference documentation).

If an end user tries to use functions that are not in one of the groups mentioned above, a message appears: “Function not allowed for use in expression.”

Not every end user will have the aptitude needed to use the runtime expression editor.  However, more advanced users who want to be able to adjust business rules at runtime in order to view different results will find this a very powerful feature. Instead of rewriting the application, the business rule can be modified at runtime allowing for various kinds of what-if analysis. This takes the burden off of programming teams and gives power users the ability to work their Magic. After all "it's Magic, you know!"

Partial List of Functions Available in the Runtime Expression Editor

Numeric Functions

Multiplication Operator

Addition Operator

Subtraction Operator

Division Operator

Exponentiation Operator

ABS – Returns the absolute value of a real number, without regard to sign.

ACOS – Returns the arc cosine value of a number, in radians.

ASIN – Returns the trigonometric arc sine of a number, in radians.

ATAN – Returns the arc tangent of a number, in radians.

ChkDgt – Generates a check digit.

COS – Returns the cosine of an angle, where the angle is expressed in radians.

EXP – Calculates the exponential value of x.

Fix – Extracts a specified part of a number, real or integer.

HStr – Returns the hexadecimal (base 16) value of a decimal (base 10) number.

LOG – Returns the natural logarithm of a number.

MAX – Returns the greatest value from a group of values with the same attributes.

MIN – Returns the smallest of a group of values with the same attribute.

MOD – Returns the remainder of an integer division.

MStr – Converts a number to a Magic number with a specified length in bytes.

RAND – Generates random numbers.

Range – Checks whether a number falls within a range, and returns a Boolean true or false.

Round – Extracts a specified part of a number and rounds the result.

SIN – Returns the sine of an angle, where the angle is expressed in radians.

Str – Converts a number to an alpha string, according to a picture.

TAN – Returns the tangent of an angle, where the angle is expressed in radians.

 

String Functions

  

& – Concatenates Alpha strings.

ANSI2OEM – Converts data from ANSI to OEM.

ASCIIChr – Converts a number to a corresponding character in the ASCII character set.

ASCIIVal – ASCII value of a string character.

AStr – Applies a selected format to a string value.

CRC – Calculates redundancy check.

Del – Deletes characters from a string.

DStr – Converts a date or a date expression to a character string.

Fill – Repeats a string.

Flip – Inverts a string.

HVal – Returns the decimal (base 10) value of a hexadecimal (base 16) number.

Ins – Inserts a string in another string.

InStr – Searches for the first occurrence of a string in another string.

Left – Extracts a substring from the left.

Len – Returns the defined length of an Alpha string.

Logical – Converts a visual representation to a logical representation.

Lower – Returns a string in lowercase.

LTrim – Removes leading blanks.

MID – Extracts a substring.

MlsTrans – Returns the translation of a string.

mTVal – Converts a time value in milliseconds from an Alpha string to a numeric value.

MVal – Converts a Magic xpa number (with a specified length in bytes) to a number.

OEM2ANSI – Converts data from OEM to ANSI.

Rep – Replaces a substring within a string.

RepStr – Replaces all occurrences of a defined substring with another substring in a given source string.

Right – Extracts a substring from the right.

RTrim – Removes trailing blanks.

SoundX – Compares homonyms.

StrBuild – Replaces placeholders in a template string with string values.

StrToken – Returns a token from a delimited string.

StrTokenCnt – Returns the number of existing delimited tokens in a given string.

StrTokenIdx – Returns the token index in a delimited Alpha string.

Translate – Translates all logical names and nested logical names to their actual values.

TranslateNR – Translates all logical names, including nested logical names, in a string to their actual values.

Trim – Removes leading and trailing blanks.

TVal – Converts a time value stored as an Alpha character string to a numeric value.

UnicodeChr – Converts a numeric value to its corresponding Unicode character.

UnicodeFromANSI – Converts an ANSI string to Unicode characters as determined by the selected code page.

UnicodeToANSI – Converts a Unicode string to ANSI characters according to a selected code page.

UnicodeVal – Converts a Unicode character to its corresponding numeric value.

Upper – Returns a string in uppercase.

Val – Converts an Alpha character to a number.

Visual – Converts a logical representation to a Visual representation.

Date and Time Functions

AddDate – Performs calculation on date.

AddDateTime – Calculates the difference between two Datetime values Adds a time interval to a Datetime value, which is represented by Magic xpa Date and Time fields. The specified amount of years, months, days, hours, minutes, and seconds are added to the current value of Date & Time, and stored back into those two variables.

AddTime – Performs calculations on a time variable.

BOM – Returns start date of month specified.

BOY – Returns end date of year specified.

CDOW – Name of the day (e.g. Sunday) from date.

CMonth – Name of the month (e.g. January) from date.

Date – System date.

Day – Day of month (1-31) from date.

DifDateTime – Calculate the difference between two Datetime values.

DOW – Number of the day of the week (1-7) from date.

DStr – Date-to-string conversion.

DVal – String-to-date conversion.

EOM – Returns date of end of month specified.

EOY – Returns date of end of year specified.

Hour – Returns the hour portion of the time value.

MDate – Returns the Magic xpa date as input in logon screen.

Minute – Returns the minute portion of the time value.

Month – Returns the month portion of a date.

mTime – Retrieves the time value in milliseconds from midnight to the current time.

mTStr – Converts a time value in milliseconds to a specified Alpha string picture format.

NDOW – Converts the number of the day to the name of the day.

NMonth – Converts the number of the month to the name of the month.

Second – Returns the second portion of the time value.

Time – Returns the system time.

TStr – Converts the time value to an Alpha string.

TVal - Converts a time value stored as an Alpha character string to a numeric value, according to a picture.

Year – Returns the year of a date.

Variable Functions

CaretPosGet – Returns the current caret position in the Edit control.

DataViewToDNDataTable – Generates a .NET DataTable object from the current data view.

DataViewToHTML – Creates an HTML file from the data view variables sent to it.

DataViewToText – Creates a text file from the data view variables sent to it.

DataViewToXML – Creates an XML file from the data view variables sent to it.

DataViewVars – Fetches the variables displayed on the form from where the Print Data event was raised.

EditGet – Retrieves the control value in the edit mode.

EditSet – Sets the edited value of the control that invoked the last handler.

GetComponentName – Fetches the name of the current component.

GetGUID – Fetches the GUID of the application.

IsDefault – Tests if the value of a variable is equal to its default value.

ISNULL – Checks for the existence of a NULL value in a variable.

MarkedTextGet – Returns marked text.

MarkedTextSet – Replaces the marked text with a specified string.

MarkText – Marks the specified number of characters starting from a defined start position.

Var Functions

All Var functions use pointers to variables in memory. Each variable in the memory has a unique number according to the runtime tree. For example, if program A calls Program B, and in Program A there are 3 variables and in B there are 2, then Variable A in program A receives the number 1 in Runtime and variable A in program B receives the number 4. The Var functions allow you to get information about dynamic variables.

VarAttr – Returns a column’s attribute.

VarCurr – Retrieves the variable identifier.

VarCurrN – Returns the current value of a variable according to the variable’s name.

VarDbName – Queries a selected data view to retrieve the physical definition of each variable.

VarIndex – Returns the index of a variable according to the variable’s name.

VarInp – Identifies the last variable where the input has occurred.

VarMod – Variable modification check.

VarName – Provides a variable’s origin and description.

VarPic – Returns a string value that represents the picture of the selected field.

VarPrev – Retrieves the original value of a variable, based on a dynamic value representing a variable index within the Variable list.