Review of the free version of Delphi. Delphi Free Edition Review What's New in the Development Environment

Delphi 6 is a powerful high-performance application development environment that greatly simplifies the development of next generation e-business applications. Delphi includes a large set of tools for managing and delivering business data using open standards.

The BizSnap Web Services development platform simplifies the development and integration of business-to-business (B2B) applications by building Web Services based on SOAP / XML standards and providing interconnection tools to integrate the business of the product manufacturer with the business of its suppliers and customers. companies.

The WebSnap Web Application Development Platform delivers fast, efficient, and reliable development.

The DataSnap platform enables developers to create high-performance, multi-tier solutions that access data through software middle tier, allowing you to integrate such solutions with any applications of your business partners.

BizSnap
Providing Web Services Integration

Delphi BizSnap is a powerful Web Services development platform. BizSnap simplifies the exchange, transformation, and manipulation of XML documents, making your business applications flexible and extensible for the next wave of e-business. Delphi is fully compliant with industry standards, which means it can adequately respond to the rapidly changing demands of today's business. Delphi allows you to work closely with the various applications of your channel partners using platforms such as .Net and BizTalk from Micorsoft, ONE from Sun Microsystems.

WebSnap
Accelerate Web Application Development

WebSnap is a complete web development platform for Delphi using the most advanced Rapid Application Development (RAD) tools. Tools included with WebSnap, such as the debug Web server, make it easier to debug and test applications. The ability to tightly integrate WebSnap applications into corporate Web sites, portals developed using well-known tools such as DreamWeaver and FrontPage, as well as support for server-side scripting in JavaScript, VBScript, and other languages allow you to leverage existing Web application developments.

DataSnap
Providing Web-Enabled Mid-Range Application Development

Delphi DataSnap leverages all existing distributed data processing standards such as SOAP, XML, COM, CORBA, and TCP / IP tools to simplify the integration of existing systems with new e-business applications. These standards allow Delphi applications to interact with any business process or Web service from your partners. DataSnap provides high performance access to DBMS such as DB2, Informix, InterBase, MS SQL Server, Oracle and Sybase.

DataSnap optimizes the number of connections and data flows between clients and database servers by centralizing data access and updates among all e-business processes and applications, and also allows applications to scale based on changes in the amount of data processed.

Name: Delphi 6 - Object Pascal Programming.

The book is a guide to programming in the Delphi 6 environment. It covers the entire process of creating a program: from developing an algorithm and a dialog box to debugging and creating a help system. The material includes a number of topics that, as a rule, remain outside the scope of books addressed to novice programmers: processing symbolic information, using dynamic structures, working with files, creating a help system. The questions of working with graphics, multimedia and databases are considered. The description of the animation creation process in Macromedia Flash 5, the creation of the help system using the Microsoft HTML Help Workshop program is given.
The book is notable for the ease of presentation, a large number of illustrative examples and is addressed to students, high school students and all those who study programming in an educational institution or on their own. The accompanying diskette contains examples of the programs shown in the book.

