Visual Programming User Guide
Visual Programming User Guide
About this book
Who this book is for
What's new?
Conventions used in this book
Tell us what you think
Introduction to Visual Programming
Adding scripts
Scripting language fundamentals
Objects and messages
Writing simple scripts
Common errors
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
Extra practice
Attribute-from-script connections
Changing the window
Adding an attribute-from-script connection
Extra practice
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
Extra practice
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
Extra practice
Using variables
Creating a visual part that contains a variable
Passing the variable
Extra practice
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
Extra practice
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
General advice
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
Extra practice
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
Windows parts
Tab strips and tabs
Tool bars and buttons
Status bars and status panels
Track bars
Progress bars
Tree views
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 icons
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
Extra practice
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
Extra practice
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
abt.ini file
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
Adding a part
Deleting a category or part
Extra practice
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
Think small
Managing your visual application
Saving your work
Saving parts
Saving your image file
Saving Smalltalk source code
General advice
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
Using scripts
Assigning parts to instance variables
Attribute-to-script connections
Analyzing performance
Managing your image size
Memory requirements
VA Smalltalk XML Support.
XML Documents
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
Sample DTD
Sample XML
Sample Mapping
Sample Schema
Building parts
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
Extra practice
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
Copying 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
Extra practice
General advice
Advanced C function calls
Sample source code
Adding the parts
Understanding record structures
Writing the script
Extra practice
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
Extra practice
Using DDE with Smalltalk objects
Building the server window
Extra practice
Exchanging data with other applications
VA Smalltalk DDE server
VA Smalltalk DDE client
Extra practice
How threads work
Using threads
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
Extra practice
Bidirectional Languages Support
Areas of Bidi support
Smalltalk library
Visual parts
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
Extra practice
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
Error handling
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