User's Guide


Contents

  • Notices
  • Trademarks
  • About this book
  • What this book includes
  • Examples to try for immediate use of VisualAge
  • Who this book is for
  • About this product or feature
  • Conventions used in this book
  • Tell us what you think
  • What's new

  • Exploring VisualAge application development

  • Getting started
  • Starting VisualAge
  • Working with applications
  • Using the Quick Start window
  • Using the VisualAge Organizer
  • Adding and changing parts
  • Adding parts
  • Changing the labels of parts using direct editing
  • Changing the settings of parts
  • Tearing off an attribute from a part
  • Connecting parts
  • Making connections
  • Adding scripts to applications
  • Scripting language fundamentals
  • Objects and messages
  • Classes
  • Writing simple scripts
  • Messages
  • Blocks
  • 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
  • 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
  • Building the OS/2 - Windows Notebook
  • Adding the notebook part
  • Adding the initial page
  • Adding additional pages
  • Adding parts to pages
  • Changing the orientation
  • Connecting the notebook to the menu
  • Notebook events
  • Portable notebook events
  • OS/2 - Windows Notebook events
  • 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
  • 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

  • Enhancing your applications

  • Packaging your VisualAge 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 NT Services
  • Making your application into an NT service
  • Installing your NT service
  • Starting your NT service
  • Removing your NT service
  • Runtime files needed to run and redistribute your NT service
  • VisualAge NT Services Maintenance Utility command line parameters
  • VisualAge NT service error codes
  • 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
  • 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
  • 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
  • Using Windows 95 controls
  • Windows 95 parts
  • Loading the Windows 95 Controls feature
  • Tab strips and tabs
  • Tool bars and buttons
  • Status bars and status panels
  • Track bars
  • Progress bars
  • Tree views
  • Adding messages to your application
  • 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 preferences
  • 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 OS/2
  • 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 VisualAge 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 VisualAge 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 a VisualAge 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
  • VisualAge 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 VisualAge Smalltalk XML Support
  • Using the VisualAge Smalltalk XML DOM parser
  • Using the VisualAge SAX parser
  • Creating Mapping Specifications and Mapping DTDs
  • XML Mapping Types
  • Creating object instances from XML using mapping specifications
  • Generating XML from Objects
  • Caching XML Objects
  • Handling Exceptions
  • Using Smalltalk Initialization Information
  • XML Samples and Tools
  • Building XML Server applications
  • Mapping Specification Classes
  • AbtXmlMappingSpec
  • AbtClassElementMapping
  • AbtAttributeMapping
  • Sample DTD
  • Sample XML
  • Sample Mapping

  • 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
  • Preparation
  • 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
  • Installing
  • Copying files
  • Loading the image
  • Creating feature config maps
  • User's instructions
  • Software installation utilities

  • Using external functions in a VisualAge application

  • Accessing external functions
  • Accessing C and COBOL
  • Loading VisualAge 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
  • Building the client window
  • Extra practice
  • Exchanging data with other applications
  • VisualAge DDE server
  • VisualAge DDE client
  • 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 to your VisualAge application
  • 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 VisualAge 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

  • Index

  • [ Top of Page | Previous Page | Next Page | Table of Contents | Index ]