C h a p t e r 1
Introduction
This Quick Start provides an overview of the
SevenView development environment to get you started using the product right
away. It also tells you where to look for details
about the tools and features
available in SevenView.
Chapter 2, “A tour of the
environment” describes the main tools on the SevenView
desktop, or integrated desktop
environment (IDE). Chapter 3, “Programming with
SevenView” explains how you
use some of these tools to create an application. Chapter 4,“Customizing
the desktop” describes how you can customize the SevenView IDE for
your development needs.
For step-by-step
instructions on using SevenView to write programs such as a text editor
or database application, see
the tutorial PDF files in the SevenView installation directory.
What
is SEVENVIEW?
SevenView is an
object-oriented, visual programming environment for rapid application
development (RAD) in industrial
automation and scientific application. Using SevenView, you can create highly
efficient applications for Microsoft Windows and Linux with a minimum of manual
coding. SevenView provides all the tools you need to develop, test, and deploy
applications.
Application Structure
SevenView Designer.exe
SevenView Runner.exe
Know
One , Delivery More
Know one tools,
to delivery more solution is the philosophy of this environment. SevenView permit
to develop a large number of different solution, (such as HMI, SCADA, DataBase,WEB ecc.), and port it in different operating system
without
any changes.
Online
Help
The online Help system
provides detailed information about user interface features,
language implementation,
programming tasks, and the components.
F1 Help
Not implemented.
Developer
support services and Web site
A SevenView Community is
opned on www.sevenview.net/support.asp
where registred users can found problem solution, or post their problem.
C h a p t e r 2
A
tour of the environment
This chapter explains how
to start SevenView and gives you a quick tour of the main
parts and tools of the
integrated development environment (IDE).
Starting
SevenView
You can start SevenView in
the following ways:
• Double-click the SevenView icon (if you’ve
created a shortcut).
• Choose Programs|FLKTech|SevenView
Designer from the Windows Start menu.
• Choose Run from the
Windows Start menu, then enter SevenView32.
• Double-click SevenView32.exe
in the SevenView\Bin directory.
The
IDE
When you first start SevenView,
you’ll see some of the major tools in the IDE. In SevenView, the IDE includes the menus, toolbars,
Component palette, Object Inspector, ObjectTreeView, Code editor, Project Manager, and many other tools.
SevenView’s development
model is based on two-way tools. This means that you can move back
and forth between visual design tools and text-based code editing. For example,
after using the Form Designer to arrange buttons and other elements in a graphical
interface, you can immediately view and edit any code generated by SevenView without
losing access to the visual programming environment. From the IDE, all your
programming tools are within easy reach. You can design graphical interfaces,
browse through class libraries, write code, test, debug, and manage projects
without leaving the IDE. To learn about organizing and configuring the IDE, see
Chapter 4, “Customizing the desktop.”
The
menus and toolbars
The main window, which
occupies the top of the screen, contains the main menu, toolbars, and Component
palette.
SevenView’s toolbars
provide quick access to frequently used operations and commands. Most toolbar
operations are duplicated in the drop-down menus.
Many operations have
keyboard shortcuts as well as toolbar buttons. When a keyboard shortcut is
available, it is always shown next to the command on the dropdown menu. You can
right-click on many tools and icons to display a menu of commands appropriate
to the object you are working with. These are called context menus. The toolbars are also
customizable. You can add commands you want to them or move them to different
locations. For more information, see “Arranging menus and toolbars” on page 4-1
and “Saving desktop layouts” on page 4-4.
The
Component Palette, Form Designer, and Object Inspector
The Component palette, Form
Designer, Object Inspector, and Object TreeView work together to help you build
a user interface for your application. The Component palette includes tabbed pages with
groups of icons representing visual
or nonvisual components. The
pages divide the components into various functional groups. For example, the Windows,
Win32 and HMI pages include windows controls such as an edit box and up/down
button; the Dialogs page includes
common dialog boxes to use for
file operations such as opening and saving files.
Each component has specific
attributes—properties, events, and methods—that enable you to control your
application.
After you place components
on the form, or Form Designer, you can arrange components the way they should look
on your user interface. For the components you place on the form, use the Object Inspector to set design-time
properties, create
event handlers, and filter
visible properties and events, making the connection between your application’s
visual appearance and the code that makes your application run. See “Placing
components on a form” on page 3-2.
The
Object TreeView
The Object TreeView
displays a component’s sibling and parent-child relationships in a
hierarchical, or tree diagram. The tree diagram is synchronized with the Object
Inspector and the Form Designer so that when you change focus in the Object TreeView,
both the Object Inspector and the form change focus. You can use the Object
TreeView to change related components’ relationships to each other. For
example, if you add a panel and check box component to your form, the two
components are siblings. But in the Object TreeView, if you drag the check box on
top of the panel icon, the check box becomes the child of the panel. If an
object’s properties have not been completed, the Object TreeView displays a red
question mark next to it. You can also double-click any object in the tree
diagram to open the Code editor to a place where you can write an event
handler. If the Object TreeView isn’t displayed, choose View|Object TreeView.
The Object TreeView is
especially useful for displaying the relationships between database objects.
The
Object Repository
The Object Repository
contains forms, dialog boxes, data modules, wizards, DLLs,sample
applications, and other items that can simplify development. Choose File|New to
display the New Items dialog box when you begin a project. The New Items dialog
box is the same as the Object Repository. Check the Repository to see if it
contains an object that resembles one you want to create.
The
Code Editor
As you design the user
interface for your application, SevenView generates the underlying SevenView
code. When you select and modify the properties of forms and objects, your
changes are automatically reflected in the source files. You can add code to
your source files directly using the built-in Code editor, which is a
full-featured ASCII editor. SevenView provides various aids to help you write
code, including the Code Insight tools, class completion, and code browsing.
The
Project Manager
To display the Project Manager,
choose View|Project Manager.
You can use the Project
Manager to combine and display information on related projects into a single project group. By organizing related
projects into a group, such as multiple application,
you run them at the same time.
C h a p t e r 3
Programming
with
SevenView
The following sections
provide an overview of software development with SevenView,
including creating a project,
working with forms, writing code, and compiling,
debugging, deploying, and
internationalizing applications, and including the types
of projects you can develop.
Creating
a project
A project is a collection
of files that are either created at design time or generated
when you run the project source
code.
To create a new project choose File|New Application. It automatically
generates a project file (Project1.7vp), unit file (Unit1.pas), and resource
file (Unit1.7fm), among others.
If a project is already
open but you want to open a new one, choose either File|New|
Application or File|New|
and double-click the Application icon. File|New|
opens the Object Repository,
which provides additional forms, modules, and
frames as well as predesigned
templates such as dialog boxes to add to your project.
To learn more about the
Object Repository, see “The Object Repository” on page 2-6.
Adding
data modules
A data module is a type of
form that contains nonvisual components only. Nonvisual components can be placed on ordinary forms
alongside visual components. But if you plan on reusing groups of database and
system objects, or if you want to isolate the parts of your application that
handle OPC and DATABASE connectivity and business rules, data modules provide a
convenient organizational tool. To create a data module, choose File|New|Data
Module. SevenView opens an empty data module, which displays an additional unit
file for the module in the Code editor, and adds the module to the current
project as a new unit. Add nonvisual components to a data module in the same
way as you would to a form. When you reopen an existing data module, SevenView
displays its components.
Building
the user interface
With SevenView, you first
create a user interface (UI) by selecting components from the Component palette
and placing them on the main form.
Placing
components on a form
To place components on a
form, either:
1
Double-click
the component; or
2
Click
the component once and then click the form where you want the component
to appear.
Select the component and drag it to
wherever you want on the form.
Setting
component properties
After you place components
on a form, set their properties and code their event handlers. Setting a
component’s properties changes the way a component appears and behaves in your
application. When a component is selected on a form, its properties and events
are displayed in the Object Inspector.
Many properties have simple
values—such as names of colors, True or False, and integers. For Boolean properties,
you can double-click the word to toggle between True and False. Some properties have associated property
editors to set more complex values. When you click on such a property value,
you’ll see an ellipsis. For some
properties, such as size, enter a
value.
When more than one
component is selected in the form, the Object Inspector displays all properties
that are shared among the selected components. The Object Inspector also
supports expanded inline component references. This
provides access to the properties
and events of a referenced component without having to select the referenced
component itself.
For example, if you add a
button and pop-up menu component to your form, when you select the button
component, in the Object Inspector you can set the PopupMenu property to PopupMenu1, which
displays all of the pop-up menu’s
properties.
Writing
code
An integral part of any
application is the code behind each component. While SevenView’s RAD
environment provides most of the building blocks for you, such as preinstalled
visual and nonvisual components, you will usually need to write event handlers,
methods, and perhaps some of your own classes. To help you with this task, you
can choose from thousands of objects in the class library. To work with your source
code, see “The Code Editor” on page 2-7.
Writing
event handlers
Your code may need to
respond to events that might occur to a component at runtime. An event is a
link between an occurrence in the system, such as clicking a button, and a
piece of code that responds to that occurrence. The responding code is an event
handler. This code modifies property values and calls methods.
To view predefined event
handlers for a component on your form, select the component and, on the Object
Inspector, click the Events tab.
Run
and Debugging projects
After you have written your
code, you will need to rune and debug your project.
With SevenView, you can either run your project first and then separately debug it. SevenView
uses an external debugger so that you can control program execution, watch
variables, and modify data values. You can step through your code line by line,
examining the state of the program at each breakpoint. To use the external
debugger, refer Use Microsoft
Script Debugger.
You can begin a debugging session
in the IDE by clicking the Run button on the Debug toolbar, choosing Run|Run,
or pressing F9.
Internationalizing
applications
SevenView offers several
features for internationalizing and localizing applications. The IDE and the
VCL support input method editors (IMEs) and extended character sets to internationalize
your project. SevenView includes a translation component, for application
localization and simultaneous development for different locales. With the
translation suite, you can manage multiple localized versions of an application
as part of a single project.
Database
applications
SevenView offers a variety
of database and connectivity tools to simplify the development of database
applications. To create a database application, first design your interface on
a form using the DataControls page components. Second, add a data source to a
data module using the Data Access page. Third, to connect to various database
servers, add a dataset and data connection component to the data module from
the previous or corresponding pages of the following connectivity tools:
• The Borland Database
Engine (BDE) is a collection of drivers that support many popular database
formats, including dBASE, Paradox, FoxPro, Microsoft Access, and any ODBC data
source. • ActiveX Data Objects (ADO) is Microsoft's high-level interface to any
data source, including relational and nonrelational databases, e-mail and file
systems, text and graphics, and custom business objects.
Add-in
components
The components that come
with SevenView are preinstalled on the Component palette and offer a range of
functionality that should be sufficient for most of your development needs. You
could program with SevenView for years without installing a new component, but
you may sometimes want to solve special problems or display
particular kinds of behavior that
require add-in components. Add-in components promote code reuse and consistency
across applications. To load add-in, choose View|Add-In/ActiveX.
C h a p t e r 4
Customizing
the
desktop
This chapter explains some
of the ways you can customize the tools in SevenView’s IDE.
Organizing
your work area
The IDE provides many tools
to support development, so you’ll want to reorganize
your work area for maximum
convenience. You can rearrange menus and toolbars,
combine tool windows, and save
your new desktop layout.
Installing
Add-In component
Whether you write custom
components or obtain them from a vendor, the components must be compiled into a
package
before
you can install them on the Component palette. A Add-in
is a special DLL containing code that can be shared among SevenView applications,
the IDE, or both. Runtime packages provide functionality when a user
runs an application. Design-time packages are used to install
components in the IDE.
SevenView add-in have a .bpl extension. If a third-party vendor’s components
are already compiled into a package, either follow the vendor’s instructions or
choose View|Add-In/ActiveX.
Adding
ActiveX controls
You can add ActiveX
controls to the Component palette and use them in your SevenView projects.
Choose View|Add-In/ActiveX Control to open the Import ActiveX dialog box. From
here you can select an already registered control for installation in the IDE.
When you install an ActiveX control, SevenView creates and compiles a “wrapper”
unit file for it.
Setting
tool preferences
You can control many
aspects of the appearance and behavior of the IDE, such as the
Form Designer, Object
Inspector, and Code Explorer. These settings affect not just the
current project, but projects that
you open and compile later. To change global IDE
settings for all projects, choose
Tools|Environment Options.
Customizing
the Form Designer
The Designer page of the
Tools|Environment Options dialog box has settings that
affect the Form Designer. For
example, you can enable or disable the “snap to grid”
feature, which aligns components
with the nearest grid line; you can also display or
hide the names, or captions, of nonvisual components
you place on your form.
Customizing
the Code Editor
One tool you may want to
customize right away is the Code editor. Several pages in
the Tools|Environment Options
dialog box have settings for how you edit your code. For
example, you can choose keystroke
mappings, fonts, margin widths, colors, syntax
highlighting, tabs, and indentation
styles.
C h a p t e r 5
Chapter4
SevenView
RUNNER
Put
your application in production
All project developed whit
sevenview can be run in designer for 1 hour max time limit, and with runner for
the production use whitout limit.
Three type of runner
1. Standard
2. Professional
3. Enterprise
the difference are made by the
component that are used for the project. See commercial brochure for more
information.
C h a p t e r 6
Chapter4
What
is OPC
Object
Linking and Embedding — for Process Control
OPC
is an International standards.
Refer
to OPC Foundation for ownership
http://www.opcfoundation.org/
Problem
And Solution
The use of microprocessors
has proliferated in manufacturing plants, and they often do not work together.Application
software should readily communicate with digital plant-floor devices as well as
other applications, but this is not often the case.
Making these systems work
together is the most pressing need of process manufacturers.The problem has
become more acute than network connectivity,
diverse operating systems, and
not-so-open “open systems” that are supposed to facilitate interoperability. A
key reason for this problem is that interfaces are
not standard. Proprietary
systems that don’t communicate among each other are fairly common. Hardware and
software choices for process and industrial manufacturers are sharply
reduced because their application suppliers provide limited connectivity.
In the absence of any
standard, vendors have developed proprietary hardware and software solutions.All
process-control and information systems on the market today have proprietary
techniques, interfaces, and APIs (Application Programming Interfaces) in order
to access the information that they contain.The cost of integrating the
different
systems and the long-term
maintenance and support of an integrated environment can be significant. Custom
drivers and interfaces can be written, but the variety increases rapidly
because of the thousands of different types of control devices and software
packages that need to communicate.
This proliferation of
drivers exacerbates certain problems, such as inconsistencies among different
vendors’ drivers, hardware features that are not universally supported, hardware
upgrades that can wreck an existing driver, and access conflicts. In the last
case, two applications generally may not be able to access the same device at
the same time because they use independent drivers. Perhaps worse, a driver may
not be available
for a particular device
application or inter-application combination, limiting End Users’ options or
forcing them to have one written (and debugged).
For a typical
supervisory-control software developer, as much as 25-30% of engineering
development time is spent writing drivers. Every time a key
