• Visual Programming User Guide
• Preface
• Notices
  • Trademarks
• About this book
  • Who this book is for
  • What's new?
    • VAST Platform 2021 (version 10.0.0)
  • Conventions used in this book
  • Tell us what you think
• Overview
• Introduction to Visual Programming
  • Adding scripts
    • Scripting language fundamentals
      • Objects and messages
      • Classes
      • Messages
        • Unary messages
        • Binary messages
        • Keyword messages
        • Cascaded messages
      • Blocks
        • Conditional testing
        • Loops
      • Writing simple scripts
        • Naming conventions
        • Comments
        • Declaring temporary variables
        • Statements
        • Reserved words
      • Common errors
        • Undefined variables
        • Missing separators
        • Brackets and parentheses
    • Using the Script Editor
      • Creating a script
        • Categories
      • Classifying scripts
        • Public and private
        • Class and instance
        • Comments and notes
      • What to watch for
        • Missing separators
        • Locating scripts
        • Private or public
        • Class or instance
    • Event-to-script connections
      • Creating the window
      • Adding an event-to-script connection
        • Accessing a part attribute
        • Making the connection
      • Extra practice
        • Changing the window's title
        • Connections to connections
        • Changing categories
    • Attribute-from-script connections
      • Changing the window
      • Changing the script
      • Adding an attribute-from-script connection
        • Getting the file names
        • Making the connection
      • Extra practice
        • More dependencies
      • Performance considerations
  • Creating reusable parts
    • Working with the Public Interface Editor
      • Attributes
      • Events
      • Actions
      • Promoting
      • 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
        • Adding the event to the public interface
    • 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 object factory
        • Adding the ordered collection
      • Adding the scripts
      • Adding the connections
      • Extra practice
        • Modifying the visual part
        • Populating the combo box
        • Making the connections
        • Promoting the feature
        • Testing your changes
    • Using variables
      • Creating a visual part that contains a variable
        • Adding the variable
        • Changing the variable's type
        • Making the variable public
      • Passing the variable
        • Making the connections
        • Testing your visual parts
      • Extra practice
        • Creating the Find Dialog window
          • Making the connections
        • Creating the text editor
          • Making the connections
        • Testing the parts
    • Using view wrappers
      • Adding the view wrapper
        • Making the connections
        • Testing the view wrapper
      • Opening a modal window
        • System modal windows
        • Opening a modal window from a script
      • 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
        • Trace messages
        • Using the inspector
      • Using the debugger
        • Starting the Debugger
          • Adding breakpoints using menu options
          • Adding a halt
        • Tracing message sends
        • Inspecting variables
        • Stepping through scripts
      • Common errors to watch for
        • Messages not understood
        • Missing separators
        • Sending the wrong message
        • Brackets and parentheses
    • Debugging connections
      • Using the Connection Trace Log
        • Starting connection debugging
        • Tracing connections
        • Stepping through connections
        • Inspecting values being passed along connections
      • Common errors to watch for
        • Incorrect connection order
        • Missing or extraneous connections
      • 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
        • Writing the scripts
        • Making the connections
        • Testing your work
  • Adding list parts
    • Introduction to lists
    • Using a Multiple Select List
      • Designing the objects
        • Designing the card part
        • Designing the card deck
        • Designing the playing card deck
      • Building the reusable parts
        • Building the Card part
          • Adding the attributes
          • Adding the actions
          • Generating and modifying the default scripts
        • Building the CardDeck part
          • Adding the attributes
          • Adding the actions
          • Generating and modifying the default scripts
        • Building the PlayingCardDeck part
          • Creating the scripts
          • Testing the startUp methods
          • Completing the scripts
      • Building the visual part
        • Creating the user interface
        • Adding the reusable parts
        • Completing the connections
        • Selecting the attribute to display
        • Testing the visual part
      • Extra practice
  • Adding portable container parts
    • Adding a Container Icon List part
      • Creating the visual part
        • Testing the visual part
      • Adding a menu bar
      • Completing the connections
        • Testing the visual part
    • 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
        • Making the connections
      • Testing the card game
        • Extra practice
  • 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
        • Files needed to run the packaged image
        • Statistics files
    • Renaming the startup executable and packaged image
    • Running your packaged image
      • Setting runtime path information
      • Creating a program object
        • Creating a Windows program object
        • Creating a UNIX 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
      • Troubleshooting
    • 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
    • Overview
    • Image drag and drop
      • Working with drag settings
      • Working with drop settings
      • Adding drag and drop to the card game
        • Testing the drag and drop support
      • Dynamically preventing a drop
        • Testing the drag and drop support
      • 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
        • Declaring a message group
        • Adding messages
        • Removing and changing 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
        • Binding image strings
        • Making translatable files out of .mpr files for testing
      • Translating the strings
      • Displaying translated strings
        • Building .mpr files for translated strings
        • Using a different .mpr file
        • Displaying the translated text in your application
      • Registering files when the application is running
    • Setting language prefeences
      • abtrules.nls and abtrules.all files
        • Changing code pages
      • 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
      • Label1
      • The first text part
      • Label2 and the second text part
      • The push buttons
    • Filling in the center
      • Attaching the list
      • Label4
      • 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
        • Generating code for parts
      • Filing out your application code
        • Filing out parts
      • Filing in the filed-out code
        • Filing in applications
        • Filing in parts
    • Moving, renaming, and deleting applications and parts
      • Moving a part from one application to another
      • Renaming a part or application
        • Copying parts to another application
        • Changing filed-out code
      • Deleting a part from an application
      • Deleting an application
    • Unloading features
    • Team programming features
      • Source code management
      • Configuration management
      • Integrity
  • 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
        • Document Type Definitions (DTD)
      • Parsing XML documents
    • Overview of SAX and DOM parsers
      • Simple API for XML (SAX) parser interface
        • When to use the SAX parser
        • VA Smalltalk support for SAX specification
        • VA Smalltalk deviations from the SAX specification
        • Method categories for the SAX API
      • Document Object Model (DOM) parser
        • Document Object Model (DOM)
        • When to use the DOM parser
        • VA Smalltalk support for the DOM level-2 specification
        • VA Smalltalk deviations from the DOM level-2 specification
    • Using VA Smalltalk XML Support
      • Using the VA Smalltalk XML DOM parser
        • AbtXmlDOMParser
          • Class Methods
          • Instance Methods
        • XML DOM Parser Examples
          • Create a validating parser and process a local file
          • Create a non-validating parser and process a local file
          • Special cases
      • Using the VA Smalltalk SAX parser
      • Using the VA Smalltalk XML Mapping Support
        • What is the Mapping DTD?
        • Using the Mapping DTD
        • What is a Mapping Specification?
        • Using Mapping Specifications
        • Creating Smalltalk mapping classes manually
      • XML Mapping Components
        • Mapping elements to class instances
        • Mapping schema types to class instances
        • Mapping Attributes
        • Mapping Subelements
        • Mapping Subelement Attributes
          • Mapping Collections
          • Mapping collections that contain wrapper element tags
          • Mapping to a Dictionary
        • Specifying Type Information
          • Specifying Interface Specifications
          • Specifying XML Schemas
      • Creating object instances from XML using mapping specifications
        • Input Deserialization Methods
        • Input Deserialization Example
      • Using the VA Smalltalk XML Mapping Parser
        • Input deserialization configuration
          • Schema with no mapping specification
          • No schema with a mapping specification
          • No schema and no mapping specification -
          • Invocation
        • Using AbtXmlElement as Protocol Object
        • Resolving XML resources
        • Handling errors
      • Generating XML from Objects
        • Default serialization configuration
        • Default serializer behavior
        • Output Serialization Methods
        • Changing the DOM and regenerating XML
        • Generating XML from the DOM
      • Caching XML Objects
        • AbtXmlObjectCache
          • Class Methods
          • Instance Methods
        • Caching Examples
        • Adding a DTD to the XML resource cache
        • Disabling usage of the XML resource cache for resolving external DTD
        • Retrieving XML objects from the cache
      • Handling Exceptions
        • Handling Mapping Exceptions
        • Handling Parse Exceptions
        • Handling DOM Exceptions
      • Using XML Initialization Settings
      • Parser resource resolution
    • XML Samples and Tools
      • Building XML Server applications
        • Communication via Web Server Interface (WSI)
          • Starting an xml-tcp transport from a configuration file
        • XML Server Samples
          • Creating an XML HTTP request handler using the XML DOM parser
          • Creating an XML HTTP request handler using the SAX parser
          • Application Prerequisites
        • Packaging the image with XML image components
        • Packaging considerations when using XML input deserialization
      • Additional XML Tools
    • Mapping Specification Classes
      • AbtXmlMappingSpec
        • Class Methods
        • Instance Methods
      • AbtClassElementMapping
        • Instance Methods
      • AbtAttributeMapping
        • Instance Methods
    • 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
        • Adding the repeat attribute
      • Defining the events
      • Defining the actions
    • Creating the part's code
      • Generating Smalltalk code
        • Read-only attributes
      • 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
        • Creating the view
        • Adding the parts
        • Making the connections
        • Linking the settings view to the part
        • Testing your work
  • Building visual parts
    • Building a tool bar part
      • Designing the part
      • Developing the user interface
        • Adding graphics to the push buttons
        • Adjusting the size and position
      • Defining the public interface
        • Defining the events
        • Promoting events
        • Signaling the events from scripts
    • 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
        • Default edit size
        • Callbacks
        • Reviewing your work
        • Testing your work
      • Initializing the widget
      • Supporting colors and borders
    • Extra practice
      • Adding an outline
      • Drawing rectangles and triangles
      • Adding settings pages
        • Adding help to the page
    • 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 more data types
    • Creating a complex data type
      • Creating the classes
        • Defining the Smalltalk data type
        • Defining the data type converter
      • Building the Smalltalk data type
      • Building the data converter
        • Adding types to settings views
        • Validating input data
        • Converting user data
        • Testing your work
      • Setting up quick forms
        • Making quick forms available
        • Choosing a default visual part
        • Testing your work
  • Distributing your parts
    • Preparation
    • Loading and removing your code
      • Loaded and removing methods
      • Loaded method examples
        • Adding parts to the palette
        • Adding your own category
        • Loading message files
        • Setting class variables
      • Removing method examples
        • Removing parts from the palette
        • Unregistering message files
      • Declaring pool dictionaries, pool constants and globals
        • Populating pool dictionaries
    • Exporting your code
      • Versioning and releasing
      • Exporting .dat files
    • Installing
      • 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
        • Building an AIX DLL
      • Sample source code
        • C sample source code
          • catm.c
          • catm.h
          • catm.def
          • catm.mak
        • COBOL sample source code
          • atm.cbl
          • atm.cpy
          • atm.def
          • cblmake.cmd
      • Adding the parts
        • Creating the function interface
      • Connecting parameters
        • Parsing
        • Using quick forms
      • Extra practice
      • General advice
        • COBOL compiler differences
        • Passing pointers using the C External Function part
          • Accessing the data in a pointer
          • Storing and retrieving data from a pointer
    • Advanced C function calls
      • Sample source code
        • cgraph.c
        • cgraph.h
        • cgraph.def
        • cgraph.mak
      • Adding the parts
        • Setting the points
        • Creating the function interface
      • Understanding record structures
      • Writing the script
      • Extra practice
    • Accessing external functions from scripts
      • Generating record structure classes
        • Using the parser
        • Parsing data division structures
      • Using record structure classes
      • Accessing functions
        • Creating functions manually
        • Using the parser to create functions
        • Calling functions
        • Handling errors
  • Dynamic Data Exchange
    • Introduction to DDE
      • Installing Dynamic Data Exchange
      • Using the DDE Server part
        • Creating the window
        • Specifying the DDE server settings
        • Making connections to the DDE Server part
      • Using the DDE Client part
        • DDE client settings
      • DDE connections and links
        • Starting a DDE server application
      • Completing the connections
        • Testing your window
      • Unidirectional DDE
      • Extra practice
    • Using DDE with Smalltalk objects
      • Building the server window
        • Specifying the DDE server settings
        • Making the connections
      • Extra practice
    • Exchanging data with other applications
      • VA Smalltalk DDE server
        • Building the visual part
        • Testing your window
      • VA Smalltalk DDE client
        • Building the visual part
        • Testing your window
      • Extra practice
  • Threads
    • How threads work
    • Using threads
      • threadKey: parameter
      • coroutineCallWithArray: message
      • callWithArray: message
    • Limitations
    • Performance
  • 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
      • Inheritance
  • Using Bidi support
    • Installing the Bidi support feature
      • Developing your first Bidi-enabled application
    • Extra practice
• Appendixes
  • 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
        • Parsing the C sample files
        • Parsing the COBOL sample files
        • Performing code page conversion
      • Creating pool dictionaries
        • Creating pool dictionaries for C functions
        • Creating pool dictionaries for COBOL functions
    • Calling a platform function
      • Calling a C platform function from a method
      • Calling a COBOL platform function in a method
      • Using the platformFunctions: method
        • Using the platformFunctions: method with C
        • Using the platformFunctions: method with COBOL
      • 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
• Index

Visual Programming User Guide

Index