Wednesday - August 20, 2008
The More Intelligent Xbase.
For Microsoft Windows 2000 and XP Operating Systems
- Welcome to Visual Objects 2.7!
- Visual Programming Tools and a Complete IDE
- A Fully Object-Oriented Language
- Open Database Access
- An Active Repository
- A Native Code, Incremental Compiler
- A Portable Executable Format, Incremental Linker
- Reporting Using the Report Editor
- An Open Architecture
- Visual Objects 2.7 Features
Welcome to Visual Objects 2.7!
Visual Objects 2.7 is a fully object-oriented application development system that allows you to quickly and easily create sophisticated applications that run under Microsoft Windows and Windows NT. Its power and flexibility offer new opportunities and technology to application developers of all levels and backgrounds.Visual Objects 2.7 gives you the power to create high-performance, mission-critical, cutting-edge applications and components that deliver everything Windows users have come to expect, including:
- Multiple document interfaces (MDI), with no constraints on simultaneously opening several documents (such as databases or text files) or the same document in several different windows
- Event-driven operation, with no limitations on user flexibility and control
- Top-flight graphical appearance (including support for Windows common controls, OCX controls, and OLE 2.0) and full-fledged annotation, prompting, and help
- Support for Windows conventions and subsystems, such as the Clipboard, drag-and-drop editing, and help
Visual Programming Tools and a Complete IDE
The integrated development environment (IDE) provides tools that enable you to visually design the forms, menus, reports, icons, and so on, for your applications using point-and-click and drag-and-drop techniques. These tools let you see the result of your design as it progresses.The IDE is an intuitive and powerful environment for creating applications; for example, the Repository Explorer is patterned after the Windows Explorer which provides a consistent look and feel so you can get to work right away. The Repository Explorer allows you to browse projects, applications, libraries and DLLs, modules, entities, classes and errors.
The IDE offers a sophisticated and powerful environment for the advanced developer, with features that allow you to spend more time on the business logic aspect of application development. Visual Objects, for example, automatically tracks and maintains the relationships between the various pieces of an application for you, determining which components need to be compiled in order to build an application. Make files and compiler and linker script files are, therefore, obsolete.
Additionally, the IDE offers the capability of incremental linking when running from inside the IDE or debugging. This feature enables fast prototyping and quick feedback when you make changes to your application, it also enables you to test and debug your applications efficiently using the debugger in the IDE.
Visual Objects offers a just-in-time debugging feature. If an exception or a runtime error occurs while running an application (that has the debug option turned on in the application properties) from within the IDE, the debugger will be invoked in order to look at the error.
After developing, testing, and debugging your application, distributing it as a standalone EXE is easy. You simply click a button to generate an EXE, which can be distributed royalty-free to your end users.
A Fully Object-Oriented Language
The Visual Objects language is fully object-oriented. You may ask: Why object-orientation? There are many reasons, the most fundamental of which is that programming for event-driven, GUI environments presents a set of challenges that are aptly met by object-oriented programming (OOP).As you read through the Visual Objects documentation (in particular, the Programmer’s Guide), you will see how OOP naturally lends itself to GUI environments by giving you the capability to develop complex systems through standard, reusable components, in a manner that models the real world.
To facilitate object-oriented programming, Visual Objects includes extensive class libraries for:
- GUI programming
- Database management
- Internet client services
- Internet server applications
- Object linking and embedding (OLE)
- Reporting
Note: Class libraries are no different from other libraries you would use in your applications—instead of containing functions, for example, they contain class and method definitions.
The language also features a structured superset of the Xbase language. (Xbase is the industry standard term for those programming languages that inherit from the original dBASE system, including CA-Clipper, CA-dBFast, the dBASE family of products, and FoxPro.)
The Xbase superset contains extensions for Windows and its environment, including the ability to access all Win32 Application Programming Interface (API) functions for low-level, system programming.
Open Database Access
Visual Objects gives you a wide variety of choices in terms of database access. It supports:- Both procedural and object-oriented access to Xbase
databases
Visual Objects supports the procedural database commands and functions—such as SKIP and EOF()—that are traditional to Xbase languages.
It also includes, however, an object-oriented interface to Xbase database management. The object-oriented interface is akin, semantically and syntactically, to the commands and functions traditionally used in procedural access. Instead of commands like APPEND, COMMIT, and ZAP, for example, you will use methods named Append(), Commit(), and Zap() to perform the same operation.
Note: With these new methods, all the capabilities of the traditional Xbase approach are provided, but have been enhanced to fit the event-driven, multi-tasking nature of GUI applications.
- Access to both Xbase and SQL databases
When using an object-oriented approach to database management, both Xbase and SQL databases can be accessed. Furthermore, access to these two different types of databases is accomplished using a single, compatible protocol. This allows an application to manage Xbase and SQL databases with the same code.
- Several different Xbase/SQL database formats
When accessing Xbase databases (using either a procedural or object-oriented approach), you can choose from a variety of file formats. This is accomplished through replaceable database driver (RDD) technology. With RDDs, a single application can access different database file formats using a common language interface. This allows you to tailor your applications so that migrating from one database format to another is simple and straightforward.
Visual Objects supplies several popular RDDs, and through its open architecture allows for development of third-party RDDs. See the Replaceable Database Drivers section in the “Using DBF Files” chapter in the Programmer’s Guide for more information about RDD technology. Refer to the “RDD Specifics” appendix in the same volume for detailed information about specific RDDs.
Similarly, support for SQL databases is accomplished using Open Database Connectivity (ODBC), a widely used API for SQL access under Windows. This technology also uses replaceable drivers, supplied as dynamic link libraries (DLLs), which standardize the interface to the various database formats. Visual Objects comes bundled with DLLs for many of the popular ODBC formats, and provides language support for a superset of the standard ODBC API, as well as, an object-oriented interface compatible with that used for Xbase database files.
- Access to Jasmine databases
Visual Objects now provides native access to Jasmine, Computer Associates object-oriented, multimedia database. The Jasmine database supports complex data structures and large data volumes, and contains classes with definitions for many types of common multimedia objects, like video, audio, and pictures. Using the Jasmine Editor, these Jasmine database objects become native Visual Objects objects inside your application.
An Active Repository
Visual Objects is a repository-based system. The multi-tiered repository is where the IDE stores all application components, and it automatically manages the relationships between the various components of an application. If you make a change to a library component, for example, the repository automatically marks every application with that library in its search path, indicating that it should be rebuilt.With Visual Objects 2.7 you can create and use multiple repositories which are represented by projects. This allows a repository to be used on a system different from the system that created the project. Being able to use different projects makes it much more convenient to have a backup copy of your work.
A Native Code, Incremental Compiler
Visual Objects can compile your applications down to native machine code. This gives you the flexibility of using OOP without sacrificing runtime performance.To support iterative development, the compiler works with entity-level granularity. Entities, as explained in greater detail later in this guide, are the smallest pieces of an application (like a function or a global variable declaration). Entity-level granularity means that when you make a change to an application and then build the application, the compiler determines which entities of the application have changed (or are affected by the change), and automatically recompiles only those pieces, as opposed to recompiling entire modules.
Entity-level granularity is a powerful feature because it speeds development—you spend less time waiting for your application to be built and more time designing, enhancing, and fine-tuning. It also makes prototyping fast and easy.
Visual Objects background compilation feature allows you to compile an application and still work in the IDE. For example, while compiling your application you can add controls to your data form, browse your repository, or change your application properties.
A Portable Executable Format, Incremental Linker
Visual Objects 2.7 uses an incremental linker to speed the development process. The linker produces EXEs in portable executable format, the new standard for 32-bit applications.Incremental linking means that once an application has been compiled and linked to create an executable file, changes made to the application are tracked so that only modified code needs to be linked. This allows you to test and prototype applications faster than ever before.
Incremental linking of resources requires more space for an individual entity than actually needed in the EXE file, therefore, incrementally linked EXE files are bigger than non-incrementally linked EXE files. Visual Objects uses incremental linking only for temporary EXE files called DBG files. These DBG files reside in the same directory as the target EXE file and are used when running the application from within the IDE. It is important to note that certain changes to your application may require a full relink. A full relink can be forced by manually deleting the DBG files; this will force the linker to fully relink the application.
Just as Visual Objects provides background compilation, it also offers background linking. This feature allows you to link an application and still be able to make changes to the application in the IDE. See the Building an Application section in the “Working in the Desktop” chapter of the IDE User Guide for more information.
Reporting Using the Report Editor
The Visual Objects Report Editor provides powerful reporting capabilities for your applications. The Visual Objects Report Editor consists of the CA-Report Writer and the CA-Report Viewer.The CA-Report Writer offers a sophisticated database publishing interface, allowing you to design and produce custom database reports at the press of a button. While in the CA-Report Writer, you can use its intuitive, GUI environment to define the structure and specifications of the report. For example, you can add fields, text, tables, and pictures to a report, and format the various sections (like headers, footers, and titles). The CA-Report Viewer allows you to view your reports as they are created.
In addition to creating your application reports, the Report Editor will allow you to provide your users with the ability to create their own reports from within your Visual Objects applications.
An Open Architecture
Visual Objects features extensible subsystems that facilitate the integration of third-party tools within the product. It also supports a number of powerful features that allow your applications to interact with other applications and exchange data, as well as, use routines written in other languages, such as C, C++, Pascal, and COBOL.For example, you can:
- Access the functions stored in a DLL
A DLL is a library of functions in which only the interface definitions are visible, not the source code. Visual Objects has the necessary language support (such as pointers and structures) to access standard Windows DLLs, including the Win32 API.
Not only can you use DLLs in your applications, but you can build and debug them in Visual Objects. Visual Objects-generated DLLs can be used with either Visual Objects applications or with foreign applications. When using a Visual Objects DLL with a foreign host, it is the user’s responsibility to ensure that the exported DLL interface is compatible with the host’s capabilities.
- Use Dynamic Data Exchange (DDE) to exchange information
with other DDE-compatible applications.
- Interface with your system’s Clipboard facility to transfer
different types of data between applications.
- Use object linking and embedding (OLE) to incorporate
controls, objects, and even entire OLE-compliant applications
into your Visual Objects applications.
- With just a few mouse clicks you can easily enhance the
power of your applications by using OLE 2.0. OLE 2.0 is a
powerful way to integrate professional full-fledged
applications for a wide range of areas. OLE objects can also
be stored in DBF files.
- Use the Automation Server to create a Visual Objects
class from the OLE Automation objects provided by
third-party applications. This allows you to control
applications remotely through their macro language using
Visual Objects syntax. You can also create OLE
Automation Server applications, ActiveX controls, and
Active Server Page (ASP) components.
Visual Objects 2.7 Features
- Robust object-oriented language
- Complete 32-bit support
- Robust Class Libraries
- Full access to Win32 API
- C-style data types
- Native Code Background Incremental Compiler
- Full-featured Language Prototyping
- Background Incremental Linker
- Multitiered Repository
- Robust Integrated Development Environment (IDE)
- Application Execution from IDE
- Visual Design Editors (Window, Menu, Image, Data Server and Source Code)
- Window Editor Test Mode
- Common Controls
- Visual Debugger (with Just In Time Debugging)
- OLE including OLE Automation, ActiveX Control, Drag and Drop and DDE support
- EXE, DLL, ActiveX Control, OLE Automation Server, and Library Creation
- Informative sample applications, complete online Documentation and Help Files
- Install Diskette MAKE Utility
- Royalty Free Distribution
- Visual Objects 1.0, 2.0, 2.5, CA-Clipper and Xbase Compatibility
- DBF data file access
- Visual Objects Report Editor (including support for runtime report editing)
- 32-bit ODBC drivers
- SQL data file access
- CA-OpenIngres/Desktop
- SQL tools
- Internet client services
Protocol implementation for low-level Internet access, file transfers, and e-mail.
- Internet server applications
Internet interfaces for CGI applications and ISAPI libraries.
- OLE Automation server applications
Inter-application communication via OLE automation server applications or via Web servers supporting ASP components.
- ActiveX control creation
Inter-application communication utilizing Visual Objects windows as ActiveX controls within other applications.
- Jasmine multimedia applications
Native access to Jasmine, Computer Associates object-oriented, multimedia database.
- Win32 native console applications
Alternative to Terminal Lite applications for character-based debugging and logging output.
- Version control
An interface for source code control provides integration with Microsoft Common Source Code Control API.
- Compiler enhancements
- Thread-safe kernel runtime
- Reindexing projects without shutting down
- Support for DLL debugging
- New system-wide options for the Repository Explorer, Source Code Editor, and Debugger
- IDE enhancements, including the Application Gallery, Recent Imports List, and the Jasmine Editor
- Predefined application frameworks for the above-mentioned Internet, OLE server, and console application types, as well as additional application options
- Keyboard access for properties
- New Window Editor options, including a new window type, OLEDataWindow, and new controls
- Data-aware text controls
- Interactive tab order setting
- Band-style toolbars in applications
As you may have surmised by now, much of the power of Visual Objects comes from its class libraries, which provide an elegant and extensible way of using supporting services. They are tightly integrated with both the object-oriented programming language and the visual design tools in the IDE. Naturally, new libraries and classes have been added for Internet resources and to support OLE server components, native access to the Jasmine multimedia database, and console applications.
Similarly, the IDE has been updated with many new visual programming tools and features that reflect Visual Objects innovative technology. These include the Application Gallery, with its many predefined application frameworks, the Jasmine Editor, and the built-in source code control interface, as well as new system and application options.
Note: For complete information about all of these innovative features, refer to Visual Objects 2.7 Help — the online help system—and the New Features Guide.