Squeak 3.0 Outline
Sections
Welcome to Squeak 3.0
Squeak 3.0
Squeak is a work in progress based on Smalltalk-80, with which it is still reasonably compatible.
Every Squeak release includes all source code for the Squeak system, as well as all source code for
its Virtual Machine (VM, or interpreter, also written in Smalltalk).
Browser openBrowser
[Blue items in this window are active text. If an item contains a URL, it will require internet
access and may take a while to load].
Not only is all source code included, and changeable at will, it is also completely open and free.
The Squeak system image runs bit-identically across all platforms, and VMs are available for just
about every computer and operating system available. The history of the Squeak project can be read at
ftp://st.cs.uiuc.edu/Smalltalk/Squeak/docs/OOPSLA.Squeak.html
The Squeak license and most other relevant information can be found on the Squeak Home Page,
http://www.Squeak.org
Morphic
This release of Squeak uses the Morphic graphics architecture. Squeak also includes an MVC
architecture available inside MVC projects (see the world menu 'open...' options). Most of the
standard system windows can be opened in either framework, but media support is much more highly
developed in Morphic.
Projects
Projects are separate worlds within Squeak, similar to pages on the Internet. In fact active
projects can be shared over the internet just like web pages. We have included a number of
demonstration projects in the 'Worlds of Squeak' window. Others, probably more recent than this
release, can be found by downloading a stepping-stone project over the net:
Project fromUrl: 'http://www.squeak.org/Squeaklets/Squeak%20News.002.pr'.
To 'Go Back' from a project you have entered, choose 'previous project' from the world menu, or '<
PREV' from the navigator bar.
Color graphics
Squeak's BitBlt has been retrofitted with support for variable-depth color and many performance
enhancements. It has several added functions including a paint mode that supports transparency,
and an alpha-blend mode for 32-bit color. It also has a "warp-drive" variant that will scale,
rotate, and otherwise deform bitmaps in a single pass. Interested users will want to try
Display restoreAfter: [WarpBlt test1]
and
Display restoreAfter: [WarpBlt test3].
Sound
Squeak includes base classes and some simple primitives that support real-time background
generation of sound and music. Interested users may want to try
AbstractSound stereoBachFugue play.
as well as the examples in the Worlds of Squeak.
Balloon
Squeak now includes a completely new outline-based graphics subsystem named Balloon. Balloon
graphics are independent of scale and rotation, and may be rendered simply or with 2 degrees of
anti-aliasing. For a quick demonstration, click on...
(FlashMorphReader on: (HTTPSocket
httpGet: 'http://www.audi.co.uk/flash/intro1.swf'
accept:'application/x-shockwave-flash'))
processFile startPlaying openInWorld.
This example also demonstrates that Squeak includes a fairly complete implementation of the
ShockWave graphics file format, with conversion to Balloon graphical objects. Since it's all in
Squeak, you can stop the player and take apart the morphic balloon objects.
Networking
This version of Squeak supports network access. If you are on a web-connected network, you might
want to try...
HTTPSocket httpShowGif:
'http://squeak.org/Squeak2.0/midi/Squeakers.GIF'.
There are more examples in the Socket class. Also included with this release is a complete
WikiWiki server. See the accompanying information on WikiWiki.
Squeak's FileList also supports network access. Available servers are shown at the [] root, and
new servers can be added with the 'add server...' menu command.
Finally, as mentioned above, Squeak can download active projects over the net...
Project fromUrl: 'http://www.squeak.org/Squeak2.0/FinalFrontier.morph.gz'.
Development support
Squeak includes a mature program development system. Most of the components of this system can be
found in the world menu 'open...' options. Most of the available functions can be surveyed in
various menu choices, and also in the world menu 'help...' / 'command-key help' option.
Shrinking Squeak
If you wish to unload the "Worlds of Squeak" examples from this image, make a backup copy, execute
the following five lines, close the window, and then save the resulting image...
ProjectViewMorph allInstancesDo:
[:m | (m hasProperty: #deleteWorldsOfSqueak) ifTrue:
[Project deletingProject: m project. m delete]].
Project rebuildAllProjects.
ScriptingSystem spaceReclaimed
It is possible to shrink Squeak much more than this. Using a separate copy of Squeak, fileIn
MajorShrinkFor3.0.cs, and follow the instructions to create an image that is under 1MB in size.
Also check the internet for the current best ways to shrink Squeak 3.0.
-----
(c) 1996 Apple Computer, Inc.
(c) 1997-2001 Walt Disney
ALL RIGHTS RESERVED.
Return To Top
About Squeak
Basic help information is now available in two external media:
The ReadMe.txt file. If all else fails, read this in a text editor. If it is in the same folder
as this image, you should be able to see it in a Squeak window by clicking on...
ReadMe.txt
You will also find lots of other useful and possibly more current information on the Georgia Tech
Swiki server. We thank Mark Guzdial at Georgia Tech for making this server available. You can
browse it in any web browser using the URL below, or, if you enjoy using Squeak for everything,
just click on...
http://minnow.cc.gatech.edu/Squeak.1
In addition, you will likely want to browse other sites on the web, including...
http://www.squeak.org/ -- The Squeak home page and UIUC archive
http://www.create.ucsb.edu/squeak/ -- Stephen Pope's U.S. mirror site at UCSB.
ftp://st.cs.uiuc.edu/Smalltalk/Squeak/ -- The Squeak archive at UIUC.
http://www.sugarWeb.com -- Smalltalk User Group of Argentina (SUGAR)
Return To Top
The Squeak User Interface
The Squeak Screen
To resize the Squeak Screen, click and drag the bottom right corner (just pretend it has a grow
box), and then choose 'restore display' from the screen menu. We'll clean this up soon.
Windows
To close a window, click in the left box of its title bar. To collapse or expand a window, click
in the right box. To change the name of a window, click in its title, and edit the name in the
resulting dialog box.
Windows can be moved by dragging their title bar, provided that you click in the shaded regions.
To change the size of a window, move the mouse near a corner or border and, when the cursor
changes, click and drag.
Panes
Many windows are made up of panes, and many of these have scroll bars on the left (naturally -
that's where most text is ;-). Scroll bars are divided into 4 narrow strips, and the cursor
changes to tell you which reagion you are in. Three cursors inform you of normal up/down/jump
scrolling (try them now), and the fourth indicates availability of a pop-up menu relating to the
pane you are in.
Menus
Pane menus (often different in different panes) can also be invoked by option-click (and hold) in
most panes, and window menus can be invoked by cmd-click. Many menu commands can also be invoked
by cmd-key combinations, indicated in the menus. The global 'screen menu' can be invoked simply by
clicking in the gray area within the Squeak screen, but outside any Squeak windows.
Color
Squeak graphics support 1, 2, 4, 8, 16, and 32-bit color. To change the resolution of the Squeak
screen, execute any of
Display newDepth: 1.
Display newDepth: 2.
Display newDepth: 4.
Display newDepth: 8.
Display newDepth: 16.
Display newDepth: 32.
Note that common choices are available in the screen 'do...' menu. Naturally, you will want some
reasonable correspondence between this choice and the setting of your monitor.
The screen will consume more memory in higher resolutions, but Squeak is careful to use only 1-bit
pixels for most text window images. The window menu offers a choice whether to save only two
colors or all colors of a given window (as well as a coice of background shade).
Projects
Project windows are actually more like doors than windows, since you can enter them by clicking in
the interior. You can create new ones by choosing 'open...project' from the screen menu. To exit
a project (and return to its containing project), choose 'exit project' from the screen menu. Each
project maintains its own set of windows, its own set of changes, and its own screen color depth.
Typing
The _ character in Squeak is really an underbar; that's how you type it. Note that := is an
acceptable alternative for assignment.
The Squeak text editor supports many editing operations that can be invoked by cammonad keys. For
a full list of these operations, choose 'help' from the screen menu, then choose 'command-key help'
Return To Top
Nebraska Tips
A Nebraska server has a private world and some collection of clients. It associates a
RemoteControlledHand for each client. Redraw events in the world are broadcasted to all connected
clients. A Nebraska server can listen on a TCP/IP port and accept new clients. Current version has
been modified so that the server serves the world in which it was launched. Other variations are
certainly possible.
To start a server, execute the following code:
NebraskaServerMorph serveWorld: World
To start a client, run the following in another image:
NetworkTerminalMorph openAndConnectTo: 'servername'
Fill in your server's hostname for 'servername'. At this point, everything should be working!
Before starting a server, you can tweak these:
BufferedCanvas enabled: false.
BufferedCanvas enabled: true.
At any time you can do these:
NebraskaDebug beginStats
NebraskaDebug showStats
NebraskaDebug showStats: #delays
NebraskaDebug showStats: #bigImage
NebraskaDebug showStats: #FormEncodeTimes
NebraskaDebug killStats
NOTE: if you want to have a local view of the server, you shouldn't use the TCP connections. The
problem is that the server will occasionally do a #flush, and it won't work due to single
threading. The better solution is to use a LoopBackStringSocket instead of a regular StringSocket,
but there is no handy method for that right now....
Return To Top
Managing and Saving Changes
Starting and Quitting
Obviously you have figured out how to start the system. The approved method is to double-click on
an image, although if you have several different interpreters, you may want to drag the image to
the appropriate interpeter.
To quit a Squeak session, choose 'quit' with or without saving from the screen menu. If you save,
your image file will be overwritten. You may choose 'save as...' to write a newly named copy of
your image and changes (see below).
Image File
All of the objects -- classes, dictionaries, windows and other objects that make up the Squeak
environment are stored in an image file (this must always be named 'SomeName.image'). For this
reason, when you start up an image, everything is right where you left it when you last saved the image.
Sources and Changes
For various reasons, the source code associated with the image is stored in two other files. The
code of the system as originally delivered (vers 2.0) is stored in the file 'SqueakV2.sources', and
the sources for everything done since that time is in the changes file (which must similarly be
named 'SomeName.changes').
Storing the source code in a separate file has several advantages. To begin with, if you have been
working for a couple of hours, and your dog rolls over the power cord, you will still have a
sequential record of all your program edits, and these can be perused and replayed with numerous
tools such as changes: post-snapshot log. This feature has also saved many a hacker who got too
adventurous in changing the system he or she was using.
Also, if you wish to run the system with severely limited resources, it can be operated without any
source code, owing to its ability to decompile the bytecode methods into a readable and editable
version of the original source code (only comments and temporary variable names are lost).
Finally, since the changes file does not consume memory space, Squeak keeps a continuous log of all
your program changes, and these can be examined and reinstated at any time (see 'versions' option
in browser selector pane).
FileOut, FileIn
In addition to the 'save' command that saves the entire state of your Squeak image, individual
methods, categories and classes may be 'filed out'. This option is available in most browsers, and
it results in the creation of a text file with an appropriate name, incorporating the code in question.
The format of this file is special, in that it can be read back into the same or another Squeak
image to recreate those same classes and methods in a new environment.
ChangeLists, ChangeSets, and ChangeSorters
A ChangeList is a method-by-method view of a fileOut. Note that the changes-file record of all
your program edits uses the same fileOut format, so a ChangeList can browse the change history of
any Squeak session. The recent change log option of the changes... menu is one example; other
examples in ChangeList public access include viewing other Smalltalk source code files. This can
be easly invoked through the FileList 'browse changes' option.
In addition to the sequential changes-file record of all changes, whatever project you are in, a
ChangeSet keeps a more dictionary-like record of what has been changed. This allows you to fairly
easily make a fileOut of just the most recent versions of a bunch of related changes that
constitute your work on that project.
ChangeSorters allow one to organize all system changes into a number of independent ChangeSets.
One word of caution: at the present, unaccepted changes in a changeSorter window will be lost if
you exit the window and return later, due to over-ambitious automatic updating.
Projects offer a natural way of organizing related work, windows and changeSets. The effect is
almost like many separate images in one, except (!) that all projects share the same code,
regardless of where else it may be changed.
Organizing your Disk (on the Mac)
Squeak will look for its sources file both in the folder in which the image was started, and in the
folder in which the VM exists. It is simplest to put the sources together with the VM, and then
you can use any numbe of image/changes pairs anywhere on your disk.
If you wish to maintain different versions of the VM on your disk, here is the easiest way: put
all VMs in a single folder, along with the sources. Then in any folder with images for version X,
put an alias of the VM for version X, and drag your image onto the VM alias to start it.
Return To Top
Pluggable Views
Version 2.0 of Squeak includes a complete rewrite of all the MVC windows to use pluggable views.
A pluggable view has a set of selectors that parameterize its model interface in such a way that
instances of the same view class can be used on many different models. This simplifies and factors
the system -- we were able to reclaim about 50 classes (!) from the old MVC system in the course of
this rewrite. More importantly, it left us with only a handful of classes to convert in order to
run all our existing development system in a morphic-only world. Nearly the entire view mechanism
has been funnelled down to
PluggableListView
PluggableTextView
PluggableButtonView
for which we have written morphic counterparts,
PluggableListMorph
PluggableTextMorph
PluggableButtonMorph.
Return To Top
Morphic Squeak
It is possible in Version 2.0 to run the entire Squeak development environment in morphic. You do
this by opening a morphic project, and choosing 'windows...' from the morphic world menu (use
ctrl-click). This part of the system is still smoking -- essentially none of it existed a month
ago. Some parts are slow, some parts may fail, but we feel it is instructive to see an entirely
new viewing mechanism running the same old MVC applications.
Return To Top
Scripting and End-user Access
Squeak Version 2 includes sketches of two entire end-user programming paradigms, intregrated with
the morphic environment.
One is a wiring metaphor inspired by Fabrik, that allows simple component assembly to be performed
the way you put a stereo system together. The implementation is just a toy (no real dataflow model
or encapsulation yet) but you may enjoy the demonstration in Play With Me - 6.
The other is a tile-based interface that offers viewers and scriptors as iconic and active
counterparts to Squeak's textual and more passive inspectors and browsers. It has been taken fairly
far in a number of directions, as you may discover by following the introductory tour "Programming
in Morphic".
As an explorer of Squeak, you need to know that these environments are only sketches. We are
excited about them. We are working actively on them. But they are not complete, they are not
foolproof, and they are not well documented (but then what is?). We share them in the same spirit
that we share Squeak: we invite you to play with us, to share our discovery, and perhaps to work
with us as we move forward.
Programming in Morphic
Two quite different styles of programming in Morphic are available in Squeak 2.0: "Classic Morphic
Programming" and "Scripting with Players".
(I) Classic Morphic Programming
This is the kind of programming for which Morphic was originally designed, and excellent examples
of clean and attractive style using that approach can be found, for example, in BookPageSorterMorph
and EnvelopeEditorMorph.
In "Classic Morphic Programming" style, you define your own subclasses of one or more generic Morph
classes, and blend them into a working subsystem. Here, you're directly extending Morphic, in grand
and time-honored Smalltalk manner. The fundamental tool here is the Browser: you locate and
familiarize yourself with particular Morphic classes, and you then subclass the ones that you
decide are appropriate for your application.
Most current Squeak users will prefer this traditional, mature, analytic, browser-based Smalltalk approach,
If you're still curious about the other style, read on...
(II) Scripting with Players -- The "User-Scripting" Style
The second style of programming is rather more informal, more like "scratch programming", somewhat
comparable to what we Smalltalkers do when we use a Workspace to construct and evaluate various
lines of code for some exploration or calculation in Smalltalk, and also comparable to the kind of
scripting done by users of systems like HyperCard and HyperStudio, etc.
In the User-Scripting style, you construct surface graphics by directly assembling standard Morphic
parts -- e.g. Rectangles, Images, Joysticks, etc., by dragging them from a Parts Bin and arranging
them as desired, and then you add user-defined state and behavior by adding instance variables and
writing methods for "Players" who represent the individual morphs you wish to script.
The user thus does not directly subclass any particular kind of Morph, but rather she assembles?
Morphs and gives them special state and behavior by associating them with "Players", which are the
fundamental user-scriptable object types for User Scripting.
(The basic hookup is that every Morph can have, optionally, a Player as its "player", and every
Player has an associated Morph that it "wears" as its "costume". Player itself is a class with lots
of capability but very little instance state; user-defined Players are all implemented as compact,
single-instance subclasses of Player.)
Return To Top
Blanket Disclaimer and Warning
In Squeak 2.2 we offer only a very early take on User Scripting. It has many rough edges, consumes
lots of memory, can leave garbage around that will bloat your image,
It is tempting to dwell at length on "Disclaimers" about User Scripting, but we shall resist,
beyond saying: this is early work, preliminary, much in flux, with bugs, inconsistencies,
significant gaps in design, and much that definitely will be changing before long.
If you wish to play with this stuff anyway, please do so in a spirit of high adventure, and be sure
to protect yourself by doing your exploring in a "throw-away" copy of your image, not in something
you intend to save and build on. These are very early days!
Live Examples Coming Later
In due course, we will be placing on the Squeak web site some "live examples" of use of "Player Scripting".
Eventually, we expect that full, interactive, mutlimedia-based Squeak tutorials, constructed
entirely within the User Scripting domain, will be downloadable from the Web and will be
immediately active and usable.
Technical limitations have kept us from doing that now, and space considerations have kept us from
implanting live examples in this release image.
Good advice for the moment (except for the most adventurous) is to wait until those live examples
are available on the net. They should make it much easier to absorb the basics of user-scripting,
without having to wade through so much prose.
Return To Top
The Three Basic Elements of User Scripting
(1) The "Halo" -- lets you interact with any object you can touch (i.e., any morph).
Alt-Click on a morph to bring up its halo. Successive alt-clicks will transfer the halo to the next
morph in the hierarchy -- experiment with this. Mouse over the various halo handles and read the
help-balloons that will pop up to explain what each handle does. The name of the object that
currently bears a halo will be seen at the base of its halo (and a click on the name will let you
edit it.) Note: on a Mac, Alt-Click is Apple-Click.
(2) The "Viewer" -- a dynamic graphical Inspector and Browser.
To get a Viewer for an object, drag from the cyan handle of its halo, and a Viewer will stick to
the mouse; place it wherever you wish.
Use the top part of the viewer to see and change properties of the object; use the bottom part of
the viewer to see and invoke scripts for the object. And use the buttons provided to add your own
instance variables and your own methods to the object.
(3) The "Scriptor" -- a place to define, edit, test, save, and schedule actual scripts.
In order to succeed with user scripting, you will need to be able quickly to get a Halo on any
object, open a Viewer on any object, and get a Scriptor for any object.
Return To Top
Getting started with Scripting
Preliminaries
Choose "project (construction)" or "morphic construction window" from the "open new" menu. Drag a
Playfield (light green rectangle) from the parts bin and drop it somewhere. Drag a Star from parts
bin, and drop it in the Playfield. Alt-click on the star to bring up its halo. Tear off a "viewer"
for the star by dragging from its cyan halo handle. Drop that viewer somewhere nearby (but
preferably NOT in the Playfield)
Balloon help over the various crude controls in the Viewer will give you a general orientation.
Exercise 1 -- Relationship between an object and its viewer.
a. Play with the star via its halo. Drag it around, rotate it, resize it, change other things via
its red-dot halo menu, and watch the changes in the viewer. (You may need to click to another
"bank" of parts to find the group of information you're interested in; use the little left and
right arrows )
b. Play with the star via its viewer -- set its heading, its scale factor, its border width, its
color, etc., and notice the effects on the star itself.
Anything you can manipulate in the viewer can also be manipulated via scripts, and the viewer gives
you access to scripting, as will be seen below.
Exercise 2 -- Sending requests directly to an object from its viewer.
In the lower part of the viewer are some sample lines of script. (Look at the other banks to see
the full vocabulary.)
You can click on any of the yellow "run it!" (exclamation point) buttons to send that line of
command to the star. You can change the values of parameters there in the viewer.
Make the star turn by hitting ! for "star turn by 5". Hold down that ! button to keep the star
turning. Change the "5" to larger and smaller values, and to negative values (by clicking on the
little carets that control these things) and notice the effect
We're not "scripting" yet because we're still manually issuing one command at a time. Scripting is
simply the process of assembling a sequence of such commands in a "Scriptor", so they will all run,
in sequence, when asked.
Exercise 3 -- Making a simple script
Drag from the "star turn by 5" line of the viewer, and drop onto the "desktop" of the world. A
Scriptor will result -- your own script, with the "star turn by 5" command already in there as its
first line.
Drag from the "star forward by 5" line of the viewer, and drop that down inside the same Scriptor.
You have now created a two-line script, that tells the star to turn and move forward.
Let the cursor drift over each of the five buttons at the top of the Scriptor, and read the balloon
help of each to get an idea of what they do.
Click on the "!" and the script runs. Hold down, it keeps running. Change the amount-to-turn-by and
the amount-to-move-forward-by and run again.
Now try out various alternatives for when? the script should run. Initially, when it says "Normal"
in the Scriptor, it's just cold code waiting to be called by someone, such as by the yellow "!" button.
So now make it run continuously -- choose "ticking" from the script-status menu that pops up when
you click on "Normal". The star should now start animating continuously, until you change its
status or until you hit the "Stop" button.
While it's animating, change the parameters to "forward" and "turn" in the Scriptor, to achieve
different curvature and speed as it putts along.
Now for fun you might find the "Pen" area in the star's Viewer, and change the star's "PenDown" to
true. It will start laying down ink as it moves, and now by adjusting parameters to move and turn
in the Scriptor, you can do a kind of scripted drawing.
Once you've started this, resist the temptation to change the pen's color and size in the viewer,
because you might get distracted from the real business of scripting.
Exercise 4 -- Hooking up a script to the user interface
Above, you made the star's script "run all the time". Now go back to that same menu in its
scriptor, and tell it to run on "mouseDown". Then mouse down on the star and watch the script run once.
Experiment with all the different choices -- mouseDown, mouseStillDown, mouseUp, mouseEnter,
mouseLeave. For "countinuous controls" such as scroll bars and sliders, "mouseStillDown" is a good
choice. For traditional "buttons", "mouseUp" is a traditional choice, though some controls feel
better when they react on mouseDown.
You can have one script do something on mouseDown, and another on mouseUp, etc. One easy thing to
try is to have the button change color (to something darker, for example) upon mouseDown, and then
change back to its original color upon mouseUp.
Exercise 5 -- Naming and saving a script.
Thus far, we've been working with a "temporary script". If you want to make it a permanent part of
the object, choose "name and save this script", and give it a name, such as "wander".
As soon as you've done this, you'll see "wander" show up in the star's Viewer, alongside "forward
by", "turn by", "make sound", etc.
Your "wander" script has now become a formal part of the object -- you've added a method to your
object. It can now be deployed in viewers and scriptors just like the system-defined scripts such
as "forward by". And it can be called by any other script.
Exercise 6 -- Substituting your own (textual) Smalltalk code
Here we will make a button that, when pressed, files out your current change set. This is to
illustrate the fact that you can always "escape" from the tile-scripting framework to write your
own arbitrary Smalltalk code.
Get a parts bin.
Drag out an ellipse.
Drag out a "Text for Editing", and edit its text to say "File Out Changes".
Place the text over the ellipse, nicely centered (resize the ellipse as needed), then bring up the
halo for the text and choose "embed" from its menu, and embed it in the oval
From the Text's halo menu, choose "lock", so that the label won't go into text-editing mode when
the mouse comes down on it -- that's not what we want here.
Next, bring up the ellipse's halo and from the halo tear off a Viewer.
Name the ellipse "TestButton" (you can edit the name in the halo or at the top of the viewer).
From the viewer, tear off a "TestButton make sound croak" phrase, and drop it on the world's
desktop. A scriptor opens up around it.
From the scriptor's menu, choose "name and save this script", and give it a name like "doFileout".
From the scriptor's status menu, change "normal" to "mouseUp". This will allow it to behave like a
traditional button.
Test the button -- when you click on it, you should hear a croak sound.
Now chose "edit script textually" in the scriptor. This will give you a message-editing window in
which you can type arbitrary Smalltalk code, and it will be invoked whenever the script is
triggered, be it via ticking, mouse actions, or being called from another script.
So now we type in whatever script we want, in plain Smalltalk, and submit it. For the moment, you
might edit the method to look like this:
doFileout Transcript cr; nextPutAll: 'Testing One Two Three...'. self beep: 'croak'.
Now make sure a Transcript is open, and then try the script out. When you click on the button, your
message should show up in the Transcript and you should hear the croak.
This shows that the hookup is working. Now all that remains is to edit the method to do something
useful; in this case, it will look like this:
doFileout Smalltalk changes fileOut. self beep: 'croak'
Now, whenever you click on this button, the current change set will be filed out and you will get a
frogly confirmation.
(7) Adding instance variables to an object.
Hit the "add inst var" button in a Viewer to add an instance variable. The new instance variable
starts out bearing a number, but you can change its type at any time. The type affects what form
its readout (in the Viewer) will take, and also where you can drop a tile representing the value in
a scriptor (numbers can be dropped on numbers, etc.)
If the type is a number, for example, you'll get a textual readout with arrows to change the values
manually. But if the type is "player" (i.e. object-reference, or "alias", if you will), then the
readout is a graphical thumbnail of the current referent.
(8) Scripting one morph to chase another
Get a morph (which you've named, say, "rabbit") busily animating with an ever-ticking script
involving "forward by" and either "turn by" or "bounce".
Construct another Morph, name it "chaser" and script it to pursue the animating morph by giving it
an ever-ticking script of the form:
chaser move toward dot
dot here refers to a little, faint object near the left edge of the window -- the one object in the
world that starts out life with "identity", this serves as the sample parameter for any
Player-valued scripting element, just like the "5" in "forward by 5" serves as a sample parameter
for "forward by".
To make the object move not toward dot but rather toward the "rabbit" you've earlier animated,
you'll want to tear off a tile to represent the rabbit. There is a handle on the left edge of the
Halo which, when you mouse down on it, will yield you just such a tile. Get it, and drop it over
the "dot" tile, and it will replace that tile, so that your script will now read:
chaser move toward rabbit
[For extra credit, you can adjust the speed at which pursuit takes place by adding a numeric slot
to chaser and calling it "speed".]
(9) Controlling an object with a Joystick
Generally you create scripts by dragging tiles from the viewer; this gives you simple scripts
(which already are syntactically correct, and are fully functional) to start out with, and then you
proceed to modify them.
One essential operation is dropping a tile into another tile bearing the same type of information;
this results in the old tile being replaced by whatever you dropped.
Thus, for example,
Paint an airplane using the simple painting tools:
Drag from the crude green arrow in a Parts Bin (which indicates "paint a new object") and drop
somewhere on a Playfield. Paint a rough airplane-like figure facing upward, then hit the "Keep"
button. This is your airplane. Open up its Viewer, and name it "airplane".
Make a script for the airplane that starts out: airplane forward by 5 airplane turn by 5
Get a fresh Joystick from the Parts Bin, and bring up a Viewer for it. Go to the parts bank that
shows the joystick-specific parts, "leftRight", "upDown", "angle", and "amount".
Drag from the tile showing the word "leftRight"; tiles for "joystick's leftRight" will stick to the mouse.
DROP that "joystick's leftRight" directly onto the "5", to make the airplane's script read:
airplane turn by joystick's leftRight
Now make this script run all the time ("ticking"), and you can spin the airplane by moving the
joystick's handle to the left or to the right.
A simple extension (left to the reader) is to add a "forward by" command to the same script, and
have the amount by which it is to go forward be obtained from some other number that a Joystick is
able to report. It's fun to explore various possibilities for mapping the joystick parameters into
the parameters for the "turn" and "forward" commands. Since the Joystick delivers four different
numbers, you could hook them up to other things about your airplane (such as its color or its scale
factor) and end up with some rather unusual controls!
Return To Top
More about Morphic Scripting
About Assignment
The top part of the viewer consists of rows of the form:
airplane's heading <- 0.
If you drag from the green-and-purple left-arrow, you'll get an "assignment phrase", which is a
line of code that lets you "assign a new value" for the heading. Plop it down in a script just like
any other command.
Actually, there are four kinds of assignment: simple assignment, incrementing, decrementing, and
multiplying; you move among them by hitting the carets on the assignment tile in the Scriptor. A
simple exploration will reveal how they work, but be careful with the muliplying assignment -- your
numbers can quickly get big.
Advice, Bugs, Things To Avoid, etc.
(1) You will by now have noticed that when you drop a line of script on the Morphic "desktop", it
sprouts a "scriptor" around itself, ready for editing and running. This is often what you want, but
when it gets annoying, which is to say, when you find you'd like to be able to drop naked lines of
script and have them stay as naked lines of script, for later use, you can drop them into any
"Playfield" (PasteUpMorph) rather than onto the World desktop, and you can avoid this sprouting.
(Whether or not a Playfield automatically expands a dropped phrase into a complete Scriptor is
governed by the "automatic phrase expansion" option, which will be found in the its "playfield
options" menu.)
(2) A nice standard kind of script for lots of experimentation is: star forward by 10 "move forward
ten units" star bounce silence "if hit wall of container, bounce silently"
(3) Scripts that are "ticking" provide a "live" feel, making experimentation quite easy.
(4) Be sure to try out use of the "pen" for laying down color trails. The "colorUnder" and
"colorSees" tiles provide ways that objects can easily interact with their surroundings.
(5) The "conditional" in the tile-scripting system is the "Test/Yes/No" complex (your basic
if/then/else); in the test pane go boolean-valued things; into the Yes and No panes go any sequence
of commands.
(6) When an object is scripted to handle the mouse, you won't be able to drag it with the mouse. To
drag such an object, bring up its halo, and drag it from its black-dot or brown-dot handle.
(7) At present, there is no protection against script cycles, so that you can get yourself in
trouble with two scripts or more scripts that end up calling each other.
(8) Before trying to duplicate a scripted object, make sure that all its scripts are "saved and
named", so that the duplicate you make will have the same scripts.
Return To Top
Next Steps
This User-Scripting regime is still in its infancy, as is the documentation about how to use it.
We put it out at this time only in hope that some users will find something of interest in spite of
the rough state of the design and the code (and in spite of the numerous temporary perturbations it
has caused to an otherwise elegant Morphic graphics system.)
Coming in the foreseeable future are extensions of the user-scripting design to cover "aliases",
"collections", the "stack/card" dichotomy, file-based factoring of content, Finder-like analogies
for content, integration with projects, navigation morphs, integration with the more generic Morphc
inspector and browser tools, and more.
Much of this design space has been explored in various earlier prototypes we've worked on, so we're
not starting from ground zero, but there is plenty of architectural work still to be done before we
emerge with a clean and minimal design that will extend user scripting to span the space of the
"multimedia, hypermedia, and simulation tool" that we believe it may become.
Many changes are on the way. We warmly welcome participation by the Squeak community as we pursue
this work, which is quite at right angles to the traditional course of Smalltalk. Just, please,
don't at this stage count on user-scripting to be compact, reliable, consistent, transportable, or
stable. If you can thrive on such slippery ice, please join us now! Otherwise, give it a chance to
mature over the coming months.
Return To Top
Brainstorming and Engineering
The Squeak team works in periods of expansion, when we try new approaches and write lots of new
code, and periods of reflection, where we re-factor, clean up and document (well... sometimes ;-).
It is important for critics to understand that the morphic system and the end-user programming
systems that are embedded in it, are still in an expanding brainstorming phase. We know that the
clean morphic protocols have become a huge, confusing hodge-podge.
But this is important. Morphic is being taken in new directions, including flexing, scripting, and
viewing. When we have gained experience with these new areas, when we have learned from working
with some real users, then we will better understand the real kernel of this architecture, and we
can return to clean it all up and cast it clearly in the metaphor that we don't fully understand
right now.
Return To Top
Source Code Updates
Tired of waiting months for the next release?
Now you can get code updates automatically loaded into any Squeak attached to the internet. Choose
'update code from server' in the 'help...' menu. (Wait, or have a Transcript open to watch the
progress.) The Squeak team will be putting approved changes to Squeak on two servers, at UIUC and
at WebPage.com. Updates are numbered and are loaded in order.
We've been using Updates in our group at Disney for six months and it has really improved our
productivity. If you want to set up your own Update server for your own organization, please
contact Ted Kaehler. It is an easy way to distribute changes to a group of people who all use Squeak.
Return To Top
Two Virtual Machines
With the release of Squeak 2.0 we are including two complete copies of the Squeak VM. The first,
referred to generally as "Squeak VM 2.0" is simply an updated version of the standard bytecode
interpreter that we have been using for the last year or so.
The second, referred to as "Squeak Jitter", translates Squeak bytecodes on demand to a more
efficient representation for faster execution. This project is the work of Ian Piumarta at INRIA
in France. While we and he have tested it quite thoroughly, you need to know that it is still in
an early experimental stage -- it is likely to be less stable than the normal intepreter. At the
same time, "Jitter", as Ian affectionately calls it, does run faster in many cases, and will
probably show further substantial performance gains over the next couple of months.
If you are interested in Jitter, it is entirely written in Squeak, and can be browsed in the
'Squeak-Jitter' category. If you are not interested, it can all be removed as described under
"Image Size".
Return To Top
Image Size
We have intentionally included more features with the Squeak 2.2 release than most people will
use. If space is of concern, many of these facilities can be removed to produce a considerably
smaller image.
We are in the process of sanitizing and automating this removal process. Right now, you can
execute the following to achieve the approximate savings given...
Smalltalk discardVMConstruction. "663k"
Smalltalk discardSoundSynthesis. "330k"
Smalltalk discardOddsAndEnds. "228k"
Smalltalk discardNetworking. "261k"
Smalltalk discardMorphic. "2,231k"
The above altogether saves around 3.5 megabytes. Executing
Smalltalk majorShrink
will do even more and should yield a final image size of around 800k. There will be loose ends in
that image that may cause errors when you attempt to use facilities that have been removed, but
this is usually not fatal. We will be updating the various shrinking routines to improve this
process, and they can be browsed in the 'shrinking' category of SystemDictionary.
Want to squeeze Squeak into a PDA? After executing the above shrinking routines, you can go on to execute
Smalltalk abandonSources.
This will compile method temp names into a compact trailer on every method, allowing the entire
system to be browsed by decompiling with temp names preserved. This means there is no need to
store the sources file on a very small machine. While comments are not available in system code
after abandoning sources, all the code you write will be preserved properly in the changes file, so
that you can upload it to a full Squeak when you return from your backpack trip.
Return To Top
The Wiki Wiki Server
Swiki -- A Server of Web Pages That Any User Can Modify
Version 2 of Squeak includes a complete editable web server. Every web page on a Swiki web site
has a button that says, "Edit this Page". It gives you the contents of the the page in a scrolling
window. When you change it and "Save", the page is instantly changed. The user can work from any
web browser. Changing a page is so easy enough that a workgroup or class will quickly create an
evolving spiderwork of their own pages.
To start your own Swiki, see the instructions in (PWS class howToStart), and get a folder with
necessary template files from...
http://www.cc.gatech.edu/fac/mark.guzdial/squeak/pws/
Thanks to Mark Guzdial, Georg Gollmann, and Mark's students, and to the father of WikiWiki, Ward Cunningham.
Return To Top
Stylized Text and Links in Source Code
Remember the discussion after OOPSLA about better documentation and navigation? Thanks to the
work of Ted Kaehler, this version of Squeak allows creation of hyperlinks in text, and preserves
them (and most text styles) in source code and class comments! This makes it possible to document
Squeak more effectively than before, as you will see from the limited examples in the Sample
Documentation window. Links can be created using CMD-6, and they can deactivated by selecting
(with an extra leading character, or from back to front) and using CMD-0. Here is an example link: Text.
We hope over the next month or two to rewrite all class comments to take advantage of this new
capability and establish a real "backbone" to Squeak's on-line documentation. You will notice a
new switch in the browser, suggested by Scott Wallace, that facilitates access to class comments
for just this reason.
If you never put links or emphasis in your source code, everything should work just as before.
FileOuts may include style information after each method. If you need to bring a new fileOut into
an older system, read the file 'readFileinsWithStyle.cs' into your older system first.
Return To Top
GUI Help
Squeak GUI Help
Outline
Basic GUI: Windows and Scrolling
Menus
Text Editor
Launcher
Getting More Help
Standard Lower-case command keys
a Select all
b Browse it
c Copy
d Do it
e Exchange
f Find
g Find again
h Set Search String
i Inspect it
j Again once
k Set font
l Cancel
m Implementors of it
n Senders of it
o Spawn
p Print it
q Query symbol
r Recognizer
s Save (i.e. accept)
u Align
v Paste
w Delete preceding word
x Cut
y Swap characters
z Undo
Upper-case command keys
(Hold down Cmd & Shift, or Ctrl key)
A Advance argument
B Browse it in this same browser (in System browsers only)
C Compare argument to clipboard
D Duplicate
F Insert 'ifFalse:'
J Again many
K Set style
L Outdent (move selection one tab-stop left)
N References to it
R Indent (move selection one tab-stap right)
S Search
T Insert 'ifTrue:'
W Selectors containing it
V Paste author's initials
<return> Insert return followed by as many tabs as the previous line
(with a further adjustment for additional brackets in that line)
esc Select current type-in
shift-delete Forward delete character (not currently undo-able)
[ Enclose within [ and ], or remove enclosing [ and ]
( Enclose within ( and ), or remove enclosing ( and ) NB: use ctrl (
{ Enclose within { and }, or remove enclosing { and }
< Enclose within < and >, or remove enclosing < and >
' Enclose within ' and ', or remove enclosing ' and '
" Enclose within " and ", or remove enclosing " and "
1 10 point font
2 12 point font
3 18 point font (not in base image)
4 24 point font (not in base image)
5 8 point font (not in base image)
6 add color / make active
(nb: to remove the active quality of text, you must select
more than the active part and then use command-0)
7 bold
8 italic
9 narrow
0 plain text (resets all emphasis)
- underlined
= struck out
LauncherView Buttons
Open Browser
(PackageBrowser by default, or old Browser if LeftShift)
Open File List
Open Workspace
Select from Changes Menu
Save Snapshot
Help
Return To Top
System Workspace
Squeak Version 1.1
September 24, 1996
Copyright (c) 1981, 1982 Xerox Corp.
Copyright (c) 1996 Interval Research Corp.
Copyright (c) 1985-96 Apple Computer, Inc.
All rights reserved.
The Squeak team gratefully acknowledges contributions to this image by members of the Homeworks
project at Interval.
Changes and Files
Smalltalk noChanges.
Smalltalk condenseChanges
DisplayScreen removeFromChanges.
Smalltalk changes asSortedCollection
Smalltalk browseChangedMessages
(FileStream fileNamed: 'changes.st') fileOutChanges.
(FileStream fileNamed: 'PenChanges.st') fileOutChangesFor: Pen.
(FileStream oldFileNamed: 'Toothpaste.st') fileIn.
(FileStream oldFileNamed: 'housekeeping.st') edit.
FileDirectory filesMatching: '*.st'
(FileStream oldFileNamed: 'listing29mar100pm.cs') insertLineFeeds
Inquiry
InputState browseAllAccessesTo: 'SystemStartupList'.
Smalltalk browseAllCallsOn: #changed:.
Smalltalk browseAllImplementorsOf: #confirmFirstUseOfStyle
Smalltalk browseAllCallsOn:
(Smalltalk associationAt: #Voices)
Smalltalk browseAllCallsOn:
(Cursor classPool associationAt: #ReadCursor).
Smalltalk browseAllCallsOn:
(Undeclared associationAt: #Disk)
Smalltalk browseAllMethodsInCategory: #examples
(Smalltalk collectPointersTo: StrikeFont someInstance) inspect.
Smalltalk garbageCollect.
FileStream instanceCount
FormView allInstances inspect.
Smalltalk browse: Random
HouseCleaning
Undeclared inspect.
Smalltalk cleanOutUndeclared.
(Object classPool at: #DependentsFields) inspect.
Smalltalk reclaimDependents.
Symbol rehash.
Transcript clear.
Smalltalk forgetDoIts.
Smalltalk removeKey: #GlobalName.
Smalltalk declare: #GlobalName
from: Undeclared.
Globals
Smalltalk keys select: [:k | ((Smalltalk at: k) isKindOf: Behavior) not]
Display -- a DisplayScreen
Processor -- a ProcessorScheduler
ScheduledControllers -- a ControlManager
Sensor -- an InputSensor
Transcript -- a TextCollector
SourceFiles -- Array of FileStreams
SystemOrganization -- a SystemOrganizer
StartUpList -- an OrderedCollection
ShutDownList -- an OrderedCollection
Variable Pools (Dictionaries)
Smalltalk
FilePool
TextConstants
Undeclared
System Files
Smalltalk closeSourceFiles.
Smalltalk openSourceFiles.
SourceFiles _ Array new: 2.
Measurements
Utilities garbageCollectReportString '13,370,176 bytes available'
Symbol instanceCount 12907
Time millisecondsToRun: [10 benchmark] 266
MessageTally spyOn: [100 timesRepeat: [3.14159 printString]]
MessageTally tallySends: [3.14159 printString]
Return To Top
Squeak Performance Benchmarks
Simple Squeak Benchmarks
Send speed in sends/sec:
[ | siz col r t |
siz := 64.
col := OrderedCollection new: siz.
Cursor wait showWhile:
[siz timesRepeat:
[t _ Time millisecondsToRun: [r _ 26 benchFib].
col add: (r // t * 1000)]].
Transcript show: ' max: ', col max printString, ' avg: ',
col average truncated printString; cr]
637000 -- G3/266 (tower)
654000 -- 8600/300
561000 -- 6500/300
561000 -- G3 (desktop)
1094000 -- PowerBook G3 292 MHz/jitter
1058000 -- Gateway 450 MHz Pentium II
1296000 -- PowerBook G3 400 MHz VM 2.5
1368000 -- Dell 500 MHz Pentium III VM 2.8
1623000 -- PowerBook G3 500 MHz VM 2.8.4
Bytecode speed in bytecodes/sec:
[ | siz col t |
siz := 64.
col := OrderedCollection new: siz.
Cursor wait showWhile:
[siz timesRepeat:
[t := Time millisecondsToRun: [20 benchmark].
col add: (10000000 // t * 1000)]].
Transcript show: ' max: ', col max printString, ' avg: ',
col average truncated printString; cr]
15384000 -- G3/266 (tower)
14992000 -- 8600/300
13623000 -- G3 (desktop)
18181000 -- Gateway 450 MHz Pentium II
20964000 -- PowerBook G3 292 MHz/jitter
31055000 -- PowerBook G3 400 MHz VM 2.5
46082000 -- Dell 500 MHz Pentium III VM 2.8
50000000 -- PowerBook G3 500 MHz VM 2.8.4
Return To Top
About the STP12 Goodies
STP Goodies Version 12 README File
Updated 4 February 2001
The file STP12.3.0.bld files these in to Squeak 3.0.
Source code directories: #(#System #Graphics #GUI #Tools #Packages #Fixes)
===============================================================================
System Directory
==== CaseStatement.st ====
This adds a neat shorthand for immediate dictionaries and a case statement; example:
( (#a -> [Transcript cr; show: 'a'; cr]),
(#b -> [Transcript cr; show: 'b'; cr]),
(#c -> [Transcript cr; show: 'c'; cr])
) case: #b
Note that there is a similar structure already in Squeak, but that it uses curly-braces as special
characters, and can only have blocks as keys/values. I prefer this method.
==== CodeGen.st ====
Adds the 'publish' method for automatically generating instance variable accessors. You simply need
to edit and accept the class definition of a class with instance variables, and then do 'ClassName publish.'
==== CollectionAdds.st ====
Several useful collection extensions--with:with:with:with:with:, prevIndexOfSubCollection:
aSubCollection startingAt: anIndex, ifEmpty: [], etc.
==== ColorForm-offsetColors.st ====
This makes it possible to declare color forms expliticly.
==== Dictionary-associations.st ====
Adds explicit accessors for values and associations to Dictionary.
==== FileStr-creation.st ====
A couple of new file stream creation methods. Adds global FileSep with the path name delimiter
==== Float-printPlaces.st ====
Limited-width floating point number printing
==== Float-twopi.st ====
Accessor for the class variable two * pi
==== FlushChangesOnFileOut.st ====
Remove a class from the change set after filing it out, also ask whether to empty the change set
after filing it out.
==== FormattedStr.cs ====
C-style string formatting. Takes this:
Transcript cr; show: ''Analyze '', sound name,
'' D: '', (duration printPlaces: 3),
'' R: '', sound rate printString,
'' F: '', framesize printString,
'' P: '', npoles printString; cr.
and reduces it to this:
{sound name. duration. sound rate. framesize. npoles}
showFmt: '' Analyze %s D: %f R: %d F: %d P: %d''.
Or this
Transcript show: ''TSR: '', tsr printString,
'' e: '', e truncated printString; cr.
reduces to:
{tsr . ext} showFmt: ''TSR: %s e: %d"
Try this:
{ t0 / 1000 . nFrames * fftLen } showFmt: ''Took %5.2f sec, sz: %d.''
==== IgnoreFontsInCode.st ====
Sets the compiler to ignore all changes of emphasis in code.
==== Interval-extent.st ====
Get the extent of an interval.
==== MultiModel.st ====
MultiModels have symbol-keyed dictionaries as their dependents collections. The items in the
dictionary are collections of dependents registered to receive updates to a particular aspect. This
makes updating models with large numbers of dependents much faster. The category #all receives all updates.
==== Object-dependency.st ====
This extends the changed/update messages for passing along new values (changed:with:).
==== Object-safeHalt.st ====
This makes a left-shift hack out of halt (i.e., it is different than break:)
==== Object-testing.st ====
These are a few testing methods (e.g., isString isSymbol) plus value coercion (asValue).
==== Point-accessing.st ====
Answer a point that represents the receiver as r@theta, also add setter methods for x and y
==== Printing.st ====
A few modified printing methods: Time without seconds, Dates with leading 0's (e.g., 1995.04.08).
==== PStream-skipSeparators.st ====
Adds the nil check for reading bad files.
==== RandomAdds.st ====
A few new messages for generating random numbers in limited ranges, or selecting from collections
at random.
==== ScreenAdds.st ====
Adds a few utility methods to class DisplayScreen for determining the current screen size and
getting default rectangles for view opening. This is very useful for applications that are supposed
to be portable between desk- and lap-top machines.
==== StreamIO.st ====
Code to support external I/O in floats, longs, 96-bit doubles, etc. Some of this is from the Kyma
system thanks to Kurt Hebel.
==== String-conversions.cs ====
A number of new string coersions for file I/O, e.g., asLocalFilename, asFileStream and sansLastPeriodSuffix.
==== StringAdds.st ====
Adds many useful string crunching methods--stripTrailingSpaces, padTo:, breakIntoLinesOf:,
stripCRs. cr.
==== TextEmphasis-storeOn.st ====
This code makes storing texts a bit more compact by storing the emphasis and font changes in a
'native' form.
==== TranscriptStream-limit.st ====
Makes the transcript really long (64 k).
==== Utilities-html.st ====
Various utilities for writing HTML "reference manuals"
==== ZPoint.st ====
3-D points, i.e., one can say 3@4@7.
===============================================================================
Graphics Directory
==== Color-depth.st ====
This is the 'depth' method for colors.
==== display-compatibility.st ====
These are for backward compatibility with ST80.
==== Graphics-3D.st ====
This is Hans-Martin Mosner's 3-D graphics example. It creates wire-frame models and can display and
rotate them. It also serves as a cool screen saver. It requires the 3-D point class ZPoint and the
two additional Zpoint methods in this directory.
==== Graphics-Containers.st ====
This is a minimal 'wrapper' framework. It is a pre-cursor to my new MVC implementation.
==== ZPoint-perspective.st ====
These are a few additional ZPoint methods that are needed by the 3D graphics or fractal surface code.
===============================================================================
GUI Directory
==== DisplayScreen-splash.st ====
Splash screen with the Squeak logo rolling across the screen. This reads in two GIFs from the
DesktopGIFs folder and makes them global
==== FindSelAssign.cs ====
Makes 2 changes to ParEd: Cmd-G inserts " := " and Cmd-H searches for the selection.
==== GrowBox.cs ====
This adds another button just to the left of the collapse button in window labels that
grows/shrinks the view by 50%.
==== PluggableButton-action.st ====
This makes it possible to create buttons that have blocks as their actions.
==== Preferences-desktopGIFs.st ====
This adds support for using an arbitrary GIF file as the repeating desktop pattern.
==== RealEstate.cs ====
Extent-from-user for new windows; assumes Mark''s layouts. Do [Preferences enable: #userPlacement]
==== SSView-modelLabelMinSize.st ====
This is a StandardSystemView creation method for ST80 compatibility
==== SSView-resizeInitially.st ====
This sets StandardSystemView to resize on open.
==== View-addSubView.st ====
This is for ST80 compatibility.
===============================================================================
Tools Directory
==== Browser-additions.st ====
Make the size of the recent menu in the browser a variable. I use long ones.
Adds menu items to find/inspect/count instances to the browser.
Also adds code to log categorization changes.
==== ChangeList-recent.cs ====
Make a short cut for the change list view to remove doits, clear old versions, and select current methods.
==== FileList-directory.st ====
Use a preference value to determine the default sorting order for file lists.
==== FileList-readContentsHex.st ====
When showing a file as hex, print any ASCII values found after the hex stuff on the line
==== FileList-recent.cs ====
Make the size of the recent directory list a variable size.
==== MessageTally-toFileNamed.st ====
Convenience method for tallying to a file
==== RedComments.st ====
Simple changes to the Browser to make the selector of a method appear in bold blue and make
comments red (or italics, your choice) so that they stick out more; edit to taste.
==== StringHolder-contentsText.st ====
Accepts text or strings as contents.
==== TemplateMorph.st ====
TemplateMorph is a simple generic object editor framework.
===============================================================================
Packages Directory
==== Kernel-Values.st ====
This is a minimal dynamic value framework.
It has useful items such as indirect values (AKA PluggableAdaptors), lazy-block values, range
values, and index values.
==== LauncherView.st ====
Launcher View is a Transcript with text-labeled buttons along the top that open the standard applications:
Browse Open a package browser
Files Open a file list
Editor Open a workspace
Changes Pop up the change manager menu and select a tool
Save Save a VI snapshot
Help Display the help menu
Test User-assignable test button; shift-select to redefine action
==== OutlineSupport.st ====
This is support changes for the outline and outline browser classes.
==== Tools-Outlines.st ====
An outline is a simple interface to a list of named workspaces.
It can hold onto a keyed workspace list, parse it from/save it to files, and be used with an OutlineBrowser.
An OutlineBrowser holds onto an Outline and creates a simple two-paned view on the one-level
hierarchy using pluggable view components (list and text views).
The Browser implements key-list menu items for adding new keys, removing or renaming existing ones,
and inspecting or saving the outline.
Text menu items are implemented for execution and the like.
===============================================================================
Fixes Directory
==== FileStream-concrete.st ====
Set the default to be CrLf-swapping file streams
==== menu-fixes.cs ====
Changes the menu flap to be wider and shorter.
==== PackageBrowser-Color.st ====
Makes the package browser light cream rather than bright yellow.
==== PackageBrowser-package.st ====
Added range check for package browser.
Return To Top
STP 12 Goodies File-in
"This is the build script to construct STP's image on top of the Squeak 3.0 release.
DO NOT FILE THIS IN -- READ IT AND FOLLOW THE INSTRUCTIONS.
Steps:
Fire up a new Squeak 3.0 image (or your favorite 3.0-based image).
Configure the GUI to your taste. (I set rounded corners, larger fonts,
turn flaps on, and change a few of the default window colors.)
Open file list on the STP12 directory.
Open the file STP12.3.0.bld (this file).
Read through these instructions, the file list, and the comments.
Comment-out any files you don't want.
Edit the base directory and possibly replace the filename separator
from ':' to whatever works on your platform.
Double-click just inside the open bracket bracket on the following
line to select the entire file-in expression.
Doit!
Then read and step through the blocks that follow the file-in list.
[ "Block for file-ins; double-click just inside the bracket and do-it"
"Preparation"
Preferences setPreference: #confirmFirstUseOfStyle toValue: false.
"Give path to where the file-ins are (absolute) -- edit to taste"
" Smalltalk at: #STP12RootDir put: 'Nomad:Squeak:STP12 Goodies:3.0:'. " "Mac"
Smalltalk at: #STP12RootDir put: '/home/stp/st/STP12.3.0/'. "UNIX"
Smalltalk at: #FileSep put: FileDirectory pathNameDelimiter asString.
#( "Array of files to be read in"
"First things first..."
'System:TranscriptStream-limit.st'
"System & Kernel Extensions"
'System:CaseStatement.st'
'System:CodeGen.st'
'System:CollectionAdds.st'
'System:ColorForm-offsetColors.st'
'System:Dictionary-associations.st'
'System:FileStr-creation.st'
'System:Float-printPlaces.st'
'System:Float-twopi.st'
'System:FlushChangesOnFileOut.st'
'System:FormattedStr.cs'
'System:IgnoreFontsInCode.st'
'System:Interval-extent.st'
'System:MultiModel.st'
'System:Object-dependency.st'
'System:Object-safeHalt.st'
'System:Object-testing.st'
'System:Point-accessing.st'
" 'System:Printing.st' " "optional"
'System:PStream-skipSeparators.st'
'System:RandomAdds.st'
'System:ScreenAdds.st'
'System:StreamIO.st'
'System:String-conversions.cs'
'System:StringAdds.st'
'System:TextEmphasis-storeOn.st'
'System:Utilities-html.st'
'System:ZPoint.st'
"Development Tool Extensions"
'Tools:Browser-additions.st'
'Tools:ChangeList-recent.cs'
'Tools:FileList-directory.st'
'Tools:FileList-readContentsHex.st'
'Tools:FileList-recent.cs'
'Tools:MessageTally-toFileNamed.st'
'Tools:RedComments.st'
'Tools:StringHolder-contentsText.st'
'Tools:TemplateMorph.st'
"Assorted GUI Changes (optional)"
'GUI:DisplayScreen-splash.st'
'GUI:FindSelAssign.cs'
'GUI:GrowBox.cs'
'GUI:PluggableButton-action.st'
'GUI:Preferences-desktopGIFs.st'
'GUI:RealEstate.cs'
'GUI:SSView-modelLabelMinSize.st'
'GUI:SSView-resizeInitially.st'
'GUI:View-addSubView.st'
"Display List Graphics Framework"
'Graphics:Color-depth.st'
'Graphics:display-compatibility.st'
'Graphics:Graphics-3D.st'
'Graphics:Graphics-Containers.st'
'Graphics:ZPoint-perspective.st'
"Add-on Packages"
'Packages:Kernel-Values.st'
'Packages:LauncherView.st'
'Packages:OutlineSupport.st'
'Packages:Tools-Outlines.st'
) do: [ :file | | realName |
file replaceAll: $: with: FileDirectory pathNameDelimiter.
Transcript cr; show: file.
(FileStream readOnlyFileNamed: (Smalltalk at: #STP12RootDir), file) fileIn]].
----------------------------DONE WITH BULK FILE-IN----------------------------
Now look in the Fixes directory and file in anything found there.
[ ((FileDirectory on: (STP12RootDir, 'Fixes')) fileNamesMatching: '*') do:
[ :file |
Transcript cr; show: file.
(FileStream readOnlyFileNamed:
(Smalltalk at: #STP12RootDir), 'Fixes', FileSep, file) fileIn]]
Finalize Things--execute these one at a time.
Clean up...
[ Smalltalk noChanges.
Undeclared removeUnreferencedKeys]
Morphic GUI Preferences -- Do this in a Morphic project (optional).
[ Preferences setPreference: #browserShowsPackagePane toValue: true.
Preferences setPreference: #reverseWindowStagger toValue: false.
Preferences setPreference: #thoroughSenders toValue: true.
Preferences setPreference: #disableSounds toValue: false.
Preferences setPreference: #fileListSortMode toValue: #name.
Preferences setPreference: #inboardScrollbars toValue: true.
Preferences setPreference: #scrollBarsOnRight toValue: false.
Preferences setPreference: #scrollBarsNarrow toValue: true.
Preferences setPreference: #scrollBarsWithoutMenuButton toValue: true.
Preferences setPreference: #roundedWindowCorners toValue: true.
Preferences setPreference: #allowLabelDragging toValue: true.
Preferences setPreference: #fastDragWindowForMorphic toValue: true.
Preferences setPreference: #useGlobalFlaps toValue: true.
Preferences setPreference: #ignoreAllUsesOfStyle toValue: true.
Preferences setParameter: #menuColor to: Color lightBlue.
Utilities reinstateDefaultFlaps]
Load default 128@128 desktop patterns.
[ Preferences loadDesktopPatterns: STP12RootDir, 'DesktopGIFs', FileSep.
Preferences pickDesktopPattern]
OR, load a full-screen background picture
[ Preferences desktopFromGIFFile: STP12RootDir, 'DesktopPictures', FileSep, 'Droplets.GIF'
" Preferences desktopFromGIFFile: STP12RootDir, 'DesktopPictures', FileSep, 'Blocks.GIF' "]
Open the system outline.
[ Smalltalk at: #SystemOutline put: (Outline load: STP12RootDir, 'Squeak3.0.outline').
OutlineBrowser openSystemOutline]
If setting up "Getting Started" image
[ Smalltalk at: #StartupOutline put: (Outline load: STP12RootDir, 'Starter.outline').
OutlineBrowser openOn: StartupOutline label: 'Getting Started with Squeak' ]
Now you'll have to copy/paste the first section's text from the 'Welcome to..." window in the top
MVC project.
Open a launcher view.
[ LauncherView open]
Now make a snapshot!
Return To Top
Squeak 3.0 Outline -- stp@create.ucsb.edu -- Generated #(19 February 2001 8:36:56 am)