|OLE ActiveX Control Class Generation|
|OLE 2.0, including OLE Automation, ActiveX control and OLE Drag and Drop support|
|Windows 95 and NT Common Controls|
|Window Editor Test Mode|
|CA-OpenIngres / Desktop|
|First Time Application Creation Wizard|
|Enhanced GUI Class Library|
|Language enhancements for even better performance including strong typed methods|
|Native-code background incremental compiler and linker|
|Visual Install Maker|
|Informative samples and complete online Documentation and Help Files|
|Enhanced browsers and GUI design tools|
|Enhanced Visual Debugger with Just In Time Debugging|
CA-Visual Objects 2.0 takes advantage of the new features found in the Windows 95 and Windows NT 32-bit operating systems and incorporates them into its own robust development system. With the use of CA-Visual Objects 2.0 and 32-bit operating systems, you will find new enhanced browsers and editors, many new controls, not to mention the addition of OLE 2.0 support.
CA-Visual Objects 2.0 features a robust, extensible, 32-bit object-oriented language. With it, you can create your own classes and methods, and take advantage of the most beneficial aspects of object-oriented programming (OOP), including inheritance, polymorphism, and encapsulation.
In addition to object-oriented capabilities, the CA-Visual Objects 2.0 language also contains extensions for Windows and its environment. For example, the language includes native C-style data types like pointers, structures, unions and zero-terminated strings, so you can do things like write DLLs and access Windows API functions for low-level, system programming.
To help you build applications, CA-Visual Objects includes a set of class libraries that you can use for GUI programming, OLE, and database management. These libraries provide very powerful building blocks for your applications—since they give you a head start on the most fundamental aspects of GUI database programming, you can instantly start using CA-Visual Objects efficiently and productively. Of course, at any time, you can create your own classes or subclass the supplied classes.
Not only is the language powerful and extensible, it is also tightly coupled with the tools provided with CA-Visual Objects. For example, when you use the visual design tools (such as the window and menu editors) to "paint" portions of your application and then save your work, CA-Visual Objects uses the supplied class libraries to generate object-oriented source code, based on your designs.
Creating sophisticated graphical applications without visual programming tools is difficult and time consuming. To hide the inherent complexity of GUI programming and to provide a way to create applications quickly and efficiently, CA-Visual Objects 2.0 provides an IDE with a rich set of tools. With these tools, you can visually design your applications using point-and-click, drag-and-drop techniques. For example, there are editors, which allow you to create windows, menus, source code, databases, reports, icons, cursors, bitmaps, and browsers, which let you organize and view your data.
|Source Code Editor||Repository Explorer|
|SQL and DBF Data Editors||Error Browser|
|OLE Automation Server Editor|
The newly designed Repository Explorer patterned after the Microsoft Windows Explorer combines the use of a Tree View and a List View providing 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.
Instead of working directly in programs with the CA-Visual Objects language (although you can, of course), you can interactively lay out and define both visual and data elements. When you are finished designing in the visual editors and save your work, CA-Visual Objects generates powerful and straightforward object-oriented source code based on the supplied class libraries. For example, creating a menu in the Menu Editor generates a subclass of the standard Menu class.
With the release of CA-Visual Objects 2.0, event handling routines can be cared for at either the window or control level. This provides added flexibility in coding style and allows developers to consolidate related event handlers by implementing them at the window level, and segregate specialized handlers by tying them directly to the controls with which they are associated.
The generated code is efficient and powerful, clean and maintainable, and forms a solid foundation for the future evolution of the application. Not only has it saved you the step of writing the code, but you also get a usable program, a starting point for modification into a complex program, an educational sample, or all of the above.
In addition to visual design tools and code generators, CA-Visual Objects provides a host of other complementary tools to complete the development environment, including a source code editor, a compiler, and a debugger. The IDE toolset provides a productive framework for developing all kinds of applications—including mission-critical business systems—and is specifically designed to support iterative development techniques.
Additionally, the IDE as mentioned above, offers the capability of debugging. This feature enables quick feedback when you make changes to the application, it also enables you to test and debug your applications efficiently using the debugger.
CA-Visual Objects 2.0 offers several features to help with the task of resolving those coding problems with ease. These features include, Breakpoints, just-in-time debugging, and the usage of the debugger to access other information about your application.
CA-Visual Objects 2.0 offers the ability to set your source code breakpoints before the application is even started. To accomplish this task the CA-Visual Objects 2.0 source code editor includes a breakpoint feature allowing you to set your breakpoints at a much earlier stage of development.
Another significant feature of the CA-Visual Objects 2.0 Debugger is just-in-time debugging. Just-in-time debugging allows developers trap an exception or a runtime error while running an application from within the IDE. As the application executes and a windows runtime or exception error occurs the debugger will be invoked allowing you to look directly at the problem.
CA-Visual Objects 2.0 is a multitiered repository-based development system. The repository is central to tying the features of CA-Visual Objects together in a cohesive way that increases programmer productivity.
CA-Visual Objects multitiered repository is broken into two parts (projects); the System part and the User part. The System part contains all information specific to the CA-Visual Objects system. This portion of the repository is read-only and can not be affected by the developer. The second part of CA-Visual Objects multitiered repository is the User part. The User part can contain an unlimited amount of user projects, available to be stored either locally or on a network. The user projects inherit their attributes from the System part creating a complete repository.
The repository provides a productive framework for developing all kinds of applications and is specifically designed to support iterative development techniques. Using traditional tools, developers need to create and maintain the make and link files that are necessary for tracking inter-application dependencies in a project.
The CA-Visual Objects repository, however, frees developers from worrying about details like this that can hinder them from using their time productively. It automatically keeps track of all the dependency relationships between application components, so compiling and linking applications is much simpler.
The CA-Visual Object 2.0 repository allows the whole development environment to benefit. The overall knowledge of applications, libraries and DLLs is known and utilized throughout the system. The source code editor, one prime example, stems its usage to allow the developer to right mouse click to expand prototypes and DLL declarations, or jump to other source code definitions.
In addition, the repository offers incremental compilation with entity-level granularity. Most make utilities work at the source-code file level so at least one entire module must be recompiled, even if the modification to that file was trivial. With CA-Visual Objects, only the affected entities are recompiled. So if you make a change to a single entity in a module of code, only that entity needs to be recompiled.
This greatly increases development speed, since only code that has been changed, or is affected by a change, is recompiled. Developers spend less time during the compile phase and more time designing.
The complexity involved in programming graphical user interfaces (GUIs) has inspired vendors to provide visual programming tools that hide most of the details from developers. Part of the simplification process involves postponing some decisions about how the code will operate until runtime. This means that these tools are unable to generate fully-optimized executable code.
The code that is produced instead is pseudo-code, often called PCode. PCode requires use of a runtime engine to further interpret the compiled code at runtime—this is what gives such code its flexibility and makes it easier to write. PCode, however, is much slower than fully-optimized native code. One of the most significant features of CA-Visual Objects is its background compilation native-code incremental compiler, generating executable code for the host CPU.
CA-Visual Objects compiler has also been designed to provide 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. Additionally, it makes prototyping fast and easy
The CA-Visual Objects language introduces strong typing to the xBASE language. (That is, developers can declare the data types of variables in declaration statements, such as LOCAL wDATA AS WORD.) When coupled with fine-grained scoping control and a state-of-the-art compiler, the result is high-performance, robust, native-code executables. This has significant real-world benefits:
|Since all type-compatibility checks can be performed at compile time, programs are more quickly and easily debugged.|
|You can greatly increase the integrity of your data and, therefore, the robustness of your application if you use strongly typed variables.|
|Because they involve no runtime overhead, using strongly typed variables significantly increases the efficiency, and consequently the performance, of your code.|
However, xBASE programmers like dynamic variables because of greater flexibility and easier prototyping. For this reason, CA-Visual Objects lets you decide: You can choose one programming style over another, or you can intermix strict and loose typing within the same application and even within the same function.
CA-Visual Objects allows but does not demand strict typing and scoping; it rewards but does not require meticulous programming. The more carefully structured your code, the greater the rewards in terms of performance. It’s under your control.
Moreover, with the compiler’s type inferencing facility, CA-Visual Objects can often determine the type of an untyped variable and generate native code for those routines that traditionally would have required PCode generation. You get some of the benefits of strong data typing without actually specifying data types in your code. The result is dramatic improvements in application execution speed without placing constraints on programmers.
CA-Visual Objects 2.0 uses a background incremental linker to speed the development process. The linker produces EXEs using the new standard for 32-bit applications. These new EXE files allow executables to be created for use with both Microsoft Windows 95 and Windows NT 4.0. The background linking ability of CA-Visual Objects allows you to proceed with other tasks while your application, library, or DLL is created.
Incremental linking means, 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.
One of the major new features of CA-Visual Objects 2.0 is OLE 2.0 support. CA-Visual Objects 2.0 supports much more than just what the name OLE implies. (Object Linking and Embedding). CA-Visual Objects 2.0 contains features such as OLE Automation, OLE Controls (ActiveX and OCX), data transfer, memory allocation, and file management.
The developer can now extended this new and exciting feature to their application right from within the CA-Visual Objects 2.0 development system. Using the CA-Visual Objects 2.0 Window Editor developers can directly add OLE to their applications. The Window Editor has been designed to become both an OLE Object and an OLE control (AcitiveX and OCX) container. With the incorporation of these features the Window Editor will have design and run-time modes, and the ability for dragging-and-dropping of objects and controls from the tool palette. You will also find capability for embedding and linking of objects, use of In-Place activation and editing of embedded objects. OLE support to the Window Editor also allows access to all the methods, properties and events of an ActiveX and OCX.
In addition to the usage of Object Linking and Embedding and OLE controls (ActiveX and OCX), CA-Visual Objects 2.0 also provides support for OLE Automation. OLE Automation is very different from the features of linking and embedding. While the concept of compound documents is central to linking and embedding, OLE Automation does not, at least not necessarily compound documents at all. Internally OLE Automation uses the same techniques as linking and embedding for the communication between clients and servers. Therefore, this causes OLE Automation to also be considered a part of OLE.
The basic idea behind OLE Automation is to define a standard for cross application macro languages. Most standard applications, for example word processors and spreadsheets, incorporate some kind of programmability through a macro language.
Establishing a standard for accessing the macro language may require an application to start another program to perform a specialized task. In other words, OLE Automation will standardize the protocol of a language and not the language syntax itself.
Through the use of the CA-Visual Objects 2.0 OLE Automation Server Generator, developers can now produce CA-Visual Objects code from the language defined in the OLE Automation Server. With the click of a button CA-Visual Objects will generate class, method, access, assign or any other definitions required to establish a link to the other languages.
CA-Visual Objects 2.0 for the Microsoft Windows 95 and NT operating systems allows the use of all the new common controls to be used when developing applications. Through the use of the CA-Visual Objects Window Editor using these controls is as easy as drag-and-drop. Listed below you will find those controls that have been added to increase your productivity to accomplish the many needs of today’s user.
CA-Visual Objects contains one of the most robust development languages available. With CA-Visual Objects 2.0 object-oriented programming has never been so much easier. With the use of the CA-Visual Objects language, applications will come alive. The addition of language features, such as Structure Alignment, Unions, Typed Pointers, Function Pointers, Typed Methods, Default Parameters , Variable Parameters, Expanded Class Libraries and more add more power than ever before. The developers will find that creating applications with CA-Visual Objects 2.0 suits all their Windows programming needs. Writing applications and accessing DLL’s and the Windows API has never been easier.
The STRUCTURE statement has been extended with an optional ALIGN clause. Today's modern processors demand specific data alignments in order to guarantee minimal access times. Aligning structure components on a byte boundary does not inherently fulfill this demand anymore. We might unfortunately fragment memory internally by not employing a byte boundary alignment. Trading off space for speed today is, however, quite reasonable.
UNIONs are like STRUCTUREs, but all members start at offset zero (0). In other words, assigning a value to a union member affects all other union members. You use the UNION statement to mark the beginning of the definition of a union entity, followed by one or more MEMBER statements that define what the union looks like.
With CA-Visual Objects 2.0 we have extended the view of a pointer to include semantic information. The compiler uses this information to identify the type of data held in the memory area the pointer addresses. This information now enables us to do pointer arithmetic.
Pointer typing is applicable to the majority of CA-Visual Objects' basic data types. Pointers can also be de-referenced using the [ ] operator. This will allow the developer to create de facto standard dynamic DIM arrays.
Another particular pointer type extended with the introduction of CA-Visual Objects 2.0 are the function pointers. The extension of pointers in CA-Visual Objects 2.0 is similar to that of the general typed pointers introduced above. Function pointers are now typed too; i.e. they now posses semantic information which the compiler can exploit. More to that, these function pointers can further be "de-referenced". We can, therefore, access the functions being addressed by these function pointers, i.e. indirectly calling them.
All the same, we do have special cases, were programmers should be capable of indirectly invoking functions whose specifications are completely unknown by their current applications. We, therefore, introduced special constructs which could be used in such cases
Protect and Hidden Methods
Protect and hidden methods are declared by prefixing a method declaration with the keywords PROTECT or HIDDEN. Both method types can only be called in the context of their class. You will also find that Protect methods are inherited by sub classes, were HIDDEN methods are not. The use of the Protect and Hidden Methods are for implementation of late bound (untyped) methods.
Typed Early Bound Methods
CA-Visual Objects 2.0 now includes the utilization of strongly typed messages in addition to its current untyped message implementation. The main aim of introducing strong typing of messages in CA-Visual Objects 2.0 is to provide the application programmer with a mechanism through which highly stable code can be obtained. The type information supplied, enables the compiler to perform the necessary type checking and, thus, guarantees a much improved quality of code. A further benefit obtained by utilizing strongly typed messages is that of performance. The CA-Visual Objects 2.0 implementation of typed messages presumes that when the programmer employs strongly typed messages, the compiler can effectively perform an early binding for the respective message invocation. As a result of this implementation, typed message invocations are much faster than the respective untyped counterparts.
The developer will find that CA-Visual Objects 2.0 allows strong typing of METHODs, ACCESSes and ASSIGNs. CA-Visual Object 2.0, supports the following calling conventions for typed messages: STRICT, PASCAL or CALLBACK.
CA-Visual Objects now supports the ability for developers to initialize default parameters. Developers will be able to give their applications more flexibility and can expand their usage of the PASCAL and STRICT functions. This flexibility also extends default parameters for use with strong typed methods.
CA-Visual Objects provides a mechanism for defining functions which can accept a variable number of parameters. Such functions are declared to the compiler by using an ellipses (...) as the last parameter in the parameter list of the function declaration.
CA-Visual Objects provide two special functions for accessing the variable parameters within functions defined to access a variable parameter list. These special functions are: _GetFirstParam() and _GetNextParam(). As their names suggest they are used for accessing the first and remaining parameters making up the variable parameter list respectively.
As do default parameters, variable parameters usage is also extended. This extension can also be found for use with strong typed methods.
Array Operator Use Beyond Third Dimension
CA-Visual Objects support has a dimension limit of eight when using the subscript operator to access the elements of an array. You can now directly use the subscript operator up to the eight dimension to access array elements.
Expanded Class Structures
Throughout CA-Visual Objects the class libraries have been found to be one of the most powerful development tools. The usage of these class libraries enable the developer to expand applications to greater levels. With this in mind, several class structures have been created and expanded to allow the developers easier access to features of the 32-bit operating systems.
CA-Visual Objects provides superb database access to meet all your database programming needs.
For SQL access, CA-Visual Objects 2.0 ships with the CA-OpenIngres®/Desktop™ along with several 32-bit ODBC database drivers, providing access to a wide variety of enterprise data stored in relational databases. The CA-Visual Objects language allows you to create SELECT statements for connection to your SQL backends, and fully supports joins, WHERE clauses, and ORDER BY clauses.
CA-Visual Objects 2.0 adds the ability to modify SQL statements generated by various CA-Visual Objects tools. This brings new power to developers wishing to customize or optimize SQL queries for specific databases. Such customization allows applications to be tuned giving maximum performance and flexibility.
For xBASE data sources, CA-Visual Objects utilizes replaceable database driver (RDD) technology (the same technology found in CA-Clipper). CA-Visual Objects ships with RDDs that support many standard xBASE file formats, including CA-Clipper, dBASE, and FoxPro (including FoxPro memo files).
The RDD architecture allows your CA-Visual Objects applications to remain data-format independent. Traditionally, most xBASE systems employed different database, memo, and index file formats—allowing a particular application to manipulate different database and ancillary files was difficult and time-consuming.
With RDDs, however, a single application can access different database file formats using a common language interface. By simply setting the proper RDD in your application, you can tailor your applications so that migrating from one database format to another is simple and straightforward.
CA-Visual Objects provides a set of built-in classes and editors that let you create data servers. A data server is an object-oriented "wrapper" around a data source: With this wrapper, you can easily design applications that are independent of the type of data storage used.
Designed for a Multi-Tasking Environment
Data servers are designed for the multi-tasking, multi-window world of GUIs. Database manipulation and management in a multi-tasking environment like Windows can be a difficult challenge. For example, in most Windows applications, users can open multiple databases or records in multiple windows and work with them simultaneously. This means that the same database must be open in multiple work areas; each work area must be presented in a separate window; and independent positions and locks must be managed. Each window, and the program that does the work, must be a self-contained unit that can exist in several instances (or copies) without "stepping on itself."
The procedural approach—the traditional structure of xBASE applications—is not well-suited for dealing with the complex demands of GUI environments such as Windows. For example, according to xBASE procedural programming conventions, all work areas must have unique aliases, leaving to the programmer the time-consuming task of managing the different aliases. Indeed, this problem with dynamic allocation and management of work areas, aliases, and other components is one of the main reasons most business database programming systems do not support opening the same window, with the same database, several times in independent windows. These systems thereby fail to meet one of the basic demands of Windows.
The object-oriented database services of CA-Visual Objects, on the other hand, solve this problem. The data server classes provide all the capabilities of the procedural approach, but also add structures that fit the event-driven and multi-tasking nature of GUI applications. They hide the technological artifacts of the alias and the work area, and make the database a self-contained object that can be used as many times as you want.
A Common Protocol
When using an object-oriented approach to database management, access to DBF and SQL data sources is accomplished using a single, compatible protocol. This gives you a consistent, interface for your database, allowing an application to manage SQL and XBASE databases with the same code. For example, once an SQL SELECT statement has been defined or an XBASE database has been opened in a work area, both can support the same basic protocol for moving, seeking, retrieving data; updating or deleting the current record; or inserting new records. In many cases, the same code can be used to manipulate your data, regardless of whether it is located in a SQL table or a DBF file.
This is because data servers provide a common set of methods based on a common database paradigm, encompassing fundamental operations like getting and setting field values, moving forward and backward by (logical) record positions, deleting or modifying the current record, inserting a new record, and searching for a given value. Furthermore, many of these methods have names that are similar, if not identical, to corresponding XBASE command and function names, simplifying the transition from procedural to object-oriented database programming, from flat-file data to relational SQL databases.
A Field-Level Data Dictionary
When setting up servers for your data sources, you can also design field specifications for the fields in those servers. A field specification (or fieldspec) is essentially an object with its own set of properties that are related to a field, but are independent of any particular data server.
The properties of a database field are grouped together in a FieldSpec object, and include data type and size, annotation such as a caption (label), a prompt and context-sensitive help, formatting, validation rules, error messages for the validation rules, and help for the error messages.
The benefits of using field specs are immediate:
n Ease-of-Use. Defining and maintaining all field properties in a single place is easier than defining database-related properties in one place, display-related properties in another, and so on.
n Reusability. In many cases, the different data servers your application uses contain similar, if not identical, fields. When you set up a fieldspec for one of these common field types, you can simply reuse it when creating a similar field in a different server. (For example, if you create a Salary fieldspec, you can simply reuse its properties when creating an EmpSalary field in a data server for an Employee database. You can then reuse its properties again when creating a similar field for a data server for a Payroll database. Other common examples include phone numbers and zip codes.)
n Reduced Maintenance. Another advantage to fieldspecs is that if any changes are made to a fieldspec, they are automatically propagated to all the appropriate places. For example, if you add extra validation to the AcctNum fieldspec to require that its second digit must be zero or 5, then all data servers that use that fieldspec would automatically perform that validation.
Using field specs, therefore, saves you both time and resources.
However, one of the most significant benefits of fieldspecs is that many of the other classes in CA-Visual Objects are "data-aware." Therefore, much of the information that you define for servers and fieldspecs can be used by other components of your application. If, for example, you create a data server, apply display (picture-clause) formatting and validation rules for one of its fields, and then attach that server to a window, the window will automatically honor those fieldspec properties, using the formatting rules to display the field’s data and checking the validation rules before attempting to write any data to the database.
Note: The above behavior is true of "data windows," a particular type of window in the CA-Visual Objects class hierarchy. By their very nature, data windows are capable of interacting intelligently with data servers. For example, data windows can easily display the contents of a data server and have preprogrammed methods for navigating through a data server (i.e., Go to Top and Delete Record). You’ll learn more about data windows throughout this guide.
With the creation of CA-Visual Objects 2.0, compatibility is viewed at a much greater extent then ever before. Along with providing a migration path for CA-Clipper, CA-Visual Objects 2.0 is also upward compatible from CA-Visual Objects 1.0. CA-Visual Objects 2.0 contains tools and features that allow migration of character-based applications to the Windows environment, along with the ability to import source code, and complete applications into CA-Visual Objects 2.0.
If migration from the DOS environment is an issue, then CA-Visual Objects is the answer. CA-Visual Objects allows you to take your already proven xBASE business logic and incorporate it into your applications. With the addition of the CA-Clipper preprocessor, migrating existing CA-Clipper code has never been so easy.
|Support for CA-Visual Objects 1.0 applications and
|A language layer that is largely compatible with
CA-Clipper. Including the CA-Clipper preprocessor for complete header
|An active repository that eliminates the need for the
programmer to document the intra-application dependencies or use a make
|Several compiler options geared toward compatibility
that you can change as you migrate your application to the event-driven,
GUI programming style.|
|Predefined database classes that give you the
immediate benefit of opening the same file in multiple work areas. The
methods of these classes are designed to closely resemble the database
commands and functions that you are already familiar with, and you can
use them with your existing database and index files, making the
transition from procedural to object-oriented database access as easy as
|Visual editors that can be used to quickly and easily "paint" a new interface and that generate powerful object-oriented programming (OOP) code.|
Re-engineering the user interface using the visual tools makes converting to the event-driven, multitasking, GUI environment painless and preserves tested business logic. A move from DOS to Windows requires a move away from traditional program structure. The event-driven nature of Windows (or any other GUI) requires you to use event handlers throughout your applications.
Despite sweeping and necessary architectural changes, your business logic remains surprisingly intact. The code you write to fetch data from the database, to validate data that you capture, and to commit it back to the database looks very similar to the code of traditional XBASE programs. The skeleton is entirely new, but the muscles of business logic that make it effective remain unchanged.
Efficient prototyping in CA-Visual Objects 2.0 is possible for many reasons. First, you can lay out an application and test it without having to complete the application logic. This is because many of the editors in CA-Visual Objects are visual and let you design applications (i.e., lay out various GUI controls—like push buttons, check boxes, and scroll bars—on a window, and select View, Test Mode from the Window Editor menu to run your window directly within the Window Editor) using simple point-and-click, drag-and-drop techniques. When designing in this fashion, visual feedback is immediate, helping the developer better meet the needs of the end user.
Prototyping features stem throughout the CA-Visual Objects 2.0 development system. CA-Visual Objects lets you execute applications from directly within the development environment. This is called dynamic execution . Since the repository always knows the makeup of an application under development, it can assemble the application’s components at any time. Consequently, you can test on-the-fly changes made to an application by running it from within the IDE.
A new addition to the prototyping features of CA-Visual Objects is the usage of background incremental linking. As mentioned earlier in this guide incremental linking allows the developer to speed up executable file creation. 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. Incremental linking gives you the capability to test your application prototype much faster than ever before.
Prototyping substantially improves the usefulness of CA-Visual Objects applications in two areas. First, applications that are prototyped in stages during development are more likely to meet the needs and desires of the end user. Second, since applications can be tested as they are taking shape, they will be more stable and require less debugging after they have been completed.
In combination with other features like the automatic MAKE facility, loose typing, and the type inferencer option, CA-Visual Objects provides the flexibility you need to make the development process fast and easy, as well as to free you from dealing with technical details that can hinder you from using your time productively.
To help build your applications, CA-Visual Objects includes extensive class libraries for GUI programming, database management, OLE, and reporting. These libraries provide very powerful building blocks for your applications, and are strengthened by the fact that the visual tools in the IDE use these class libraries to generate object-oriented code based on your designs.
Managing memory and system resources can consume a great
deal of time during development. For this reason, CA-Visual Objects
manages memory and system resources automatically.
The result is less time spent worrying about memory allocation conflicts, and more time on business logic. For complete control, however, CA-Visual Objects also allows manual memory management, if desired.
For many reasons, CA-Visual Objects 2.0 is the solution for today’s client/server developer who is looking for a Windows application development tool.
CA-Visual Objects starts with a proven and familiar business language , and adds complete object-orientation and the ability to do low-level system programming. As a result, you can create and distribute royalty-free EXEs and DLLs.
As a result, you get a product that respects your investment and leverages your knowledge and know-how, but at the same time provides the best of the new technologies needed to meet event-driven, GUI environments, visual design tools, repository, native-code compiler, and superb database connectivity for DBF and SQL data sources, just to name a few.
Furthermore, many client/server development tools can’t go the distance when it comes to large sophisticated application development because they do not give the programmer enough power to handle system-level tasks. CA-Visual Objects 2.0 provides full access to the Win32 API and supports both the calling and creation of DLLs. This means that developers won’t run out of steam when projects become large and complex.
In addition to client/server development, CA-Visual Objects is also the premier OLE 2.0 client development system. It gives the developer access to all OLE 2.0 features by integrating them easily and transparently into the CA-Visual Objects 2.0 class hierarchy and language.
In conclusion, CA-Visual Objects 2.0 is designed for the Microsoft Windows NT 4.0 and Windows 95 logo and will bring the ability to succeed to all developers and programming teams with a comprehensive application development system that is easy to use, uniquely powerful, and that gives the control required by corporate and independent developers alike.
CA-Visual Objects - The Simpler C++, The Smarter Basic, The Easier Pascal, The More Intelligent XBASE
Questions or problems regarding this web site should be directed to
Copyright © 1997-2014 Rocky Mountain Software Inc. All rights reserved.