wwparcel.html

Visual Programming User Guide

Visual Programming User Guide

About this book

Who this book is for

Conventions used in this book

Tell us what you think

Introduction to Visual Programming

Scripting language fundamentals

Objects and messages

Writing simple scripts

Using the Script Editor

Creating a script

Classifying scripts

What to watch for

Event-to-script connections

Creating the window

Adding an event-to-script connection

Attribute-from-script connections

Changing the window

Adding an attribute-from-script connection

Performance considerations

Creating reusable parts

Working with the Public Interface Editor

Generating default scripts

Visual tool symbols

Creating a reusable nonvisual part

Creating a nonvisual part

Designing the part

Defining the attributes

Defining the scripts

Generating default scripts

Modifying default scripts

Writing your own script

Using your nonvisual part

Creating a reusable visual part

Creating the reusable visual part

Promoting features

Using the reusable visual part

Using nonvisual parts

Using object factories

Adding the parts

Adding the scripts

Adding the connections

Using variables

Creating a visual part that contains a variable

Passing the variable

Creating the Find Dialog window

Creating the text editor

Testing the parts

Using view wrappers

Adding the view wrapper

Opening a modal window

Opening multiple windows

Validating user input

Basic data types

Validating data types

Using a Form Input Checker part

Handling errors from scripts

Setting data types from scripts

Adding a drop-down list

Creating your own data types

Checking for even integers

Testing your new type

Inheriting from existing data types

Adding help to your application

Connecting help

Adding context-sensitive help for a part

Adding general help for the main window

Adding keys help for the main window

What to watch for

Enabling hover help

Debugging your application

Debugging scripts

Examining objects

Using the debugger

Common errors to watch for

Debugging connections

Using the Connection Trace Log

Common errors to watch for

Setting connection tracepoints and breakpoints

Selecting tracepoints and breakpoints

Using Common Parts

Adding Notebooks

Building the reusable parts

Building the reusable summary form

Building the reusable address form

Building the PM Notebook

Adding the notebook part

Sizing the notebook with the window

Adding the initial page

Adding additional pages

Adding parts to pages

Changing the orientation

Building the Windows Notebook

Adding the notebook part

Adding the initial page

Adding additional pages

Changing the tabs per row

Using graphical tabs

Adding parts to pages

Notebook events

Portable notebook events

Adding list parts

Introduction to lists

Using a Multiple Select List

Designing the objects

Building the reusable parts

Building the visual part

Adding portable container parts

Adding a Container Icon List part

Creating the visual part

Adding a menu bar

Completing the connections

Providing visual information for an item

Adding a Container Icon Tree part

Adding a hasChildren attribute

Adding the visual parts

Adding the scripts

Making the connections

Changing the icon tree container's settings

Testing the Container Icon Tree part

Adding a Container Details part

Working with column settings

Adding the variable parts

Adding a pop-up menu

Adding the view wrapper

Testing the card game

Using Windows controls

Tab strips and tabs

Tool bars and buttons

Status bars and status panels

Advanced Visual Programming

Packaging your visual application

Generating a runtime image

Creating a directory to contain your runtime image

Extracting your application from the development image

Files generated during packaging

Renaming the startup executable and packaged image

Running your packaged image

Setting runtime path information

Creating a program object

Debugging a runtime image

Including deleted parts

Fixing prerequisites

Fixing problems shown in error logs

Distributing your application

Redistributable files

Reusable bitmaps

Adding your application to Windows Services

Making your application into a Windows Service

Installing your Windows Service

Starting your Windows Service

Removing your Windows Service

Runtime files needed to run and redistribute your Windows Service

VA Smalltalk Windows Services Maintenance Utility command line parameters

VA Smalltalk Windows Service error codes

Adding drag and drop support

Image drag and drop

Working with drag settings

Working with drop settings

Adding drag and drop to the card game

Dynamically preventing a drop

Platform drag and drop

Creating the Customer application

Adding the source part

Adding the target part

Dragging names from the source window to the drop site

Adding messages

Adding message prompters

Adding message boxes using the NLS Workspace - Indexed Messages window

Creating messages

Displaying messages

Adding the pool dictionary to the class definition

Binding message strings

Displaying message boxes

Changing the message type

Substituting text into messages

Changing the buttons in the message box

Accessing just the message

Retrieving other text

Adding message boxes using the NLS Workspace - Pool Dictionaries window

Adding messages to a pool dictionary

Removing messages from a pool dictionary

Displaying message strings

National language support

Translating text in messages, windows, and pool dictionaries

Enabling for translation

Defining binary files to hold language-specific strings

Registering files when the application loads

Unregistering files when the application unloads

Building .mpr files

Translating the strings

Displaying translated strings

Registering files when the application is running

Setting language prefeences

abtrules.nls and abtrules.all files

Country information

Double-byte characters

Setting single-byte or double-byte input mode

Extending the parts palette

Preparing images

Preparing a resource DLL for Windows

Preparing a resource DLL for UNIX systems

Adding a category

Using a resource DLL

Deleting a category or part

Sizing and positioning techniques

Sizing the window

Ways to adjust parts

Setting values for framingSpec

Chaining parts together

The first text part

Label2 and the second text part

The push buttons

Filling in the center

Attaching the list

