Open Source - Our Contributions

This package contains extensions to Lint (Code Critic) so that it is easier to create new rules and to fix existing rules.

AllEncodings provides definitions for additional Encoders, including EBCDIC and CP950.

Package BackgroundColor added methods in the Launcher system menu to allow a user to change the back color of the windows of an image. This allows a user to easily identify the windows of different images that are running to the same time on the same computer.

When loaded the CustomSkinCreator will automatically generate a Package "BackgroundColor-Skins" that contains all Skin classes and all registration methods. This package can easily be unloaded and recreated in order to update the skins. This package should not be published to Store. As the Skin classes contain a lot of replicated code and cannot be managed easily, it is simpler to just generate them automatically. The only parameter to a skin is the color and the color's name. The CustomSkinCreator will then create both a DefaultSkin subclass as well as a registration for a native-skin with a colored icon.

Added support for ByteOrderMarks. The interface to use the new feature is implemented in EncodedStreamConstructor. This class is not really visible. Their objects are created with the method Filename>withEncoding:.

This method now takes new symbols:

#utf32 (new UTF32Encoding)
#utf32WithBOM
#utf16WithBOM
#utf8WithBOM
#autoDetect (this is the most interesting. It checks the file and selects between #utf32WithBOM, #utf16WithBOM, #utf8WithBOM, and default [if there is no BOM]).
#autoDetectOr<Symbol> (It checks the file and selects between #utf32WithBOM, #utf16WithBOM, #utf8WithBOM, and <Symbol> [if there is no BOM], most important example #autoDetectOrUtf8)

The BOM support itself is implemented in a new class ByteOrderMarkedStream. This class is a sibling of EncodedStream. They have a common new superclass WrappingStream.

This bundle defines an interface for completely accessing the clipboard in a platform independent way. It allows for reading arbitrary data from the clipboard or to write it back. To do that an abstraction-level is provided to ask Smalltalk-Objects to convert themselves to clipboard data and to instantiate from clipboard data.

This package defines a wrapper that automatically resizes certain columns of a DataSet in order to use the full width of the widget

This Bundle is a collection of enhancements to ease debugging in VisualWorks.
It includes:

• DebuggerColors - color the stack frames in the debugger to see overrides and the selected context
• RBRecursionJumpBack - jump back to the start of a recursion in the debugger, without scrolling through the endless list of stack frames
• DebuggerAdditions
  • disable breakpoints and halts while shift is pressed
  • provide #printTopOfStackToTranscript: to print the stack to the Transcript.
  • shift-option-bluebutton click to see a list of the widgets to inspect them
• GraphicsContextInspector - send #inspectContext to a graphics context to see where the clipping area is and in which area the context is currently drawing
• Inquisitor - send #inquisition to any object to inspect changes to the object's instance variables
• ProbeEnabler - adds a tool to the Launcher at Debug->Probe Enabler that can re-arm one shot probes in a simple window.

FixedFormat implements a reader for fixed-width text files. It contains the class FixedLine that represents a line of text and subclasses only need to implement accessor methods that return substrings from a given position in the string to another position.
See implementation in the ExampleLine class for more details.

This parcel adds class GHAdHocQueryTool, an extension of the standard AdHocQueryTool. 'VisualLauncher->Tools->Database->AdHoc SQL' will open this tool instead of the old one.
Features:
1. SQL command history:
- Scroll through the list of successfully executed commands
- Save and load command history as text file
2. Error reporting:
Insert error message text at the proper position in the command text (similar to Compiler error messages in code views)
3. Clipboard:
Copy text contents of cell, row, column or table in a format that allows easy import into tables of MS Word or Excel
4. Save text for table contents as text file
(separated by semicolon when specifying extension '.csv'; separated by tab, otherwise)
5. Inspect:
Inspectors on ApplicationModel, TableAdaptor
6. Convenient GUI:
Use a single button for Connect/Disconnect
Display username and connection string in the window label if connected
Result dimension: A new text field displays the number of columns/rows of a result table

This package provides compatibility to read and write BOSS files that are compatible with VisualWorks 2.5.x and 3.x. This functionality mainly covers the namespace handling for older BOSS formats.