Content
Foreword
Delphi - what is it?
About this book
Introduction
Beginning of work
First project
The form
Components
Event and event procedure
Code editor
Hint system
reference system
Project structure
Saving the project
Compilation
Errors
Warnings and hints
Launching the program
Runtime errors
Alteration
Final application setup
Creating a unique icon for the application
Transferring an application to another computer
Chapter 1. Basics of programming
Program
Stages of program development
Determining program requirements
Algorithm development
Coding
Debugging
Testing
Algorithm and program
Compilation
Object Pascal programming language
Data type
Integer type
Real type
Character type
String type
Boolean type
Variable
Constants
Numeric constants
String and character constants
Boolean constants
Named constant
Assignment statement
Expression
Expression type
Executing an assignment statement
Standard functions
Arithmetic functions
Type conversion functions
Using functions
Data input
Input from input window
Input from edit field
Output of results
Output to the message box
Output to a dialog box field
Procedures and functions
Procedure structure
Function structure
Recording program instructions
Programming style
Chapter 2. Object Pascal Control Structures
Condition
Choice
IF statement
CASE statement
Cycles
FOR statement
WHILE statement
REPEAT statement
GOTO instruction
Chapter 3. Symbols and strings
Characters Strings
String operations
LENGTH function
DELETE procedure
POS function
COPY function
Chapter 4. Console application
Instructions WRITE WRITELN
READ and READLN instructions
Creating a console application
Chapter 5. Arrays
Array declaration
Array operations
Array output
Array input
Using the StringGrid component
Using the Memo component
Finding the minimum (maximum) element of an array.
Searching an array for a given element
Simple enumeration algorithm
Binary search method
Sorting an array
Sorting by direct selection method
Sort by exchange method
Multidimensional arrays
Errors when using arrays
Chapter 6. Procedures and functions
Function
Function declaration
Using the function
Procedure
Procedure declaration
Using the procedure
Reuse of functions and procedures
Module creation
Using the module
Chapter 7. Files
File declaration
File purpose
Output to file
Opening a file for output
File open errors
Closing the file
Sample program
Input from file
Opening a file
Reading data from a file
Reading numbers
Reading lines
End of file detection
Chapter 8. Programmer-Defined Data Types
Enumerated type
Interval type
Recording
Record announcement
WITH statement
Input and output of records to a file
Outputting a record to a file
Entering a record from a file
Dynamic data structures
Pointers
Dynamic variables
Ordered list
Adding an item to the list
Removing an item from the list
Chapter 9. Introduction to Object Oriented Programming
Class
An object
Method
Encapsulation and Object Properties
Inheritance
Protected and Private Directives
Polymorphism and virtual methods
Delphi Classes and Objects
Chapter 10. Delphi graphics capabilities
Canvas
Pencil and brush
Pencil
Brush
Text output
Methods for drawing graphic primitives
Line
Broken line
Circle and ellipse
Arc
Rectangle
Polygon
Sector
Point
Displaying illustrations
Bitmaps
Animation
Base point method
Using bitmaps
Loading a bitmap from a program resource
Creating a resource file
Connecting a resource file Viewing "cartoon"
Chapter 11. Delphi multimedia capabilities
Animate component
MediaPlayer component
Play sound
Sound recording
Watching videos and animations
Animation creation
Chapter 12. Recursion Concept of recursion Program examples
Search for files
Hilbert curve
Finding a way
Finding the shortest path
Chapter 13. Debugging a program
Error classification
Preventing and Handling Errors
Debugger
Tracing the program
Program breakpoints
Adding a breakpoint
Changing breakpoint characteristics
Removing a breakpoint
Observing Variable Values
Chapter 14. reference system
Help Document File
Creating a help system
Using the help system
Html
Help
Workshop
Preparation of reference information
Using the Microsoft Word editor
Using HTML Help Workshop
Create a help file
Compilation
Displaying help information
Chapter 15. Sample programs
Knowledge Testing System
Requirements for the program
Test file
Application form
Illustration output
Uploading a test file
Program text
Improvement of the program
Minesweeper game 2001
rules
Data presentation
Application form
Beginning of the game
The game
reference Information
Information about the program
Listings
Chapter 16. Programmer component
Choosing a base class
Creating a component module
Testing a component module
Installing a component
Component resources
Installation
Component installation errors
Component testing
Removing a component
Customizing the Component Palette
Chapter 17. Databases Database classification
Local database
Remote database
Database structure
Database Model in Delphi
Database alias
Database creation
Create a directory
Create an alias
Creating a table
Database management program
Access to the data file (table)
Database browsing
Form mode
Table mode Fetching information from the database Dynamically created aliases
Transferring the database management program to another computer
Conclusion
Annex 1. Pascal language (quick reference)
Reserved words and directives
Module structure
Basic data types
Strings
Array
Recording
Selection instructions
If statement
Case statement
Cycles
For statement
Repeat statement
While statement
Unconditional jump
GoTo instruction
Function declaration
Procedure declaration
Standard functions and procedures
Appendix 2. Windows character encoding
Appendix 3. Presentation of information in a computer
Decimal and binary numbers
computer memory
Appendix 4. Recommended Further Reading
Appendix 5. Floppy disk description
Subject index

At the beginning of May this year, Borland Software Corporation, a well-known manufacturer of development tools and middleware, announced a new, sixth version of Delphi, a tool for rapid development of Windows applications, which has long been the leading product of this company and is still very popular in our country. In this article, we'll take a quick look at what's new in this product compared to previous version... We assume that the readers are familiar with previous versions of Delphi; for those who are not familiar with this product, we can recommend referring to the books on previous versions - there are more than enough of them published in Russian.