Attaching the multiline edit box

Another way to arrange parts

Grouping parts using Forms

Adding the form

Designing effective visual applications

Designing around a single purpose

The object-oriented approach

Identifying reusable parts

Using inheritance

Creating the descendant

Inheriting scripts

Understanding inheritance

Using abstract classes

Managing your visual application

Saving your work

Saving your image file

Saving Smalltalk source code

Recovering lost work

Recovering work

Sharing code with other developers

Generating archival code

Filing out your application code

Filing in the filed-out code

Moving, renaming, and deleting applications and parts

Moving a part from one application to another

Renaming a part or application

Deleting a part from an application

Deleting an application

Unloading features

Team programming features

Source code management

Configuration management

Tips for better performance

Secondary windows

Using view wrapper parts

Assigning parts to instance variables

Attribute-to-script connections

Analyzing performance

Managing your image size

Memory requirements

VA Smalltalk XML Support.

Well-formed Documents

Valid XML Documents

Parsing XML documents

Overview of SAX and DOM parsers

Simple API for XML (SAX) parser interface

Document Object Model (DOM) parser

Using VA Smalltalk XML Support

Using the VA Smalltalk XML DOM parser

Using the VA Smalltalk SAX parser

Using the VA Smalltalk XML Mapping Support

XML Mapping Components

Creating object instances from XML using mapping specifications

Using the VA Smalltalk XML Mapping Parser

Generating XML from Objects

Caching XML Objects

Handling Exceptions

Using XML Initialization Settings

Parser resource resolution

XML Samples and Tools

Building XML Server applications

Additional XML Tools

Mapping Specification Classes

AbtXmlMappingSpec

AbtClassElementMapping

AbtAttributeMapping

Building your first part

Designing the part

Creating the part's class

Creating the part's public interface

Defining the attributes

Defining the events

Defining the actions

Creating the part's code

Generating Smalltalk code

Initialization preferences

Adding more Smalltalk code

Testing your new part

Finishing touches

Adding parts to the palette

Descriptive part names

Changing the icon

Changing the connection pop-up menu

Generic properties view

Custom settings view

Building visual parts

Building a tool bar part

Designing the part

Developing the user interface

Defining the public interface

Testing the tool bar

Adding accessories

Changing the default name

Changing the icon

Building primitive visual parts

Designing the part

Building the part

Defining the public interface

Drawing the shape's appearance

Translation considerations

Defining a custom widget

Defining the widget class

Adding drawing methods

Initializing the widget

Supporting colors and borders

Adding an outline

Drawing rectangles and triangles

Adding settings pages

Adding a custom edit part

Changing the pop-up menu

Creating data types

Creating a simple data type

Checking for discrete values

Testing your new type

Creating a complex data type

Creating the classes

Building the Smalltalk data type

Building the data converter

Setting up quick forms

Distributing your parts

Loading and removing your code

Loaded and removing methods

Loaded method examples

Removing method examples

Declaring pool dictionaries, pool constants and globals

Exporting your code

Versioning and releasing

Exporting .dat files

Loading the image

Creating feature config maps

User's instructions

Software installation utilities

Using external functions

Accessing external functions

Accessing C and COBOL

Loading VA Smalltalk language features

Building a Dynamic Link Library

Sample source code

Adding the parts

Connecting parameters

Advanced C function calls

Sample source code

Adding the parts

Understanding record structures

Writing the script

Accessing external functions from scripts

Generating record structure classes

Using record structure classes

Accessing functions

Dynamic Data Exchange

Introduction to DDE

Installing Dynamic Data Exchange

Using the DDE Server part

Using the DDE Client part

DDE connections and links

Completing the connections

Unidirectional DDE

Using DDE with Smalltalk objects

Building the server window

Exchanging data with other applications

VA Smalltalk DDE server

VA Smalltalk DDE client

How threads work

threadKey: parameter

coroutineCallWithArray: message

callWithArray: message

Using OLE Support

Loading the OLE Support feature

Using OLE Client parts

Testing the OLE Client parts

Enabling drag and drop for an OLE object

Adding OLE controls

Fundamentals of OLE controls

Registering OLE controls

Using controls in applications

Wrapping OLE controls

Bidirectional Languages Support

Areas of Bidi support

Smalltalk library

Bidi spec property sheet

Linked attributes in case of Windows

Platform-applicable Bidi attributes

Using Bidi support

Installing the Bidi support feature

Developing your first Bidi-enabled application

Appendix A. Mouse button actions on parts

Appendix B. Calling external functions using Smalltalk

Loading VA Smalltalk language features

Building a Dynamic Link Library

Understanding record structures

Creating record wrappers

Parsing the source file

Creating pool dictionaries

Calling a platform function

Calling a C platform function from a method

Calling a COBOL platform function in a method

Using the platformFunctions: method

Calling a platform function on another thread

Passing parameters with the AbtRecord class

Using the AbtRecord class with C

Using the AbtRecord class with COBOL

Passing a pointer to a pointer in Smalltalk

Appendix C. Other useful examples

Creating a reusable menu bar

Adding the menu parts

Promoting the features to the public interface

Using the reusable menu bar

Dynamically adding notebooks and pages

Printing the contents of a list

Adding the connections

Appendix D. Reusable icons