The application developer must register the namespaces that contain the classes of objects in BOSS files. We only check local bindings - that means we do not check imported bindings. This is done as we have no control over imports in namespaces and we want to avoid name clashes when there are classes in the image with the same name but different namespaces.

To register a namespace call the class method registerNamespace: in class BOSSCompatReader, i.e:
BOSSCompatReader registerNamespace: Heeg

Using the compatible BinaryObjectStorage uses the same methods as the regular BinaryObjectStorage.

Examples:
reading objects:
CompatibleBinaryObjectStorage onOld: 'written-by-vw252.bos' asFilename readStream
writing objects:
CompatibleBinaryObjectStorage onNew: 'to-be-read-by-vw252.bos' asFilename writeStream

This package logs the Time in the Change-File every minute so that it is easier to find the right spot in a ChangeList upon recovery. It also logs when a Pundle was published.

Support of reading and writing the CSV (Comma Separated Value) text file format. A simple viewing utility is included.

This package provides two ways of using CSV files:
1. Each row represents an Array. Use CsvReader and CsvWriter.
2. Each row represents an object, instance of a subclass of CsvLine. Use CsvFileReader or CsvReaderWriter.

This package implements base classes to simplify the work with Excel.

It provides input and output using COM.

This parcel implements a Find Dialog for VisualWorks text editors, designed to replace the simple find dialog from ParagraphEditor. Use of this advanced Find Dialog is configurable. See VisualWorksSettings page "Tools> Find Dialog".

Features are known from various applications dealing with text, such as editors or internet browsers. The basic features provided are
+ Input field for search string, combined with a Combobox remembering entered search strings
+ Option checkboxes for selecting
- case-sensitive/-insensitive search
- word search
- wildcard match
- regular expression search, with the search string interpreted as regular expression to match
(this feature requires Regex support parcel from the distribution)
+ Search buttons with search direction control (search forward or backward)

The new FindDialog stays opened as long as the user does not close with an extra Cancel button (opposed to the default dialog from ParagraphEditor which accepts a single request, closes and processes the search operation). The user can proceed finding occurrences of the search string, while the dialog stays open and makes the underlying text editor track the selection according to found matches.
A special feature is the match lookahead: The dialog automatically searches the next and the previous match, and enables search buttons accordingly. This gives immediate feedback for the user whether it is useful to request a next or previous search. The typical dialog after unsuccessful search ('no more matches found') is not necessary for this implementation.

Adds InputFields to settings that show formated numbers like input fields in normal applications are able to.

This parcel sets up Georg Heeg specific namespace for GH Contributions

It simply includes namespace 'Heeg'.

This package adds better navigation support for Pragmas to the SystemBrowser for the selected method by providing two simple functions

• browse all methods that use the same Pragma.
  • E.g all methods that contain <foo: > 
• browse all methods that refer to the Pragma's symbol, but don't use it as Pragma.
  • E.g. all methods that do not contain <foo: > but that use #foo or #foo:
  • like in Pragma allNamed: #foo in: self

Both functions integrate into the SystemBrowser's Method-menu where they extend the Senders/Implementors submenus.

This parcel implements a general utiliies menu for SequenceController. Holding <shift> while opening the operate menu (context menu) a local menu will come up instead of the menu defined by the application. This means that every list pane can perform the following clipboard and inspection functions:
- Copy Selection : Copy display text of selected list element(s) into Clipboard
- Copy List : Copy display text of all list elements into Clipboard
- Find... : Find and select a list element matching string requested from the user (requires parcel GHFindDialog)
- Inspect Model / Inspect View / Inspect Controller / Inspect Window : Open an Inspector on model/view/controller/window
- Remove from list : Remove selected element(s) from list (not from the model)

This parcel speeds up parsing of XML-Files by caching content of DTD. The cache is twofold, it caches the content of the DTD-file and it also caches the parsed DTD object. That way DTD is only parsed once and it is possible to avoid downloading the DTD at all.

To prefill the cache with a DTD-file, cache it using #cacheFileContent:underPublicKey:systemID:

To prefill the xhtml-special entities dtd call:
SAXDriver new
   cacheFileContent: aString
   underPublicKey: '-//W3C//ENTITIES Special for XHTML//EN'
   systemID: 'http://www.w3.org/TR/xhtml1/DTD/xhtml-special.ent'.

Display enhancements to Store related Browsers and Tools:
- Display bundles and packages with version string (in red color if modified)
- add a special 'Loaded Items' tool, which is opened by the normal VisualLaunchers 'Store->Loaded Items' menu.
The following functionality is provided by this tool in addtion to the existing tool:
+ the list of items in the tool can be filtered using an additional filter menu located below the list,
+ the default filter is 'show modified'
+ the pundles in the list also show the version information,
+ the list also provides a 'Publish ...' and a 'Changed Methods...' menu item, if the conditions apply.

This bundle contains one programmer tool for VisualWorks:
GHUndeclaredBrowser - is a tool to view and handle the 'Undeclared' namespace.
The tool can be launched via the 'Tools' menu in the VisualLauncher, and has online
help available through his menu bar 'Help -> Open Help...'.

This package contains a status-item for the system browser that lists the current number of undeclared variables.

This package adds the ability to set printer, paper size, paper orientation and number of copies to the VisualWorks Settings. That meens you don't have to configure these settings everytime you open the print dialog.
If you change something in the print dialog these settings are stored as well as if you make the change in the VisualWorks settings.

GHXhtmlSupport provides the following functions

1. GHXhtmlDTDPreloader, which provides the XHTML DTDs to the XMLParser so that it doesn't have to download them each time
2. GHXhtmlDecoder, which can be used to decode Xhtml strings by resolving HTML Entities like &Auml;. It uses the XML Parser together with the XHTML DTDs to properly decode the HTML Entities.
3. GHXhtmlDifferences, which can diff HTML strings, producing HTML that contains <del> and <ins> tags to highlight the differences

Usage
     GHXhtmlDTDPreloader preloadDTDs "automatically executed during postload"
    GHXhtmlDecoder decodeString: '&Auml;nc&ouml;d&uuml;ng'.
    GHXhtmlDecoder decodeString: '<p>&Auml;nc&ouml;d&uuml;ng</p>'.
    GHXhtmlDifferences wordDifferencesBetween: '<p>test1</p><p>test2</p><p>test3</p>' and:'<p>test</p><p>test3</p><h1>test3</h1>'

This bundle contains various tools to help use HTML in VisualWorks:

• Clipboard support for copying and pasting Text2.Document as HTML
• LibCurl for performing HTTP-Requests using libcurl
• GHSpeedUpXMLParser for parsing XML/HTML without DTD Parsing
• GHSimpleXmlAndHtmlParser
  • parses HTML in a very forgiving way, taking into account elements that don't need/are closed
  • includes a CSS-Like XML Query API
    • xmlElement findAllMatching:'.foo a img.bar'
    • xmlElement findFirstMatching:'p[data-description=foo]'
• HtmlRenderer to convert HTML to and from Text2.Document

This package modifies the inspector to display a Chinese Character next to each item in order to quickly identify identical objects

Isam Toolbox provides a simple, fast, and reliable persistancy mechanism for collections using the index sequential access method.

L10n is a tool for translating the UserMessages

conains MultiDictionary and DiscriminatedMultiDictionary

This package version is based on PetitParser from Lucas Renggli. It includes fixes which are required to successfully load it.

Rtf includes an RTF parser and renderer along with tests and clipboard support.

Rtf includes an parser and renderer for RTF with tests and Clipboard support.

EncodedStreams are reconstructed in a way that they can be composed on top of each other. The main new class is WrappingStream.

These featues have been developed for ByteOrderMark support. It turned out that the concept was very helpful to improve URI Support also.

This little package enables writing full stacks e.g. in exception handlers or in other situations where debugging is very difficult.

Developed in the context of ObjectStudio8 by Georg Heeg, but can be useful elsewhere, specifically in support.

Usage examples:

Just before something critical happens, execute in a workspace:

[(Core.Delay forSeconds: 10) wait.
Kernel.Processor verbosePrintAllOnFile] forkAt: 100

or when you know that debugging is impossible and the notifier even does not work: put in UnhandledException>defaultAction

thisContext verbosePrintOnFile.
ObjectMemory quit.

or you could hold down <shift> and <alt> when an error orccurs then the process dump is written and the image quits.

Bundle All SmalltyPy combines the base product, the tests and the examples showing how to connect the two worlds of Cincom Smalltalk and Python.
After installation, a new menu 'Python' is added to the Launcher, which provides quick links to the help system.

While loading this bundle from Store, a dialog may report that there is no Python installation.
If this happened, please install Python 3.7 or 3.8, and try to load 'All SmalltyPy' again.
When starting an image with SmalltyPy loaded, logs in the Transcript may indicate that no Python could be found during startup.
In this case, ensure that Python 3.7 or 3.8 is installed correctly, and that you can execute 'python -V' or 'python3 -V' from a command line or terminal.
Try to start the image again.

In order to run the tests and the examples, certain Python modules have to be installed. Execute the following expression to ensure that everything is installed and/or updated:
PythonConnect.ComponentsLoader installAllComponents
Some modules are only available for certain platforms, that is why some tests may fail on MacOSX.

Look into package GHPythonConnect-Tests, which shows basic usage patterns of how SmalltyPy can interface to Python code embedded in SUnit tests.
Bundle 'SmalltyPy Examples' contains applications composed of a VisualWorks and a Python part. Please read the package comments for any additional prerequisites.

SmalltyPy was tested on Linux, Windows and MacOSX, and is only compatible with the 64Bit Versions of both VisualWorks and Python.

Extends core classes with useful methods.

Copyright (c) 2005-2007 Adrian Kuhn and Mauricio Seeberger, with contributions by Tudor Girba, Markus Hofstetter, Matthias Junker, Adrian Lienhard, Martin von Löwis, and Michael Meyer. CodeFoo is licensed under a Creative Commons Attribution-ShareAlike 3.0 license. The long term goal of CodeFoo is that its code is picked up by vendors and made part of their Smalltalk distributions.

Georg Heeg eK made it work under VisualWorks 8.3.2.

Dakar Testing is a completely new framework to test your application with unit-tests. It adds a link between a method and its tests.

INTRODUCTION
=============

Whereas unit tests are known to be part of the best practices in software development, they are seldom used because of the difficulties to create them and maintain them. In fact, when writing software, developers often have to switch between the development process and the testing process which is kind of disturbing. The aim of this application is to improve the developer's workflow allowing more efficiency and less disturbance.

The Frost project was originally planned to be a Java IDE written in Smalltalk. Since the original IBM Java compilers and IDE were written in Smalltalk, this was not as crazy of an idea as one currently may expect. Later the goals of Frost developers were to import Java code into a Smalltalk image.

This version provides the latest state of 2004.

This bundle merges the big package by John Borden and those published by xp. 35 of the 36 tests work fine, one error.

What is working?
- read simple .class files (FrostClassFilesTest)
- read simple .java files (no Test)
- translate simple Java Bytecode (FrostBytecodeTest)
- translate simple Java Sourcecode (FrostSourcecodeTest)
- simple Java DoIts (FrostEvaluationTest)

What is not working?
- correct Namespace resolution in complex examples
- AWT and Co.
- many other things

What is still to be done?
- remove old proprietary Namespace reminders
- adapt many locations to VW 7.x Namespaces
- clean up many Overrides
- remove many many Bugs
- integrate GUI into RB
- adapt to newer Java than 1.0.2

Environment:
- VisualWorks 7.3

Install:
- Install Java 1.0.x to <dir>
- unpack <dir>\lib\classes.zip to <dir>\lib\classes\
- startup the image with frost
- edit Frost.JavaReader class>>defaultClassPath to reflect
your classes directory
- execute Frost.JavaReader initialize
- Run the tests in Package FrostTests (currently 36 run, 0 failed, 1 errors)

Usage:
- take a look at the tests in Package FrostTests

The work has been done by Chris Burkert

Georg Heeg