What's new in the development environment

All open content packages are now displayed in the project manager. This can be convenient when writing components: in the process of testing them, you can work simultaneously with a project intended for testing components and with a package that contains the component under test.

A new element has appeared in the development environment - the Object TreeView, which displays the hierarchy of application components in terms of their belonging to each other (Fig. 1). In the object tree, you can perform drag-and-drop operations, moving child components to other containers, and these changes are synchronously displayed in the form editor.

Note that components that do not have key properties defined are marked with question marks in the object tree, which immediately grab attention. In addition, the object tree also displays components that are implicitly created (Fig. 2).

The code editor now has the ability to select view modes using the shortcuts at the bottom of the code editor (the list of available modes depends on the type of application you are creating). In general, in addition to displaying the actual application code, the following display modes are available:

Diagram - displaying connections between data access components like the data module editor from the previous version of Delphi);
HTML Scrip - displaying HTML and JavaScript code generated by components that are designed to create interactive Web applications (you can read more about them in the article "Developing Internet Applications Using Borland Delphi and Kylix" in this issue of the journal);
HTML Resul - displays the HTML code generated when using the HTML template;
Preview - displays the generated HTML output as it appears in the client browser (Figure 3).

There is also something new in the object inspector. In particular, if the property value is a component, then it is displayed in a different color, and if you click on it, you can expand the list of its properties. In our opinion, this is a rather convenient innovation (Fig. 4).

Read-only properties are now also displayed in a different color. In addition, you can specify what colors to display in the object inspector - for this purpose the Object Inspector Properties dialog is used (Fig. 5).

The Code Insight and Code Completion tools have also undergone some changes. So, now you can use the Code completion tool in the module interface section, get a list of virtual methods, properties and interface methods, filter the values of the elements in the list. Changed somewhat appearance dropdown list Code Completion: items different types are displayed in different colors, along with the method name, a list of parameters appears, and the size of the list box can now be changed (Fig. 6).

Note that the new version provides a separate toolbar for creating Web applications (Fig. 7).

Compiler changes

Let's briefly list some of the changes made to the compiler:

all procedures and functions intended for working with Variant data types have been removed from the System module and moved to the new Variants module. Note that in Delphi 6 you can create your own variant data types - the corresponding classes must inherit from the TcustomVariantType class;
the Consts.pas module is split into two parts: Consts.pas and RTLConsts.pas;
the $ IFDEF compiler directive supports the evaluation of expressions using constants, for example: ($ IF Defined (WIN32) and (MyValue> 1)) ... ($ ENDIF)
Pascal constants can also be used in these expressions, and you can check whether they are declared, for example:
($ IF Declared (SomeConst)) ... ($ ENDIF)
Delphi 6 contains a new inline assembler. Details about it (as well as some other changes made to the compiler) can be found in the product help system.

New in VCL and RTL

The Visual Component Library, as is always the case with the release of the next version of Delphi, has been replenished with new components. From components designed to create user interfaces Windows applications should be specially noted:

TLabeledEdit - a field for entering text with a label (Fig. 8);
TValueListEditor - a component designed to display a list of pairs of "parameter-value" type, similar to that shown in the object inspector (Fig. 9);
TComboBoxEx - a combo box to display next to text graphic images(fig. 10);
TColorBox is a combo box for choosing a color (Fig. 11).

Many of the components have acquired additional properties (for example, indicating how component borders look like BevelEdges, BevelInner, BevelOuter, BevelKind, BevelWidth).

Another innovation in VCL is the ability to use so-called subcomponents as properties, that is, components owned by another component rather than a form. In other words, a property of a component can be a reference to a component, which is either a regular component or a subcomponent. This means that the properties of the subcomponents should now be available in the property list of the owner components, and it is for this purpose that the corresponding changes have been made to the object inspector, which were mentioned above.

The introduction of the TActionList component in one of the previous versions of Delphi made it much easier to create user interfaces for applications. Delphi 6 adds new components to work with TAction objects - TActionManager (for storing a collection of Taction objects; Fig. 12), TToolActionBar and TMainMenuActionBar (interface elements designed to provide the user with access to the functionality described in TAction objects).

Note that you can create menu items in the TMainMenuActionBar component and buttons on toolbars created using the TtoolActionBar components by transferring the corresponding objects using the drag-and-drop method from the properties editor of the TActionManager component. Delphi 6 also contains an impressive set of standard TAction components.

