Case Tools





Case Tools Gold Edition is a true enterprise-grade, cross-vendor Rapid Application Development product that enables developers to quickly design, program, test and deploy batch, wired or wireless mobile device applications. CASE-Tools greatly reduces the total cost of ownership and utilizes existing LAN and WAN infrastructure to collect, verify, and integrate transactional data into any enterprise system. When used with Pathfinder Enterprise Transaction Server for system integration, IT managers have full control of how each application program integrates into various in-house systems.

Capabilities

  • rapidly develop, debug and test mobile device applications
  • compile applications for multiple vendor’s devices.
  • manage screen layouts with entry validation
  • download/upload tables for validation, look-ups or updates
  • execute full label printing
  • version control with automatic program distribution
  • collect data with automatic reconnects while out-of-range, during hardware failure, or downed resource
  • empower mobile devices to execute remote SQL or stored procedures
  • empower mobile devices to communicate with legacy or host systems utilizing XML conversations
  • empower mobile devices to communicate with any server-side user written COM DLL
  • integrate into any enterprise or legacy system
  • reuse file structures and subroutines
  • easily perform ongoing changes or enhancements
  • RS-232 control from the device for scale or sign control
  • Extend CASE-Tools functionality by calling .NET functions residing on the device

CASE-Tools is a flexible yet powerful application builder where any application can be built and linked into any database or API application. Its structured object approach allows developers to create projects, maintain applications, debug, compile and test programs for deployment to remote devices. CASE-Tools objects like Subroutines, Files, Panels and Transactions can be reused throughout the enterprise to build many different applications - again reducing the total cost of ownership. 

The CASE-Tools product has been used to create a full range of barcode and RFID applications. Decisionpoint has experience building CASE-Tools applications for many industries. The software tools are horizontal by definition, so any collection application can be built - the capabilities are endless.

When CASE-Tools applications are combined with the SBS-Pathfinder Enterprise Transaction Server, the development experience is maximized. Each deployed solution combines expert communication facilities and terminal services that Decisionpoint has developed over the past 30 years. This functionality is included in every CASE-Tools application with no additional programming. This creates a major benefit by reducing the design and development work for the programmer. Most importantly, it guarantees successful communications dialogs with your host computer, manages system load balancing, record queuing, in-range and out-of-range recovery, auto-reconnect, terminal time-outs, time/date syncing and a list of other features that guarantee your project's success.

The CASE-Tools environment provides a thick-client approach in building your enterprise data collection project. All aspects of the terminal user interface are created with this product along with defining which resources the mobile device will use to communicate. CASE-Tools makes all three aspects of a project easier: Programming and Maintenance, Debugging and Testing, and Deployment.

Programming & Maintenance

Project Explorer is where you create the CASE-Tools project file, subroutines, panel definitions, file definitions, transaction definitions, label definitions, and global data. This section contains all the necessary information about your project and allows the developer to navigate through each section to enhance the development effort.

  • Familiar project structure, with all parts of your project accessible from the Project Explorer.
  • Subroutines contain Instructions that interact with Global, Local, and System data and various top-level objects. Instructions can be drag-dropped from the Toolbox into your Subroutine, and each is configured with a simple dialog. With a single Instruction you can transfer a file, execute a stored procedure, or download the newest version of your program! You can even invoke your own .NET code, for the ultimate in flexibility.

Instructions include:
- Move, Arithmetic, and Function
- If/ElseIf/Else, GoTo/Label, For/Next, While/Loop
- Call Subroutine and Exit Subroutine
- File Transfer, Execute Transaction, Remote Label Print
- Show Panel and Message Box
- Structure File I/O, Text File I/O
- Program Version Control
- And many, many, more!

  • Panels are built with a WYSIWYG designer
  • Transactions are used to define your interactions with Pathfinder and your Enterprise. ODBC Transactions include an SQL builder for remote database manipulation.
  • Files are used to create structured storage on your device. Indexes can be added for faster lookups.
  • Rules allow common validations to be bundled together. They can be attached to Panel controls for automatic validation, or invoked separately.