Parcel GHFractalExplorer contains support for easy implementation of MandelbrotSet calculation and display.
Abstract class IterativeGraphicsPart is available to simplify things, for instance by buffering all display activities onto a private Pixmap. Class IterativeImagePart enhances this buffering behaviour by using an Image for the same purpose. Look at its subclasses for examples, and into its class protocol 'examples' for help on using them.

Some concrete subclasses have been added to show, how easy it is to use this class library.
Execute:
Heeg.FractalExplorer open
to explore all available parts. The application provides a 'Help' menu with some usage instructions.
If you want to use the AcceleratedCMandelbrotPart, you have to install the C-library first. Look at the class comment in THAPIMandel.

Some hints about the theoretical background of the formulas used in this program can be found in:
'A First Course In Chaotic Dynamical Systems' by Robert L. Deveney,
Addison-Wesley 1992, ISBN 0-201-55406-2,

It should work on every VisualWorks platform.
Prerequisites:
GHNamespaces
DLLCC
AT MetaNumerics (for Complex number support)
MatriX

This package contains an extension to SystemError to better document an underlying error on Unix based systems.
The SystemError printString will look like this:
a SystemError(#'exception occured', SIGSEGV at: 0xFFFFFFFFFFFFFFFF)

Decoding the signal name is the addition of this extension.
The extension was tested with VW8.3.2 and VW9.0.

Growl lets you post growl notifications.

Growl new notify: 'Hello' description: 'Hello World!'
Growl new notify: 'Hello' description: 'Hello World!' image: '~/Pictures/hello.jpg'

A simple EXIF scanner.

Usage

exif := JpegScanner parse: 'Z:\Photos\1979\1.JPG'

answers a dictionary of properties. Supported property names:
#Make
#Model
#DateTime
#DateTimeOriginal
#DateTimeDigitized
#ResolutionUnit
#YResolution
#XResolution
#YCbCrPositioning
#Orientation
#GPSAltitude
#GPSAltitudeRef
#GPSImgDirection
#GPSImgDirectionRef
#GPSLatitude
#GPSLatitudeRef
#GPSLongitude
#GPSLongitudeRef
#GPSTimeStamp

If more properties needed, #addField:to: should be extended using EXIF specs which can be found at:
http://www.exif.org/specifications.html
http://www.exif.org/Exif2-2.PDF

This package was originally created by Michel Bany. Georg Heeg has added an example and prerequisites.

First public release of some simple ray tracing code. To execute, run:

RayTrace.RayTraceExamples example1

This code is released under the MIT open source license at http://minnow.cc.gatech.edu/squeak/32.

If you make any changes, please let me know - david@simberon.com

Heeg adaptations:

Added my RaytraceCamera to the bundle, which explained in package Ray Tracing UI.
Try:
RaytraceCamera openScene: RaytraceCamera exampleScene2 size: 320@200

for a small example.

In RB, when you select a class, you get a list of method categories (or protocols). This package puts this concept to the extreme. New protocols are dynamically added based on the class content. Here is a list of some protocols you will find in this package:

- HaltUsage: lists the methods with breakpoints or halts.
- Required: list methods that need to be implemented in order to make your class concrete (shows subclass responsibilities and methods that are sent but not implemented)
- Deleted: lists the methods that have been deleted.

If a protocol does not contain any method, it is not shown.

It is easy to write your own dynamic protocols. Have a look at the class DynamicProtocol. You are only limited by your imagination and needs.

Shows the classes, that are normally alphabetically sorted, in a hierarchical way in the RefactoringBrowser

RBToolBarCustomization provides a class RBToolBarCustomActions that scans its 'actions' protocol when the class is initialized. On initializing, this class scanns for all instance methods that start with 'action' and that have 2 pragmas #name and #icon. this method has to define a RBCommand that is executed when the toolbaricon is pressed

after adding actions, just initialize the class and open a new browser with the new toolbar item

self initialize

This package uses the XMLParser to read the DOM from an SVG string, which then is converted to a SVGDocument on a second pass, displaying the result using Cairo.
Using the XMLParser ensures that any SVG can be at least read, while the second pass might skip some of the available attributes and properties.
The hierarchy of SVGObjects has been extended, handling of some of the attributes has been refined.
Nevertheless, several features of SVG described on the W3C-Website (https://www.w3.org/TR/2011/REC-SVG11-20110816/) are not supported, animation and interactivity being the major ones.
While support for all CSS color constant names is available, the usage of real world units is not implemented.

The SmaccParser used in the previous version is still available. It has been developed by Annick Fron, annick.fron@afceurope.com (http://www.afceurope.com) with some parts from Scarab and earlier work on SVG in the public repository.
The tests for the parser are also still in the package. The syntax is not complete, and for instance the xmlns attribute is not handled, but the package presents no less than 200 examples.

To see examples, look into package SVGViewer-Tests for class TestParseAndDraw.

For test purposes, the binding to Librsvg external library has been kept.

SXOR Compatibility can be used to convert XML Methods that store sxor objects into methods with literal arrays, that store slar encoded objects.

That's only used for compatibility in seaBreeze.

Usage:

execute:
SxorToSlar.ConverterUI open
1. click on "convert" to convert all sxor methods to slar methods. slar methods will have the suffix _slar.
this takes a while as it searches through all methods in the system.
2. (optional) click on "browse" to compare the sxor methods and the new slar methods
3. click on "rename" to replace the sxor methods with the slar methods.

This is a new implementation of Tar. It implements both reading and writing of Tar files.

The abstract class TarFile with its subclasses TarReadFile and TarWriteFile provide SequenceableCollection protocol to access the contents which are TarredReadStream or TarredWriteStream instances.

A TarGzArchiver is also provided.

Adds a filter field to the behavior inspector. (which is shown via the methods-tab in the inspector)

The package adds utilities to access time related file properties on unix platforms.
See instance protocoll 'utilities' for more detail.

ValueInterface was written by Steven T Abell. he can be reached at info@brising.com

Also see ObservedUserInterface, a Widgetry (new VisualWorks GUI) based variant of ValueInterface.

Both these frameworks were presented at Smalltalk Solutions 2007.

email athomas@cincom.com if you would like a coy of the presentation.

Georg Heeg eK added support for the CanvasViewer code tool

This package contains a reader for the stack.txt files written by VerboseProcessDump.

usage:

LogViewer open

Zork-Analysis may dynamically recover type and coverage information as code is run. This version prereqs John Brant's Method Wrappers Base. It has been tested on VW9.0.

The original Analysis Browser was written by Michel Tilman (mtilman@acm.org). It has been replaced with an integration of the code coverage analysis machinery into the normal SystemBrowser.

• MenuItems are provided to install/uninstall coverage analysis wrappers to pundle/class/protocol/method.
• Installing/Uninstalling for selected pundles will instrument all instance and class methods belonging to the selected pundles.
• Installing/Uninstalling for a single class or protocols will instrument either instance or class methods.

The result display of coverage percentages is added to the list items of the pundle/class/protocol/method lists; percentages for a class will not be shown when in class hierarchy mode.
Currently, the result display for Bundles slows down the SystemBrowser operation because of extensive calculations, therefore a setting is available which switches the bundle display off by default (Settings -> Zork-Analysis -> Display Coverage Values for Bundles); use at your own risk!

Coverage results for classes are displayed according to another setting: (Settings -> Zork-Analysis -> Display Instance and Class Coverage Values for Classes). By default, either instance or class coverage values are displayed, like '[28%] Array'. With the setting switched on, the display will be like: '[28%/70%] Array'.

Coverage results are displayed in every open SystemBrowser.
If a method with coverage information is selected, an additional Tab 'Coverage' is provided as a CodeTool, allowing to analyze the collected information for the method. Statements in the methods source will be displayed with a green background where coverage information was collected. Such statements will show their collected type information in a hover help window. When clicking into such a statement, either a browser opens on the tracked type (a.k. the class), or if multiple types were traced, a Menu opens with all available types (a.k. class names).
Implementation details:
- display of the percentage values for PundleModels reuses some methods also to be found in package 'SUnitToo(lsoverage)'.
PLEASE do not try to load both coverage tools at the same time!
(Authors: Ralf Propach, Roland Wagener, Georg Heeg eK)

Use
===
1) Launch the SystemBrowser from the VisualLauncher. Select a pundle, or a class, or a protocol, or a method, and choose 'Install Coverage' from the respective list menu. As a first feedback, the initial percentage of coverage of the selected items in the lists will show '[0%]' in front of each item.

2) Exercise the code you have just instrumented (i.e. run the application you are interested in, run some tests, whatever).

3) Refresh the browser should be almost instantly, if you re-select the pundle containing the instrumented code. Now browse the code:

• for an instrumented method, the Coverage-Tab will show the collected information,
• hover over an expression element in the code pane to see the recovered type(s) in a hover help window,
• click on the expression element to navigate directly to a single collected type, or choose the desired type from the menu;
  • click on the browsers back button to go back to the selected method again.
• code colored green means: these statements of the method were executed,
• code that is not colored means: the statements were not executed
  • no hover help will be shown, because there was no information collected.

4) Uninstall wrappers when you are done. This may be done selectively for a single method, a protocoll or a class, or for all code of a pundle.
Closing the SystemBrowser window will NOT uninstall wrappers! If you save the image, installed wrappers will also be saved.
(FYI, "Refactory.Wrappers.MethodWrapper nuke" is a last ditch method for eliminating wrappers from your image if you don't know what is wrapped.)

Wrapped code runs some 6 times slower than unwrapped.

Known Limitations
==============
This is work in progress and needs refactoring in places.

• There are currently no safeguards against tracing methods used by the tool. This may lead into all sorts of problems, hence either stay away from monitoring kernel classes until this is remedied or take the risk but save first (which might be prudent anyway when methods are being wrapped).
• Not all Smalltalk constructs are supported; e.g. 'thisContext' is not recognized.
• The hypertext functionality is currently rather ad-hoc (so is the implementation).
• In prior versions, with wrappers installed, the PDP debugger had trouble when selecting certain stack frames within an #eval: by an Analysis Browser wrapper. This is being examined.

Further information
===============
Michel Tilman's web page describes the VW2.5 implementation and has a picture of the 5i.3 version: visit
http://users.pandora.be/michel.tilman/Smalltalk/

Niall Ross' ESUG2000 conference report describes the tool in the section on meta-programming, report on 'Building Run-Time Analysis Tools using Pluggable Interpreters': visit
http://www.esug.org/summerschools/2000_Southampton/report/ESUG2000publicV2.pdf

Eurydike is a schema-less object-relational mapper designed for easy-to-use. You do not need to write table-descriptors or anything else to describe a mapping between objects and tables. With Eurydike it is possible to store any object on an SQL database and access it through a root object called ObjectSpace. Because of performance reasons primitive objects like strings, symbols, numbers and byteencoded objects like ByteArray or UninterpretedBytes cannot be stored directly as stand-alone object, they can be only stored as variables of another complex object.

An ObjectSpace defines the root of the objects you want to persist in your database. You need to subclass ObjectSpace and implement the class-method #connectionProfile. This method must return an instance of Eurydike.ConnectionProfile and contains the database connection information like environment, user and password. You can then add your needed instance variables or accessor methods to your ObjectSpace. Normally you will speak only with the default instance of your ObjectSpace. This can be retrieved be sending the message #default to your ObjectSpace class. Your changes on the ObjectSpace or any referenced objects will be stored in the database by sending #commit to your ObjectSpace instance.

Assume we have an PersonObjectSpace class with instance accessor method #person, an example code could look like this:

| space |
space := PersonObjectSpace default.
space person
name: 'Winnie';
lastName: 'Puuh';
yourself.
space commit

Please have a look at class AddressManagementSpace and AddressManagementTestCase for more examples.

This package adds the messages catalogs that are part of the Heeg Contributions to the current image.

Extracted from VW-Installer Framework for WikiWorks4SSP

In VisualWorks 7.10 WikiWorks4SSP requires Web Application Server (Legacy) to be installed.

WikiWorks4SSP with CSS support has been adapted to Web Toolkit