Several new properties and events have appeared for the TTreeView, TMenuItem, TListView, TCheckListBox, THeaderControl, TDateTimePicker, TDBLookupListBox, TDBLookupComboBox, TDBComboBox, TDBListBox, TOpenDialog, TListListTlist, TScreen TComponentList, TClassList, TCollection, TStack, TQueue, TObjectStack, and TObjectQueue. Several new classes have also appeared, for example. TCustomListControl, THashedStringList)

Properties of type Interface can now be published if there is at least one component that implements this interface.

Other changes in the VCL and RTL include the presence of some new functions for working with date and time, a couple of new functions for working with dynamic arrays, several new standard colors, including clMoneyGreen - gray-green like a dollar (oh, those Americans who consider your country is the navel of the earth and the center of the universe!). Note also that many of the functions for working with Variant data no longer call Windows functions API, and functions from the Variants.pas module are made to support multi-platform application development.

Database Applications: What's New?

Delphi 6 introduces a new universal data access mechanism, dbExpress. To use it in applications, Delphi 6 contains data access components and database drivers that implement the interfaces of this universal data access mechanism using the client APIs of the corresponding server DBMS. Delphi 6 delivery set includes dbExpress drivers for InterBase, Oracle, DB2, MySQL. DbExpress drivers are one DLL, and they are usually the only one required when shipping client applications that use dbExpress. DbExpress was developed by Borland but is open source, so you can create dbExpress drivers for your applications as needed.

All of these features set dbExpress apart from the BDE library traditionally used in Delphi and the only supported universal data access engine before Delphi 5 introduced ADO component-level support. BDE, being a descendant of the Paradox Engine library, has retained many of the features of the desktop database access mechanism that cannot always be successfully applied when working with server-side DBMS. We can say that by now the issue of replacing the universal data access mechanism with a more relevant modern needs has already matured, especially since such a mechanism still needed to be developed when creating Kylix - the Linux version of Delphi (you can find an article about Kylix in this issue of the journal ).

However, BDE is still supported in Delphi 6, so there is no need to rewrite legacy applications that use this data access mechanism yet.

Due to the fact that Delphi now supports three universal data access mechanisms: BDE, ADO, and dbExpress, the component palette has been reorganized somewhat (Figure 13).

Note that in Delphi 6 there is no MIDAS page in the component palette (and the term MIDAS itself has been deprecated). Components for distributed applications have been moved to new page DataSnap, which also contains several new components (Figure 14).

The main components of dbExpress data access include:

TSQLConnection - a component that provides a database connection and interacts directly with the dbExpress driver;
TSQLDataSet - a client dataset that implements the functionality of a unidirectional cursor (the dbExpress library itself allows you to create only a unidirectional cursor, since it does not buffer data in the client application);
TSQLQuery, TSQLStoredProc, and TSQLTable are client datasets that also implement unidirectional cursor functionality and are designed primarily for compatibility with their respective BDE components in legacy applications that are replacing BDE with dbExpress.

If you need to edit the data retrieved with dbExpress, you can use the TClientDataSet or TSQLClientDataSet components. To implement client datasets cached in random access memory client application, Delphi 6 has three new classes: TBDEClientDataSet, TSQLClientDataSet, TIBClientDataSet, which are descendants of the new base class TСustomClientDataset, intended for use with different data access mechanisms.

The TClientDataSet component has gained several additional properties related to handling trailing spaces in string data, accessing data packets in XML format, changing the data access component, and choosing a data source. In addition, several components have appeared that allow you to convert client datasets to XML and vice versa.

The TUpdateSQL component has also undergone some changes: now it can be used not only with BDE datasets, but also with other datasets; you can also use several of these components when caching data using client datasets. It should be noted that client datasets, which appeared in Delphi 3 only as a means of caching data in the presentation layer of distributed applications, have gradually become the main mechanism for working with databases in all applications, regardless of their architecture. However, this was to be expected - after all, many developers have been using them for this very purpose for a long time.

To support client datasets in distributed applications, two new components have been created: TSharedConnection, which allows a client application to access multiple remote data units on the same server, and TLocalConnection, which is intended for use with data providers that are contained in the same application as the client dataset.