Transactions
The Execute Transaction command allows developers to create advanced processing such as interaction with remote databases and other computers. This instruction will actually allow the developer to key in and test any SQL command with limitations only dependent on the ODBC driver. In fact, you can actually execute stored procedures.
+ one-way transactions with no results
+ one-way transactions with execution confirmation
+ bi-directional transactions with single return result
+ bi-directional transactions with multiple results
Note: Each transaction type can be setup for local queuing to handle out-of-range conditions, priorities, and FIFO control.

Instructions
There are over 25 instructions that are used to create your project. These instructions can be found in the Instruction Toolbox and are added to a program listing using simple drag-n-drop procedures. Instructions include prompt, entry/prompt and message box for screen manipulation; file I/O and file transfer instructions for file manipulation; move, function and arithmetic for data manipulation; label print; and classical ‘if’ blocks, for-while loops and subroutines for program control. Other instructions such as: version control for program distribution, DIDO for door access, serial CFG and serial I/O to communicate with RS232 devices are also included.

As you select each instruction, a simple wizard dialog pops up allowing you to define the parameters for that instruction. Once the parameters are selected, the code is inserted into the mainline window. A top-down flow is followed for the program and full branching logic is supported through classical Go-To’s For-Next/While-Loops and If-Then-Else blocks. The Project Explorer will break out each subroutine for easy viewing. As you select each subroutine, only that source is displayed. This makes the program easy to modify and maintain in the future. If more capability or some special function is required, the External Function² instruction can be used to call an external user written DLL program. Developers can write their own routines in C++ and compile them as a .DLL extension.

Panels
Panels are used to define the graphical user interface. Panels support graphical objects such as labels, text boxes, command buttons, list boxes, drop-down boxes, lines, boxes and frames. Utilizing panels allows you to present standard Windows behavior or data collection process control behavior to the data entry operation.

Local db Files
The File I/O, File Transfer and Execute Transaction instructions will allow the developer to handle any database function (internal or external) to the terminal. CASE-Tools supports 32 local files, with up to 9 indexes each. These files conform to row and column, or table-like structures. Each row contains information from the fields created by the File Definition function. Multiple indexes may be setup with one or more contiguous fields providing a way to gain different logical or physical views of a local file.

Local ASCII Files
The Local I/O and Local File Transfer instructions will allow the developer to transfer or process flat ASCII files in its native form.

Debugging & Testing

Once a program is written, all aspects of the program may be tested to ensure it works to your satisfaction. The menu and tool bar section will assist the developer to place bookmarks, run the program, single step, start/view traces and view the terminal screen as it executes your program. Variable information can be viewed or changed as the program is tested. The trace function can be turned on and all events can be captured to a trace file.

Features
+ Integrated debugger allows you to step through your Instructions
+ Breakpoints, Single stepping, Run To Cursor are all supported
+ View & Modify variable data with the Data Tree while the program is running
+ Device simulator lets you test your mobile application on your PC
+ Browse into your structured files
+ Detailed tracing show every instruction executed.

Deployment

Compiling your application generates everything you need to get your system running:

  • All of your screens and application logic are compiled into single compact program file called a TIP (Terminal Interpreted Program).
  • There is no need to manually deploy the TIP to each device. Simply import your program into Pathfinder to make it available for download by all of your mobile devices.
  • Each TIP has embedded version information that your program can use to update itself.
  • The Transactions you defined in CASE-Tools are compiled as well and are also imported into Pathfinder. These transaction definitions act as a template so that when a mobile device utilizes an Execute Transaction Instruction, only the data from the mobile device needs to be transmitted. Your SQL and/or other definition fields reside only on the server.

The Compiler
With CASE-Tools there are no software development kits, no C licenses, or special libraries to load. The CASE-Tools compiler generates the application to run on the selected terminal with a supplied run-time module. All aspects of your program will execute once the compiled file is loaded on the terminal. These files are relatively small in size and execute very quickly.

 
RSS PRIVACY | CONTACT US