When discussing database support in Delphi 6, one cannot help but dwell on ADO support. Unfortunately, nothing new has appeared here - neither a query editor, even remotely resembling SQL Builder, nor bug fixes in the help file (for example, in the list of methods of the TADOStoredProc component, there is still no reference to ExecProc - one of the most important methods of this component); as before, there is no OLAP support, except for the presence of DecisionCube components, which still do not work with ADO sources; there is no component-level support for the new objects introduced in ADO 2.5 and 2.6. It seems that ADO support in Delphi has received little attention this year. But such annoying little things can make someone think that there are other development tools ...

XML support

Delphi 6 supports the creation of applications that use XML documents and allow them to be integrated into database applications. In particular, this product contains several different tools for working with XML documents:

components and interfaces for working with XML documents in applications;
XML Data Binding wizard that generates classes to represent a specific XML document;
components and utilities for converting XML documents into data packages and vice versa, including the XML Mapping Tool (Fig. 15).

The new version allows you to work with XML documents in the same way as with regular databases. Support for the use of XML in database applications relies on components that convert data packets to XML documents and vice versa. To use these components, you must define the appropriate rules for converting XML to data packets and vice versa, which is done using the XML Mapping Tool. After defining the transformation rules (saved in a file), you can either convert the XML document to a client dataset, or work with it like a database, reading the data and saving the editing results in it.

New tools for creating Internet applications

Tools for creating Internet applications have undergone significant changes in the new version of Delphi. Now Delphi supports Web services and writing clients for them using SOAP, creating applications for Apache, and much more (you can also read about what's new in the tools for creating Web applications in Delphi 6 in the article "Developing Internet Applications using Borland Delphi and Kylix ").

CORBA support

Three years after acquiring VisiBroker, Delphi finally includes the IDL2PAS compiler for building CORBA servers and clients. It can be used to generate code for stub and skeleton objects in Pascal (until now, VisiBroker users could generate the corresponding code only in C ++ and Java, which excluded full CORBA support in Delphi - early CORBA support was based on the use of COM for this purpose ). The IDL2PAS compiler is available through the Tools | Regenerate CORBA IDL files menu item in the Delphi development environment.

Delphi's full CORBA support means that you can now create client applications for CORBA servers built with other development tools and programming languages (in particular, C ++ or Java), as well as for CORBA-enabled application servers (mainly Borland Application Server ; see the article in this issue of the journal).

Building multi-platform applications

The Delphi 6 package contains another component library, Borland Component Library for Cross-Platform (CLX), intended for use on both Windows and Linux (see the Borland Kylix article for details). Many of the CLX components and classes have the same names as their corresponding VCL components and classes, as well as overlapping property, event, and method lists. CLX can be used to create source-compatible Kylix applications.

To create an application portable to Linux, select File | New | CLX application from the development environment menu. After that, the palette of components will change: it will display the components available in the CLX.

It should be borne in mind that today there are not many RAD tools that allow you to create multi-platform applications - especially those based on compilers.

Instead of a conclusion

The development of application building and data exchange technologies seems to be difficult to stop. And if you ignore this fact, it will be difficult to survive in a competitive environment, especially for toolmakers.

We made sure that Delphi 6 is certainly an interesting and noteworthy product, and the innovations that are present in it mainly reflect the current trends in the development of the industry: this product has support for Web services, SOAP, XML data exchange, full CORBA support and even multi-platform support. Progress is clearly noticeable compared to the previous version, in which there were, perhaps, not so many innovations: ADO support, some changes in distributed computing technology, changes in COM support - but that's, in fact, that's all ... to argue that the best results (from the point of view of the desire to purchase a product) are led by the release of new versions more than once a year according to the calendar, as it was before, namely at the moment when new technologies, standards, platforms appear, the support of which is needed by the developers.

And nevertheless, it should be noted that so far not all are supported in Delphi. modern technologies... For example, there is no hint of Microsoft .NET support, and this is in a situation where the Windows version of Delphi ( operating system, created, as you know, by the same Microsoft company) remains one of the most popular and best-selling Borland products. Borland managers assure that they are just waiting for the corresponding operating system to appear. They, of course, know better. And it is up to us to decide whether we are also ready to wait with them.

ComputerPress 6 "2001

Is one of the most successful products in Borland's line of IDEs (which began with Borland Delphi and most recently at this moment 10.1 Berlin). The program is intended primarily for developing applications in the client-server architecture. The main modules Delphi 7 produces are .exe and .dll. The visual design environment of the program takes on many routine functions for preparing the application. By doing this, it speeds up the creation time of the application and improves its quality. In many ways, the Borland C ++ Builder product has similar parameters, but instead of Pascal, it uses the C ++ language.

Delphi advantages and disadvantages

Application development time is significantly lower than when working in similar programs;
+ high performance in a compact volume;
+ the created application has minimum requirements to PC resources;
+ the ability to build the potential of the program through plug-in modules;
+ as well as the ability to create such modules in the Delphi environment itself;
+ harmonious hierarchy of objects;
- big size some final applications and programs;
- impossibility of using other standard UI;
- lack of flexibility and originality: for any program executed in Delphi, one can understand that it is executed in Delphi.

Key features

creation of applications and application programs in the Delphi language;
launching and debugging programs in the Delphi language;
creation of cross-platform reports Rave Reports;
work in the modeling environment ModelMaker;
development of WEB-applications;
editing, debugging and launching WEB applications;
visualization, integration and reengineering;
built-in manuals for basic functions;
possibility of using ready-made templates design;
using the modules.exe and.dll.

If you want to develop applications faster than in Visual Basic, and at the same time not approach the problem too complex, as in C ++, then Delphi is for you.

Borland continues its development, and - here new package Delphi 6. It is the fastest Windows developer and application builder and now supports all the most common WEB features and servers. With Delphi 6, individual or corporate users can create next-generation e-business packages and applications quickly and easily.
Delphi 6 is a powerful, highly productive application development tool. He helps to complete any project in the shortest possible time. This application builder provides you with powerful, state-of-the-art, standardized utilities for controlling and fine-tuning your business data.
Delphi 6 now provides Linux compatibility, and supports database programming for Access, DB2, Dbase, FoxPro, InterBase, Informix, MS SQL, MySQL, MyBase, Oracle, Paradox, and Sybase.
Delphi 6 has new features and changes in the following areas: IDE, Internet, XML, Compiler, COM / Active X, Database support, CORBA, Actions, Custom Variants, VCL units and features, RTL units and features, Cross-platform development, Translation tools, Deployment changes, Help system extensibility.
However, some changes are not available in individual versions of Delphi 6.
Let's consider what features the integrated development environment Delphi 6 Enterprise Edition has.
After starting Delphi, the following windows will open in front of you (Figure 1).
You can see that a new element has appeared above the object inspector - this is the Object TreeView. Located in the top-left corner of the IDE, the TreeView is a tree diagram that shows the logical relationship between visual and non-visual components on a form.
The TreeView is synchronized with the Object Inspector and the Form Designer so that if you select a component and change it in any of the three tools (form, Object Inspector, or TreeView object), the changes are reflected in the other two tools.
The TreeView object has some characteristics, let's look at them. It's located above the Object Inspector, and if you've hidden it, it appears when you press Alt + Shift + F11 or select View | Object TreeView.
The TreeView object displays both visual and non-visual components.
The toolbar includes a delete command and up and down navigation buttons that work for the composite properties of components. For example, if you added a dataset component, you can select a value from a population.
Additionally, each component placed on the form is represented by its own image, for example, a parent component or a child component, a visual component or a non-visual component is displayed differently (Figure 2).
If you activate a component in the Object TreeView, then it is activated on the form and the Object Inspector.
Clicking right button mouse, a pop-up menu opens with editing commands, the position of the component on the form (foreground or background), hiding the Object TreeView, etc. (Figure 3).
The Code Editor window has a standard page with an embedded Code Explorer window. In addition, there is an additional Diagram page.
The Charts page in the Code Editor provides visual tools for charting to show relationships among visual and non-visual components. A diagram is a documentation tool that illustrates relationships in a diagrammatic manner and allows you to add comments to the diagram. Components do not appear on the Diagrams page until you drag them from the Object TreeView (Figure 4).
You can select many components from the TreeView and drag them onto the Charts page at the same time.
The left side of the Charts page has an edit control where you can type a title and description for each chart you create. At the top, there is a combo box for navigating to the next diagram.
At the top of the page is a Toolbar of buttons for connecting the blocks you place to create a diagram.
You can create a chart for each data module, forms that are added to your project.