Etoys Reference Manual Vol. II
Implementation of Etoys
The purpose of this chapter is to provide basic information on every kind of Morph in Etoys, so that a person who understands the Squeak IDE tools described elsewhere in this manual can find out the rest of the details. Clues as to which tools can be used to get at various kinds of information are also provided. This is necessary in part because not all Morphs have Morphic object classes, so that they are not trivial to find in the system. There are other important details about how Morphs are initialized and their structure and usage that is not obvious in much the same way.
No attempt is made to explain the usage of these morphs beyond noting which other classes make use of them, and showing how to find the methods in which that happens.
Squeak Definitions of Morphs and Other Etoys Objects
Information about the Squeak objects corresponding to an Etoys object can be found via object inspectors and explorers. One inspector is provided via the halo menu of the object. On the debug submenu select inspect it. For the car in the home view of Etoys, the values shown are in this form.
Title: a SketchMorph
self: a SketchMorph
owner: a TransformationMorph<Car>(2040) on a SketchMorph(1216)
Further information is provided via the Etoys Players tool, which is in the Object Catalog in the Scripting category. Open an object of the kind desired, and open its viewer. It will appear in the listing in Players. On the menu for that object in Players, select inspect object. For the same car in the home view, a different set of values is displayed, in the following form.
Title: aPlayer140132117123
self: a Player140132117123 (2162) named Car
costume: a TransformationMorph<Car>(2040) on a SketchMorph(1216)
Each object has a player, a costume, and an owner. Composite objects have submorphs.
In Etoys 5.0, this information is available in the object's viewer if the eToyFriendly preference is turned off. Select the as object category.
- The class name tile shows the object's player
- The name tile shows the object's name
- The print string tile shows the object's costume and name
Many objects are implemented using UnscriptedPlayer (when no scripts are defined for that object) and Player, with Morphs as costumes. Some have players of other classes, such as NCCurveMorph. In some cases, the costume is defined in a class method, and is not itself an instance of a class of its own.
Some objects are composites of other Etoys objects such as Alignments of Buttons and other controls. These are dissected out in the Objects and More Objects chapters in Volume I of this manual.
Some objects are implemented using multiple Squeak classes. Chess is an example, where it is necessary to define the board, the pieces, the moves, game records, and other data. These are noted where applicable.
List of Morphs
This list was generated first by sorting the result of print it on the expression
Morph withAllSubclasses
in a Squeak Workspace window in instances of Etoys 4.0 and 5.0, and taking a diff of the results. Execute the following in a Workspace to see the version of any running Etoys.
SystemVersion current version.
Th list below was checked by examining the subclass tree of Morph in a Hierarchy Browser. One can get a similar result by examining the various Morphic-Extras, Etoys, and other such categories in a System Browser.
In addition to these Morph classes, there are objects created as special cases of Morphs using particular class methods. Such objects occur under
- NCAAConnectorMorph
- NCCurveMorph
- PolygonMorph
You can test most of these Morphs by opening a Workspace from the Open menu or with the keyboard shortcut ctrl-k in World (not in an object, where this shortcut brings up a font menu). Type the name of the Morph, then either of the command strings "new openInWorld" or "new openInHand". For example,
EllipseMorph new openInWorld
Select this line with the mouse, and then do it, either from the left-button menu within the workspace or with the keyboard shortcut ctrl-d. The morph will appear at the top left of the World. Some of it may be outside the Etoys window. Opening a Morph in hand puts it at the cursor, allowing the user to place it anywhere. The user can then explore the properties of the Morph in its Viewer and its Halo menu, including the name of its Etoys player.
Morphs created as specializations require a different syntax, in this form.
MorphName objectPrototoype openInHandFor each Morph discussed below, its entry gives its name, its Class definition (superclass, variable names, System Browser category), its Class comment (if any), a summary of objects that refer to it in any way (if any), and any Etoys object that it implements.
To explore an object in a System Browser,
- Open a Workspace (ctrl-k, cmd-k)
- Enter or paste in the name of the object to explore.
- Open a System Browser to that object. (ctrl-b, cmd-b, or browse on the more submenu on the middle-click menu). This gives access to the object's superclass, class definition, variables, methods, and category, and to tools for further exploration on each of these: senders, implementors, versions, its place in the object hierarchy, instance variables, class variables.
- Open a Users or Class Refs tool on that object. (ctrl-N, cmd-N, or references to it on the more submenu on the middle-click menu). The menu selection senders of it produces a very similar view. Both show all methods that use this object.
AbstractMediaEventMorph
RectangleMorph subclass: #AbstractMediaEventMorph instanceVariableNames: 'startTimeInScore endTimeInScore' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Demo'
An abstract representation of media events to be placed in a PianoRollScoreMorph (or others as they are developed)
Senders of it:
There are no senders of AbstractMediaEventMorph
AcceptableCleanTextMorph
PluggableTextMorph subclass: #AcceptableCleanTextMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Pluggable Widgets'
No class comment.
Senders of it:
ChangeList buildMorphicCodePaneWith: editString
AlignmentMorph
RectangleMorph subclass: #AlignmentMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Basic'
Used for layout.
Since all morphs now support layoutPolicy the main use of this class is no longer needed.
Kept around for compatibility.
Supports a few methods not found elsewhere that can be convenient, eg. newRow
Senders of it: 215 users
AlignmentMorphBob1
AlignmentMorph subclass: #AlignmentMorphBob1 instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-AdditionalSupport'
A quick and easy to space things vertically in absolute or proportional amounts.[sic]
Senders of it:
EtoyDAVLoginMorph
FancyMailComposition
GenericPropertiesMorph
PasteUpMorph
AllPlayersTool
AlignmentMorph subclass: #AllPlayersTool instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
A tool that lets you see find, view, and obtain tiles for all the active players in the project.
Senders of it:
PasteUpMorph galleryOfPlayers
"Put up a tool showing all the players in the receiver's presenter. This would normally be all players in the world, but in the case of a 'private presenter', such as a so-called Scripting Area, the gallery will show only players within the presenter's scope."
AllScriptsTool
AlignmentMorph subclass: #AllScriptsTool instanceVariableNames: 'showingOnlyActiveScripts showingAllInstances showingOnlyTopControls' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
A tool for controlling and viewing all scripts in a project. The tool has an open and a closed form. In the closed form, stop-step-go buttons are available, plus a control for opening the tool up. In the open form, it has a second row of controls that govern which scripts should be shown, followed by the individual script items.
Senders of it: Presenter
Optionally associated with a PasteUpMorph, provides a local scope for the running of scripts.
Once more valuable, may be again, but at present occupies primarily a historical niche.
Maintains a playerList cache.
Holds, optionally three 'standard items' -- standardPlayer standardPlayfield standardPalette -- originally providing idiomatic support of ongoing squeak-team internal work, but now extended to more general applicability.
Costume for All Scripts (Scripting category), implemented in this class.
AnimatedImageMorph
ImageMorph subclass: #AnimatedImageMorph instanceVariableNames: 'images delays stepTime nextTime imageIndex stepper' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-AdditionalMorphs'
I am an ImageMorph that can hold more than one image. Each image has its own delay time.
Senders of it:
ExternalDropHandler
Form
AnonymousSoundMorph
AbstractMediaEventMorph subclass: #AnonymousSoundMorph instanceVariableNames: 'sound interimName' classVariableNames: '' poolDictionaries: '' category: 'Sound-Interface'
Holds a free-standing sound, i.e. one not associated with the system's sound library.
Can be played by hitting Play button, and can stop its playing by hitting Stop.
Can be dropped into a piano roll or into an event roll
Can also be named and added to the system sound library, by hitting the save button.
Senders of it:
RecordingControls, A facelifted version of John Maloney's original RecordingControlsMorph.
ArchiveViewer
SystemWindow subclass: #ArchiveViewer instanceVariableNames: 'archive fileName memberIndex viewAllContents' classVariableNames: '' poolDictionaries: '' category: 'Tools-ArchiveViewer'
This is a viewer window that allows editing and viewing of Zip archives.
Senders of it:
There are no senders of ArchiveViewer
Zip Tool is implemented in this class.
AssignmentTileMorph
TileMorph subclass: #AssignmentTileMorph instanceVariableNames: 'assignmentRoot assignmentSuffix dataType' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
No class comment.
Senders of it:
Morph (3 methods)
PhraseTileMorph (6 methods)
AtomMorphEllipseMorph subclass: #AtomMorph instanceVariableNames: 'velocity' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Demo'
AtomMorph represents an atom used in the simulation of
an ideal gas. It's container is typically a BouncingAtomsMorph.
Try:
BouncingAtomsMorph new openInWorld
to open the gas simulation or:
AtomMorph example
to open an instance in the current world
Senders of it:
BouncingAtomsMorph (3 methods)
Attachment Adjuster
This is implemented in the NCAttachmentPointAdjuster class, a subclass of EllipseMorph, and in the NCAttachmentPointAdjusterWindow class, a subclass of PasteUpMorph, both in the ConnectorsTools category in Squeak.
BackgroundMorph
Morph subclass: #BackgroundMorph instanceVariableNames: 'image offset delta running' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Widgets'
This morph incorporates tiling and regular motion with the intent of supporting, eg, panning of endless (toroidal) backgrounds.
The idea is that embedded morphs get displayed at a moving offset relative to my position. Moreover this display is tiled according to the bounding box of the submorphs (subBounds), as much as necesary [sic] to fill the rest of my bounds.
Senders of it:
BackgroundMorph test
BalloonMorph
PolygonMorph subclass: #BalloonMorph instanceVariableNames: 'target offsetFromTarget balloonOwner' classVariableNames: 'BalloonColor BalloonFont' poolDictionaries: '' category: 'Morphic-Widgets'
A balloon with text used for the display of explanatory information.
Balloon help is integrated into Morphic as follows:
If a Morph has the property #balloonText, then it will respond to #showBalloon by adding a text balloon to the world, and to #deleteBalloon by removing the balloon.
Moreover, if mouseOverEnabled is true (see class msg), then the Hand will arrange to cause display of the balloon after the mouse has lingered over the morph for a while, and removal of the balloon when the mouse leaves the bounds of that morph. In any case, the Hand will attempt to remove any such balloons before handling mouseDown events, or displaying other balloons.
Balloons should not be duplicated with veryDeepCopy unless their target is also duplicated at the same time.
Senders of it:
MenuMorph Keystroke:
Morph (3 methods)
MorphWorldController
NCMakerButton
PasteUpMorph
Preferences
SugarNavigatorBar
Balloon is implemented in this BalloonMorph class.
BalloonRectangleMorph
RectangleMorph subclass: #BalloonRectangleMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Balloon-Geometry'
BalloonRectangleMorph is an example for drawing using the BalloonEngine.
Senders of it:
There are no senders of BalloonRectangleMorph
BasicButton
RectangleMorph subclass: #BasicButton instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Widgets'
A minimalist button-like object intended for use with the tile-scripting system.
Senders of it:
PasteUpMorph buildShowClickableButton
"Return a button that momentarily highlights all clickable objects on the screen. Showing the highlights takes a second or two, so press and be patient.
BOBTransformationMorph
TransformationMorph subclass: #BOBTransformationMorph instanceVariableNames: 'worldBoundsToShow useRegularWarpBlt' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-AdditionalSupport'
No Class comment.
Senders of it:
NetworkTerminalMorph openScaled
PasteUpMorph (3 methods)
BooklikeMorph
AlignmentMorph subclass: #BooklikeMorph instanceVariableNames: 'pageSize newPagePrototype' classVariableNames: 'PageFlipSoundOn' poolDictionaries: '' category: 'MorphicExtras-Books'
A common superclass for BookMorph and WebBookMorph
Senders of it:
There are no senders of BooklikeMorph
BookMorph
BooklikeMorph subclass: #BookMorph instanceVariableNames: 'pages currentPage' classVariableNames: 'MethodHolders VersionNames VersionTimes' poolDictionaries: '' category: 'MorphicExtras-Books'
A collection of pages, each of which is a place to put morphs. Allows one or another page to show; orchestrates the page transitions; offers control panel for navigating among pages and for adding and deleting pages.
Normal bookMorphs live in an image. "Squeak Pages" live on a server.
To write a book out to the disk or to a file server, decide what folder it goes in. Construct a url to a typical page:
file://myDisk/folder/myBook1.sp
or
ftp://aServer/folder/myBook1.sp
Choose "send all pages to server" from the book's menu (press the <> part of the controls). Choose "use page numbers". Paste in the url.
To load an existing book, find its ".bo" file in the file list browser. Choose "load as book".
To load an existing book from its url, execute:
¦(URLMorph grabURL: 'ftp://aServer/folder/myBook1.sp') book: true.
Multiple people may modify a book. If other people may have changed a book you have on your screen, choose "reload all from server".
Add or modify a page, and choose "send this page to server".
The polite thing to do is to reload before changing a book. Then write one or all pages soon after making your changes. If you store a stale book, it will wipe out changes that other people made in the mean time.
Pages may be linked to each other. To create a named link to a new page, type the name of the page in a text area in a page. Select it and do Cmd-6. Choose 'link to'. A new page of that name will be added at the back of the book. Clicking on the blue text flips to that page.
To create a link to an existing page, first name the page. Go to that page and Cmd-click on it. The name of the page is below the page. Click in it and backspace and type. Return to the page you are linking from. Type the name. Cmd-6, 'link to'.
Text search: Search for a set of fragments. allStrings collects text of fields. Turn to page with all fragments on it and highlight the first one. Save the container and offset in properties: #searchContainer, #searchOffset, #searchKey. Search again from there. Clear those at each page turn, or change of search key.
[rules about book indexes and pages: Index and pages must live in the same directory. They have the same file prefix, followed by .bo for the index or 4.sp for a page (or x4.sp). When a book is moved to a new directory, the load routine gets the new urls for all pages and saves those in the index. Book stores index url in property #url.
Allow mulitple indexes (books) on the same shared set of pages. If book has a url in same directory as pages, allow them to have different prefixes.
save all pages first time, save one page first time, fromRemoteStream: (first time)
save all pages normal , save one page normal, reload
where I check if same dir]
URLMorph holds url of both page and book.
Senders of it:
36 methods
Book is implemented in BookMorph.
BookPageSorterMorph
AlignmentMorph subclass: #BookPageSorterMorph instanceVariableNames: 'book pageHolder' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Books'
No Class comment.
Senders of it:
BooklikeMorph sortPages
BookPageThumbnailMorph
SketchMorph subclass: #BookPageThumbnailMorph instanceVariableNames: 'page pageNumber bookMorph flipOnClick' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Books'
A small picture representing a page of a BookMorph here or somewhere else. When clicked, make that book turn to the page and do a visual effect and a noise.
page either the morph of the page, or a url
pageNumber
bookMorph either the book, or a url
flipOnClick
Senders of it:
BookMorph (4 methods)
PasteUpMorph (4 methods)
BooleanScriptEditor
ScriptEditorMorph subclass: #BooleanScriptEditor instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Support'
A ScriptEditor required to hold a Boolean
Senders of it:
CompoundTileMorph initialize
BooleanTile
ScriptEditorMorph subclass: #BooleanScriptEditor instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Support'
A tile whose result type is boolean.
Senders of it:
Presenter systemQueryPhraseWithActionString: labelled:
StandardScriptingSystem tilesForQuery: label:
BorderedMorph
ScriptEditorMorph subclass: #BooleanScriptEditor instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Support'
BorderedMorph introduce borders to morph. Borders have the instanceVariables borderWidth and borderColor.
BorderedMorph new borderColor: Color red; borderWidth: 10; openInWorld.
BorderedMorph also have a varaity of border styles: simple, inset, raised, complexAltFramed, complexAltInset, complexAltRaised, complexFramed, complexInset, complexRaised.
These styles are set using the classes BorderStyle, SimpleBorder, RaisedBorder, InsetBorder and ComplexBorder.
BorderedMorph new borderStyle: (SimpleBorder width: 1 color: Color white); openInWorld.
BorderedMorph new borderStyle: (BorderStyle inset width: 2); openInWorld.
Senders of it:
12 methods
Bordered is implemented in this BorderedMorph.
BorderedStringMorph
ScriptEditorMorph subclass: #BooleanScriptEditor instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Support'
THIS CLASS HAS NO COMMENT!
Senders of it:
NCButtonBar class buttonTarget: target action: selector arguments: args icon: iconName label: label
"Construct an IconicButton with the given icon and label
and make it send selector to target with args
BorderedSubpaneDividerMorph
BorderedMorph subclass: #BorderedSubpaneDividerMorph instanceVariableNames: 'resizingEdge' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Windows'
THIS CLASS HAS NO COMMENT!
Senders of it:
20 methods providing dividers within windows
BouncingAtomsMorph
Morph subclass: #BouncingAtomsMorph instanceVariableNames: 'damageReported infectionHistory transmitInfection recentTemperatures temperature' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Demo'
This morph shows how an ideal gas simulation might work. When it gets step messages, it makes all its atom submorphs move along their velocity vectors, bouncing when they hit a wall. It also exercises the Morphic damage reporting and display architecture. Here are some things to try:
1. Resize this morph as the atoms bounce around.
2. In an inspector on this morph, evaluate "self addAtoms: 10."
3. Try setting quickRedraw to false in invalidRect:. This gives the
default damage reporting and incremental redraw. Try it for
100 atoms.
4. In the drawOn: method of AtomMorph, change drawAsRect to true.
5. Create a HeaterCoolerMorph and embed it in the simulation. Extract
it and use an inspector on it to evaluate "self velocityDelta: -5", then
re-embed it. Note the effect on atoms passing over it.
Senders of it:
PasteUpMorph class newWorldTesting {project}
Bouncing Atoms is implemented in this BouncingAtomsMorph class.
BroomMorph
Morph subclass: #BroomMorph instanceVariableNames: 'centered drawBroomIcon filter hotspot lastHotspot moved span start transient unmoved width' classVariableNames: 'BroomIcon' poolDictionaries: '' category: 'BroomMorphs-Base'
This is a Morph (actually a family of Morphs) that do alignment of other morphs.
BroomMorphs become: an object of one of their subclasses when dragged far enough.
Drag a BroomMorph in some direction and it becomes a broom that can align the Morphs it touches.
This idea is borrowed from the GEF framework (http://gef.tigris.org)
If you want to pick up a BroomMorph, you can use the Shift key.
Hitting the ESC key will re-position all moved Morphs to their original position.
BroomMorph newTransient will give you a BroomMorph that will delete itself on mouse up.
unmoved the set of Morphs that I won't move
moved the set of Morphs that I might move
start my first hotspot
span how wide to make (each half of) my bar initially
width the width of the main lines
hotspot my active position
lastHotspot my last active position
drawBroomIcon true if I look like a broom while idle (false=look like a +)
transient if true, then I delete myself on mouse-up
Senders of it:
BroomMorph basicClass {private}
BroomMorphDown
BroomMorph subclass: #BroomMorphDown instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'BroomMorphs-Base'
I am a BroomMorph that pushes morphs down.
Senders of it:
BroomMorph morphIfNecessary: {stepping and presenter}
BroomMorphLeft
BroomMorphRight subclass: #BroomMorphLeft instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'BroomMorphs-Base'
I am a BroomMorph that pushes morphs left.
Senders of it:
BroomMorph morphIfNecessary: {stepping and presenter}
BroomMorphRight
BroomMorph subclass: #BroomMorphRight instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'BroomMorphs-Base'
I am a BroomMorph that pushes morphs right.
Senders of it:
BroomMorph morphIfNecessary: {stepping and presenter}
BroomMorphUp
BroomMorphDown subclass: #BroomMorphUp instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'BroomMorphs-Base'
I am a BroomMorph that pushes morphs up.
Senders of it:
BroomMorph morphIfNecessary: {stepping and presenter}
BrowserCommentTextMorph
PluggableTextMorph subclass: #BrowserCommentTextMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Tools-Browser'
I am a PluggableTextMorph that knows enough to make myself invisible when necessary.
Senders of it:
Browser buildMorphicCommentPane {class comment pane}
ButtonPropertiesMorph
GenericPropertiesMorph subclass: #ButtonPropertiesMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Experimental'
ButtonPropertiesMorph basicNew
targetMorph: self;
initialize;
openNearTarget
Senders of it:
Morph openAButtonPropertySheet {meta-actions}
CachingMorph
Morph subclass: #CachingMorph instanceVariableNames: 'damageRecorder cacheCanvas' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Kernel'
This morph can be used to cache the picture of a morph that takes a long time to draw. It should be used with judgement, however, since heavy use of caching can consume large amounts of memory.
Senders of it:
There are no senders of CachingMorph.
CalendarMorph
Morph subclass: #CalendarMorph instanceVariableNames: 'date stepTime shouldUpdate' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Calendar'
CalendarMorph, by Ricardo Moran, 2011, with some changes by Scott Wallace, January 2012.
A CalendarMorph is single-month calendar that is scriptable using tiles in its viewer. It always has a 'selected' date, for which the correct month and year are shown; the actual day corresponding to the selected date is highlighted on the calendar.
Senders of it:
Vocabulary class initializeStandardVocabularies {class initialization}
CategoryViewer
Viewer subclass: #CategoryViewer instanceVariableNames: 'namePane chosenCategorySymbol' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
A viewer on an object. Consists of three panes:
Header pane -- category-name, arrows for moving among categories, etc.
List pane -- contents are a list of subparts in the chosen category.
Editing pane -- optional, a detail pane with info relating to the selected element of the list pane.
Senders of it:
13 methods in StandardViewer and various tile Classes.
CenterBroomMorphDown
BroomMorphDown subclass: #CenterBroomMorphDown instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'BroomMorphs-Base'
THIS CLASS HAS NO COMMENT!
Senders of it:
BroomMorph morphIfNecessary: {stepping and presenter}
CenterBroomMorphLeft
BroomMorphLeft subclass: #CenterBroomMorphLeft instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'BroomMorphs-Base'
THIS CLASS HAS NO COMMENT!
Senders of it:
BroomMorph morphIfNecessary: {stepping and presenter}
CenterBroomMorphRight
BroomMorphRight subclass: #CenterBroomMorphRight instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'BroomMorphs-Base'
THIS CLASS HAS NO COMMENT!
Senders of it:
BroomMorph morphIfNecessary: {stepping and presenter}
CenterBroomMorphUp
BroomMorphUp subclass: #CenterBroomMorphUp instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'BroomMorphs-Base'
THIS CLASS HAS NO COMMENT!
Senders of it:
BroomMorph morphIfNecessary: {stepping and presenter}
ChessMorph
BorderedMorph subclass: #ChessMorph instanceVariableNames: 'board history redoList animateMove autoPlay' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Games-Chess'
This class defines the user interface for a fine game of chess.
Senders of it:
ChessPieceMorph wantsToBeDroppedInto: {dropping/grabbing}
ChessPieceMorph
ImageMorph subclass: #ChessPieceMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Games-Chess'
THIS CLASS HAS NO COMMENT!
Senders of it:
ChessMorph newPiece:white: {initialize}
ChineseCheckerPiece
EllipseMorph subclass: #ChineseCheckerPiece instanceVariableNames: 'boardLoc myBoard' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Games'
I represent a player piece for Chinese Checkers. Mostly I act as an ellipse, but my special methods ensure that I cannot be picked up or dropped except in the proper circumstances.
Structure:
myBoard a ChineseCheckers morph
boardLoc my current logical position on the board.
Senders of it:
ChineseCheckers, 4 methods
ChineseCheckers
BorderedMorph subclass: #ChineseCheckers instanceVariableNames: 'board sixDeltas teams homes autoPlay whoseMove plannedMove plannedMovePhase colors movePhase animateMoves pathMorphs' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Games'
An implementation of Chinese Checkers by Dan Ingalls. April 9, 2000.
board: A 19x19 rhombic array, addressed by row@col points, in which is imbedded the familiar six-pointed layout of cells. A cell outside the board is nil (-).
- - - - - - - - - - - - - - - - - - -
- - - - - - - - - - - - - 5 - - - - -
- - - - - - - - - - - - 5 5 - - - - -
- - - - - - - - - - - 5 5 5 - - - - -
- - - - - - - - - - 5 5 5 5 - - - - -
- - - - - 6 6 6 6 0 0 0 0 0 4 4 4 4 -
- - - - - 6 6 6 0 0 0 0 0 0 4 4 4 - -
- - - - - 6 6 0 0 0 0 0 0 0 4 4 - - -
- - - - - 6 0 0 0 0 0 0 0 0 4 - - - -
- - - - - 0 0 0 0 0 0 0 0 0 - - - - -
- - - - 1 0 0 0 0 0 0 0 0 3 - - - - -
- - - 1 1 0 0 0 0 0 0 0 3 3 - - - - -
- - 1 1 1 0 0 0 0 0 0 3 3 3 - - - - -
- 1 1 1 1 0 0 0 0 0 3 3 3 3 - - - - -
- - - - - 2 2 2 2 - - - - - - - - - -
- - - - - 2 2 2 - - - - - - - - - - -
- - - - - 2 2 - - - - - - - - - - - -
- - - - - 2 - - - - - - - - - - - - -
- - - - - - - - - - - - - - - - - - -
Cells within the board contain 0 if empty, or a team number (1..6) if occupied by a piece of that team. An extra border of nils around the whole reduces bounds checking to a nil test.
sixDeltas: An array giving the x@y deltas for the 6 valid steps in CCW order from a given cell. For team 1 they are: in fr, fl, l, bl, br, r. To get, eg fl for a given team, use (sixDeltas atWrap: team+1).
teams: An array of six teams, each of which is an array of the x@y locations of the 10 pieces.
homes: The x@y coordinates of the six home points, namely 14@2, 18@6, 14@14, 6@18, 2@14, 6@6. The goal, or farthest point in destination triangle, is thus (homes atWrap: teamNo+3).
autoPlay: An array of booleans, parallel to teams, where true means that Squeak will make the moves for the corresponding team.
whoseMove: A team number specifying whose turn it is next. Set to 0 when game is over.
plannedMove: If not nil, it means the board is in a state where it is animating the next move to be made so that it can be seen.
movePhase: Holds the state of display of the planned move so that, eg, it can appear one jump at a time. Advances from 1 to (plannedMove size * 2).
A move is an array of locs which are the path of the move.
Once the morph is open, the menu command 'reset...' allows you to reset the board and change the number of players. The circle at turnIndicatorLoc indicates the color of the team whose turn it is. If it is a human, play waits for drag and drop of a piece of that color.
The current strategy is very simple: generate all moves, score them and pick the best. Beyond this, it will look ahead a number of moves, but this becomes very expensive without pruning. Pruning would help the speed of play, especially in the end game where we look a little deeper. A more effective strategy would consider opponents' possible moves as well, but this is left as an exercise for the serious programmer.
Senders of it:
ChineseCheckerPiece mouseDown: {event handling}
CipherPanel
WordGamePanelMorph subclass: #CipherPanel instanceVariableNames: 'originalText quote originalMorphs decodingMorphs' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Games'
The CipherPanel, as its name suggests, is a tool for decoding simple substitution codes, such as are presented on the puzzle pages of many Sunday newspapers. Most of the capability is inherited from the two WordGame classes used. To try it out, choose newMorph/Games/CipherPanel in a morphic project, or execute, in any project:
CipherPanel new openInWorld
Senders of it:
CipherPanel squeakCipher {menu}
Cipher is implemented in this CipherPanel class.
CircleMorph
EllipseMorph subclass: #CircleMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Basic'
I am a specialization of EllipseMorph that knows enough to remain circular.
Senders of it:
CircleMorph class supplementaryPartsDescriptions {as yet unclassified}
NCLineEndConstraintMorph class filledCircleShape {line end shapes}
NCLineEndConstraintMorph class junctionDotShape {line end shapes}
Circle is implemented in this CircleMorph class.
ClassRepresentativeMorph
ObjectRepresentativeMorph subclass: #ClassRepresentativeMorph instanceVariableNames: 'classRepresented' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of ClassRepresentativeMorph
Note: This Class has neither instance nor class methods of its own, only those it inherits.
ClipboardMorph
TextMorph subclass: #ClipboardMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
A morph that always displays the current contents of the text clipboard.
Senders of it:
There are no senders of ClipboardMorph
ClockMorph
StringMorph subclass: #ClockMorph instanceVariableNames: 'showSeconds show24hr nowTime' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Demo'
THIS CLASS HAS NO COMMENT!
Senders of it:
ClockMorph class registerInFlapsRegistry {class initialization}
Flaps class defaultsQuadsDefiningSuppliesFlap {flaps registry}
Flaps class defaultsQuadsDefiningWidgetsFlap {flaps registry}
Flaps class newLoneSuppliesFlap {predefined
CodecDemoMorph
RectangleMorph subclass: #CodecDemoMorph instanceVariableNames: 'codecClassName' classVariableNames: '' poolDictionaries: '' category: 'Sound-Interface'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of CodecDemoMorph
CollapsedMorph
SystemWindow subclass: #CollapsedMorph instanceVariableNames: 'uncollapsedMorph' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Windows'
THIS CLASS HAS NO COMMENT!
Senders of it:
Morph collapse {menus}
TileMorph handReferentMorph {misc}
ColorPickerMorph
SketchMorph subclass: #ColorPickerMorph instanceVariableNames: 'selectedColor sourceHand deleteOnMouseUp updateContinuously target selector argument originalColor theSelectorDisplayMorph command isModal clickedTranslucency noChart' classVariableNames: 'ColorChart DeleteBox DragBox FeedbackBox OpenFullBox RevertBox TransparentBox TransText' poolDictionaries: '' category: 'Morphic-Widgets'
A gui for setting color and transparency. Behaviour can be changed with the Preference modalColorPickers.
Senders of it:
27 methods
ColorPicker is implemented in this class.
ColorSeerTile
ColorTileMorph subclass: #ColorSeerTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
THIS CLASS HAS NO COMMENT!
Senders of it:
CategoryViewer addColorSeesDetailTo: {entries}
PhraseTileMorph isColorSeer {code generation}
ScriptEditorMorphBuilder specialSend:with:with: {reconstituting scripting tiles }
Viewer colorSeesPhrase {special phrases}
ColorSwatch
UpdatingRectangleMorph subclass: #ColorSwatch instanceVariableNames: 'argument' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Support'
THIS CLASS HAS NO COMMENT!
Senders of it:
Preferences class windowSpecificationPanel {window colors}
ColorTileMorph
TileMorph subclass: #ColorTileMorph instanceVariableNames: 'colorSwatch showPalette' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
THIS CLASS HAS NO COMMENT!
Senders of it:
10 methods
CommandTilesMorph
TileLikeMorph subclass: #CommandTilesMorph instanceVariableNames: 'morph playerScripted' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
An entire Smalltalk statement in tiles. A line of code.
Senders of it:
There are no senders of CommandTilesMorph.
ComponentLayout
PasteUpMorph subclass: #ComponentLayout instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Components'
THIS CLASS HAS NO COMMENT!
Senders of it:
Component justDroppedInto:event: {drag and drop}
ComponentLikeModel justDroppedInto:event: {dropping/grabbing}
ComponentLikeModel
MorphicModel subclass: #ComponentLikeModel instanceVariableNames: 'pinSpecs' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Components'
THIS CLASS HAS NO COMMENT!
Senders of it:
SystemDictionary computeImageSegmentation {shrinking}
CompoundTileMorph
TileLikeMorph subclass: #CompoundTileMorph instanceVariableNames: 'type testPart yesPart noPart justGrabbedFromViewer' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
A statement with other whole statements inside it. If-Then. Test.
Senders of it:
Used in ImageSegment, Morph, PhraseTileForTest, ScriptEditorMorph, StandardScriptingSystem, and StandardViewer.
ConnectorPropertiesMorph
GenericPropertiesMorph subclass: #ConnectorPropertiesMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Tools'
THIS CLASS HAS NO COMMENT!
Senders of it:
NCAAConnectorMorph openAConnectorPropertySheet {visual properties}
CrosticPanel
WordGamePanelMorph subclass: #CrosticPanel instanceVariableNames: 'crosticPanel quotePanel cluesCol2 answers quote clues cluesPanel' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Games'
The CrosticPanel, as its name suggests, is a tool for decoding acrostic puzzles, such as are presented on the puzzle pages of some Sunday newspapers. Much of the capability is inherited from the two WordGame classes used. To try it out, choose newMorph/Games/CrosticPanel in a morphic project, or execute, in any project:
CrosticPanel new openInWorld
The instance variables of this class include...
letterMorphs (in superclass) a collection of all the letterMorphs in this panel
quote a string, being the entire quote in uppercase with no blanks
clues a collection of the clue strings
answers a collection of the answer indices.
For each answer, this is an array of the indices into the quote string.
The final structure of a CrosticPanel is as follows
self a CrosticPanel the overall holder
quotePanel a CrosticQuotePanel holds the grid of letters from the quote
cluesPanel an AlignmentMorph holds most of the clue rows
cluesCol2 an AlignmentMorph holds the rest of the clue rows
Each clue row is a horizontal AlignmentMorph with a textMorph and another alignmentMorph full of the letterMorphs for the answer.
Senders of it:
CrosticPanel openFile {menu}
CrosticPanel quote:clues:answers:quotePanel: {initialization}
CrosticQuotePanel quote:answers:cluesPanel: {initialization}
CrosticQuotePanel
WordGamePanelMorph subclass: #CrosticQuotePanel instanceVariableNames: 'cluesPanel' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Games'
THIS CLASS HAS NO COMMENT!
Senders of it:
CrosticPanel initializeToStandAlone {parts bin}
CrosticPanel class newFromFile: {instance creation}
CurveMorph
PolygonMorph subclass: #CurveMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Basic'
This is really only a shell for creating Shapes with smooth outlines.
Senders of it:
CurveMorph class registerInFlapsRegistry {*MorphicExtras-class initialization}
CurveMorph class supplementaryPartsDescriptions {*MorphicExtras-parts bin}
TabbedPalette class authoringPrototype {scripting}
DoCommandOnceMorph
BorderedMorph subclass: #DoCommandOnceMorph instanceVariableNames: 'target command actionBlock innerArea deleteAfterExecution' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Basic'
I am used to execute a once-only command. My first use was in loading/saving the current project. In such cases it is necessary to be in another project to do the actual work. So an instance of me is added to a new world/project and that project is entered. I do my stuff (save/load followed by a re-enter of the previous project) and everyone is happy.
Senders of it:
Project armsLengthCommand:withDescription: {file in/out}
Project class enterNewWithInitialBalloons {instance creation}
DoubleClickExample
RectangleMorph subclass: #DoubleClickExample instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Demo'
Illustrates the double-click capabilities of Morphic.
If you have a kind of morph you wish to have respond specially to a double-click, it should:
(1) Respond "true" to #handlesMouseDown:
(2) In its mouseDown: method, send #waitForClicksOrDrag:event: to the hand.
(3) Reimplement #click: to react to single-clicked mouse-down.
(4) Reimplement #doubleClick: to make the appropriate response to a double-click.
(5) Reimplement #drag: to react to non-clicks. This message is sent continuously until the button is released. You can check the event argument to react differently on the first, intermediate, and last calls.
Senders of it:
There are no senders of DoubleClickExample.
DownloadingImageMorph
Morph subclass: #DownloadingImageMorph instanceVariableNames: 'url altText defaultExtent image downloadQueue imageMapName formatter' classVariableNames: '' poolDictionaries: '' category: 'Network-HTML-Formatter'
a placeholder for an image that is downloading
Senders of it:
HtmlImage addToFormatter: {formatting}
HtmlInput addImageButtonToFormatter: {formatting}
DrawErrorMorph
Morph subclass: #DrawErrorMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Experimental'
This morph simply invokes errors during drawing and stepping.
Senders of it:
There are no senders of DrawErrorMorph.
DrGArcMorph (v5)
DrGPolylineMorph subclass: #DrGArcMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-Item-View'
THIS CLASS HAS NO COMMENT!
Senders of it:
DrGAngle3PointsCostume instantiateMorph {initialize-release}
DrGAngle3PointsCostume redrawArc {updating}
DrGArcCostume instantiateMorph {initialize-release}
DrGArcCostume redraw {updating}
DrGCircleMorph (v5)
DrGMorph subclass: #DrGCircleMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-Item-View'
THIS CLASS HAS NO COMMENT!
Senders of it:
DrGCircleCostume instantiateMorph {initialize-release}
DrGDrawable (v5)
PasteUpMorph subclass: #DrGDrawable instanceVariableNames: 'balloonTarget tipOn selection app ox oy scale' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-App'
I represent the area/place where a Drgeo figure is drawn. It is a subpart of the GeometricView
Senders of it:
DrGService initialize {initialize-release}
DrGLabelMorph (v5)
DrGStringMorph subclass: #DrGLabelMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-Item-View'
THIS CLASS HAS NO COMMENT!
Senders of it:
DrGMathItemCostume textMorph: {accessing}
DrGLineMorph (v5)
DrGSegmentMorph subclass: #DrGLineMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-Item-View'
A DGLineMorph is extented to the boundary of its parent morph, a drawable in Dr. Geo jargon.
Senders of it:
DrGCircleCostume redrawAsLine {updating}
DrGLineCostume instantiateMorph {initialize-release}
DrGLocusMorph (v5)
DrGPolylineMorph subclass: #DrGLocusMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-Item-View'
THIS CLASS HAS NO COMMENT!
Senders of it:
DrGLocusCostume instantiateMorph {initialize-release}
DrGMorph (v5)
BorderedMorph subclass: #DrGMorph instanceVariableNames: 'costume blink' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-Item-View'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of DrGMorph.
DrGPointMorph (v5)
DrGMorph subclass: #DrGPointMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-Item-View'
THIS CLASS HAS NO COMMENT!
Senders of it:
DrGPointCostume instantiateMorph {initialize-release}
DrGPolygoneMorph[sic] (v5)
DrGPolylineMorph subclass: #DrGPolygoneMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-Item-View'
THIS CLASS HAS NO COMMENT!
Senders of it:
MCStReader typeOfSubclass: {as yet unclassified}
DrGPolylineMorph (v5)
PolygonMorph subclass: #DrGPolylineMorph instanceVariableNames: 'blink costume' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-Item-View'
THIS CLASS HAS NO COMMENT!
Senders of it:
DrGAngle3PointsCostume redrawRec {updating}
DrGRayMorph (v5)
DrGSegmentMorph subclass: #DrGRayMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-Item-View'
A DGRayMorph is extended in one 'sens' to the boundary of its parents morph, a drawable in Dr. Geo jargon.
Senders of it:
DrGRayCostume instantiateMorph {initialize-release}
DrGSegmentMorph (v5)
DrGPolylineMorph subclass: #DrGSegmentMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-Item-View'
THIS CLASS HAS NO COMMENT!
Senders of it:
DrGArcCostume redraw {updating}
DrGSegmentCostume instantiateMorph {initialize-release}
DrGService (v5)
BorderedMorph subclass: #DrGService instanceVariableNames: 'app area' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-App'
THIS CLASS HAS NO COMMENT!
Senders of it:
DrGRayCostume instantiateMorph {initialize-release}
DrGStringMorph (v5)
StringMorph subclass: #DrGStringMorph instanceVariableNames: 'costume blink' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-Item-View'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of DrGStringMorph.
DrGValueMorph (v5)
DrGStringMorph subclass: #DrGValueMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-Item-View'
THIS CLASS HAS NO COMMENT!
Senders of it:
DrGValueCostume instantiateMorph {initialize-release}
DrGVectorMorph (v5)
DrGSegmentMorph subclass: #DrGVectorMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-Item-View'
THIS CLASS HAS NO COMMENT!
Senders of it:
DrGVectorCostume instantiateMorph {initialize-release}
DrGWizard (v5)
RectangleMorph subclass: #DrGWizard instanceVariableNames: 'pages currentPage' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-UI'
A DrGMacroMorph is an abstractact dialog to build and play macro.
It emits event when
- the user changes the page with the next and previous buttons
- the user press apply and cancel
Instance Variables
pages: dictionary of pages Morph
pages
- xxxxx
Senders of it:
There are no senders of DrGWizard.
DrGWizardMacroBuild (v5)
DrGWizard subclass: #DrGWizardMacroBuild instanceVariableNames: 'builder' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-UI'
THIS CLASS HAS NO COMMENT!
Senders of it:
DrGMacroBuilder initialize {initialize-release}
DrGWizardMacroPlay (v5)
DrGWizard subclass: #DrGWizardMacroPlay instanceVariableNames: 'builder macroFactories' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-UI'
THIS CLASS HAS NO COMMENT!
Senders of it:
DrGMacroPlayer initialize {initialize-release}
DrGWizardPage (v5)
Morph subclass: #DrGWizardPage instanceVariableNames: 'cancel previous nextOrApply buttons model content' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-UI'
A DrGWizardPage is a page morph to add in a wizard dialog..
Content can be added with the #content: message
Alternatively, it can be subclassed this class, to do so
override intialiaze with super call and at the end of
initialize use #content: message
Instance Variables
buttons: <Object>
cancel: <Object>
content: <Object>
model: <Object>
nextOrApply: <Object>
previous: <Object>
buttons
- xxxxx
cancel
- xxxxx
content
- xxxxx
model
- xxxxx
nextOrApply
- xxxxx
previous
- xxxxx
Senders of it:
DrGWizard goPage: {accessing}
DrGWizard class example {as yet unclassified}
DrGWizardMacroBuild firstPage {initialization}
DrGWizardMacroBuild fourthPage {initialization}
DrGWizardMacroBuild secondPage {initialization}
DrGWizardMacroBuild thirdPage {initialization}
DrGWizardMacroPlay firstPage {initialization}
DrGWizardMacroPlay secondPage {initialization}
DrGWizardScript firstPage {initialization}
DrGWizardScript secondPage {initialization}
DrGWizardScript (v5)
DrGWizard subclass: #DrGWizardScript instanceVariableNames: 'builder methodList instanceList' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-UI'
THIS CLASS HAS NO COMMENT!
Senders of it:
DrGScriptPlayer initialize {initialization}
DropDownChoiceMorph
PopUpChoiceMorph subclass: #DropDownChoiceMorph instanceVariableNames: 'items border' classVariableNames: 'SubMenuMarker' poolDictionaries: '' category: 'MorphicExtras-Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
HtmlSelect addToFormatter: {formatting}
DumberMenuMorph
MenuMorph subclass: #DumberMenuMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Explorer'
Contributed by Bob Arning as part of the ObjectExplorer package.
Senders of it:
EToyHierarchicalTextGizmo genericMenu: {as yet unclassified}
EllipseMorph
BorderedMorph subclass: #EllipseMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Basic'
A round BorderedMorph. Supports borderWidth and borderColor.
Only simple borderStyle is implemented.
EllipseMorph new borderWidth:10; borderColor: Color green; openInWorld.
EllipseMorph new borderStyle:(SimpleBorder width: 5 color: Color blue); openInWorld.
Senders of it:
31 methods
EmbeddedWorldBorderMorph
AlignmentMorph subclass: #EmbeddedWorldBorderMorph instanceVariableNames: 'heights minWidth minHeight' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-AdditionalSupport'
THIS CLASS HAS NO COMMENT!
Senders of it:
PasteUpMorph installAsActiveSubprojectIn:at:titled: {world state}
PasteUpMorph repairEmbeddedWorlds {world state}
ThreadNavigationMorph deleteCurrentPage {navigation}
EnvelopeEditorMorph
RectangleMorph subclass: #EnvelopeEditorMorph instanceVariableNames: 'sound soundName envelope hScale vScale graphArea pixPerTick limits limitXs limitHandles line prevMouseDown sampleDuration showAllEnvelopes denominator keyboard' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-SoundInterface'
THIS CLASS HAS NO COMMENT!
Senders of it:
AbstractSound class updateScorePlayers {sound library-file in/out}
MidiInputMorph atChannel:from:selectInstrument: {as yet unclassified}
ScorePlayerMorph atTrack:from:selectInstrument: {controls}
EnvelopeLineMorph
PolygonMorph subclass: #EnvelopeLineMorph instanceVariableNames: 'editor' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-SoundInterface'
THIS CLASS HAS NO COMMENT!
Senders of it:
EnvelopeEditorMorph addCurves {construction}
EToyChatMorph
EToyChatOrBadgeMorph subclass: #EToyChatMorph instanceVariableNames: 'listener receivingPane myForm recipientForm acceptOnCR sendingPane' classVariableNames: '' poolDictionaries: '' category: 'Nebraska-Morphic-Collaborative'
EToyChatMorph new open setIPAddress: '1.2.3.4'
"
EToyChatMorph represents a chat session with another person. Type your message in the top text pane and press cmd-S.
"
Senders of it:
EToyChatMorph class chatWindowForIP:name:picture:inWorld: {as yet unclassified}
EToyIncomingMessage class handleNewChatFrom:sentBy:ipAddress: {handlers}
EToyIncomingMessage class handleNewSeeDesktopFrom:sentBy:ipAddress: {handlers}
EToyIncomingMessage class handleNewStatusRequestFrom:sentBy:ipAddress: {handlers}
EToySenderMorph startChat: {as yet unclassified}
EToyChatOrBadgeMorph
EToyCommunicatorMorph subclass: #EToyChatOrBadgeMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Nebraska-Morphic-Experimental'
THIS CLASS HAS NO COMMENT!
Senders of it:
EToyChatOrBadgeMorph class includeInNewMorphMenu {new-morph participation}
Badge is implemented in this EtoyChatOrBadgeMorph class.
EToyCommunicatorMorph
AlignmentMorphBob1 subclass: #EToyCommunicatorMorph instanceVariableNames: 'fields resultQueue' classVariableNames: 'LastFlashTime' poolDictionaries: '' category: 'Etoys-Experimental'
====== find and report all instances =====
EToySenderMorph instanceReport
====== zap a bunch of ipAddresses =====
EToySenderMorph allInstances do: [ :each |
each ipAddress = '11.11.11.11' ifTrue: [each ipAddress: 'whizzbang']
].
==================== now change one of the whizzbang's back to the right address=====
====== delete the whizzbangs ======
EToySenderMorph allInstances do: [ :each |
each ipAddress = 'whizzbang' ifTrue: [each stopStepping; delete]
].
Senders of it:
EToyChatMorph
EToyCommunicatorMorph
EToyIncomingMessage
EToyMultiChatMorph
EtoyDAVLoginMorph
AlignmentMorphBob1 subclass: #EtoyDAVLoginMorph instanceVariableNames: 'theName theNameMorph thePassword thePasswordMorph actionBlock cancelBlock panel' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Experimental'
THIS CLASS HAS NO COMMENT!
Senders of it:
FileList2 loginHit {private}
EToyFridgeMorph
EToyCommunicatorMorph subclass: #EToyFridgeMorph instanceVariableNames: 'recipients incomingRow recipientRow updateCounter groupMode' classVariableNames: 'FridgeRecipients NewItems TheFridgeForm UpdateCounter' poolDictionaries: '' category: 'Nebraska-Morphic-Collaborative'
EToyFridgeMorph new openInWorld
Senders of it:
EToyIncomingMessage class handleNewFridgeMorphFrom:sentBy:ipAddress: {handlers}
EToySenderMorph aboutToBeGrabbedBy: {dropping/grabbing}
EToySenderMorph startChat: {as yet unclassified}
EToyGateKeeperEntry
MorphicModel subclass: #EToyGateKeeperEntry instanceVariableNames: 'ipAddress accessAttempts lastTimes acceptableTypes latestUserName attempsDenied lastRequests' classVariableNames: 'KnownIPAddresses' poolDictionaries: '' category: 'Nebraska-Morphic-Experimental'
THIS CLASS HAS NO COMMENT!
Senders of it:
EToyGateKeeperMorph class entryForIPAddress: {as yet unclassified}
EToyGenericDialogMorph
AlignmentMorphBob1 subclass: #EToyGenericDialogMorph instanceVariableNames: 'namedFields' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Experimental'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of EToyGenericDialogMorph.
EToyHierarchicalTextMorph
SimpleHierarchicalListMorph subclass: #EToyHierarchicalTextMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Outliner'
THIS CLASS HAS NO COMMENT!
Senders of it:
EToyHierarchicalTextGizmo notInAWindow {as yet unclassified}
EToyHierarchicalTextMorph class new {instance creation}
EToyListenerMorph
EToyCommunicatorMorph subclass: #EToyListenerMorph instanceVariableNames: 'listener updateCounter' classVariableNames: 'GlobalIncomingQueue GlobalListener QueueSemaphore UpdateCounter WasListeningAtShutdown' poolDictionaries: '' category: 'Nebraska-Morphic-Collaborative'
EToyListenerMorph new open
EToyListenerMorph startListening.
EToyListenerMorph stopListening.
"
EToyListenerMorph listens for messgaes from other EToy communicators. You need one of these open to receive messages from elsewhere.
- Received Morphs are shown in a list. Items can be grabbed (a copy) or deleted.
- Chat messages are sent to an appropriate EToyChatMorph (created if necessary)
"
Senders of it:
EToyListenerMorph class ensureListenerInCurrentWorld {as yet unclassified}
EToyPeerToPeer makeOptionalHeader {sending}
EtoyLoginMorph
AlignmentMorphBob1 subclass: #EtoyLoginMorph instanceVariableNames: 'theName theNameMorph actionBlock cancelBlock' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Experimental'
THIS CLASS HAS NO COMMENT!
Senders of it:
ProjectLauncher doEtoyLogin {eToy login}
EToyMorphsWelcomeMorph
EToyCommunicatorMorph subclass: #EToyMorphsWelcomeMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Nebraska-Morphic-Collaborative'
EToyMorphsWelcomeMorph new openInWorld
Senders of it:
EToyIncomingMessage class handleNewMorphFrom:sentBy:ipAddress: {handlers}
EToyMultiChatMorph
EToyChatMorph subclass: #EToyMultiChatMorph instanceVariableNames: 'targetIPAddresses' classVariableNames: '' poolDictionaries: '' category: 'Nebraska-Morphic-Collaborative'
THIS CLASS HAS NO COMMENT!
Senders of it:
EToyIncomingMessage class handleNewMultiChatFrom:sentBy:ipAddress: {handlers}
EToyProjectDetailsMorph
EToyProjectRenamerMorph subclass: #EToyProjectDetailsMorph instanceVariableNames: 'projectDetails' classVariableNames: 'AgeTriplets RegionTriplets SubjectTriplets' poolDictionaries: '' category: 'Etoys-Experimental'
THIS CLASS HAS NO COMMENT!
Senders of it:
FileList2 loginHit {private}
InternalThreadNavigationMorph insertNewProject {navigation}
Project validateProjectNameIfOK: {menu messages}
ProjectNavigationMorph editProjectInfo {the actions}
ProjectSorterMorph insertNewProject: {menu commands}
EToyProjectHistoryMorph
EToyCommunicatorMorph subclass: #EToyProjectHistoryMorph instanceVariableNames: 'changeCounter' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Experimental'
EToyProjectHistoryMorph new openInWorld
EToyProjectHistoryMorph provides a quick reference of the most recent projects. Click on one to go there.
Senders of it:
ProjectNavigationMorph gotoAnother {the actions}
EToyProjectQueryMorph
EToyProjectDetailsMorph subclass: #EToyProjectQueryMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Experimental'
THIS CLASS HAS NO COMMENT!
Senders of it:
ProjectNavigationMorph findSomethingOnSuperSwiki {the buttons}
EToyProjectRenamerMorph
EToyGenericDialogMorph subclass: #EToyProjectRenamerMorph instanceVariableNames: 'actionBlock theProject' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Experimental'
Nowadays, anyway, EToyProjectRenamerMorph only occurs as an abstract superclass for EToyProjectQueryMorph and EToyProjectDetailsMorph.
Senders of it:
MCStReader typeOfSubclass: {as yet unclassified}
EToySenderMorph
EToyChatOrBadgeMorph subclass: #EToySenderMorph instanceVariableNames: 'userPicture' classVariableNames: 'DEBUG' poolDictionaries: '' category: 'Nebraska-Morphic-Collaborative'
EToySenderMorph
new
userName: 'Bob Arning'
userPicture: nil
userEmail: 'arning@charm.net'
userIPAddress: '1.2.3.4';
position: 200@200;
open
"
EToySenderMorph represents another person to whom you wish to send things. Drop a morph on an EToySenderMorph and a copy of that morph is sent to the person represented. Currently only peer-to-peer communications are supported, but other options are planned.
"
Senders of it:
EToyChatMorph startOfMessageFromMe {as yet unclassified}
EToyChatMorph class chatFrom:name:text: {as yet unclassified}
EToyChatMorph class chatWindowForIP:name:picture:inWorld: {as yet unclassified}
EToyFridgeMorph acceptDroppingMorph:event: {layout}
EToyFridgeMorph handlesMouseDown: {event handling}
EToyFridgeMorph mouseEnterEither: {as yet unclassified}
EToyMultiChatMorph acceptDroppingMorph:event: {layout}
EToyMultiChatMorph wantsDroppedMorph:event: {dropping/grabbing}
EToySenderMorph class nameForIPAddress: {as yet unclassified}
EToySenderMorph class pictureForIPAddress: {as yet unclassified}
NebraskaClient initialize: {initialization}
SugarBuddy makeBadge {actions}
SugarLauncher badgeFor: {presence}
EToyTextNode
TextMorph subclass: #EToyTextNode instanceVariableNames: 'children firstDisplay' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Outliner'
THIS CLASS HAS NO COMMENT!
Senders of it:
EToyHierarchicalTextGizmo class example {as yet unclassified}
EToyHierarchicalTextMorph class new {instance creation}
EToyTextNode addNewChildAfter: {as yet unclassified}
EtoyUpdatingThreePhaseButtonMorph
UpdatingThreePhaseButtonMorph subclass: #EtoyUpdatingThreePhaseButtonMorph instanceVariableNames: '' classVariableNames: 'CheckedForm MouseDownForm UncheckedForm' poolDictionaries: '' category: 'Etoys-Widgets'
A slight variation wherein the actionSelector and getSelector both take argument(s).
Senders of it:
AlignmentMorphBob1 simpleToggleButtonFor:attribute:help: {as yet unclassified}
EToyFridgeMorph groupToggleButton {as yet unclassified}
GenericPropertiesMorph directToggleButtonFor:getter:setter:help: {as yet unclassified}
ParameterDescription asBooleanMorph {creation}
ParameterDescription asExtentMorph {creation}
- blackTriangularOpener creates a circular button bearing a triangle.
- checkBox creates a check box.
- RadioButton creates a radio button.
Each of the methods above requires some further context to define the button's actions. Look at their senders for examples.
EToysLauncher
Morph subclass: #EToysLauncher instanceVariableNames: 'window showGallery' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Demo'
I am a simple launcher for recent projects.
EToysLauncher new openInHand
- I find latest ten projects in "My Squeak" and image directories (see: EToysLauncher>>directories).
- A thumbnail can be shown if there is "project name.gif" file.
- You can enter a project when you click a thumbnail.
- The list is updated when you go and back project.
Senders of it:
Sketch5 click
EventMorph
RectangleMorph subclass: #EventMorph instanceVariableNames: 'event' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
An abstract superclass for KeyboardEventMorph, MediaEventMorph, and MouseEventSequenceMorph. These are morphs used on an EventRoll to represent events on an event tape.
Senders of it:
There are no senders of EventMorph.
EventPlaybackButton
IconicButton subclass: #EventPlaybackButton instanceVariableNames: 'caption contentArea tape autoStart autoDismiss initialPicture finalPicture' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
Obsolete -- the functionality of this class was subsumed in March 2007 by class PlaybackInvoker.
Class retained "temporarily" in support of pre-existing content. Probably can now be gotten rid of...
Formerly:
A button which, when clicked, will open up an event-playback space, in which the user can play an event "movie".
caption - a String --the label beneath the button's icon.
contentArea - a Worldlet - a veryDeepCopy of the contentArea of the contributing MentoringEventRecorder at the time the recording was made.
tape - an Array of MorphicEvent objects.
voiceRecorder - a copy of the voiceRecorder of the contributing MentoringEventRecorder.
Senders of it:
There are no senders of EventPlaybackButton.
EventPlaybackSpace
EventRecordingSpace subclass: #EventPlaybackSpace instanceVariableNames: 'autoStart autoDismiss' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
An area used for playback of event-recorded movies, as it were.
Senders of it:
EventPlaybackButton launchPlayback {initialization}
PlaybackInvoker launchPlayback {initialization}
EventRecorderMorph
AlignmentMorph subclass: #EventRecorderMorph instanceVariableNames: 'tape state time deltaTime recHand playHand lastEvent lastDelta tapeStream saved statusLight voiceRecorder startSoundEvent recordMeter caption journalFile noCondense areaBounds areaOffset lastInterpolation' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-AdditionalSupport'
During recording, the EventRecorder subscribes to all events of the normal morphic hand, and saves them as they occur.
For replay, a second playback hand is created that reads events from the recorder and plays the events back in the world.
Recording a second time erases the previous recording (in this recorder). A tape of events can be saved to a file, which is then safe on the disk.
noCondense = true during a brush stroke in the paint system, which we do not want to condense or remove any points from.
The EventRecorder began with the work of Ted Kaehler and John Maloney. This was then signifcantly expanded by Leandro Caniglia and Valeria Murgia as a tutorial aid for the Morphic Wrapper project.
Since that time, I have...
Changed to a simple inboard array for the tape (event storage).
Provided the ability to condense linear mouse movement with interpolation at replay.
Made simple provisions for wrap-around of the millisecond clock.
Eliminated step methods in favor of using the processEvents cycle in the playback hand.
Provided a pause/resume mechanism that is capable of surviving project changes.
Added the ability to spawn a simple 'play me' button that can be saved as a morph.
Caused the playback hand to display its cursor double size for visibility.
Integrated a voice recorder with on-the-fly compression.
This currently does NOT survive project changes, nor is its data stored on the tape.
Right now it can only be saved by saving the entire recorder as a morph.
This will be fixed by adding a startSound event at each project change.
We will also convert read/write file to use saveOnFile.
Added a journal-file facility to help debug recording sequences that end in a crash.
The above two features can be engaged via the ER's morph menu.
- Dan Ingalls 3/6/99
Changes for OLPC by TK:
Don't condense brush strokes in painting.
Notice when we are recording inside of a Scripting Area (property #tutorial).
The bounds of the Scripting Area is noted in the inst var areaBounds (stream (UnknownEvent type #tutorialBounds)). Upon playback, the events are translated for the enclosing Scripting Area's new origin.
Handling of events is done relative to the Scripting Area to let playback work when some other object occludes it.
An ajdustment for screen size area change and still opening Flaps?
Senders of it:
EventPlaybackButton duration {initialization}
EventRecorderMorph createPlayButton {commands}
EventRecorderMorph spawnStartingState {commands}
FileList class initialize {class initialization}
HandMorph eventRecorders {listeners}
HandMorph pauseEventRecorderIn: {event handling}
EventRecordingSpace
AlignmentMorph subclass: #EventRecordingSpace instanceVariableNames: 'contentArea controlsPanel soundPanel publishButton abandonButton menuButton recordButton recordAgainButton recordVoiceoverButton stopRecordingVoiceoverButton scriptButton playButton rewindButton stopButton pauseButton resumeButton captionMorph showingSoundButton eventRecorder state initialContentArea balloonHelpString initialPicture finalPicture showingSoundPanel eventRoll priorVersions' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
Externally called the Event Theatre, this is a tool for authoring event-recorded sequences with possible voiceover. Event "tapes" created with an Event Theatre can be edited using the Event Roll.
Values for the "state" instance variable, which characterizes the combined state of an Event-Theatre + MentoringEventRecorder complex:
readyToRecord No recording ever made
rewound Recording exists; not actively doing anything, and recently rewound.
atEndOfPlayback Recording exists; not actively doing anything; played since last rewind.
recordingWithSound Currently making primary recording, with sound
recording Currently making primary recording, sans sound
playback
playbackAddingVoiceover Currently running playback while recording a voiceover for a portion of it
suspendedPlayback In the midst of playback, user hit the Pause button
Senders of it:
EventPlaybackButton changeCaption {menu }
EventPlaybackButton openInRecordingSpace {button}
EventPlaybackSpace openForScoreEditing {commands}
EventRecordingSpace class openFromPlaybackButton: {instance creation}
InteriorSugarNavBar setupSuppliesFlap {initialization}
PlaybackInvoker changeCaption {menu }
PlaybackInvoker openInRecordingSpace {menu }
TheWorldMenu openMenu {construction}
EventRecordingSpaceNavigator
ProjectNavigationMorph subclass: #EventRecordingSpaceNavigator instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Navigators'
A custom navigator to use within the content area of an EventRecordingSpace.
Senders of it:
EventRecordingSpace addNavigatorFlap {flaps}
EventRollCursor
Morph subclass: #EventRollCursor instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
A Morph serving as the cursor on an EventTimeline in an EventRoll.
At present, there is no real benefit to having a separate class for the cursor, since it has no unique behavior yet. However, in the future we may wish for the cursor to be more dynamic, and this gives us a way in for doing things like that.
Senders of it:
EventRollMorph initialize {initialization}
EventRollMorph
AlignmentMorph subclass: #EventRollMorph instanceVariableNames: 'startTime millisecondsPerPixel totalDuration eventTheatre rawEventTape mouseTrack keyboardTrack mediaTrack actualRoll eventPlaybackCursor' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
A tool used in conjunction with an event-recording-space to view and edit events in an event score.
Senders of it:
EventPlaybackButton putEventsOnto: {event roll}
EventRecordingSpace makeHorizontalRoll {commands}
Morph eventRoll {accessing}
SoundTile putEventsOnto: {event handling}
EventTimeline
PasteUpMorph subclass: #EventTimeline instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
An EventTimeline is the scrollable surface on which the events are laid out in the EventRoll.
Senders of it:
EventMorph justDroppedInto:event: {drag and drop}
EventRollMorph formulate {processing}
FatBitsPaint
SketchMorph subclass: #FatBitsPaint instanceVariableNames: 'formToEdit magnification brush brushSize brushColor lastMouse currentTools currentSelectionMorph selectionAnchor backgroundColor' classVariableNames: 'FormClipboard' poolDictionaries: '' category: 'MorphicExtras-AdditionalWidgets'
Extensions to FatBitsPaint
With the goal of making FatBitsPaint a fairly nifty Form fixer-upper in the Squeak/morphic environment, I have started this set of extensions. It will probably be updated as the mood strikes, so keep an eye out for new versions.
First, some basic operating instructions:
Get a Form and send it the message #morphEdit. To get started, you can try:
(Form fromUser) morphEdit
And there is the form in all its glory. Control click on the form to get theFatBitsPaint menu and choose the "keep this menu up" item. This will be your main tool/command palette. With it you can:
¥ Change the magnification
¥ Change the brush size (in original scale pixels)
¥ Change the brush color (via a ColorPickerMorph)
Now to some of the enhancements:
(25 September 1999 2:38:25 pm )
¥ ColorPickerMorphs now have a label below that indicates their use (you might have more than one open)
¥ A quirk that could get the brush size out of alignment with the pixel size is fixed.
¥ A background has been added so that you can see the full extent of the Form and so that you can observe the effect of translucent pixels in the form.
¥ A menu item has been added to change the background color so that you can simulate the real environment the form will be displayed in.
¥ The magnification and brush size menus now highlight their current value.
¥ An inspect option has been added to the menu so that you can do arbitrary things to the form.
¥ A file out option has been added to write the form to a file.
(25 September 1999 10:02:13 pm )
¥ New menu item: Tools allows you to choose between (for now) Paint Brush (all there was before) and Selections. Selections allows you to select rectangular regions of the form where the next menu takes over.
¥ New menu item: Selections gives you choices:
¥ edit separately - opens a new editor on the selected rectangle. Useful for cropping.
¥ copy - copies the selection rectangle to a clipboard. Can be pasted to this or another FatBitsPaint.
¥ cut - does a copy and clears the selection to transparent.
¥ paste - paints the contents of the clipboard over the current selection. Only the starting point of the selection matters - the extent is controlled by the clipboard.
Senders of it:
Form bitEdit {editing}
Form morphEdit {editing}
FillInTheBlankMorph
RectangleMorph subclass: #FillInTheBlankMorph instanceVariableNames: 'response done textPane responseUponCancel' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Windows'
THIS CLASS HAS NO COMMENT!
Senders of it:
22 methods
FishEyeMorph
MagnifierMorph subclass: #FishEyeMorph instanceVariableNames: 'gridNum d clipRects toRects quads savedExtent' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Demo'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of FishEyeMorph.
FlapTab
ReferenceMorph subclass: #FlapTab instanceVariableNames: 'flapShowing edgeToAdhereTo slidesOtherObjects popOutOnDragOver popOutOnMouseOver inboard dragged lastReferentThickness edgeFraction labelString referentMargin' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Flaps'
The tab associated with a flap.
nb: slidesOtherObjects and inboard are instance variables relating to disused features. The feature implementations still exist in the system, but the UI to them has been sealed off.
Senders of it:
39 methods
Flaps are implemented also in the Flaps class, a subclass of Object, and ViewerFlapTab, a subclass of Flaptab.
Flaps newNavigatorFlap openInHand. Flaps newObjectsFlap openInHand. Flaps newPaintingFlap openInHand. Flaps newSqueakFlap openInHand. Flaps newStackToolsFlap openInHand. Flaps newSugarNavigatorFlap openInHand. Flaps newSuppliesFlap openInHand. Flaps newToolsFlap openInHand. Flaps newWidgetsFlap openInHand.
FlashButtonMorph
FlashCharacterMorph subclass: #FlashButtonMorph instanceVariableNames: 'events sounds target' classVariableNames: 'ActionHelpText' poolDictionaries: '' category: 'Flash-Morphs'
THIS CLASS HAS NO COMMENT!
Senders of it:
FlashMorphReader recordDefineButton: {defining buttons}
FlashCharacterMorph
FlashMorph subclass: #FlashCharacterMorph instanceVariableNames: 'id stepTime frame renderTime vData mData dData cmData rData' classVariableNames: '' poolDictionaries: '' category: 'Flash-Morphs'
THIS CLASS HAS NO COMMENT!
Senders of it:
FlashMorphReader recordEndSprite: {misc}
FlashMorphReader recordShapeEnd: {composing shapes}
Flasher
EllipseMorph subclass: #Flasher instanceVariableNames: 'onColor' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Demo'
A simple example - a circle that flashes.
The "onColor" instance variable indicates the color to use when "on", A darker color is used to represent "off".
The #step method, called every 500ms. by default, alternatively makes the flasher show its "on" and its "off" color.
Senders of it:
Player availableCostumeNames {costume}
SmartRefStream initKnownRenames {read write}
FlashGlyphMorph
FlashMorph subclass: #FlashGlyphMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Flash-Morphs'
THIS CLASS HAS NO COMMENT!
Senders of it:
FlashMorphReader recordFontShapeEnd:with: {defining text}
FlashMorph
MatrixTransformMorph subclass: #FlashMorph instanceVariableNames: 'colorTransform' classVariableNames: 'FlashSoundVolume' poolDictionaries: '' category: 'Flash-Morphs'
THIS CLASS HAS NO COMMENT!
Senders of it:
FlashMorphReader recordButton:character:state:layer:matrix:colorTransform: {defining buttons}
PasteUpMorph isSafeToServe {Nebraska}
FlashMorphingMorph
FlashCharacterMorph subclass: #FlashMorphingMorph instanceVariableNames: 'srcShapes dstShapes morphShapes' classVariableNames: '' poolDictionaries: '' category: 'Flash-Morphs'
THIS CLASS HAS NO COMMENT!
Senders of it:
FlashMorphReader recordMorphShapeEnd: {composing morphs}
FlashPlayerMorph
FlashSpriteMorph subclass: #FlashPlayerMorph instanceVariableNames: 'activationKeys activeMorphs localBounds sourceUrl progressValue' classVariableNames: '' poolDictionaries: '' category: 'Flash-Morphs'
THIS CLASS HAS NO COMMENT!
Senders of it:
FlashMorphReader on: {initialize}
FlashPlayerMorph copyMovieFrom:to: {copying}
HtmlEmbedded class initialize {initialize}
FlashPlayerWindow
SystemWindow subclass: #FlashPlayerWindow instanceVariableNames: 'startButton stopButton progress' classVariableNames: '' poolDictionaries: '' category: 'Flash-Morphs'
THIS CLASS HAS NO COMMENT!
Senders of it:
FlashPlayerMorph openInMVC {initialize}
FlashPlayerMorph openInWorld {initialize}
FlashShapeMorph
FlashMorph subclass: #FlashShapeMorph instanceVariableNames: 'shape' classVariableNames: '' poolDictionaries: '' category: 'Flash-Morphs'
THIS CLASS HAS NO COMMENT!
Senders of it:
FlashCharacterMorph shape {testing}
FlashMorphingMorph from:to: {initialize}
FlashMorphReader endShape {computing shapes}
FlashSorterMorph
TransformMorph subclass: #FlashSorterMorph instanceVariableNames: 'player' classVariableNames: '' poolDictionaries: '' category: 'Flash-Morphs'
THIS CLASS HAS NO COMMENT!
Senders of it:
FlashPlayerMorph openSorter {menu}
FlashSpriteMorph
FlashMorph subclass: #FlashSpriteMorph instanceVariableNames: 'playing maxFrames loadedFrames frameNumber stepTime damageRecorder sounds actions labels lastStepTime useTimeSync' classVariableNames: '' poolDictionaries: '' category: 'Flash-Morphs'
THIS CLASS HAS NO COMMENT!
Senders of it:
FlashMorphReader recordBeginSprite:frames: {misc}
FlashTextMorph
FlashCharacterMorph subclass: #FlashTextMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Flash-Morphs'
THIS CLASS HAS NO COMMENT!
Senders of it:
FlashMorphReader recordTextStart:bounds:matrix: {defining text}
FlashThumbnailMorph
BorderedMorph subclass: #FlashThumbnailMorph instanceVariableNames: 'player frameNumber image selected' classVariableNames: '' poolDictionaries: '' category: 'Flash-Morphs'
THIS CLASS HAS NO COMMENT!
Senders of it:
FlashSorterMorph addThumbnails: {initialization}
FlexMorph
SketchMorph subclass: #FlexMorph instanceVariableNames: 'originalMorph borderWidth borderColor' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-AdditionalMorphs'
THIS CLASS HAS NO COMMENT!
Senders of it:
BookMorph reserveUrlsIfNeeded {menu}
BookPageThumbnailMorph makeFlexMorphFor: {as yet unclassified}
FloatingBookControlsMorph
AlignmentMorph subclass: #FloatingBookControlsMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Navigators'
THIS CLASS HAS NO COMMENT!
Senders of it:
BookMorph buildFloatingPageControls {navigation}
FollowingWatcher (v5)
WatcherWrapper subclass: #FollowingWatcher instanceVariableNames: 'attachmentEdge offset' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Support'
A watcher that follows its watchee around.
attachmentEdge: can be #left, #right #bottom, #top, #topLeft, #topRight, #bottomLeft, #bottomRight, #center)
offset: (x,y) offset from the nominal attachment point.
Senders of it:
Morph addGraphLocationPlotter {*MorphicExtras-accessing}
Player tearOffAttachedLabeledWatcherFor: {slots-user}
Player tearOffAttachedWatcherFor: {slots-user}
FrameRateMorph
StringMorph subclass: #FrameRateMorph instanceVariableNames: 'lastDisplayTime framesSinceLastDisplay' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Demo'
THIS CLASS HAS NO COMMENT!
Senders of it:
Flaps class defaultsQuadsDefiningWidgetsFlap {flaps registry}
FrameRateMorph class registerInFlapsRegistry {class initialization}
FreeCell
AlignmentMorph subclass: #FreeCell instanceVariableNames: 'board cardsRemainingDisplay elapsedTimeDisplay gameNumberDisplay lastGameLost state autoMoveRecursionCount myFillStyle' classVariableNames: 'Statistics' poolDictionaries: '' category: 'Morphic-Games'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of FreeCell.
FreeCellBoard
AlignmentMorph subclass: #FreeCellBoard instanceVariableNames: 'cardDeck lastCardDeck freeCells homeCells stacks target actionSelector hardness' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Games'
The model of a freecell game. Holds the stacks of cards.
cardDeck
lastCardDeck
freeCells
homeCells
stacks array of CardDecks of the columns of cards.
----
Hardness: a number from 1 to 10000.
After dealing, count down the number. For each count, go to next column, pick a ramdom card (with same generator as deck) and move it one place in its stack. This is a kind of bubble sort. Interesting that the slowness of bubble sort is a plus -- gives fine gradation in the hardness.
Moving a card: Move red cards to deep half, black to shallow (or vice versa). Within a color, put low cards deep and high cards shallow.
If speed is an issue, move several steps at once, decrementing counter.
(May make it easier? If running columns, need a way to make harder in other ways.)
Senders of it:
FreeCell board {accessing}
FunctionComponent
TextComponent subclass: #FunctionComponent instanceVariableNames: 'inputSelectors functionSelector outputSelector outputValue' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Components'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of FunctionComponent.
FunctionNameTile
TileMorph subclass: #FunctionNameTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
An operator tile holding the name of a function; used in conjunction with a FunctionTile which is always its owner.
Senders of it:
FunctionTile operator:wording:helpString:pad: {initialization}
FunctionTile
TileMorph subclass: #FunctionTile instanceVariableNames: 'functionNameTile argumentPad' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
A scripting tile consisting of a function-name and an argument pad, and representing a call to a numeric function of a single argument.
Senders of it:
BooleanScriptEditor wantsDroppedMorph:event: {dropping/grabbing}
CategoryViewer booleanPhraseFromPhrase: {support}
Flaps class defaultsQuadsDefiningScriptingFlap {flaps registry}
FunctionTile class randomNumberTile {scripting}
Morph class supplementaryPartsDescriptions {*MorphicExtras-parts bin}
Presenter valueTiles {tile support}
ScriptEditorMorph handUserFunctionTile {other}
ScriptEditorMorph handUserRandomTile {other}
ScriptEditorMorphBuilder functionSend:with:with: {reconstituting scripting tiles }
StandardScriptingSystem randomNumberTile {gold box}
StandardScriptingSystem seminalFunctionTile {gold box}
TileMorph couldAddSuffixArrow {arrows}
TileMorph showSuffixChoices {arrows}
TileMorph wrapPhraseInFunction {arrows}
TilePadMorph wrapInFunction {miscellaneous}
GeeBookMorph
BookMorph subclass: #GeeBookMorph instanceVariableNames: 'geeMail' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-GeeMail'
THIS CLASS HAS NO COMMENT!
Senders of it:
GeeMailMorph convertToBook {as yet unclassified}
TextPlusPasteUpMorph acceptDroppingMorph:event: {layout}
TextPlusPasteUpMorph wantsDroppedMorph:event: {dropping/grabbing}
GeeBookPageMorph
PasteUpMorph subclass: #GeeBookPageMorph instanceVariableNames: 'geeMail geeMailRectangle' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-GeeMail'
THIS CLASS HAS NO COMMENT!
Senders of it:
GeeBookMorph initialize {initialization}
GeeBookMorph rebuildPages {as yet unclassified}
GeeMailMorph
ScrollPane subclass: #GeeMailMorph instanceVariableNames: 'theTextMorph thePasteUp' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-GeeMail'
GeeMail is a scrolling playfield with a text morph (typically on the left) and room on the right for other morphs to be placed. The morphs on the right can be linked to text selections on the left so that they remain positioned beside the pertinent text as the text is reflowed. Probably the best thing is and example and Alan will be making some available soon.
Senders of it:
Flaps class defaultsQuadsDefiningWidgetsFlap {flaps registry}
TextPlusMorph parentGeeMail {as yet unclassified}
GeePrinterDialogMorph
AlignmentMorphBob1 subclass: #GeePrinterDialogMorph instanceVariableNames: 'printSpecs printBlock' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-GeeMail'
THIS CLASS HAS NO COMMENT!
Senders of it:
GeePrinter doPages {Postscript Canvases}
GenericPropertiesMorph
AlignmentMorphBob1 subclass: #GenericPropertiesMorph instanceVariableNames: 'myTarget thingsToRevert' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Experimental'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of GenericPropertiesMorph.
GoldBoxMenu
AlignmentMorph subclass: #GoldBoxMenu instanceVariableNames: 'scriptor lastItemMousedOver' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
A graphical menu that is put up whe the user requests it from the gold-box icon in the header of a Blue scriptor.
Senders of it:
ScriptEditorMorph goldBoxMenu {gold box}
GrabPatchMorph
ImageMorph subclass: #GrabPatchMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Widgets'
When an instance of GrabPatchMorph is dropped by the user, it signals a desire to do a screen-grab of a rectangular area.
Senders of it:
Flaps class defaultsQuadsDefiningPlugInSuppliesFlap {predefined flaps}
GradientFillMorph
RectangleMorph subclass: #GradientFillMorph instanceVariableNames: 'fillColor2 gradientDirection colorArray colorDepth' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Widgets'
Class GradientFillMorph is obsolete. For getting gradient fills use a BorderedMorph with an appropriate fill style, e.g.,
| morph fs |
morph _ BorderedMorph new.
fs _ GradientFillStyle ramp: {0.0 -> Color red. 1.0 -> Color green}.
fs origin: morph bounds center.
fs direction: (morph bounds width // 2) @ 0.
fs radial: true.
morph fillStyle: fs.
World primaryHand attachMorph: morph.
Here's the old (obsolete) comment:
GradientFills cache an array of bitpatterns for the colors across their rectangle. It costs a bit of space, but makes display fast enough to eschew the use of a bitmap. The array must be recomputed whenever the colors, dimensions or display depth change.
Senders of it:
SmartRefStream gradientFillbosfcepbbfgcc0 {conversion}
GraphicalDictionaryMenu
GraphicalMenu subclass: #GraphicalDictionaryMenu instanceVariableNames: 'baseDictionary entryNames lastSearchString' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-AdditionalWidgets'
A morph that allows you to view, rename, and remove elements from a dictionary whose keys are strings and whose values are forms.
Senders of it:
Imports viewImages {images}
StandardScriptingSystem inspectFormDictionary {form dictionary}
GraphicalMenu
AlignmentMorph subclass: #GraphicalMenu instanceVariableNames: 'target selector argument currentIndex formChoices formDisplayMorph coexistWithOriginal' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-AdditionalWidgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
BitmapFillStyle chooseNewGraphicIn:event: {*Morphic-Balloon}
Morph chooseNewGraphicCoexisting: {menus}
GraphicTile
TileMorph subclass: #GraphicTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
A tile representing a graphic image.
Senders of it:
GraphicType defaultArgumentTile {*Etoys-tiles}
ScriptEditorMorphBuilder literal: {reconstituting scripting tiles }
GraphMorph
RectangleMorph subclass: #GraphMorph instanceVariableNames: 'data dataColor cursor cursorColor cursorColorAtZeroCrossings startIndex minVal maxVal cachedForm hasChanged' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Widgets'
I display a graph of numbers, normalized so the full range of values just fits my height. I support a movable cursor that can be dragged with the mouse.
Implementation notes: Some operations on me may be done at sound sampling rates (e.g. 11-44 thousand times/second). To allow such high bandwidth application, certain operations that change my appearance do not immediately report a damage rectangle. Instead, a flag is set indicating that my display needs to refreshed and a step method reports the damage rectangle if that flag is set. Also, I cache a bitmap of my graph to allow the cursor to be moved without redrawing the graph.
Senders of it:
BouncingAtomsMorph showInfectionHistory: {other}
SpectrumAnalyzerMorph showSignal {private}
SpectrumAnalyzerMorph showSpectrum {private}
SystemDictionary discardSoundSynthesis {shrinking}
WaveEditor initialize {initialization}
GraphPaperPanel (v5)
GenericPropertiesMorph subclass: #GraphPaperPanel instanceVariableNames: 'backgroundColor gridColor gridEvery showDarkerGridAlso darkerGridColor darkerGridEvery offset' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Experimental'
A panel for authoring "graph paper"
backgroundColor -- the color of the ground
gridColor -- the color of the fine lines
gridEvery -- number of pixels between fine grid lines.
darkerGridColor -- color of the secondary, less-frequently-drawn grid
darkerLineEvery -- number of primary grid units between darker grid lines
offset -- the offset of the InfiniteForm produced.
Senders of it:
ColorPickerMorph allowsTranslucency {event handling}
GraphPaperPanel class supplementaryPartsDescriptions {parts-bin}
Morph makeGraphPaper {e-toy support}
Morph putUpGraphPaperPanel {e-toy support}
GStreamerDisplayMorph
Morph subclass: #GStreamerDisplayMorph instanceVariableNames: 'frameBuffer gstreamer running desiredFrameRate repeat soundTrack volume stopFrame fullScreen pendingMoviePosition' classVariableNames: '' poolDictionaries: '' category: 'GStreamer-UI'
THIS CLASS HAS NO COMMENT!
Senders of it:
GStreamerMoviePlayerMorph initialize {initialization}
GStreamerMoviePlayerMorph
AlignmentMorph subclass: #GStreamerMoviePlayerMorph instanceVariableNames: 'moviePlayer positionSlider volumeSlider' classVariableNames: '' poolDictionaries: '' category: 'GStreamer-UI'
THIS CLASS HAS NO COMMENT!
Senders of it:
GStreamerDisplayMorph toggleFullScreen {menu}
GStreamerMoviePlayerMorph class registerInFlapsRegistry {class initialization}
HaloMorph
Morph subclass: #HaloMorph instanceVariableNames: 'target innerTarget positionOffset angleOffset minExtent growingOrRotating directionArrowAnchor haloBox simpleMode originalExtent' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
This morph provides a halo of handles for its target morph. Dragging, duplicating, rotating, and resizing to be done by mousing down on the appropriate handle. There are also handles for help and for a menu of infrequently used operations.
Senders of it:
Morph addHalo: {halos and balloon help}
Morph addMagicHaloFor: {halos and balloon help}
Morph haloClass {halos and balloon help}
PasteUpMorph abandonReplayHandsAndHalos {olpc}
PasteUpMorph abandonReplayHandsAndHalosFor: {olpc}
PasteUpMorph acceptDroppingMorph:event: {dropping/grabbing}
SelectionMorph selectSubmorphsOf: {private}
HandleMorph
EllipseMorph subclass: #HandleMorph instanceVariableNames: 'pointBlock lastPointBlock' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
A HandleMorph provides mouse-up control behavior.
Senders of it:
19 methods
HandMorph
Morph subclass: #HandMorph instanceVariableNames: 'mouseFocus keyboardFocus eventListeners mouseListeners keyboardListeners mouseClickState mouseOverHandler lastMouseEvent targetOffset damageRecorder cacheCanvas cachedCanvasHasHoles temporaryCursor temporaryCursorOffset hasChanged savedPatch userInitials lastEventBuffer genieGestureProcessor keyboardInterpreter modal' classVariableNames: 'CompositionWindowManager DoubleClickTime EventStats NewEventRules NormalCursor PasteBuffer ShowEvents' poolDictionaries: 'EventSensorConstants' category: 'Morphic-Kernel'
The cursor may be thought of as the HandMorph. The hand's submorphs hold anything being carried by dragging.
There is some minimal support for multiple hands in the same world.
Senders of it:
22 methods
HandMorphForReplay
HandMorph subclass: #HandMorphForReplay instanceVariableNames: 'recorder suspended' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-AdditionalSupport'
I am a hand for replaying events stored in an EventRecorderMorph. When there are no more events, I delete myself.
Senders of it:
EventRecorderMorph resumePlayIn: {pause/resume}
EventRecorderMorph userStopReplayMaybe: {pause/resume}
MentoringEventRecorder resumePlayIn: {pause/resume}
MentoringEventRecorder userStopReplayMaybe: {pause/resume}
Morph openInWorldOrWorldlet {initialization}
PasteUpMorph abandonReplayHandsAndHalos {olpc}
PasteUpMorph abandonReplayHandsAndHalosFor: {olpc}
HeadingMorph
RectangleMorph subclass: #HeadingMorph instanceVariableNames: 'degrees magnitude' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Demo'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no Users of HeadingMorph.
HelpFlap
AlignmentMorph subclass: #HelpFlap instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Help'
THIS CLASS HAS NO COMMENT!
Senders of it:
StandardScriptingSystem openInfoFlapWithLabel:helpContents:edge: {help in a flap}
HighlightMorph (v5)
Morph subclass: #HighlightMorph instanceVariableNames: 'target lastHash stepTime' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Debugger'
THIS CLASS HAS NO COMMENT!
Senders of it:
EtoysDebugger highlight: {highlighting}
HorizontalNumberLineMorph (v5)
NumberLineMorph subclass: #HorizontalNumberLineMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Charts'
A number line horizontally oriented.
Senders of it:
GraphPaperPanel class classicCartesianGraph {examples}
Player getXOnGraph {*morphicExtras-Charts}
Player setXOnGraph: {*morphicExtras-Charts}
HTTPProxyEditor
SystemWindow subclass: #HTTPProxyEditor instanceVariableNames: 'serverName port serverNameWidget portWidget serverNameLabelWidget portLabelWidget acceptWidget cancelWidget' classVariableNames: '' poolDictionaries: '' category: 'Network-UI'
An editor for the http proxy settings.
To open it evaluate:
HTTPProxyEditor open.
or use the World Menu (open... >> http proxy editor).
Senders of it:
HTTPProxyEditor class registerInOpenMenu {class initialization}
IconicButton
SimpleButtonMorph subclass: #IconicButton instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
A "Simple Button" in which the appearance is provided by a Form.
Senders of it:
23 methods
IconicButtonWithLabel
IconicButton subclass: #IconicButtonWithLabel instanceVariableNames: 'label labelMorph' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
PartsBin listDirection:quadList:withPreviousEntries: {initialization}
ImageMorph
Morph subclass: #ImageMorph instanceVariableNames: 'image' classVariableNames: 'DefaultForm' poolDictionaries: '' category: 'Morphic-Basic'
ImageMorph is a morph that displays a picture (Form). My extent is determined by the extent of my form.
Use #image: to set my picture.
Structure:
instance var Type Description
image Form The Form to use when drawing
Code examples:
ImageMorph new openInWorld; grabFromScreen
(Form fromFileNamed: 'myGraphicsFileName') asMorph openInWorld
Relationship to SketchMorph: ImageMorph should be favored over SketchMorph, a parallel, legacy class -- see the Swiki FAQ for details ( http://minnow.cc.gatech.edu/squeak/1372 ).
Senders of it:
55 methods
ImageMorphWithSpotlight
ImageMorph subclass: #ImageMorphWithSpotlight instanceVariableNames: 'spotImage spotShape spotBuffer spotOn' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Demo'
This class implements an image that appears one way or another depending upon whether it lies within a spotlight shape that moves with the cursor. As delivered, the shape is a simple circle, the spotlighted appearance is that of a ColorForm, and the non-highlighted apperarance is a derived gray-scale form.
The implementation will space-efficient if supplied with a ColorForm, because the gray-scale derived form will share the same bitmap.
In general, any two images can be used -- one could be blurred, the other sharp -- and the masking form can be any shape.
At some point this class should be merged somehow with ScreeningMorph.
Senders of it:
There are no senders of ImageMorphWithSpotlight.
IndentingListItemMorph
StringMorph subclass: #IndentingListItemMorph instanceVariableNames: 'indentLevel isExpanded complexContents firstChild container nextSibling' classVariableNames: '' poolDictionaries: '' category: 'Tools-Explorer'
An IndentingListItemMorph is a StringMorph that draws itself with an optional toggle at its left, as part of the display of the SimpleHierarchicalListMorph.
It will also display lines around the toggle if the #showLinesInHierarchyViews Preference is set.
Instance variables:
indentLevel <SmallInteger> the indent level, from 0 at the root and increasing by 1 at each level of the hierarchy.
isExpanded <Boolean> true if this item is expanded (showing its children)
complexContents <ListItemWrapper> an adapter wrapping my represented item that can answer its children, etc.
firstChild <IndentingListItemMorph|nil> my first child, or nil if none
container <SimpleHierarchicalListMorph> my container
nextSibling <IndentingListItemMorph|nil> the next item in the linked list of siblings, or nil if none.
Contributed by Bob Arning as part of the ObjectExplorer package.
Don't blame him if it's not perfect. We wanted to get it out for people to play with.
Senders of it:
SimpleHierarchicalListMorph indentingItemClass {initialization}
VeryPickyMorph justDroppedInto:event: {dropping/grabbing}
IndentingListParagraphMorph
IndentingListItemMorph subclass: #IndentingListParagraphMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Outliner'
THIS CLASS HAS NO COMMENT!
Senders of it:
EToyHierarchicalTextMorph indentingItemClass {as yet unclassified}
IndexTabs
PasteUpMorph subclass: #IndexTabs instanceVariableNames: 'highlightColor regularColor basicHeight basicWidth verticalPadding fixedWidth' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Palettes'
Used in conjunction wi[th a TabbedPalette -- each TabbedPalette has one. Each submorph of an IndexTabs is a TabMorph. When you click on one of the tabs, a corresponding action is taken -- sometimes, the existing palette gets replaced by the new one, other times, the tab results in some selector being invoked; in any case, tab highlighting takes place accordingly.
Senders of it:
ReferenceMorph setLabelFontTo: {menu}
ReferenceMorph tabSelected {events}
ReferenceMorph useGraphicalTab {menu}
ReferenceMorph useTextualTab {menu}
TabbedPalette initialize {initialization}
TabbedPalette newTabs: {initialization}
TabMorph tabSelected {as yet unclassified}
InfoStringMorph
StringMorph subclass: #InfoStringMorph instanceVariableNames: 'stepTime block' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Demo'
A generalization of the clock morph
Try
InfoStringMorph new openInWorld
or
(InfoStringMorph on: [Smalltalk vmParameterAt: 9])
stepTime: 50;
openInWorld
Senders of it:
There are no senders of InfoStringMorph.
InterimSoundMorph
RectangleMorph subclass: #InterimSoundMorph instanceVariableNames: 'graphic sound' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-SoundInterface'
THIS CLASS HAS NO COMMENT!
Senders of it:
RecordingControlsMorph makeTile {button commands}
InteriorFlapTab
FlapTab subclass: #InteriorFlapTab instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
A Flap Tab that clings to an edge of a PasteUpMorph that is not a World.
Senders of it:
EventRecordingSpace addNavigatorFlap {flaps}
EventRecordingSpace addSuppliesFlap {flaps}
InteriorSolidSugarSuppliesTab
InteriorFlapTab subclass: #InteriorSolidSugarSuppliesTab instanceVariableNames: 'sugarNavBar' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
A "solid" flap tab used in conjunction with the sugar supplies bin used on the interior of an event theatre.
Senders of it:
EventRecordingSpace sugarSuppliesFlapTab {sugar flaps}
InteriorSugarNavBar
SugarNavigatorBar subclass: #InteriorSugarNavBar instanceVariableNames: 'edgeToAdhereTo' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
Used for the "fake sugar navigator bar" that optionally appears at the top of an Event Theatre.
Senders of it:
EventRecordingSpace addSugarNavigatorFlap {flaps}
EventRecordingSpace removeSugarNavigatorFlap {sugar flaps}
EventRecordingSpace sugarNavBarOrNil {flaps}
EventRecordingSpace sugarNavigatorFlapOrNil {flaps}
InteriorSugarSuppliesTab
InteriorFlapTab subclass: #InteriorSugarSuppliesTab instanceVariableNames: 'sugarNavBar' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
DISUSED... Superseded by InteriorSolidSugarSuppliesTab. Retained for a while for backward compatability, in consideration of existing content.
A flap-tab for the the *fake* fake Sugar supplies flap at the top of an event-recording theatre or event-playback theatre.
Because this object cannot inherit both from InteriorFlapTab and from SugarSuppliesTab, it inherits only from the former, with code copied over from the latter as needed.
Senders of it:
There are no Users of InteriorSugarSuppliesTab.
InternalThreadNavigationMorph
ThreadNavigationMorph subclass: #InternalThreadNavigationMorph instanceVariableNames: 'threadName preferredIndex' classVariableNames: 'CachedThumbnails KnownThreads' poolDictionaries: '' category: 'MorphicExtras-Navigators'
THIS CLASS HAS NO COMMENT!
Senders of it:
BookMorph buildThreadOfProjects {menu}
InternalThreadNavigationMorph loadPageWithProgress {private}
Project makeThumbnail {menu messages}
ProjectHistory mostRecentThread {accessing}
ProjectSorterMorph clickFromSorterEvent:morph: {as yet unclassified}
ProjectSorterMorph sorterMorphForProjectNamed: {as yet unclassified}
JoystickMorph
SketchMorph subclass: #JoystickMorph instanceVariableNames: 'handleMorph xScale yScale radiusScale lastAngle autoCenter realJoystickIndex lastRealJoystickValue button1 button2' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
A widget that simulates a joystick. Mosly used in etoy scripting.
Senders of it:
EventRecordingSpace sugarPartsBinQuads {sugar flaps}
Flaps class defaultsQuadsDefiningPlugInSuppliesFlap {predefined flaps}
Flaps class defaultsQuadsDefiningScriptingFlap {flaps registry}
Flaps class defaultsQuadsDefiningSuppliesFlap {flaps registry}
Flaps class newLoneSuppliesFlap {predefined flaps}
JoystickMorph class registerInFlapsRegistry {class initialization}
NCAttachmentPointAdjusterWindow makeButtons {buttons}
KedamaCategoryViewer
CategoryViewer subclass: #KedamaCategoryViewer instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-StarSqueak'
THIS CLASS HAS NO COMMENT!
Senders of it:
KedamaStandardViewer categoryViewerFor: {categories}
KedamaStandardViewer replaceTargetsWithExampler {turtle view}
KedamaStandardViewer replaceTargetsWithStub {turtle view}
KedamaGetColorComponentTile
TileMorph subclass: #KedamaGetColorComponentTile instanceVariableNames: 'patchTile' classVariableNames: '' poolDictionaries: '' category: 'Etoys-StarSqueak'
I provide the red, green or blue component getter tile.
Senders of it:
PhraseTileMorph operatorNodeWith: {code generation}
PhraseTileMorph setGetColorComponentOperator:componentName:type:rcvrType:argType: {initialization}
PhraseTileMorph sexpOperatorWith: {code generation}
Viewer colorComponentPhraseFor: {special phrases}
KedamaMorph
Morph subclass: #KedamaMorph instanceVariableNames: 'dimensions wrapX wrapY pixelsPerPatch patchesToDisplay patchVarDisplayForm lastTurtleID turtleCount turtlesDict turtlesDictSemaphore turtlesToDisplay magnifiedDisplayForm autoChanged topEdgeMode bottomEdgeMode leftEdgeMode rightEdgeMode topEdgeModeMnemonic bottomEdgeModeMnemonic leftEdgeModeMnemonic rightEdgeModeMnemonic defaultPatch drawRequested changePending' classVariableNames: 'RandomSeed' poolDictionaries: '' category: 'Etoys-StarSqueak'
A tile-scriptable variant of StarSqueak.
Senders of it:
20 methods
KedamaPatchMorph
Morph subclass: #KedamaPatchMorph instanceVariableNames: 'form displayMax shiftAmount useLogDisplay displayForm diffusionRate scaledEvaporationRate sniffRange formChanged tmpForm displayType kedamaWorld changePending' classVariableNames: '' poolDictionaries: '' category: 'Etoys-StarSqueak'
I represent the patch variable.
Senders of it:
CategoryViewer isSpecialPatchCase:and: {support}
CategoryViewer isSpecialPatchReceiver:and: {support}
KedamaMorph defaultPatch {drawing}
KedamaPatchMorph class migrateInstancesWithoutChangePending {class initialization}
KedamaPatchType defaultArgumentTileFor: {tile protocol}
PhraseTileMorph replacePlayerWith: {kedama}
Player addPatchVarNamed: {slot-kedama}
Player newPatch {slot-kedama}
Player newPatchForSet {slot-kedama}
SyntaxMorph resultType {type checking}
TileCommandWithArgumentMorph setArgumentDefaultTo: {all}
TileMorph resultType {accessing}
TileMorph sexpWith: {code generation}
KedamaPatchTile
TileMorph subclass: #KedamaPatchTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-StarSqueak'
A special Tile that represents the Patch.
Senders of it:
KedamaPatchType defaultArgumentTileFor: {tile protocol}
PhraseTileMorph replacePlayerInReadoutWith: {kedama}
PhraseTileMorph replacePlayerWith: {kedama}
KedamaSetColorComponentTile
AssignmentTileMorph subclass: #KedamaSetColorComponentTile instanceVariableNames: 'patchTile' classVariableNames: '' poolDictionaries: '' category: 'Etoys-StarSqueak'
I provide the red, green or blue component setter tile.
Senders of it:
PhraseTileMorph setColorComponentRoot:componentName:type:rcvrType:argType:vocabulary: {initialization}
PhraseTileMorph updatingOperatorNodeWith: {code generation}
KedamaSetPixelValueTile
AssignmentTileMorph subclass: #KedamaSetPixelValueTile instanceVariableNames: 'patchTile' classVariableNames: '' poolDictionaries: '' category: 'Etoys-StarSqueak'
I provide the special tile of 'patchValueIn' setter.
Senders of it:
PhraseTileMorph setPixelValueRoot:type:rcvrType:argType:vocabulary: {initialization}
PhraseTileMorph updatingOperatorNodeWith: {code generation}
KedamaStandardViewer
StandardViewer subclass: #KedamaStandardViewer instanceVariableNames: 'stub restrictedIndex restrictedWho' classVariableNames: '' poolDictionaries: '' category: 'Etoys-StarSqueak'
THIS CLASS HAS NO COMMENT!
Senders of it:
KedamaWhoSearchingViewer doSearchFrom:interactive: {search}
Presenter nascentPartsViewerFor: {viewer}
Presenter updateViewer:forceToShow: {viewer}
KedamaTurtleMorph
Morph subclass: #KedamaTurtleMorph instanceVariableNames: 'kedamaWorld turtleCount isGroup' classVariableNames: '' poolDictionaries: '' category: 'Etoys-StarSqueak'
The exampler[sic] of turtles.
Senders of it:
CategoryViewer isSpecialPatchCase:and: {support}
KedamaPatchType defaultArgumentTileFor: {tile protocol}
Player newTurtle {slot-kedama}
Player newTurtleForSet {slot-kedama}
Player newTurtleSilently {slot-kedama}
KedamaWhoSearchingViewer
CategoryViewer subclass: #KedamaWhoSearchingViewer instanceVariableNames: 'searchString' classVariableNames: '' poolDictionaries: '' category: 'Etoys-StarSqueak'
THIS CLASS HAS NO COMMENT!
Senders of it:
KedamaStandardViewer categoryViewerFor: {categories}
KedamaStandardViewer searchingViewerMorphs {turtle view}
KeyboardEventMorph
EventMorph subclass: #KeyboardEventMorph instanceVariableNames: 'character' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
A morph representing a keyboard event.
Senders of it:
EventRollMorph setKeyboardEventMorphs {display}
EventRollMorph setKeystrokeEventMorphs {display}
EventTapeParser ambientTrack {accessing}
KeyboardMorphForInput
PianoKeyboardMorph subclass: #KeyboardMorphForInput instanceVariableNames: 'pianoRoll duration durationModifier articulation buildingChord insertMode prevSelection startOfNextNote numberOfKeys' classVariableNames: '' poolDictionaries: '' category: 'Sound-Scores'
This class adds state and controls to the basic PianoKeyboardMorph so that notes of reliable duration can be keyed into a score without the need for a real keyboard.
To try this out, execute...
| n score | n _ 3.
score _ (MIDIScore new tracks: ((1 to: n) collect: [:i | Array new]);
trackInfo: ((1 to: n) collect: [:i | 'Instrument' , i printString]);
tempoMap: nil; ticksPerQuarterNote: 96).
ScorePlayerMorph openOn: score title: 'empty score'
Then open a pianoRoll and, from that, open a keyboard. The rule is that the keyboard will append after the current selection. If the current selection is muted or nil, then input will go to the end of the first non-muted track.
Senders of it:
PianoRollScoreMorph addKeyboard {menu}
KeyPressMorph (v5)
Morph subclass: #KeyPressMorph instanceVariableNames: 'currentKey lastTimePressed isWaitingToSetCurrentKey' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Input'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of KeyPressMorph.
KidNavigationMorph
ProjectNavigationMorph subclass: #KidNavigationMorph instanceVariableNames: '' classVariableNames: 'PreExistingProjects' poolDictionaries: '' category: 'Morphic-Navigators'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no Users of KidNavigationMorph.
LanguageEditor (v4 but not v5)
SystemWindow subclass: #LanguageEditor instanceVariableNames: 'translator translations untranslated selectedTranslation selectedTranslations selectedUntranslated translationsList untranslatedList translationText translationsFilter untranslatedFilter newerKeys' classVariableNames: 'CheckMethods' poolDictionaries: '' category: 'Multilingual-Editor'
Editor for Babel's languages.
Open it from
World Menu >> open... >> Language Editor (to open on default language)
World Menu >> open... >> Language Editor for... (to choose the language)
Or click:
LanguageEditor openOnDefault.
LanguageEditor open.
See http://swiki.agro.uba.ar/small_land/191 for documentation
Senders of it:
There are no senders of LanguageEditor.
LassoPatchMorph
ImageMorph subclass: #LassoPatchMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Widgets'
When dropped by the user, a cursor is presented, allowing the user to grab a rectangular patch from the screen.
Senders of it:
Flaps class defaultsQuadsDefiningPlugInSuppliesFlap {predefined flaps}
LazyListMorph
Morph subclass: #LazyListMorph instanceVariableNames: 'listItems font selectedRow selectedRows listSource' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
The morph that displays the list in a PluggableListMorph. It is "lazy" because it will only request the list items that it actually needs to display.
Senders of it:
PluggableListMorph listMorphClass {as yet unclassified}
LedCharacterMorph
Morph subclass: #LedCharacterMorph instanceVariableNames: 'char highlighted' classVariableNames: 'BSegments CHSegmentOrigins CHSegments CVSegmentOrigins CVSegments DSegments TSegments' poolDictionaries: '' category: 'MorphicExtras-Leds'
char 36 is SPACE
Senders of it:
LedMorph chars: {accessing}
LedDigitMorph
Morph subclass: #LedDigitMorph instanceVariableNames: 'digit highlighted' classVariableNames: 'HSegmentOrigins HSegments VSegmentOrigins VSegments' poolDictionaries: '' category: 'MorphicExtras-Leds'
I am a 7-segment LED that can display a decimal digit
Senders of it:
LedMorph digits: {accessing}
LedMorph
Morph subclass: #LedMorph instanceVariableNames: 'digits chars value flashing flash string scroller scrollLoop' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Leds'
I am a collection of LED digits that can display a decimal value. The display can be set to flash by sending flash: true.
LedMorph can now display characters:
LedMorph new string:'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'; openInWorld
Lowercase letters will be converted to Uppercase. Carachters not in the examle
above will be shown as SPACE which is char 36 in LedCharacterMorph.
LedMorph new chars: 10; string:' I must get a life';flash:true;scrollLoop:true; openInWorld
The number of letters is set by chars.
If chars is not specified it will be set to the string size.
When the string size is bigger than chars
the string will scroll across the led. WOW!
scrollLoop let's you set the scrolling to start over once its finished.
Enjoy.
Senders of it:
FreeCell makeCardsRemainingDisplay {initialization}
FreeCell makeGameNumberDisplay {initialization}
Mines makeControls {initialize}
SameGame makeControls {initialization}
Tetris showScoreDisplay {initialization}
LedTimerMorph
LedMorph subclass: #LedTimerMorph instanceVariableNames: 'counting startSeconds' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Leds'
THIS CLASS HAS NO COMMENT!
Senders of it:
FreeCell makeElapsedTimeDisplay {initialization}
Mines makeControls {initialize}
LineMorph
PolygonMorph subclass: #LineMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Basic'
This is really only a shell for creating single-segment straight-line Shapes.
Senders of it:
BorderedMorph changeBorderWidth: {menu}
DrGIcons class segmentMorph:color:dash: {form}
FlexMorph changeBorderWidth: {as yet unclassified}
HaloMorph addDirectionHandles {private}
NCAAConnectorMorph changeBorderWidthInteractively: {menus}
NCAAConnectorMorph changeLineWidthInteractively: {menus}
NCLineMorph changeArrowScaleInteractively: {arrows}
PolygonMorph customizeArrows: {menu}
PolygonMorph class fromHandFreehand: {instance creation}
PolygonMorph class fromHand: {instance creation}
TextMorph changeMargins: {menu}
TransferMorphLineAnimation initPolygon {initialization}
ListComponent
PluggableListMorph subclass: #ListComponent instanceVariableNames: 'selectedItem setSelectionSelector' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Components'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no Users of ListComponent.
ListViewLine
ObjectRepresentativeMorph subclass: #ListViewLine instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
THIS CLASS HAS NO COMMENT!
Senders of it:
Morph listViewLineForFieldList: {*Etoys-support}
MagnifierMorph
BorderedMorph subclass: #MagnifierMorph instanceVariableNames: 'magnification trackPointer srcExtent showPointer roundness' classVariableNames: 'RecursionLock' poolDictionaries: '' category: 'MorphicExtras-Demo'
MagnifierMorph instances are magnifying lenses that magnify the morphs below them (if grabbed or if trackPointer is false) or the area around the mouse pointer.
Instance variables:
magnification <Number> The magnification to use. If non-integer, smooths the magnified form.
trackPointer <Boolean> If set, magnifies the area around the Hand. If not, magnfies the area underneath the magnifier center.
showPointer <Boolean> If set, display a small reversed rectangle in the center of the lens. Also enables the display of Morphs in the Hand itself.
srcExtent <Rectangle> The extent of the source rectangle.
Class variables:
RecursionLock <MagnifierMorph|nil> Used to avoid infinite recursion when getting the source patch to display.
Senders of it:
Flaps class defaultsQuadsDefiningWidgetsFlap {flaps registry}
Flaps class newLoneSuppliesFlap {predefined flaps}
MagnifierMorph class registerInFlapsRegistry {class initialization}
MagnifierMorph class supplementaryPartsDescriptions {parts bin}
MarqueeMorph
Morph subclass: #MatrixTransformMorph instanceVariableNames: 'transform' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Balloon'
MatrixTransformMorph is similar to TransformMorph but uses a MatrixTransform2x3 instead of a MorphicTransform. It is used by clients who want use the BalloonEngine for vector-based scaling instead of the standard WarpBlt pixel-based mechanism.
Senders of it:
BalloonRectangleMorphnewTransformationMorph
TTSampleFontMorph newTransformationMorph
MatrixTransformMorph
Morph subclass: #MatrixTransformMorph instanceVariableNames: 'transform' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Balloon'
MatrixTransformMorph is similar to TransformMorph but uses a MatrixTransform2x3 instead of a MorphicTransform. It is used by clients who want use the BalloonEngine for vector-based scaling instead of the standard WarpBlt pixel-based mechanism.
Senders of it:
BalloonRectangleMorph newTransformationMorph {rotate scale and flex}
TTSampleFontMorph newTransformationMorph {rotate scale and flex}
MediaEventMorph
EventMorph subclass: #MediaEventMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
An EventMorph representing a media event, such as the playing of a sound or a movie clip.
Senders of it:
EventRollMorph setMediaEventMorphs {display}
MentoringEventRecorder
EventRecorderMorph subclass: #MentoringEventRecorder instanceVariableNames: 'recordingSpace startPlaybackTime millisecondsIntoPlayback' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
A custom subclass of the EventRecorderMorph used within the olpc mentoring system. The event theatre's "state" constitutes the state for the MentoringEventRecorder itself as well. These are not the same states that are used by the vanilla EventRcorderMorph superclass.
The states are:
readyToRecord No recording ever made
rewound After a rewind. Not recording, not playing
atEndOfPlayback After a playback Not recording, not playing
recordingWithSound Currently making primary recording, with sound
recording Currenty making primary recoring, sans sound
playback Amid playback
playbackAddingVoiceover Recording a voiceover while while playing back
suspendedPlayback User hit Pause while doing playback
Senders of it:
EventPlaybackButton durationInMilliseconds {accessing}
EventRecordingSpace initialize {initialization}
Morph openInWorldOrWorldlet {initialization}
MenuItemMorph
StringMorph subclass: #MenuItemMorph instanceVariableNames: 'isEnabled subMenu isSelected target selector arguments icon extraIcon' classVariableNames: 'SubMenuMarker' poolDictionaries: '' category: 'Morphic-Menus'
I represent an item in a menu.
Instance variables:
isEnabled <Boolean> True if the menu item can be executed.
subMenu <MenuMorph | nil> The submenu to activate automatically when the user mouses over the item.
isSelected <Boolean> True if the item is currently selected.
target <Object> The target of the associated action.
selector <Symbol> The associated action.
arguments <Array> The arguments for the associated action.
icon <Form | nil> An optional icon form to be displayed to my left.
If I have a dynamic marker, created by strings like <yes> or <no> in my contents, it will be installed as a submorph.
Senders of it:
MenuItemMorph deselectItem {private}
MenuMorph add:subMenu: {construction}
MenuMorph add:subMenu:target:selector:argumentList: {construction}
MenuMorph add:target:selector:argumentList: {construction}
MenuMorph deleteIfPopUp {control}
MenuMorph detachSubMenu: {menu}
MenuMorph displayFiltered: {keyboard control}
MenuMorph doButtonAction {menu}
MenuMorph items {accessing}
MenuMorph lastItem {accessing}
MenuMorph moveSelectionDown:event: {keyboard control}
NCConstraintMorph selectShapeMenu {menus}
PasteUpMorph actionButtonsDo: {e-toy support}
SugarNavigatorBar shareMenu {the actions}
TabSorterMorph acceptSort {as yet unclassified}
MenuLineMorph
Morph subclass: #MenuLineMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Menus'
THIS CLASS HAS NO COMMENT!
Senders of it:
MenuMorph addLine {construction}
TabSorterMorph acceptSort {as yet unclassified}
MenuMorph
AlignmentMorph subclass: #MenuMorph instanceVariableNames: 'defaultTarget selectedItem stayUp popUpOwner activeSubMenu' classVariableNames: 'CloseBoxImage PushPinImage' poolDictionaries: '' category: 'Morphic-Menus'
Instance variables:
defaultTarget <Object> The default target for creating menu items
selectedItem <MenuItemMorph> The currently selected item in the receiver
stayUp <Boolean> True if the receiver should stay up after clicks
popUpOwner <MenuItemMorph> The menu item that automatically invoked the receiver, if any.
activeSubMenu <MenuMorph> The currently active submenu.
Senders of it:
202 methods
MenuTile
TileMorph subclass: #MenuTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
A tile representing a menu item
Senders of it:
MenuType defaultArgumentTile {*Etoys-tiles}
ScriptEditorMorphBuilder literal: {reconstituting scripting tiles }
MethodMorph
PluggableTextMorph subclass: #MethodMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
THIS CLASS HAS NO COMMENT!
Senders of it:
BookMorph installRollBackButtons {scripting}
BookMorph methodHolders {scripting}
MethodHolder doItReceiver {menu}
MethodHolder class isolatedCodePaneForClass:selector: {instance creation}
ScriptEditorMorph methodNode {customevents-buttons}
ScriptEditorMorph methodString {other}
ScriptEditorMorph renameScriptTo: {other}
MIDIControllerMorph
AlignmentMorph subclass: #MIDIControllerMorph instanceVariableNames: 'channel controller midiPort lastValue' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-SoundInterface'
THIS CLASS HAS NO COMMENT!
Senders of it:
MIDIPianoKeyboardMorph makeMIDIController: {as yet unclassified}
ScorePlayerMorph makeMIDIController: {layout}
MIDIPianoKeyboardMorph
PianoKeyboardMorph subclass: #MIDIPianoKeyboardMorph instanceVariableNames: 'midiPort channel velocity' classVariableNames: '' poolDictionaries: '' category: 'Sound-Interface'
I implement a piano keyboard that can be played with the mouse. I can output to a MIDI port, if MIDI is supported on this platform. I can also spawn controllers for other MIDI parameters, such as pitch bend.
Senders of it:
There are no senders of MIDIPianoKeyboardMorph.
MidiInputMorph
AlignmentMorph subclass: #MidiInputMorph instanceVariableNames: 'midiPortNumber midiSynth instrumentSelector' classVariableNames: '' poolDictionaries: '' category: 'Sound-Scores'
I am the user interface for a simple software MIDI synthesizer that is driven by external MIDI input. I come with controls for a single MIDI channel (channel 1), but allow channel controls for additional MIDI channels to be added by the user. The volume, pan, and instrument of each channel can be controlled independently.
Senders of it:
There are no senders of MidiInputMorph.
Mines
AlignmentMorph subclass: #Mines instanceVariableNames: 'board minesDisplay timeDisplay helpText' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Games'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of Mines.
MinesBoard
AlignmentMorph subclass: #MinesBoard instanceVariableNames: 'protoTile rows columns flashCount tileCount target actionSelector arguments gameStart gameOver' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Games'
THIS CLASS HAS NO COMMENT!
Senders of it:
Mines board {access}
MinesTile
SimpleSwitchMorph subclass: #MinesTile instanceVariableNames: 'switchState disabled oldSwitchState isMine nearMines palette mineFlag' classVariableNames: 'PreferredColor' poolDictionaries: '' category: 'Morphic-Games'
THIS CLASS HAS NO COMMENT!
Senders of it:
MinesBoard protoTile {accessing}
ModifyVariableDialogMorph (v5)
NewVariableDialogMorph subclass: #ModifyVariableDialogMorph instanceVariableNames: 'slot' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
THIS CLASS HAS NO COMMENT!
Senders of it:
Player changeSlotInfo: {slots-user}
MonthMorph
AlignmentMorph subclass: #MonthMorph instanceVariableNames: 'month todayCache tileRect model' classVariableNames: '' poolDictionaries: '' category: 'Morphic-PDA'
A widget that displays the dates of a month in a table.
Senders of it:
PDA openAsMorphIn: {initialization}
PDA openMonthView {initialization}
Morph
Object subclass: #Morph instanceVariableNames: 'bounds owner submorphs fullBounds color extension' classVariableNames: 'EmptyArray' poolDictionaries: '' category: 'Morphic-Kernel'
A Morph (from the Greek "shape" or "form") is an interactive graphical object. General information on the Morphic system can be found at http://minnow.cc.gatech.edu/squeak/30.
Morphs exist in a tree, rooted at a World (generally a PasteUpMorph). The morphs owned by a morph are its submorphs. Morphs are drawn recursively; if a Morph has no owner it never gets drawn. To hide a Morph and its submorphs, set its #visible property to false using the #visible: method.
The World (screen) coordinate system is used for most coordinates, but can be changed if there is a TransformMorph somewhere in the owner chain.
My instance variables have accessor methods (e.g., #bounds, #bounds:). Most users should use the accessor methods instead of using the instance variables directly.
Structure:
instance var Type Description
bounds Rectangle A Rectangle indicating my position and a size that will enclose me.
owner Morph My parent Morph, or nil for the top-level Morph, which is a
or nil world, typically a PasteUpMorph.
submorphs Array My child Morphs.
fullBounds Rectangle A Rectangle minimally enclosing me and my submorphs.
color Color My primary color. Subclasses can use this in different ways.
extension MorphExtension Allows extra properties to be stored without adding a
or nil storage burden to all morphs.
By default, Morphs do not position their submorphs. Morphs may position their submorphs directly or use a LayoutPolicy to automatically control their submorph positioning.
Although Morph has some support for BorderStyle, most users should use BorderedMorph if they want borders.
Senders of it:
150 methods
MorphExample
RectangleMorph subclass: #MorphExample instanceVariableNames: 'phase ball star' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Demo'
This is a example of how to use a morph. It consists of only two
methods, initialize and step.
DoIt:
MorphExample new openInWorld.
Senders of it:
There are no senders of MorphExample.
MorphicModel
BorderedMorph subclass: #MorphicModel instanceVariableNames: 'model slotName open' classVariableNames: 'TimeOfError' poolDictionaries: '' category: 'Morphic-Kernel'
MorphicModels are used to represent structures with state and behavior as well as graphical structure. A morphicModel is usually the root of a morphic tree depicting its appearance. The tree is constructed concretely by adding its consituent morphs to a world.
When a part is named in a world, it is given a new slot in the model. When a part is sensitized, it is named, and a set of mouse-driven methods is also generated in the model. These may be edited to induce particular behavior. When a variable is added through the morphic world, it is given a slot in the model, along with a set of access methods.
In addition for public variables (and this is the default for now), methods are generated and called in any outer model in which this model gets embedded, thus propagating variable changes outward.
Senders of it:
MorphicModel nameFor: {compilation}
MorphicModel removeAll {compilation}
MorphicModel class acceptsLoggingOfCompilation {compiling}
MorphicModel class officialClass {testing}
MorphicModel class removeUninstantiatedModels {housekeeping}
MorphicModel class wantsChangeSetLogging {compiling}
PasteUpMorph createCustomModel {model}
SystemDictionary majorShrink {shrinking}
MorphThumbnail
SketchMorph subclass: #MorphThumbnail instanceVariableNames: 'morphRepresented' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Books'
A morph whose appearance is a thumbnail of some other morph.
Senders of it:
Morph representativeNoTallerThan:norWiderThan:thumbnailHeight: {thumbnail}
MorphThumbnail representativeNoTallerThan:norWiderThan:thumbnailHeight: {thumbnail}
PasteUpMorph morphToDropFrom: {dropping/grabbing}
PasteUpMorph updateSubmorphThumbnails {*Etoys-viewing}
MouseActionIndicatorMorph
Morph subclass: #MouseActionIndicatorMorph instanceVariableNames: 'siblings' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
I am used to highlight morphs which have a special mouseup action
Senders of it:
There are no senders of MouseActionIndicatorMorph.
MouseEventEditor
PasteUpMorph subclass: #MouseEventEditor instanceVariableNames: 'mouseEventSequenceMorph' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
A nascent graphical editor for the mouse events constituting a mouse-event sequence. This is just a beginning -- there is no UI yet for propagating the results of edits back to the originating mouse-event sequence.
Senders of it:
MouseEventSequenceMorph openExpandedView {menu}
MouseEventSequenceMorph openExpandedView: {menu}
MouseEventSequenceMorph
EventMorph subclass: #MouseEventSequenceMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
A morph representing a related sequence of mouse events.
Senders of it:
EventRollMorph setMouseEventMorphs {display}
EventTimeline acceptDroppingMorph:event: {dropping/grabbing}
MouseEventToken
EllipseMorph subclass: #MouseEventToken instanceVariableNames: 'index event' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
A token representing a single mouse event. Used in mouse-event sequence editors.
Senders of it:
MouseEventEditor discRepresentingEvent:index: {initialization}
MovieClipEndMorph
MovieClipStartMorph subclass: #MovieClipEndMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Movies-Player'
The idea is that soon we will show the soundtrack extending between the start cue and the end morph.
Senders of it:
MovieClipStartMorph setEndFrameNumber:tickTime: {private}
MovieClipStartMorph
MovieFrameSyncMorph subclass: #MovieClipStartMorph instanceVariableNames: 'movieClipPlayer movieClipFileName soundTrackFileName soundTrackPlayerReady soundTrackMorph soundTrackTimeScale scoreEvent endMorph clipColor colorMorph' classVariableNames: '' poolDictionaries: '' category: 'Movies-Player'
This class and its subclasses act to syncronize movie players with the progress of a MIDI score and further background can be found in the comment for MoviePlayerMorph.
MovieClipStartMorphs are used where you have a movie clip player plex. You can create such a plex by opening a midi score, spawning a piano roll (by the button of that name), and then choosing 'add movie clip player' from the piano roll menu. Much simpler, you can open a MoviePlayerMorph as a new morph, and then choose 'make a new movie' from its menu. This plex then serves as a central editable score for composing movie clips.
To add a new movie clip to the score, open a movie from the fileList (or as a new morph followed by 'open a movie'). Play or otherwise position the clip to the desired starting position, and then tear off a thumbnail and drop it into the score at the desired time. The starting thumbnail (MovieClipStartMorph) will appear in the score, tied to an endMorph by a colored stripe. The ending time will be chosen based on the total length of the clip, a default starting clip length (200 frames), and possible interference with other clips that follow it.
To reposition a clip, you can pick up its clipStart with halo black handle, and drop it elsewhere. The rest of the clip will follow as best it can. To delete a clip, delete its clipStart. To change the duration of a clip, play the composition up to some point in that clip, and pause it. Then use the controls on the central movie player to move forward or backward to the desired ending frame, and choose 'end clip here' from the player menu.
Senders of it:
MoviePlayerMorph makeThumbnailInHand: {private}
MovieFrameSyncMorph
ImageMorph subclass: #MovieFrameSyncMorph instanceVariableNames: 'moviePlayerMorph frameNumber' classVariableNames: 'ColorIndex' poolDictionaries: '' category: 'Movies-Player'
This class and its subclasses act to syncronize[sic] movie players with the progress of a MIDI score and further background can be found in the comment for MoviePlayerMorph.
There are two main forms of synchroniztion.[sic]
MovieFrameSyncMorphs are used where you have a MIDI score open with a piano roll, and a separate MoviePlayer Morph. A MovieFrameSyncMorph can be torn off from the MoviePlayer with a shift-drag gesture or menu command, and can then be dropped into a MIDI score. They are used to start a movie player at a given place in the score, and then to stretch or compress the movie frame rate so that certain frames are synchronized with the corresponding points in the score.
MovieClipStartMorphs (q.v.) and MovieClipEndMorphs are used for the other kind of synchronization, namely where you wish to assemble a number of movie clips in a sequence.
Senders of it:
MovieClipStartMorph justDroppedInto:event: {dropping/grabbing}
MovieFrameSyncMorph justDroppedInto:event: {dropping/grabbing}
MovieMorph
Morph subclass: #MovieMorph instanceVariableNames: 'playMode msecsPerFrame rotationDegrees scalePoint frameList currentFrameIndex dwellCount' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Basic'
THIS CLASS HAS NO COMMENT!
Senders of it:
Morph addPaintingItemsTo:hand: {menus}
MovieMorph addCustomMenuItems:hand: {menu}
MovieMorph insertIntoMovie: {menu}
SketchMorph insertIntoMovie: {menu}
SketchMorph replaceSelfWithMovie {other}
MoviePlayerMorph
BookMorph subclass: #MoviePlayerMorph instanceVariableNames: 'movieFileName movieFile frameSize frameDepth frameNumber frameCount playDirection msSinceStart msAtStart msAtLastSync frameAtLastSync msPerFrame frameBufferIfScaled soundTrackFileName scorePlayer soundTrackForm soundTrackMorph pianoRoll cueMorph' classVariableNames: '' poolDictionaries: '' category: 'Movies-Player'
MoviePlayerMorph plays images from a file using async io. The file format is simple but non-standard (see below).
The heart of the play logic is in the step method. Note that play is driven by a simulated time since start. For a movie with a sound score, this is the millisecondsSinceStart of the score player, whereas a movie by itself gets this from the millisecondClock minus msAtStart.
Movie players are designed to be used in three ways
1. Select a movie in the file list, 'open as movie', and play it.
2. As in (1), but drop thumbnails for various frames into a
MIDI piano roll to synchronize video with music.
3. Open a MoviePlayerMorph as a 'new morph', and choose
'make a new movie' from the menu.
In (1) and (2), a shift-drag is used to 'tear off' a thumbnail reference morph to the currently visible frame of this clips. The thumbnail can then be dropped in a MIDI score player to either syncronize that frame with what point in the music, or to cause that clip to being playing in the shared player of a SqueakMovie plex.
When making a new movie, an empty score and piano roll are linked to the movie player, as a SqueakMovie plex. You can then open another movie as a clip, and drop a thumbnail morph into the score to start that clip playing at that frame in the shared player. If you pause while playing that clip, you can manually play the clip forward and backward in the current clip. if you stop at a given frame, you can choose 'end clip here' from the shared player menu to shorten or lengthen the clip.
Clips can be moved by picking up the starting thumbnail (use halo black handle), and dropping them elsewhere. If you try to place one clip in the middle of another, it will slide to the end. If you position one clip close to the end of another, it will sidle up to make them contiguous.
If you wish a soundtrack to be included with a clip, make sure it has been opened in the source clip player before tearing off the starting thumbnail.
About the .movie file format...
The following code was used to convert 27 files into a movie. They were named
'BalloonDrop10fps003.bmp' through 'BalloonDrop10fps081.bmp'
incrementing by 003. Each was known to be a 320x240 image in 32-bit BMP format.
Note the 27 in the 5th line is the number of frames, = (3 to: 81 by: 3) size.
| ps zps f32 out ff |
out _ FileStream newFileNamed: 'BalloonDrop10fps.movie'.
out binary.
ff _ Form extent: 320@240 depth: 16.
#(22 320 240 16 27 100000) , (7 to: 32)
do: [:i | out nextInt32Put: i].
3 to: 81 by: 3 do:
[:i | ps _ i printString. zps _ ps padded: #left to: 3 with: $0.
f32 _ Form fromFileNamed:
'BalloonDrop10fps' , zps , '.bmp'.
f32 displayOn: ff at: 0@0. "Convert down to 16 bits"
ff display; writeOnMovie: out].
out close.
Senders of it:
FileList class initialize {class initialization}
PianoRollScoreMorph addMovieClipPlayer {*movies}
MovingEyeMorph
EllipseMorph subclass: #MovingEyeMorph instanceVariableNames: 'inner iris' classVariableNames: 'IrisSize' poolDictionaries: '' category: 'Morphic-Demo'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of MovingEyeMorph.
MPEGDisplayMorph
Morph subclass: #MPEGDisplayMorph instanceVariableNames: 'frameBuffer mpegFile running desiredFrameRate allowFrameDropping repeat soundTrack volume startMSecs startFrame stopFrame subtitles fullScreen subtitlesDisplayer' classVariableNames: '' poolDictionaries: '' category: 'Movies-Player'
I am a simple display screen for an MPEG movie player. My step method advances the movie according to the current frame rate. If necessary, frames as skipped to maintain the desired frame rate. However, since even skipping frames takes time, it may not be possible to achieve fast frame rates with large frame sizes on slow machines.
Senders of it:
MPEGMoviePlayerMorph initialize {initialization}
MPEGMoviePlayerMorph
AlignmentMorph subclass: #MPEGMoviePlayerMorph instanceVariableNames: 'moviePlayer positionSlider volumeSlider' classVariableNames: '' poolDictionaries: '' category: 'Movies-Player'
I provide the user-interface for playing MPEG movies, including play/stop/rewind buttons and volume and position sliders. To create an instance of me, evaluate:
MPEGMoviePlayerMorph new openInWorld
Then use the "open" button to open an MPEG movie file. This class supplies the front panel; the real work is done by MPEGDisplayMorph and StreamingMP3Sound.
Senders of it:
FileList class initialize {class initialization}
Flaps class defaultsQuadsDefiningWidgetsFlap {flaps registry}
MPEGDisplayMorph toggleFullScreen {menu}
MPEGMoviePlayerMorph class registerInFlapsRegistry {class initialization}
MPEGSubtitlesDisplayer
UpdatingTextMorph subclass: #MPEGSubtitlesDisplayer instanceVariableNames: 'font' classVariableNames: '' poolDictionaries: '' category: 'Movies-Player'
THIS CLASS HAS NO COMMENT!
Senders of it:
MPEGDisplayMorph initializeSubtitlesDisplayer {private}
MulticolumnLazyListMorph
LazyListMorph subclass: #MulticolumnLazyListMorph instanceVariableNames: 'columnWidths' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
A variant of LazyListMorph that can display multi-column lists.
Senders of it:
PluggableMultiColumnListMorph listMorphClass {accessing}
MultiuserTinyPaint
SketchMorph subclass: #MultiuserTinyPaint instanceVariableNames: 'drawState' classVariableNames: 'LastMouseIndex PenColorIndex PenIndex PenSizeIndex' poolDictionaries: '' category: 'Morphic-Widgets'
A very simple paint program that handles multiple users (hands).
Each user has their own brush size and color.
Senders of it:
There are no senders of MultiuserTinyPaint.
MVCMenuMorph
MenuMorph subclass: #MVCMenuMorph instanceVariableNames: 'done mvcSelection' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Menus'
I simulate the MVC menu classes PopUpMenu, SelectionMenu, and CustomMenu when running in a Morphic world. I am also used to implement Utilities>informUser:during:.
Senders of it:
Flaps class addLocalFlap {new flap}
MoviePlayerMorph invokeBookMenu {menu}
PartsWindow invokePartsWindowMenu {as yet unclassified}
PopUpMenu startUpWithCaption:at:allowKeyboard: {basic control sequence}
PopUpMenu startUpWithCaption:at:allowKeyboard:centered: {basic control sequence}
SecurityManager generateKeyPairInBackground {private}
Utilities class informUserDuring: {user interface}
Utilities class informUser:during: {user interface}
MVCWiWPasteUpMorph
WiWPasteUpMorph subclass: #MVCWiWPasteUpMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'ST80-Morphic'
A subclass of WiWPasteUpMorph that supports Morphic worlds embedded in MVC Views.
Senders of it:
Model containingWindow {dependents}
Morph containingWindow {e-toy support}
MorphWorldView class convertToMVCWiWPasteUpMorph {instance creation}
MorphWorldView class openWorld {instance creation}
MorphWorldView class openWorldWith:labelled: {instance creation}
Object currentWorld {macpal}
Preferences class windowSpecificationPanel {window colors}
PreferencesPanel class isAPreferenceViewToKill: {cleanup}
Utilities class windowMenuWithLabels:colorPattern:targets:selections:title: {durable menus}
Utilities class windowMenuWithLabels:colorPattern:targets:selections:wordingSelectors:title: {durable menus}
NameStringInHalo
UpdatingStringMorph subclass: #NameStringInHalo instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
Shows the name of the morph in the halo.
Senders of it:
HaloMorph acceptNameEdit {initialization}
HaloMorph addNameBeneath:string: {private}
NCAAConnectorMorph
QHsmMorph subclass: #NCAAConnectorMorph instanceVariableNames: 'constraints line graphModel' classVariableNames: 'ArrowGlyphs' poolDictionaries: '' category: 'Connectors-Base'
This is the Anti-Aliased ConnectorMorph, part of Connectors2.
Senders of it:
Senders of NCAAConnectorMorph [13]
ConnectorArrowNameType choices {queries}
ConnectorArrowNameType initialize {initialization}
Flaps class quadsDefiningClassDiagramConnectorsFlap {*connectors-shapes-flaps}
Flaps class quadsDefiningConnectorsFlap {*connectors-shapes-flaps}
Flaps class quadsDefiningFSMConnectorsFlap {*connectors-shapes-flaps}
NCAAConnectorMorph class supplementaryPartsDescriptions {new-morph participation}
NCArrowDictionaryMenu glyphDictionary {accessing}
NCButtonBar class newClassDiagramToolbar {instance creation}
NCButtonBar class newFSMToolbar {instance creation}
NCClassHierarchyDiagrammer connectParentFor:morph: {drawing}
NCClassHierarchyDiagrammer connectSubclassesFor:morph: {drawing}
NCGlyphEditor install {button actions}
PasteUpMorph defaultConnectorClass {*connectors-misc}
Implements the following costumes in its class methods:
- Association (not in Object Catalog), a connector with no arrows
- newCurvyArrow method: Curvy Arrow (Graphics category)
- newCurvyConnector method: Curvy Connector (Connectors category)
- newDirectionalAssociation (not in Object Catalog), a connector with an arrow
- newGeneralizationRelationship method: Generalization (not in Object Catalog), a connector with a hollow arrowhead for UML
- newMakerButton method: Maker Button (Connectors category)
- newNoteConnector method: NoteConnector (not in Object Catalog)
- newRandomButton method: Random Connectors (Connectors category)
- newStateTransition
- newWithArrow method: Arrow (not in Object Catalog; provided by clicking Connector Button, which is in the Connectors category)
NCAAConnectorMorph newAssociation openInHand. NCAAConnectorMorph newCurvyArrow openInHand. NCAAConnectorMorph newCurvyConnector openInHand. NCAAConnectorMorph newDirectionalAssociation openInHand. NCAAConnectorMorph newGeneralizationRelationship openInHand. NCAAConnectorMorph newImplementationRelationship openInHand. NCAAConnectorMorph newMakerButton openInHand. NCAAConnectorMorph newNoteConnector openInHand. NCAAConnectorMorph newRandomButton openInHand. NCAAConnectorMorph newStateTransition openInHand. NCAAConnectorMorph newWithArrow openInHand.
NCArrowDictionaryMenu
GraphicalDictionaryMenu subclass: #NCArrowDictionaryMenu instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Tools'
THIS CLASS HAS NO COMMENT!
Senders of it:
NCAAConnectorMorph chooseArrowGlyphFor: {menus}
NCAAConnectorMorph class chooseArrowGlyphFor:selector:argument: {arrows}
NCAttachmentPointAdjuster
GraphicalDictionaryMenu subclass: #NCArrowDictionaryMenu instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Tools'
THIS CLASS HAS NO COMMENT!
Senders of it:
NCAAConnectorMorph chooseArrowGlyphFor: {menus}
NCAAConnectorMorph class chooseArrowGlyphFor:selector:argument: {arrows}
Attachment Adjuster is implemented in this NCAttachmentPointAdjuster class.
NCAttachmentPointAdjusterWindow
PasteUpMorph subclass: #NCAttachmentPointAdjusterWindow instanceVariableNames: 'joystick originalPosition target' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Tools'
This is a tool that allows you to adjust the attachment points of a dropped Morph.
There are two buttons: one turns the grid on or off, and the other selects between movable and non-movable attachment points. The difference is that if a Connector with not attachment preference is attached to a Morph with non-movable attachment points, the attachment will remain stuck to that position.
This is appropriate for (for instance) schematic drawings.
Senders of it:
Flaps class quadsDefiningConnectorsFlap {*connectors-shapes-flaps}
NCAttachmentPointAdjuster justDroppedInto:event: {stepping and presenter}
NCBasicEllipseMorph
EllipseMorph subclass: #NCBasicEllipseMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Shapes'
This adds a standard yellow-button menu to EllipseMorph.
Senders of it:
There are no senders of NCBasicEllipseMorph.
NCBasicShapeMorph
EllipseMorph subclass: #NCBasicEllipseMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Shapes'
This adds a standard yellow-button menu to EllipseMorph.
Senders of it:
There are no senders of NCBasicShapeMorph.
NCBroomMorph
BroomMorph subclass: #NCBroomMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'BroomMorphs-Connectors'
This is a BroomMorph that won't move labels or connectors.
Senders of it:
NCBroomMorph basicClass {initialization}
NCButtonBar
AlignmentMorph subclass: #NCButtonBar instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Tools'
I am a general purpose toolbar that usually holds buttons of some kind, especially NCMakerButtons.
Senders of it:
Flaps class quadsDefiningConnectorsFlap {*connectors-shapes-flaps}
NCButtonBar class supplementaryPartsDescriptions {instance creation}
NCMakerButton handlesMouseDown: {menus}
NCCircleMorph
NCEllipseMorph subclass: #NCCircleMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Shapes'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of NCCircleMorph.
NCCompositeStateMorph
NCBasicShapeMorph subclass: #NCCompositeStateMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Shapes'
I am a shape intended as a container for other Morphs.
Senders of it:
Flaps class quadsDefiningClassDiagramConnectorsFlap {*connectors-shapes-flaps}
Flaps class quadsDefiningFSMConnectorsFlap {*connectors-shapes-flaps}
NCButtonBar class newClassDiagramToolbar {instance creation}
NCButtonBar class newFSMToolbar {instance creation}
NCCompositeStateMorph class supplementaryPartsDescriptions {instance creation}
NCStateDiagramMorph becomeComposite {menus}
NCConstraintMorph
Morph subclass: #NCConstraintMorph instanceVariableNames: 'constrained constraint dieWithInput inputs lastTarget stepTime lastTargetBounds' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Base'
I apply the result of a pluggable MessageSend to some inputs, and then
take the value of that MessageSend and apply it to some other object.
Typically the result of the MessageSend is a Point, and I constrain the other object by moving it to that Point.
The MessageSend (if I have a single input) is assumed to return a Point in the coordinate system of my input. I translate this to my coordinate system prior to applying it.
I do this in my step method.
Senders of it:
There are no senders of NCConstraintMorph.
NCCurveHandleMorph
Morph subclass: #NCCurveHandleMorph instanceVariableNames: 'dragStartPoint targetPoint desiredPoint getPoint setPoint offset' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Lines and Curves'
THIS CLASS HAS NO COMMENT!
Senders of it:
NCCurveMorph handles {curve editing}
NCLineMorph handleForPosition:addAllowed: {editing}
NCLineMorph handles {arrows}
NCCurveMorph
NCTextRectangleMorph subclass: #NCCurveMorph instanceVariableNames: 'curve shadowForm' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Shapes'
THIS CLASS HAS NO COMMENT!
Senders of it:
NCCurveMorph class happyFace {contours library}
NCCurveMorph class pointingHand2 {instance creation}
NCCurveMorph class sadFace {instance creation}
NCCurveMorph class supplementaryPartsDescriptions {parts bin}
NCGlyphEditor createCurveMorph {button actions}
Implements the following costumes in its class methods:
- andGate method: AND Gate (eToyFriendlyOff, no category in Object Catalog)
- circle method: Circle (Graphics category)
- diamond method: Diamond (eToyFriendlyOff, no category in Object Catalog)
- happyFace method: Happy face (eToyFriendlyOff, no category in Object Catalog)
- orGate method: OR Gate (eToyFriendlyOff, no category in Object Catalog)
- pointingHand method: Pointing Hand (eToyFriendlyOff, no category in Object Catalog)
- pointingHand2 method: Pointing Hand2 (eToyFriendlyOff, no category in Object Catalog)
- sadFace method: Sad face (eToyFriendlyOff, no category in Object Catalog)
- xorGate method: XOR Gate (eToyFriendlyOff, no category in Object Catalog)
NCCurveMorph andGate openInHand.
NCDisplayTextMorph
NCTextMorph subclass: #NCDisplayTextMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Text'
THIS CLASS HAS NO COMMENT!
Senders of it:
NCButtonBar addLabel: {label}
NCDisplayTextMorph class supplementaryPartsDescriptions {parts bin}
NCEllipseMorph
NCTextRectangleMorph subclass: #NCEllipseMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Shapes'
This adds a standard yellow-button menu to EllipseMorph.
Senders of it:
Flaps class quadsDefiningFSMConnectorsFlap {*connectors-shapes-flaps}
NCButtonBar class newFSMToolbar {instance creation}
NCEllipseMorph class supplementaryPartsDescriptions {parts bin}
NCGlyphEditor
BorderedMorph subclass: #NCGlyphEditor instanceVariableNames: 'font glyph transform fontSample rotation joinPoint endPoint showDots clickPoints transformedClickPoints arrowScale sampleLine' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Tools'
This is a tool that lets you define NCLineArrowGlyphs from TrueType fonts.
Senders of it:
NCArrowDictionaryMenu openGlyphEditor {menu commands}
NCArrowDictionaryMenu showMenu {menu commands}
NCGrabbableDisplayTextMorph
NCDisplayTextMorph subclass: #NCGrabbableDisplayTextMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Text'
THIS CLASS HAS NO COMMENT!
Senders of it:
Flaps class quadsDefiningConnectorsFlap {*connectors-shapes-flaps}
NCGrabbableDisplayTextMorph class supplementaryPartsDescriptions {parts bin}
NCLabelMorph class textClass {defaults}
NCTextRectangleMorph class textClass {nil}
NCHighlightMorph
Morph subclass: #NCHighlightMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Base'
THIS CLASS HAS NO COMMENT!
Senders of it:
Morph highlightMorphForAPRect: {*connectors-private}
Morph highlightMorphForBoundaryRect: {*connectors-private}
NCLabelMorph
NCOffsetConstraintMorph subclass: #NCLabelMorph instanceVariableNames: 'label' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Text-Base'
I am a ConstraintMorph that owns a TextMorph. I follow attempts to
move myself by remembering an offset.
I am movable by pressing the shift key, or by selecting my edge.
My menu has an "attach to" choice that lets the user pick what object
to connect to.
I prtetend[sic] to be a TextMorph, and delegate any message not understood
to my label.
Senders of it:
Flaps class quadsDefiningClassDiagramConnectorsFlap {*connectors-shapes-flaps}
Flaps class quadsDefiningConnectorsFlap {*connectors-shapes-flaps}
Flaps class quadsDefiningFSMConnectorsFlap {*connectors-shapes-flaps}
NCAAConnectorMorph labelClass {connectors-labels}
NCLabelMorph class supplementaryPartsDescriptions {instance creation}
NCLineEndConstraintMorph
NCConstraintMorph subclass: #NCLineEndConstraintMorph instanceVariableNames: 'firstVertex lineAttachmentPoint' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Base'
My constrained object is one end of an open PolygonMorph (a/k/a LineMorph).
Senders of it:
NCAAConnectorMorph class defaultLineEndConstraintClass {defaults}
NCLineMorph
BorderedMorph subclass: #NCLineMorph instanceVariableNames: 'lineWidth fillStyle smoothCurve vertices segments contours arrows arrowForms arrowScales arrowJoints' classVariableNames: 'CurveDebug' poolDictionaries: '' category: 'Connectors-Lines and Curves'
THIS CLASS HAS NO COMMENT!
Senders of it:
NCAAConnectorMorph class defaultLineClass {defaults}
NCGlyphEditor sample {accessing}
NCMakerButton
IconicButton subclass: #NCMakerButton instanceVariableNames: 'triggerEventType' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Tools'
I am an IconicButton that holds on to a prototype instance of a Morph.
When I am pressed, I duplicate my target and send it my selector with my arguments.
By default, this causes the new Morph to be grabbed by the Hand.
Senders of it:
Flaps class preferredConnectorsButtonClass {*connectors-shapes-flaps}
Flaps class quadsDefiningConnectorsFlap {*connectors-shapes-flaps}
Morph makeButton: {*connectors-tools-menus}
NCAAConnectorMorph addBasicMenuItemsTo:event: {menus}
NCAAConnectorMorph class newMakerButton {instance creation}
NCAAConnectorMorph class newRandomButton {instance creation}
NCAAConnectorMorph class supplementaryPartsDescriptions {new-morph participation}
NCBasicShapeMorph addBasicMenuItemsTo:event: {menus}
NCButtonBar class buttonClass {instance creation}
NCButtonBar class buttonTarget:action:arguments:icon:label: {instance creation}
NCDisplayTextMorph addBasicMenuItemsTo:event: {event handling}
NCLineEndConstraintMorph class updateOldShapes26June2002 {conversion}
NCPartsBin morphToDropFrom: {*connectors-tools-menus}
NCPartsBin class buttonClass {as yet unclassified}
NCSketchMorph addYellowButtonMenuItemsTo:event: {menu}
RandomConnector is implemented in this class.
NCNoteMorph
NCTextRectangleMorph subclass: #NCNoteMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Shapes'
This is a rectangular shape with text inside and an angled top left corner.
Senders of it:
Flaps class quadsDefiningClassDiagramConnectorsFlap {*connectors-shapes-flaps}
NCButtonBar class newClassDiagramToolbar {instance creation}
NCNoteMorph class supplementaryPartsDescriptions {instance creation}
NCOffsetConstraintMorph
NCConstraintMorph subclass: #NCOffsetConstraintMorph instanceVariableNames: 'offset' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Base'
I am a ConstraintMorph with an offset. The point I get from evaluating my MessageSend is offset by a point.
Senders of it:
There are no senders of NCOffsetConstraintMorph.
NCPartsBin
PartsBin subclass: #NCPartsBin instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Shapes'
I am a parts bin that holds NCMakerButtons, for use in a flap.
Senders of it:
Flaps class preferredConnectorsFlapBinClass {*connectors-shapes-flaps}
NCMakerButton addYellowButtonMenuItemsTo:event: {menus}
NCMakerButton handlesMouseDown: {menus}
NCMakerButton isLabeled {accessing}
NCPinMorph
CircleMorph subclass: #NCPinMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Shapes'
I am a circle that wants to act as a connection pin.
I offer to embed myself on drop.
When embedded, I will create a Player-valued variable in my new owner.
Senders of it:
CircleMorph class supplementaryPartsDescriptions {as yet unclassified}
NCSchematicConnectorMorph
NCAAConnectorMorph subclass: #NCSchematicConnectorMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Base'
This is a Connector that automatically sets its connection mode as appropriate for use in electronic schematic diagrams.
It also automatically decorates its ends that are attached to other Connectors with junction dots.
Senders of it:
There are no senders of NCSchematicConnectorMorph.
Schematic Connector is implemented in this class.
NCScrolledCompositeStateMorph
NCCompositeStateMorph subclass: #NCScrolledCompositeStateMorph instanceVariableNames: 'scrollPane' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Shapes'
This is a shape with a scrolled playfield in its center and a name tab attached.
Senders of it:
Flaps class quadsDefiningFSMConnectorsFlap {*connectors-shapes-flaps}
NCButtonBar class newClassDiagramToolbar {instance creation}
NCButtonBar class newFSMToolbar {instance creation}
NCScrolledCompositeStateMorph class supplementaryPartsDescriptions {parts bin}
NCSketchMorph
SketchMorph subclass: #NCSketchMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Shapes'
I am a SketchMorph that has similar user interaction to the NCBasicShapeMorph (menus, etc.)
Senders of it:
There are no senders of NCSketchMorph.
NCSmartLabelMorph
NCLabelMorph subclass: #NCSmartLabelMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Text-Base'
I am a label that attempts to keep out of the way of any connectors I'm attached to.
Senders of it:
Flaps class quadsDefiningClassDiagramConnectorsFlap {*connectors-shapes-flaps}
Flaps class quadsDefiningConnectorsFlap {*connectors-shapes-flaps}
Flaps class quadsDefiningFSMConnectorsFlap {*connectors-shapes-flaps}
NCAAConnectorMorph labelClass {connectors-labels}
NCButtonBar class newClassDiagramToolbar {instance creation}
NCSmartLabelMorph class supplementaryPartsDescriptions {parts bin}
NCSTUMLDiagramMorph
NCUMLDiagramMorph subclass: #NCSTUMLDiagramMorph instanceVariableNames: 'className' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Shapes'
THIS CLASS HAS NO COMMENT!
Senders of it:
NCClassHierarchyDiagrammer draw: {drawing}
NCSTUMLDiagramMorph class supplementaryPartsDescriptions {instance creation}
NCUMLDiagramMorph newStateSymbol openInHand. NCUMLDiagramMorph newUMLClassSymbol openInHand.
NCStateDiagramMorph
NCUMLDiagramMorph subclass: #NCStateDiagramMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Shapes'
THIS CLASS HAS NO COMMENT!
Senders of it:
NCButtonBar class newFSMToolbar {instance creation}
NCTestUUIDMorph
NCTextRectangleMorph subclass: #NCTestUUIDMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Shapes'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of NCTestUUIDMorph.
NCTextMorph
TextMorph subclass: #NCTextMorph instanceVariableNames: 'acceptOnCR acceptOnFocusLoss' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Text-Base'
I am a subclass of TextMorph that can be told to accept on either focus loss and/or CR.
Senders of it:
NCLabelMorph class textClass {defaults}
NCTextRectangleMorph
NCBasicShapeMorph subclass: #NCTextRectangleMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Shapes'
I am a shape that has one or more embedded TextMorphs, with optional lines between them.
Senders of it:
Flaps class quadsDefiningClassDiagramConnectorsFlap {*connectors-shapes-flaps}
Flaps class quadsDefiningConnectorsFlap {*connectors-shapes-flaps}
Flaps class quadsDefiningFSMConnectorsFlap {*connectors-shapes-flaps}
NCButtonBar class newClassDiagramToolbar {instance creation}
NCCompositeStateMorph initialize {initialization}
NCTextRectangleMorph class supplementaryPartsDescriptions {instance creation}
NCUMLDiagramMorph
NCTextRectangleMorph subclass: #NCUMLDiagramMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Connectors-Shapes'
THIS CLASS HAS NO COMMENT!
Senders of it:
NCTextRectangleMorph class newStateSymbol {instance creation}
NCTextRectangleMorph class newUMLClassSymbol {instance creation}
NCUMLDiagramMorph class supplementaryPartsDescriptions {as yet unclassified}
Class is implemented in this NCUMLDiagramMorph class.
NebraskaNavigationMorph
ProjectNavigationMorph subclass: #NebraskaNavigationMorph instanceVariableNames: 'nebraskaBorder nebraskaTerminal' classVariableNames: '' poolDictionaries: '' category: 'Nebraska-Morphic-Remote'
THIS CLASS HAS NO COMMENT!
Senders of it:
NetworkTerminalMorph openScaled {initialization}
NebraskaServerMorph
AlignmentMorphBob1 subclass: #NebraskaServerMorph instanceVariableNames: 'server slowCounter previousBacklog lastFullUpdateTime currentStatusString fullDisplay previousClients currentBacklogString' classVariableNames: '' poolDictionaries: '' category: 'Nebraska-Morphic-Remote'
A cheezy morph that simply steps a Nebraska server instance over and over.
Senders of it:
NebraskaServerMorph class killOldServers {as yet unclassified}
NebraskaServerMorph class serveWorldButton {as yet unclassified}
NebraskaServerMorph class supplementaryPartsDescriptions {as yet unclassified}
ProjectNavigationMorph shareThisWorld {*nebraska-*nebraska-Morphic-Remote}
SugarNavigatorBar startNebraska {sharing}
SugarNavigatorBar stopSharing {sharing}
NetworkTerminalBorderMorph
EmbeddedWorldBorderMorph subclass: #NetworkTerminalBorderMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Nebraska-Morphic-Remote'
THIS CLASS HAS NO COMMENT!
Senders of it:
NetworkTerminalMorph openScaled {initialization}
NetworkTerminalMorph
Morph subclass: #NetworkTerminalMorph instanceVariableNames: 'connection decoder eventEncoder backgroundForm enteringHand' classVariableNames: '' poolDictionaries: '' category: 'Nebraska-Morphic-Remote'
A morph used to communicate with a remote image. It sends all mouse/keyboard events to the remote side, and it displays canvas commands that are sent back.
Senders of it:
EToySenderMorph startNebraskaClient {as yet unclassified}
NebraskaNavigationMorph wantsToBeDroppedInto: {dropping/grabbing}
NebraskaServer acceptPhonyConnection {networking}
NewHandleMorph
HandleMorph subclass: #NewHandleMorph instanceVariableNames: 'hand offset waitingForClickInside' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
EToyFridgeMorph acceptDroppingMorph:event: {layout}
EToySenderMorph acceptDroppingMorph:event: {layout}
NCConstraintMorph addSelectedMorph: {menus}
NCConstraintMorph attachToSelectedMorph: {menus}
NCConstraintMorph selectPointWith:thenDo: {menus}
NetworkTerminalMorph acceptDroppingMorph:event: {layout}
NewWorldWindow spawnReframeHandle: {resize/collapse}
PinMorph startWiring: {wires}
ProjectViewMorph acceptDroppingMorph:event: {layout}
SelectionMorph extendByHand: {initialization}
SimpleSelectionMorph extendByHand: {extending}
SystemWindow spawnOffsetReframeHandle:divider: {resize/collapse}
SystemWindow spawnPaneFrameHandle: {resize/collapse}
SystemWindow spawnReframeHandle: {resize/collapse}
TextPlusPasteUpMorph acceptDroppingMorph:event: {layout}
TextPlusPasteUpMorph wantsDroppedMorph:event: {dropping/grabbing}
NewVariableDialogMorph (v5)
GenericPropertiesMorph subclass: #NewVariableDialogMorph instanceVariableNames: 'varNameText varTypeButton decimalPlacesButton' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
THIS CLASS HAS NO COMMENT!
Senders of it:
Player addInstanceVariable {slots-user}
NewWorldWindow
SystemWindow subclass: #NewWorldWindow instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Windows'
THIS CLASS HAS NO COMMENT!
Senders of it:
PasteUpMorph installAsActiveSubprojectIn:at:titled: {world state}
NoHaloMorph
Morph subclass: #NoHaloMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Sugar'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of NoHaloMorph.
NullTerminalMorph
NetworkTerminalMorph subclass: #NullTerminalMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Nebraska-Morphic-Remote'
THIS CLASS HAS NO COMMENT!
Senders of it:
NebraskaServer acceptNullConnection {networking}
NumberLineMorph (v5)
Morph subclass: #NumberLineMorph instanceVariableNames: 'minValue actualColor axis showZero pixelsPerUnit unitsPerMark marksPerLegend' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Charts'
An abstract superclass for VerticalNumberLine and HorizontalNumberLine.
minValue - Number - the value corresponding to the left edge of the line.
pixelsPerUnit - Integer - the number of pixels on the graph that correspond to a single unit in the metric space of the line.
actualColor - the color borne by the axis
axis - a two-vertex PolygonMorph which is the actual line
showZero - Boolean - if false, then a 0 legend will *not* be show.
Senders of it:
There are no senders of NumberLineMorph.
NumericReadoutTile
TileMorph subclass: #NumericReadoutTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
A readout tile for Number-valued variables.
If it bears property #PointValued, it will actually represent a Point-valued variable.
Senders of it:
NumberType newReadoutTile {*Etoys-tiles}
NumericReadoutTile class supplementaryPartsDescriptions {instance creation}
PointType newReadoutTile {tiles}
SyntaxMorph readOut {accessing}
UpdatingStringMorph valueFromContents {accessing}
ObjectPropertiesMorph
GenericPropertiesMorph subclass: #ObjectPropertiesMorph instanceVariableNames: 'simplePanel' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Experimental'
THIS CLASS HAS NO COMMENT!
Senders of it:
Morph openAPropertySheet {meta-actions}
ObjectRepresentativeMorph
AlignmentMorph subclass: #ObjectRepresentativeMorph instanceVariableNames: 'objectRepresented' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of ObjectRepresentativeMorph.
ObjectsTool
AlignmentMorph subclass: #ObjectsTool instanceVariableNames: 'searchString modeSymbol currentCategory asStandAlone' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-PartsBin'
I am a Master Parts Bin that allows the user to drag out a new Morph from a voluminous iconic list.
Choose "objects" from the world menu, or type Alt-o (Cmd-o on the Mac).
To add a new kinds of Morphs:
In the class of the Morph, implement the message:
descriptionForPartsBin
^ self partName: 'Rectangle'
categories: #('Graphics' ' Basic 1 ')
documentation: 'A rectangular shape, with border and fill style'
The partName is the title that will show in the lower pane of the Object Tool.
When is categories mode, an object can be seen in more than one category. The list above tells which ones.
Documentation is what will show in the balloon help for each object thumbnail.
The message #initializeToStandAlone creates the actual instance.
To make a second variant object prototype coming from the same class, implement #supplementaryPartsDescriptions. In it, you get to specify the nativitySelector. It is sent to the class to get the variant objects. Often it is #authoringPrototype. (A class may supply supplementaryPartsDescriptions without implementing descriptionForPartsBin. This gives you better control.)
Senders of it:
ConnectorsBasicDistroInfo class rebuildObjectsToolIcons {distribution}
EventRecordingSpace sugarPartsBinQuads {sugar flaps}
Flaps class defaultsQuadsDefiningPlugInSuppliesFlap {predefined flaps}
Flaps class defaultsQuadsDefiningWidgetsFlap {flaps registry}
Flaps class newObjectsFlap {predefined flaps}
ObjectsTool class registerInFlapsRegistry {class initialization}
PasteUpMorph activateObjectsTool {world menu}
TheWorldMenu createStandardPartsBin {*MorphicExtras-action}
TheWorldMenu launchCustomPartsBin {*MorphicExtras-action}
OLPCHelpDisplayer
AlignmentMorphBob1 subclass: #OLPCHelpDisplayer instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
A scrolling help displayer.
Senders of it:
StandardScriptingSystem buildPanelTitled: {utilities}
PaintBoxColorPicker
ImageMorph subclass: #PaintBoxColorPicker instanceVariableNames: 'currentColor locOfCurrent' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Support'
A pop-up, 32-bit color palette used as part of a PaintBoxMorph.
Senders of it:
PaintBoxMorph loadColorChooser {initialization}
PaintBoxMorph
ImageMorph subclass: #PaintBoxMorph instanceVariableNames: 'action tool currentCursor thumbnail currentColor currentBrush colorMemory colorPatch stampHolder rotationTabForm scaleTabForm colorMemoryThin brushes focusMorph weakDependents recentColors' classVariableNames: 'AllOffImage AllOnImage AllPressedImage ColorChart OriginalBounds Prototype RecentColors' poolDictionaries: '' category: 'MorphicExtras-Support'
This is the set of controls for painting. Has tool section, color section, stamps pull-down, shape tool pull-down.
The class variable Prototype holds the master PaintBoxMorph. It is veryDeepCopied to get a new one. See #new.
action the selector used for mouseMove of this tool. paint: or erase:
tool the actual buttonMorph that the user last clicked on
currentCursor
thumbnail
currentColor
currentBrush
colorMemory The colorPicker with current color marked
colorPatch
stampHolder not a morph
rotationTabForm
scaleTabForm
colorMemoryThin when closed
brushes
focusMorph The sketch we are painting
weakDependents
recentColors OrderedCollection of colors
Senders of it:
19 methods
PaintInvokingMorph
ImageMorph subclass: #PaintInvokingMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Widgets'
When this is dropped inside some appropriate place, then painting is invoked for that place.
Senders of it:
Flaps class defaultsQuadsDefiningScriptingFlap {flaps registry}
Flaps class defaultsQuadsDefiningWidgetsFlap {flaps registry}
Flaps class newLoneSuppliesFlap {predefined flaps}
PaintInvokingMorph class registerInFlapsRegistry {class initialization}
PasteUpMorph newDrawingFromMenu: {world menu}
ParameterTile
TileMorph subclass: #ParameterTile instanceVariableNames: 'scriptEditor' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
Represents a parameter in a user-defined script in "classic" tile-scripting. The type of a script's parameter is declared in the ScriptEditor for the script, and a parameter tile gets its type from the script. But because the user can change the parameter type *after* having created parameter tiles, we can later have type mismatches. Which however we at least deal with reasonably cleverly.
Senders of it:
BooleanScriptEditor wantsDroppedMorph:event: {dropping/grabbing}
CategoryViewer booleanPhraseFromPhrase: {support}
ScriptEditorMorph assureParameterTilesValid {dropping/grabbing}
ScriptEditorMorph handUserParameterTile {other}
ScriptEditorMorphBuilder variable: {reconstituting scripting tiles }
PartsBin
PasteUpMorph subclass: #PartsBin instanceVariableNames: '' classVariableNames: 'Thumbnails' poolDictionaries: '' category: 'MorphicExtras-PartsBin'
THIS CLASS HAS NO COMMENT!
Senders of it:
21 methods
PartsWindow
SystemWindow subclass: #PartsWindow instanceVariableNames: 'book prevButton nextButton menuButton openForEditing' classVariableNames: '' poolDictionaries: '' category: 'Morphic-PartsBin'
Disused. Instances may persist in users' images, so this obsolete code is kept around for the time being. Supplanted by the ObjectsTool.
Senders of it:
There are no senders of PartsWindow.
PasteUpMorph
BorderedMorph subclass: #PasteUpMorph instanceVariableNames: 'presenter model cursor padding backgroundMorph turtleTrailsForm turtlePen lastTurtlePositions isPartsBin autoLineLayout indicateCursor resizeToFit wantsMouseOverHalos worldState griddingOn' classVariableNames: 'DisableDeferredUpdates MinCycleLapse StillAlive WindowEventHandler' poolDictionaries: '' category: 'Morphic-Worlds'
A morph whose submorphs comprise a paste-up of rectangular subparts which "show through". Anything called a 'Playfield' is a PasteUpMorph.
Facilities commonly needed on pages of graphical presentations and on simulation playfields, such as the painting of new objects, turtle trails, gradient fills, background paintings, parts-bin behavior, collision-detection, etc., are (or will be) provided.
A World, the entire Smalltalk screen, is a PasteUpMorph. A World responds true to isWorld. Morph subclasses that have specialized menus (BookMorph) build them in the message addBookMenuItemsTo:hand:. A PasteUpMorph that is a world, builds its menu in HandMorph buildWorldMenu.
presenter A Presenter in charge of stopButton stepButton and goButton,
mouseOverHalosEnabled soundsEnabled fenceEnabled coloredTilesEnabled.
model <not used>
cursor ??
padding ??
backgroundMorph A Form that covers the background.
turtleTrailsForm Moving submorphs may leave trails on this form.
turtlePen Draws the trails.
lastTurtlePositions A Dictionary of (aPlayer -> aPoint) so turtle trails can be drawn
only once each step cycle. The point is the start of the current stroke.
isPartsBin If true, every object dragged out is copied.
autoLineLayout ??
indicateCursor ??
resizeToFit ??
wantsMouseOverHalos If true, simply moving the cursor over a submorph brings up its halo.
worldState If I am also a World, keeps the hands, damageRecorder, stepList etc.
griddingOn If true, submorphs are on a grid
Senders of it:
76 methods
PDAChoiceMorph
PopUpChoiceMorph subclass: #PDAChoiceMorph instanceVariableNames: 'backgroundColor' classVariableNames: '' poolDictionaries: '' category: 'Morphic-PDA'
See PDA comment.
Senders of it:
PDA openAsMorphIn: {initialization}
PDAClockMorph
WatchMorph subclass: #PDAClockMorph instanceVariableNames: 'backgroundColor' classVariableNames: '' poolDictionaries: '' category: 'Morphic-PDA'
See PDA comment. '
Senders of it:
PDA openAsMorphIn: {initialization}
PDAMorph
SystemWindow subclass: #PDAMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-PDA'
See PDA comment.
Senders of it:
PDA openMonthView {initialization}
PhraseTileForTest
PhraseTileMorph subclass: #PhraseTileForTest instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
THIS CLASS HAS NO COMMENT!
Senders of it:
CategoryViewer phraseForTest {entries}
PhraseTileForTimesRepeat
PhraseTileMorph subclass: #PhraseTileForTimesRepeat instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
A place-holder for a Times-Repeat complex of etoy tiles. Used in a Viewer; when the user drags one of these, he ends up with a fully-instantiated Times/Repeat complex of tiles in his hand; if he drops such a group on the desktop, a new script is created for the object associated with the Viewer in question, with the Times/Repeat as its initial contents.
Senders of it:
CategoryViewer phraseForTimesRepeat {entries}
PhraseTileMorph
TileLikeMorph subclass: #PhraseTileMorph instanceVariableNames: 'resultType brightenedOnEnter userScriptSelector justGrabbedFromViewer vocabulary vocabularySymbol' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
Phrase Tile World: A single smalltalk expression in tiles. Like (car forwardBy: number), having 3 tiles.
type = command
rcvrType = #actor
In the Old Single tile world: Holder for a phrase of tiles as it came from the viewer and while it is being dragged by the hand.
Senders of it:
60 methods
PhraseWrapperMorph
AlignmentMorph subclass: #PhraseWrapperMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
An alignment morph designed for use in scripting Viewers; it wraps a set of phrases in a category viewer, and repels attempts to drop phrases upon it.
Senders of it:
There are no senders of PhraseWrapperMorph.
PianoKeyboardMorph
RectangleMorph subclass: #PianoKeyboardMorph instanceVariableNames: 'whiteKeyColor blackKeyColor playingKeyColor nOctaves target noteOnSelector noteOffSelector soundPrototype soundPlaying frequency allowingChord soundPlayingList' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-SoundInterface'
THIS CLASS HAS NO COMMENT!
Senders of it:
EnvelopeEditorMorph addKeyboard {construction}
WaveEditor initialize {initialization}
PianoRollNoteMorph
Morph subclass: #PianoRollNoteMorph instanceVariableNames: 'trackIndex indexInTrack hitLoc editMode selected notePlaying' classVariableNames: 'SoundPlaying' poolDictionaries: '' category: 'Sound-Scores'
A PianoRollNoteMorph is drawn as a simple mroph, but it carries the necessary state to locate its source sound event via its owner (a PianorRollScoreMorph) and the score therein. Simple editing of pitch and time placement is provided here.
Senders of it:
PianoRollNoteMorph mouseDown: {event handling}
PianoRollScoreMorph addNotes {drawing}
PianoRollScoreMorph deleteSelection {editing}
PianoRollScoreMorph notesInRect: {scrolling}
PianoRollScoreMorph
RectangleMorph subclass: #PianoRollScoreMorph instanceVariableNames: 'scorePlayer score colorForTrack lowestNote leftEdgeTime timeScale indexInTrack lastUpdateTick lastMutedState cursor selection timeSignature beatsPerMeasure notePerBeat showMeasureLines showBeatLines soundsPlaying soundsPlayingMorph movieClipPlayer' classVariableNames: 'NotePasteBuffer' poolDictionaries: '' category: 'Sound-Scores'
A PianoRollScoreMorph displays a score such as a MIDIScore, and will scroll through it tracking the progress of a ScorePlayerMorph (from which it is usually spawned).
timeScale is in pixels per score tick.
Currently the ambient track (for synchronizing thumbnails, eg) is treated specially here and in the score. This should be cleaned up by adding a trackType or something like it in the score.
Senders of it:
AnonymousSoundMorph justDroppedInto:event: {piano roll}
MovieClipStartMorph delete {submorphs-add/remove}
MovieClipStartMorph justDroppedInto:event: {dropping/grabbing}
MovieFrameSyncMorph justDroppedInto:event: {dropping/grabbing}
MoviePlayerMorph makeAMovie {menu}
ScorePlayerMorph makePianoRoll {layout}
PinMorph
ImageMorph subclass: #PinMorph instanceVariableNames: 'component pinForm pinSpec wires' classVariableNames: 'InputPinForm IoPinForm OutputPinForm' poolDictionaries: '' category: 'Morphic-Components'
THIS CLASS HAS NO COMMENT!
Senders of it:
ComponentLikeModel addPinFromSpec: {components}
ComponentLikeModel extent: {geometry}
ComponentLikeModel pinsDo: {components}
PinMorph startWiring: {wires}
PlaybackInvoker
SketchMorph subclass: #PlaybackInvoker instanceVariableNames: 'caption contentArea tape beforeBitmap afterBitmap initialPicture finalPicture timesPlayed offeringHint autoStart autoDismiss whereToAppear postPlaybackImageFeature' classVariableNames: 'HintForm' poolDictionaries: '' category: 'Morphic-Mentoring'
When clicked on by the user, open up an EventPlaybackSpace positioned within the receiver's container, ready to play back a given event tape with a given optional voice track.
caption A textual title for the exercise
contentArea The reference bounds to which the coordinates in the tape are bound.
tape An EventRecorder tape
voiceRecorder An optional SoundRecorder
beforeBitmap The bitmap of the receiver before the first time the user has requested the hint
afterBitmap The bitmap of the receiver after the first time the user has requested the hint
timesPlayed How many times the hint has been invoked
autoStart If true, playback will happen automatically when the playback unit is opened.
autoDismiss If true, as soon as playback ends, the playback unit will go away, revealing the "afterBitmap" view of the receiver.
Senders of it:
EventRecordingSpace openTextualPlaybackButton {processing}
EventRecordingSpace openUnhintedPlaybackButton {processing}
PlaybackInvoker changeCaption {menu }
PlayerReferenceReadout
ThumbnailMorph subclass: #PlayerReferenceReadout instanceVariableNames: 'putSelector' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Support'
A thumbnail that serves as the value readout for a player-valued slot in a Viewer. Clicking on it allows the user to select a new object for the slot to point to.
Senders of it:
PlayerType updatingTileForTarget:partName:getter:setter: {tiles}
PlayerSurrogate
AlignmentMorph subclass: #PlayerSurrogate instanceVariableNames: 'playerRepresented' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
An morph representing an E-Toy "Player" in an AllPlayersTool.
Senders of it:
Player entryForPlayersTool: {misc}
PlayingCardDeck
AlignmentMorph subclass: #PlayingCardDeck instanceVariableNames: 'layout stackingPolicy stackingOrder emptyDropPolicy target acceptCardSelector cardDroppedSelector cardDoubleClickSelector cardDraggedSelector seed' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Games'
THIS CLASS HAS NO COMMENT!
Senders of it:
FreeCellBoard cardCell {layout}
FreeCellBoard pickGame: {initialization}
FreeCellBoard stack {card in a stack}
PlayingCardDeck subDeckStartingAt: {accessing}
PlayingCardMorph justDroppedInto:event: {dropping/grabbing}
PlayingCardMorph
ImageMorph subclass: #PlayingCardMorph instanceVariableNames: 'cardNumber suitNumber' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Games'
This class displays images from the PlayingCard class as morphs. It attempts to be space-efficient by only producing its images on demand.
Senders of it:
FreeCellBoard cardCell {layout}
FreeCellBoard cellsRowSpacer {layout}
PlayingCardDeck newDeck {initialization}
PlayingCardDeck newSuit: {initialization}
PlayingCardDeck repelsMorph:event: {dropping/grabbing}
PlayingCardMorph class test {testing}
PlayWithMe1
MorphicModel subclass: #PlayWithMe1 instanceVariableNames: 'slider1 valuePrinter scrollBar1 listPane1 listPane2' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Models'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of PlayWithMe1.
PluggableButtonMorph
AlignmentMorph subclass: #PluggableButtonMorph instanceVariableNames: 'model label getStateSelector actionSelector getLabelSelector getMenuSelector shortcutCharacter askBeforeChanging triggerOnMouseDown offColor onColor feedbackColor showSelectionFeedback allButtons arguments argumentsProvider argumentsSelector' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Pluggable Widgets'
A PluggableButtonMorph is a combination of an indicator for a boolean value stored in its model and an action button. The action of a button is often, but not always, to toggle the boolean value that it shows. Its pluggable selectors are:
getStateSelector fetch a boolean value from the model
actionSelector invoke this button's action on the model
getLabelSelector fetch this button's lable from the model
getMenuSelector fetch a pop-up menu for this button from the model
Any of the above selectors can be nil, meaning that the model does not supply behavior for the given action, and the default behavior should be used. For example, if getStateSelector is nil, then this button shows the state of a read-only boolean that is always false.
The model informs its view(s) of changes by sending #changed: to itself with getStateSelector as a parameter. The view tells the model when the button is pressed by sending actionSelector.
If the actionSelector takes one or more arguments, then the following are relevant:
arguments A list of arguments to provide when the actionSelector is called.
argumentsProvider The object that is sent the argumentSelector to obtain arguments, if dynamic
argumentsSelector The message sent to the argumentProvider to obtain the arguments.
Options:
askBeforeChanging have model ask user before allowing a change that could lose edits
triggerOnMouseDown do this button's action on mouse down (vs. up) transition
shortcutCharacter a place to record an optional shortcut key
Senders of it:
ArchiveViewer createButtonBar {initialization}
Browser buildMorphicSwitches {initialize-release}
ChangeList optionalButtonRow {menu actions}
CodeHolder buttonWithSelector: {controls}
CodeHolder optionalButtonRow {controls}
Debugger customButtonRow {initialize}
Debugger optionalButtonRow {initialize}
HTTPProxyEditor createLabel: {initialization}
HtmlInput addFileInputToFormatter: {formatting}
HtmlInput addToFormatter: {formatting}
Lexicon customButtonRow {control buttons}
MailComposition openInMorphic {interface}
MCTool buttonRow: {morphic ui}
PluggableButtonMorph class example {example}
PluggableFileList openAsMorphLabel:inWorld: {initialize-release}
SimpleServiceEntry buttonToTriggerIn: {performing service}
SystemWindow setWindowColor: {menu}
PluggableListMorph
ScrollPane subclass: #PluggableListMorph instanceVariableNames: 'list getListSelector getListSizeSelector getListElementSelector getIndexSelector setIndexSelector keystrokeActionSelector autoDeselect lastKeystrokeTime lastKeystrokes lastClickTime doubleClickSelector handlesBasicKeys potentialDropRow listMorph' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Pluggable Widgets'
...
When a PluggableListMorph is in focus, type in a letter (or several
letters quickly) to go to the next item that begins with that letter.
Special keys (up, down, home, etc.) are also supported.
Senders of it:
48 methods
PluggableListMorphByItem
PluggableListMorph subclass: #PluggableListMorphByItem instanceVariableNames: 'itemList' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Pluggable Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
ChangeSetBrowser openAsMorphIn:rect: {initialization}
ChangeSorter openAsMorphIn:rect: {creation}
PluggableListMorphOfMany
PluggableListMorph subclass: #PluggableListMorphOfMany instanceVariableNames: 'dragOnOrOff getSelectionListSelector setSelectionListSelector' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Pluggable Widgets'
A variant of its superclass that allows multiple items to be selected simultaneously. There is still a distinguished element which is selected, but each other element in the list may be flagged on or off.
Senders of it:
ChangeList openAsMorphName:multiSelect: {initialization-release}
MCTool multiListMorph:selection:listSelection:menu: {morphic ui}
PluggableMessageCategoryListMorph
PluggableListMorph subclass: #PluggableMessageCategoryListMorph instanceVariableNames: 'getRawListSelector priorRawList' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Pluggable Widgets'
A variant of PluggableListMorph designed specially for efficient handling of the --all-- feature in message-list panes. In order to be able *quickly* to check whether there has been an external change to the list, we cache the raw list for identity comparison (the actual list is a combination of the --all-- element and the the actual list).
Senders of it:
Browser buildMorphicMessageCatList {initialize-release}
PluggableMultiColumnListMorph
PluggableListMorph subclass: #PluggableMultiColumnListMorph instanceVariableNames: 'lists' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Pluggable Widgets'
This morph can be used to show a list having multiple columns, The columns are self width sized to make the largest entry in each list fit. In some cases the pane may then be too narrow.
Use it like a regular PluggableListMorph except pass in an array of lists instead of a single list.
There are base assumptions made here that each list in the array of lists is the same size.
Also, the highlight color for the selection is easy to modify in the #highlightSelection method. I used blue
when testing just to see it work.
Senders of it:
MCWorkingCopyBrowser workingCopyListMorph {morphic ui}
SoundLibraryTool addSoundList {initialization}
PluggableMultiColumnListMorphByItem
PluggableMultiColumnListMorph subclass: #PluggableMultiColumnListMorphByItem instanceVariableNames: 'itemList' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Pluggable Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of PluggableMultiColumnListMorphByItem.
PluggableTabBarMorph
Morph subclass: #PluggableTabBarMorph instanceVariableNames: 'target tabs activeTab' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
This morph manages a set of PluggableTabButtonMorphs. Each tab should be added in the left to right order that they should be displayed. Each tab will be evenly sized to fit the available space. This morph intercepts mouse clicks, figures out which tab was clicked, pops up the new tab as the active tab and triggers the registered event. See PluggableTabButtonMorph for information on what a tab can consist of.
Example:
(PluggableTabBarMorph on: nil)
addTab: (Text fromString: 'Test') withAction: [Transcript show: 'Test'; cr];
addTab: (Text fromString: 'Another') withAction: [Transcript show: 'Another'; cr];
width: 200;
openInHand
Senders of it:
There are no senders of PluggableTabBarMorph .
PluggableTabButtonMorph
Morph subclass: #PluggableTabButtonMorph instanceVariableNames: 'active model textSelector arcLengths subMorph' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Pluggable Widgets'
This is a specialized pluggable button morph that is meant to represent a tab in a set of tabs arranged horizontally. Each tab will overlap slightly when drawn. All but one tab will be drawn in left to right order in the specified color, but lighter. The active tab will be drawn last in the full color and slightly taller to indicate that it is selected. Clicking the active tab has no effect but clicking any other tab will change the active tab to the clicked tab.
This morph does not itself accept any events. The parent tab set will grab the mouse clicks and handle notifying the appropriate tabs that they have been activated or deactivated.
There is a single selector which provides the text for the button label and affects the width of the tab. When the width changes the tab will inform its parent that it has changed and that the layout needs to be updated. The model for the text selector of course should be the client for the tab set.
The button label can be a String, Text, or Morph. Texts work better than plain Strings.
Senders of it:
PluggableTabBarMorph addTab:withAction: {access}
PluggableTextMorph
ScrollPane subclass: #PluggableTextMorph instanceVariableNames: 'textMorph getTextSelector setTextSelector getSelectionSelector hasUnacceptedEdits askBeforeDiscardingEdits selectionInterval hasEditingConflicts' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Pluggable Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
70 methods
PluggableTextMorphPlus (v5)
PluggableTextMorph subclass: #PluggableTextMorphPlus instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'ToolBuilder-Morphic'
THIS CLASS HAS NO COMMENT!
Senders of it:
MCTool codePane: {morphic ui}
PluggableTextMorphWithModel
PluggableTextMorph subclass: #PluggableTextMorphWithModel instanceVariableNames: 'myContents' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Pluggable Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of PluggableTextMorphWithModel.
PluggableTileScriptorMorph
TwoWayScrollPane subclass: #PluggableTileScriptorMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Tile Scriptors'
THIS CLASS HAS NO COMMENT!
Senders of it:
CodeHolder installTextualCodingPane {diffs}
CodeHolder installTilesForSelection {tiles}
Lexicon acceptTiles {*Etoys-tiles}
Lexicon installTilesForSelection {tiles}
SyntaxMorph inAPluggableScrollPane {initialization}
PolygonMorph
BorderedMorph subclass: #PolygonMorph instanceVariableNames: 'vertices vertexCursor closed filledForm arrows arrowForms smoothCurve curveState borderDashSpec handles borderForm' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Basic'
This class combines the old Polygon and Curve classes.
The 1-bit fillForm to make display and containment tests reasonably fast. However, this functionality is in the process of being supplanted by balloon capabilities, which should eventually provide anti-aliasing as well.
Senders of it:
35 methods
Implements the following costumes in its class methods:
- arrowPrototype method: Arrow (eToyFriendly off, Graphics category)
- curvePrototoype method: Curve (Basic and Graphics categories)
- trianglePrototype method: Triangle (Graphics category)
PolygonMorph curvePrototype openInHand PolygonMorph arrowPrototype openInHand PolygonMorph trianglePrototype openInHand.
PopUpChoiceMorph
StringMorph subclass: #PopUpChoiceMorph instanceVariableNames: 'target actionSelector arguments getItemsSelector getItemsArgs choiceSelector choiceArgs' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
EnvelopeEditorMorph addControls {construction}
FreeTranslation class translatePanel:fromTo: {translation}
MidiInputMorph channelNumAndMuteButtonFor: {as yet unclassified}
ScorePlayerMorph trackNumAndMuteButtonFor: {layout}
PreDebugWindow
SystemWindow subclass: #PreDebugWindow instanceVariableNames: 'proceedButton debugButton' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Windows'
THIS CLASS HAS NO COMMENT!
Senders of it:
Debugger buildMorphicNotifierLabelled:message: {nil}
PrintComponent
TextComponent subclass: #PrintComponent instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Components'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of PrintComponent.
ProgressBarMorph
BorderedMorph subclass: #ProgressBarMorph instanceVariableNames: 'value progressColor lastValue' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
FlashPlayerWindow addProgressIndicator {as yet unclassified}
FlashPlayerWindow addProgressIndicator: {as yet unclassified}
ProgressMorph initProgressMorph {initialization}
ProgressMorph
RectangleMorph subclass: #ProgressMorph instanceVariableNames: 'labelMorph subLabelMorph progress' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
ProgressMorph class example {example}
ProjectNavigationMorph
AlignmentMorphBob1 subclass: #ProjectNavigationMorph instanceVariableNames: 'mouseInside soundSlider' classVariableNames: 'LastManualPlacement' poolDictionaries: '' category: 'MorphicExtras-Navigators'
THIS CLASS HAS NO COMMENT!
Senders of it:
EventRecordingSpace inspectNavBar {sugar flaps}
Flaps class newNavigatorFlap {predefined flaps}
PasteUpMorph windowEvent: {event handling}
Project assureNavigatorPresenceMatchesPreference {menu messages}
Project finalEnterActions {menu messages}
Project finalExitActions {enter}
Project setFlaps {language}
ProjectNavigationMorph class preferredNavigator {as yet unclassified}
ProjectSorterMorph
BookPageSorterMorph subclass: #ProjectSorterMorph instanceVariableNames: 'sizeOfEachMorph' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Navigators'
THIS CLASS HAS NO COMMENT!
Senders of it:
InternalThreadNavigationMorph editThisThread {navigation}
ProjectViewMorph
ImageMorph subclass: #ProjectViewMorph instanceVariableNames: 'project lastProjectThumbnail mouseDownTime string' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Windows'
I am a Morphic view of a project. I display a scaled version of the project's thumbnail, which itself is a scaled-down snapshot of the screen taken when the project was last exited. When I am displayed, I check to see if the project thumbnail has changed and, if so, I update my own view of that thumbnail.
Senders of it:
20 methods
QHsmMorph
Morph subclass: #QHsmMorph instanceVariableNames: 'eventHandler' classVariableNames: '' poolDictionaries: '' category: 'FSM-Morphic'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of QHsmMorph.
QHsmTestMorph
QHsmMorph subclass: #QHsmTestMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'FSM-Tests'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of QHsmTestMorph.
QuickGuideGenerator
Morph subclass: #QuickGuideGenerator instanceVariableNames: 'input output inputMorph outputMorph fileList' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Books'
Used to generate .sexp files for the Quick Guides. These are the help system for Etoys.
How to use:
Pressing the Help button [?] at the top left of the screen, brings up the QuickGuides flap. The index page has categories of help. The Jump To... button allows you to get to any help guide.
To create a new guide, copy the bookmorph out of the flap. Use the halos to completely change the contents. Create help pages for a new topic.
When you are done, write the entire project out using "Keep the current project". It is now a .pr file.
If you put the .pr into the QuickGuides folder, you will be able to see it in the Help flap. (Click the Help button [?] once to close help, and once again to open it.)
You can test a .pr file in the QuickGuides folder, but it is not in the proper format to include in the OLPC build.
The purpose of QuickGuideGenerator is to put a guide in to the proper format for distribution.
0) Get the new Guides from http://tinlizzie.org/quickguides
1) Make a folder called "To-Be-Translated" at the top level of your file system. Put the .pr files of all new guides into this folder.
1.5) Make a folder called "Newer" in the folder that has the Etoys image file. Must be a fresh new folder.
2) Start Etoys. You will NOT save this image.
3) Execute
QuickGuideGenerator new openInWorld.
4) Wait until a new window appears.
5) Find the folder "To-Be-Translated" in the list and click on it. It's path will appear in the top pane.
6) Press the "Generate" button. Wait.
7) Quit Etoys.
8) "Newer" will now have a .sexp file for each guide that was a .pr file. Files ending in .sexp contain Yoshiki's S-expression linearization of object trees.
9) Copy the .sexp files to QuickGuides, and delete the .pr files of the same name.
10) Rename Newer to be Newer-day-month-year
11) Copy Newer-xx to http://tinlizzie.org/share/QG-compressed
12) copy the .sexp files into http://tinlizzie.org/share/QG-compressed/Quickguides
Senders of it:
There are no senders of QuickGuideGenerator.
QuickGuideHolderMorph
PasteUpMorph subclass: #QuickGuideHolderMorph instanceVariableNames: 'guideName guideNameInWords guideCategory' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Books'
This is the Flap that holds the Guides. Shows one guide at a time,
Senders of it:
QuickGuideMorph guideToWebWithJPEGs: {write web pages}
QuickGuideMorph initialize {initialization}
QuickGuideMorph jPegOutDir: {write web pages}
QuickGuideMorph loadPages {initialization}
QuickGuideMorph order: {initialization}
QuickGuideMorph
BookMorph subclass: #QuickGuideMorph instanceVariableNames: 'control order' classVariableNames: 'Categories FileNameStems HTMLJumpTo IndexPage IndexPageMimeString PagesForCategory' poolDictionaries: '' category: 'Morphic-Books'
A BookMorph that holds QuickGuides.
World
an AlignmentMorph (the flap)
an AlignmentMorph
a QuickGuideMorph (one page per guide, 54 pages.
Page may be a stub if guide not in)
a QuickGuideHolderMorph
a BookMorph (4 pages)
a PasteUpMorph (a page)
QuickGuides are stored in Contents/Resources/QuickGuides/
or by language in Contents/Resources/locale/<id>/QuickGuides/
(see guidePath)
Categories = OrderedCollection of {catKey. catTitle}
where catKey appears at the start of a file name 'Menu'
catTitle may be UTF-8 full name.
PagesForCategory dictionary of (catKey -> list). list has elements {guideName. guideTitle}. guideName is last part of a file name and guideTitle may be in UTF-8.
Senders of it:
Project helpGuideIfOpen {flaps support}
QuickGuideGenerator generate {all}
QuickGuideHolderMorph load {file in/file out}
QuickGuideMorph checkForIndexOnDisk {transition}
QuickGuideMorph class fileNameStems {defaults}
QuickGuideMorph class loadIndex {initialization}
QuickGuideMorph class loadIndexAndPeekOnDisk {initialization}
ReleaseBuilderSqueakland buildInitialScreen {squeakland}
ReleaseBuilderSqueakland finalStripping {utilities}
SugarNavigatorBar buildAndOpenHelpFlap {help flap}
SugarNavigatorBar toggleHelp {help flap}
RandomNumberTile
TileMorph subclass: #RandomNumberTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
Disused; retained "temporarily" for backward compatibility. The duties formerly served by the RandomNumberTile are now handled by the generic FunctionTile.
Senders of it:
RandomNumberTile class registerInFlapsRegistry {class initialization}
RecordingControls
AlignmentMorph subclass: #RecordingControls instanceVariableNames: 'recorder recordingStatusLight recordMeter recordingSaved' classVariableNames: '' poolDictionaries: '' category: 'Sound-Interface'
A facelifted version of John Maloney's original RecordingControlsMorph.
Senders of it:
EventRecordingSpace sugarPartsBinQuads {sugar flaps}
Flaps class defaultsQuadsDefiningPlugInSuppliesFlap {predefined flaps}
Flaps class defaultsQuadsDefiningWidgetsFlap {flaps registry}
Flaps class newLoneSuppliesFlap {predefined flaps}
RecordingControls class registerInFlapsRegistry {class initialization}
RecordingControlsMorph
AlignmentMorph subclass: #RecordingControlsMorph instanceVariableNames: 'recorder recordingStatusLight recordMeter' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-SoundInterface'
THIS CLASS HAS NO COMMENT!
Senders of it:
RecordingControlsMorph class registerInFlapsRegistry {class initialization}
RectangleMorph
BorderedMorph subclass: #RectangleMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Basic'
A subclass of BorderedMorph that supports different fillStyles.
RectangleMorph diagonalPrototype openInWorld.
RectangleMorph gradientPrototype openInWorld.
Senders of it:
65 methods
ReferenceMorph
BorderedMorph subclass: #ReferenceMorph instanceVariableNames: 'referent isHighlighted' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Palettes'
Serves as a reference to any arbitrary morph; used, for example, as the tab in a tabbed palette The wrapper intercepts mouse events and fields them, passing them on to their referent morph.
Senders of it:
IndexTabs addTabForBook: {tabs}
IndexTabs addTabFor:font: {tabs}
IndexTabs tabMorphs {tabs}
TabbedPalette tabNamed: {user-interface}
TabMorph convertToReferenceMorph {as yet unclassified}
RemoteControlledHandMorph
HandMorph subclass: #RemoteControlledHandMorph instanceVariableNames: 'eventDecoder viewExtent nebraskaClient' classVariableNames: '' poolDictionaries: '' category: 'Nebraska-Morphic-Remote'
Used as part of the Nebraska system. It is controlled by commands sent through a socket. The encoding is interpreted via a MorphicEventDecoder.
Senders of it:
NebraskaClient initialize: {initialization}
RemoteHandMorph
HandMorph subclass: #RemoteHandMorph instanceVariableNames: 'remoteWorldExtent remoteAddress sendSocket sendBuffer sendState socket waitingForConnection receiveBuffer' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-AdditionalSupport'
THIS CLASS HAS NO COMMENT!
Senders of it:
PasteUpMorph connectRemoteUserWithName:picture:andIPAddress: {world menu}
PasteUpMorph disconnectAllRemoteUsers {world menu}
WorldState doOneCycleInBackground {*MorphicExtras-update cycle}
RulerMorph
RectangleMorph subclass: #RulerMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of RulerMorph.
SameGame
AlignmentMorph subclass: #SameGame instanceVariableNames: 'board scoreDisplay selectionDisplay helpText' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Games'
See SameGame>>helpString for an explanation of how to play
helpString
^ 'The object of SameGame is to maximize your score by removing tiles from the board. Tiles are selected and removed by clicking on a tile that has at least one adjacent tile of the same color (where adjacent is defined as up, down, left, or right).
The first click selects a group of adjacent tiles, a second click in that group will remove it from the board, sliding tiles down and right to fill the space of the removed group. If you wish to select a different group, simply click on it instead.
The score increases by "(selection - 2) squared", so you want to maximize the selection size as much as possible. However, making small strategic selections may allow you to increase the size of a later selection.
If you are having a hard time finding a group, the "Hint" button will find one and select it for you (although it is likely not the best group to select!).
When there are no more groups available, the score display will flash with your final score. Your final score is reduced by 1 for each tile remaining on the board. If you manage to remove all tiles, your final score is increased by a bonus of 5 times the number of tiles on a full board.
Come on, you can beat that last score! Click "New game" ;-)
SameGame was originally written by Eiji Fukumoto for UNIX and X; this version is based upon the same game concept, but was rewritten from scratch.' translated
Senders of it:
There are no senders of SameGame.
SameGameBoard
AlignmentMorph subclass: #SameGameBoard instanceVariableNames: 'protoTile rows columns palette selection selectionColor flashColor flash target actionSelector arguments' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Games'
I am an MxN array of SameGameTiles, and implement most of the logic to play the SameGame, including adjacent tile selection and removal.
Senders of it:
SameGame board {access}
SameGameTile
SimpleSwitchMorph subclass: #SameGameTile instanceVariableNames: 'switchState disabled oldSwitchState' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Games'
I am a single tile for the SameGame. I act much like a switch.
Senders of it:
SameGameBoard protoTile {accessing}
ScorePlayerMorph
AlignmentMorph subclass: #ScorePlayerMorph instanceVariableNames: 'scorePlayer trackInstNames instrumentSelector scrollSlider' classVariableNames: 'LastMIDIPort' poolDictionaries: '' category: 'Sound-Scores'
A ScorePlayerMorph mediates between a score such as a MIDIScore, a PianoRollScoreMorph, and the actual SoundPlayer synthesizer.
It provides control over volume, tempo, instrumentation, and location in the score.
Senders of it:
AbstractSound class updateScorePlayers {sound library-file in/out}
ExternalDropHandler class defaultMidiHandler {private}
FileList class initialize {class initialization}
MIDIFileReader class playFileNamed: {as yet unclassified}
MIDIFileReader class playStream: {as yet unclassified}
MIDIFileReader class playURLNamed: {as yet unclassified}
MoviePlayerMorph makeAMovie {menu}
ScratchClientMorph (v5)
Morph subclass: #ScratchClientMorph instanceVariableNames: 'connectionIndicatorPane connectionIndicator indicators scratchHost scratchPort scratchSocket isVerbose isDebugMode' classVariableNames: '' poolDictionaries: '' category: 'ScratchConnect-Etoys'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of ScratchClientMorph.
ScreeningMorph
Morph subclass: #ScreeningMorph instanceVariableNames: 'screenForm displayMode passingColor passElseBlock' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Demo'
ScreeningMorph uses its first submorph as a screen, and its second submorph as a source. It also wants you to choose (when showing only the screen) the passing color in the screen. It then makes up a 1-bit mask which clips the source, and displays transparently outside it.
Senders of it:
MagnifierMorph class newRound {instance creation}
ScriptActivationButton
SimpleButtonMorph subclass: #ScriptActivationButton instanceVariableNames: 'uniclassScript' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
A button associated with a particular player and script. You can "tear off" such a button for any etoy script, using menu items available in both Viewers and Scriptors. The button initially is given a label reflecting its player and script name, but this can be edited via the button's halo menu, as can its other appearance parameters. Such buttons are automatically kept in synch when the object's name or the script name change.
Senders of it:
MethodWithInterface allScriptActivationButtons {script editor}
Player tearOffButtonToFireScriptForSelector: {costume}
UniclassScript allScriptGoverningButtons {script editor}
ScriptableButton
UpdatingSimpleButtonMorph subclass: #ScriptableButton instanceVariableNames: 'scriptSelector' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
A button intended for use with the card architecture and the user-scripting system.
Senders of it:
EventRecordingSpace sugarPartsBinQuads {sugar flaps}
Flaps class defaultsQuadsDefiningScriptingFlap {flaps registry}
Flaps class defaultsQuadsDefiningStackToolsFlap {flaps registry}
Flaps class defaultsQuadsDefiningSuppliesFlap {flaps registry}
NebraskaServerMorph class serveWorldButton {as yet unclassified}
PartsBin listDirection:quadList:withPreviousEntries: {initialization}
Project displayProgressWithJump: {menu messages}
Project displayProgressWithMessage: {menu messages}
ScriptableButton class registerInFlapsRegistry {class initialization}
ScriptEditorMorph
AlignmentMorph subclass: #ScriptEditorMorph instanceVariableNames: 'scriptName firstTileRow timeStamp playerScripted handWithTile showingMethodPane threadPolygon previousDropHandPosition dropSpaces' classVariableNames: 'Evaluator GenerateParseNodeDirectly Rewrite TrackedEditor WritingUniversalTiles' poolDictionaries: '' category: 'Etoys-Scripting'
Presents an EToy script to the user on the screen. Has in it:
a Morph with the controls for the script.
a Morph with the tiles. Either PhraseMorphs and TileMorphs,
or a TwoWayScroller with SyntaxMorphs in it.
WritingUniversalTiles -- only vlaid while a project is being written out.
True if using UniversalTiles in that project.
Senders of it:
51 methods
ScriptingTileHolder
AlignmentMorph subclass: #ScriptingTileHolder instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
Serves as a wrapper for a scripting-tile element that otherwise would be bare on the desktop.
Senders of it:
AnonymousSoundMorph addToSoundLibrary {menu}
ImageSegment comeFullyUpOnReload: {fileIn/Out}
PhraseTileMorph morphToDropInPasteUp: {mouse}
SystemQueryPhrase morphToDropInPasteUp: {miscellaneous}
TileLikeMorph morphToDropInPasteUp: {mouse}
TileMorph morphToDropInPasteUp: {event handling}
ScriptNameTile
SymbolListTile subclass: #ScriptNameTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
A tile which refers to a script name. The choices available to the user, via the arrows and via the pop-up she gets when she clicks on the current script-name, are the names of all the user scripts in any Players in the active World.
Senders of it:
PasteUpMorph attemptCleanupReporting: {*Etoys-world menu}
ScriptEditorMorphBuilder literal: {reconstituting scripting tiles }
ScriptNameType defaultArgumentTile {tiles}
ScriptNameType newReadoutTile {tile}
ScriptOpeningButtonMorph (v5)
SimpleButtonMorph subclass: #ScriptOpeningButtonMorph instanceVariableNames: 'affiliatedScriptor' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Buttons'
THIS CLASS HAS NO COMMENT!
Senders of it:
ScriptEditorMorph buttonToOpenOrCloseThisScript {customevents-other}
UniclassScript allScriptGoverningButtons {script editor}
ScriptStatusControl
AlignmentMorph subclass: #ScriptStatusControl instanceVariableNames: 'tickPauseWrapper tickPauseButtonsShowing scriptInstantiation' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
A structure consisting of a TickIndicatorMorph and an UpdatingSimpleButtonMorph, used to control the status of a given script for a given object. Used both in the headers of ScriptEditorMorphs and in Viewers.
Senders of it:
PasteUpMorph attemptCleanupReporting: {*Etoys-world menu}
ScriptEditorMorph updateStatus {buttons}
ScriptInstantiation statusControlMorph {status control}
ScriptInstantiation updateAllStatusMorphs {status control}
ScriptStatusLine
AlignmentMorph subclass: #ScriptStatusLine instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
THIS CLASS HAS NO COMMENT!
Senders of it:
ScriptInstantiation statusControlRowIn: {misc}
ScrollableField
PluggableTextMorphWithModel subclass: #ScrollableField instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
Flaps class defaultsQuadsDefiningStackToolsFlap {flaps registry}
ScrollableField class registerInFlapsRegistry {class initialization}
ScrollBar
Slider subclass: #ScrollBar instanceVariableNames: 'menuButton upButton downButton pagingArea scrollDelta pageDelta interval menuSelector timeOfMouseDown timeOfLastScroll nextPageDirection currentScrollDelay' classVariableNames: 'ArrowImagesCache BoxesImagesCache CachedImages UpArrow UpArrow8Bit' poolDictionaries: '' category: 'Morphic-Windows'
Inspired by an oiginal design of Hans-Martin Mosner, this ScrollBar is intended to exercise the handling of input events in Morphic. With sufficient flexibility in this area, all particular behavior can be concentrated in this single class with no need to specialize any other morphs to achieve button, slider and menu-button behavior.
Once we have this working, put in logic for horizontal operation as well.
CachedImages was added to reduce the number of forms created and thrown away. This will be helpful for Nebraska and others as well.
Senders of it:
MethodMorph installRollBackButtons: {as yet unclassified}
ScrollBar class arrowSamples {images - samples}
ScrollBar class boxSamples {images - samples}
ScrollPane flatColoredScrollBarLook {access}
ScrollPane hInitScrollBarTEMPORARY {initialization}
ScrollPane initializeScrollBars {initialization}
TwoWayScrollPane createScrollBarNamed: {initialization}
ScrollPane
ComponentLikeModel subclass: #ScrollPane instanceVariableNames: 'scrollBar scroller retractableScrollBar scrollBarOnLeft getMenuSelector getMenuTitleSelector scrollBarHidden hasFocus hScrollBar' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Windows'
The scroller (a transform) of a scrollPane is driven by the scrollBar. The scroll values vary from 0.0, meaning zero offset to 1.0 meaning sufficient offset such that the bottom of the scrollable material appears 3/4 of the way down the pane. The total distance to achieve this range is called the totalScrollRange.
Senders of it:
AllPlayersTool playersOnDisplay {reinvigoration}
AllPlayersTool reinvigorate {reinvigoration}
BookPageSorterMorph book:morphsToSort: {as yet unclassified}
EventRollMorph formulate {processing}
FlashSorterMorph openInWindow {initialization}
SuperSwikiServer showQueryAsPVM: {testing}
SystemWindow areasRemainingToFill: {drawing}
SystemWindow fullScreen {menu}
SystemWindow fullScreenMaximumExtent {menu}
SystemWindow mouseLeaveEvent:fromPane: {resize/collapse}
SearchingViewer
CategoryViewer subclass: #SearchingViewer instanceVariableNames: 'searchString' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
A SearchingViewer is a custom Viewer which has a type-in 'search' pane; the user types a word or fragment into the search pane and hits the 'search' button (or hits Return or Enter) and the pane gets populated with all the phrases that match (in the currently-installed language) the search-string.
Senders of it:
StandardViewer categoryViewerFor: {categories}
StandardViewer searchingViewerMorphs {categories}
SectorMorph (v5)
PolygonMorph subclass: #SectorMorph instanceVariableNames: 'angle' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-AdditionalMorphs'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of SectorMorph.
SelectionMorph
BorderedMorph subclass: #SelectionMorph instanceVariableNames: 'selectedItems slippage dupLoc dupDelta itemsAlreadySelected otherSelection undoProperties' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Support'
A selectionMorph supports the selection of multiple objects in a morphic world or pasteUp.
Structure:
selectedItems an OrderedCollection of Morphs
These are the morphs that have been selected
slippage a Point
Keeps track of actual movement between the
steps of gridded movement
dupLoc a Point
Notes the position when first duplicate request occurs from halo
dupDelta a Point
Holds the final delta of the first duplicate plus subsequent moves.
Senders of it:
DrGDrawable mouseMove: {event handling}
KedamaMorph class newSet {class initialization}
PasteUpMorph dragThroughOnDesktop: {world state}
ShowEmptyTextMorph
TextMorph subclass: #ShowEmptyTextMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Experimental'
A slight modification on TextMorph to show empty fields just as one would fields with data: with a cursor and without the pink field
Senders of it:
EToyGenericDialogMorph genericTextFieldNamed: {as yet unclassified}
SimpleButtonDelayedMenuMorph
SimpleButtonMorph subclass: #SimpleButtonDelayedMenuMorph instanceVariableNames: 'didMenu' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
Project setFlaps {language}
ProjectNavigationMorph makeButton:balloonText:for: {as yet unclassified}
ThreadNavigationMorph makeButton:balloonText:for: {initialization}
SimpleButtonMorph
RectangleMorph subclass: #SimpleButtonMorph instanceVariableNames: 'target actionSelector arguments actWhen oldColor mouseDownTime' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
I am labeled, rectangular morph which allows the user to click me. I can be configured to send my "target" the message "actionSelector" with "arguments" when I am clicked. I may have a label, implemented as a StringMorph.
Example:
SimpleButtonMorph new
target: Smalltalk;
label: 'Beep!';
actionSelector: #beep;
openInWorld
Structure:
instance var Type Description
target Object The Object to notify upon a click
actionSelector Symbol The message to send to Target (#messageName)
arguments Array Arguments to send with #actionSelection (optional)
actWhen Symbol When to take action: may be #buttonUp (default), #buttonDown,
#whilePressed, or #startDrag
oldColor Color Used to restore color after click
Another example: a button which quits the image without saving it.
SimpleButtonMorph new
target: Smalltalk;
label: 'quit';
actionSelector: #snapshot:andQuit:;
arguments: (Array with: false with: true);
openInWorld
Senders of it:
113 Methods
SimpleHierarchicalListMorph
ScrollPane subclass: #SimpleHierarchicalListMorph instanceVariableNames: 'selectedMorph getListSelector keystrokeActionSelector autoDeselect columns sortingSelector getSelectionSelector setSelectionSelector potentialDropMorph lineColor' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Explorer'
Display a hierarchical list of items. Each item should be wrapped with a ListItemWrapper.
For a simple example, look at submorphsExample. For beefier examples, look at ObjectExplorer or FileList2.
Senders of it:
DBusExplorer notInAWindow {opening}
FileList2 isDirectoryList: {drag'n'drop}
FileList2 morphicDirectoryTreePaneFiltered: {user interface}
MCTool treeMorph:selection:menu: {morphic ui}
MCWorkingCopyBrowser workingCopyTreeMorph {morphic ui}
NebraskaServerMorph rebuild {initialization}
ObjectExplorer explorerFor: {accessing}
QuickGuideGenerator makeInputDirList {all}
SimpleHierarchicalListMorph class submorphsExample {examples}
SMLoader buildMorphicCategoriesList {interface}
SMLoader buildMorphicPackagesList {interface}
SimpleSelectionMorph
Morph subclass: #SimpleSelectionMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Support'
A morph used in the implementaiton of Karl Ramberg's omnidirectional grab-patch tool
Senders of it:
PasteUpMorph grabDrawingFromScreen: {world menu}
SimpleSliderMorph
Slider subclass: #SimpleSliderMorph instanceVariableNames: 'target arguments minVal maxVal truncate' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
36 methods
SimpleSwitchMorph
SimpleButtonMorph subclass: #SimpleSwitchMorph instanceVariableNames: 'onColor offColor' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Widgets'
I represent a switch that can be either on or off. I chnage my state in response to a mouse click. When clicked, I also send my actionSelector to my target, just like a SimpleButtonMorph.
Senders of it:
FlashPlayerMorph makeControls {initialize}
KeyboardMorphForInput addRecordingControls {initialization}
KeyboardMorphForInput articulation:onOff: {note controls}
KeyboardMorphForInput duration:onOff: {note controls}
KeyboardMorphForInput durMod:onOff: {note controls}
MidiInputMorph channelNumAndMuteButtonFor: {as yet unclassified}
MidiInputMorph makeControls {as yet unclassified}
Mines makeControls {initialize}
MonthMorph highlightToday {initialization}
SameGame makeControls {initialization}
ScorePlayerMorph makeControls {layout}
ScorePlayerMorph trackNumAndMuteButtonFor: {layout}
WeekMorph tile {all}
WeekMorph tileLabeled: {all}
SketchEditorMorph
Morph subclass: #SketchEditorMorph instanceVariableNames: 'hostView palette ticksToDwell rotationCenter registrationPoint newPicBlock emptyPicBlock paintingForm dimForm formCanvas rotationButton scaleButton cumRot cumMag undoBuffer enclosingPasteUpMorph forEachHand' classVariableNames: 'SketchTimes' poolDictionaries: '' category: 'MorphicExtras-Support'
Inst vars (converting to morphic events)
hostView -- SketchMorph we are working on.
stampForm -- Stamp is stored here.
canvasRectangle -- later use bounds
palette -- the PaintBox interface Morph
dirty -- not used
currentColor
ticksToDwell rotationCenter registrationPoint
newPicBlock -- do this after painting
action -- selector of painting action
paintingForm -- our copy
composite -- now paintArea origin. world relative. stop using it.
dimForm -- SketchMorph of the dimmed background. Opaque.
installed behind the editor morph.
buff
brush -- 1-bit Form of the brush,
paintingFormPen
formCanvas -- Aim it at paintingForm to allow it to draw ovals, rectangles, lines, etc.
picToComp dimToComp compToDisplay -- used to composite -- obsolete
picToBuff brushToBuff buffToBuff buffToPic
rotationButton scaleButton -- submorphs, handles to do these actions.
strokeOrigin -- During Pickup, origin of rect.
cumRot cumMag -- cumulative for multiple operations from same original
undoBuffer
lastEvent
currentNib -- 1 bit deep form.
For now, we do not carry the SketchMorph's registration point, rotation center, or ticksToDwell.
New -- using transform morphs to rotate the finished player. How get it rotated back and the rotationDegrees to be right? We cancel out rotationDegrees, so how remember it?
Registration point convention:
In a GraphicFrame, reg point is relative to this image's origin.
During painting, it is relative to canvasRectangle origin, and thus us absolute within the canvas. To convert back, subract newBox origin.
Be sure to convert back and forth correctly. In deliverPainting. initializeFromFrame:inView:
Senders of it:
EventRecordingSpace dismantlePaintBoxArtifacts {commands}
EventRecordingSpace pausePlayback {commands}
GraphicalDictionaryMenu repaintEntry {menu commands}
Morph class allSketchMorphForms {testing}
PaintBoxMorph focusMorph {other}
PasteUpMorph makeNewDrawing:at: {world menu}
PasteUpMorph sketchEditorOrNil {world state}
SketchMorph editDrawingIn:forBackground: {menu}
StandardScriptingSystem benchmarkPainter {benchmarks}
TabbedPalette selectTab: {user-interface}
TabbedPalette showNoPaletteAndHighlightTab: {misc menu items}
TrashCanMorph findActivePaintBox {private}
SketchMorph
Morph subclass: #SketchMorph instanceVariableNames: 'originalForm rotationStyle scalePoint framesToDwell rotatedForm' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Basic'
The morph that results when the user draws a color bitmap using the PaintBox (SketchEditorMorph and PaintBoxMorph).
forwardDirection is the angle at which the object will go forward. When the rotationStyle is not #normal, then forwardDirection is any angle, while the rotation is highly restricted. If flexed, this is remembered by the Transform morph. For non-normal rotationStyle, it is rotationDegrees.
setupAngle (a property) is where the user put the green arrow to indicate which direction on the picture is forward. When #normal, draw the morph initially at (0.0 - setupAngle). The enclosing TransformationMorph then rotates it to the true angle.
rotationDegrees In a #normal object, rotationDegrees is constant an equal to setupAngle.
For non-normal, it is the direction the object is going.
When repainting, set it back to its original state. The green arrow is set to setupAngle, and the sketch is shown as drawn originally (rotationDegrees = 0).
rotationStyle = normal (turns), leftRight, upDown, fixed.
When leftRight upDown or fixed, bit map has severe restrictions.
Senders of it:
34 methods
Slider
MorphicModel subclass: #Slider instanceVariableNames: 'slider value setValueSelector sliderShadow sliderColor descending' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Windows'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of Slider.
SMLoader
SystemWindow subclass: #SMLoader instanceVariableNames: 'squeakMap packagesList selectedItemWrapper selectedCategoryWrapper filters categoriesToFilterIds' classVariableNames: 'DefaultCategoriesToFilterIds DefaultFilters' poolDictionaries: '' category: 'SMLoader'
A simple package loader that is the standard UI for SqueakMap.
Senders of it:
SMLoader reOpen {private}
TheWorldMenu class openPackageLoader {open-menu registry}
SolidSugarSuppliesTab
FlapTab subclass: #SolidSugarSuppliesTab instanceVariableNames: 'sugarNavTab' classVariableNames: '' poolDictionaries: '' category: 'Sugar'
Represents the horizontal "solid" tab by which the sugar-supplies flap can be resized. When the supplies flap is *closed*, the tab is invisible.
Senders of it:
Flaps class newSuppliesFlapFromQuads:positioning:withPreviousEntries: {predefined flaps}
PasteUpMorph sissWriteValue {*siss-interface}
Sonogram
ImageMorph subclass: #Sonogram instanceVariableNames: 'lastX scrollDelta columnForm minVal maxVal pixValMap' classVariableNames: '' poolDictionaries: '' category: 'Sound-Synthesis'
Sonograms are imageMorphs that will repeatedly plot arrays of values as black on white columns moving to the right in time and scrolling left as necessary.
Senders of it:
SampledSound sonogramMorph:from:to:nPoints: {sound tracks}
SpectrumAnalyzerMorph showSonogram {private}
SystemDictionary computeImageSegmentation {shrinking}
SorterTokenMorph
BorderedMorph subclass: #SorterTokenMorph instanceVariableNames: 'morphRepresented' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Palettes'
THIS CLASS HAS NO COMMENT!
Senders of it:
ReferenceMorph sorterToken {misc}
TabSorterMorph acceptSort {as yet unclassified}
SoundDemoMorph
AlignmentMorph subclass: #SoundDemoMorph instanceVariableNames: 'soundColumn' classVariableNames: '' poolDictionaries: '' category: 'Sound-Interface'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of SoundDemoMorph.
SoundEventMorph
AbstractMediaEventMorph subclass: #SoundEventMorph instanceVariableNames: 'sound' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-SoundInterface'
A morph representing a Sound event.
Senders of it:
RecordingControlsMorph makeSoundMorph {button commands}
SoundLibraryTool
AlignmentMorph subclass: #SoundLibraryTool instanceVariableNames: 'listBox button soundIndex currentSound showCompression' classVariableNames: '' poolDictionaries: '' category: 'Sound-Interface'
A tool for browsing and managing the sound library.
Offers a self-updating, scrolling list of all the sounds in the library.
Has a row of buttons to initiate various functions on the selected sound; the buttons are:
Play Play the selected sound
Stop Stop playing selected sound (if it is playing)
Tile Hand the user a tile for the selected sound.
Rename Rename the selected sound.
Delete Delete the selected sound from the ibrary
Load Load a sound into the sound library from a file.
Additionally, a wave-editor can be invoked via an item in the tool's halo menu.
The Sound Library tool can be launched from the Objects catalog, and also from the authoring-tools menu
Senders of it:
TheWorldMenu fullScriptingMenu {*Etoys}
TheWorldMenu scriptingMenu {*Etoys}
SoundLoopMorph
RectangleMorph subclass: #SoundLoopMorph instanceVariableNames: 'samplesUntilNextControl seqSound cursor controlIndex' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-SoundInterface'
THIS CLASS HAS NO COMMENT!
Senders of it:
SoundSequencerMorph initialize {initialization}
SoundMorph
ImageMorph subclass: #SoundMorph instanceVariableNames: 'sound' classVariableNames: '' poolDictionaries: '' category: 'Sound-Interface'
Note: as of December 2000, this does not work. SoundMorph>>buildImage requires the sound to implement #volumeEnvelopeScaledTo: and as yet, no one does.
Senders of it:
There are no senders of SoundMorph.
SoundReadoutTile
SymbolListTile subclass: #SoundReadoutTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
A tile comprising a readout for a sound-valued instance variable in a Viewer. It sports up/down arrows, and a click on the sound name results in a pop-up menu, offering the user the opportunity to choose a new one.
Senders of it:
SoundType newReadoutTile {*Etoys-tiles}
SoundSequencerMorph
RectangleMorph subclass: #SoundSequencerMorph instanceVariableNames: 'controlPanel' classVariableNames: '' poolDictionaries: '' category: 'Sound-Interface'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of SoundSequencerMorph.
SoundTile
TileMorph subclass: #SoundTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
A scripting tile representing a 'sound' constant. Sounds are represented by their names, which are strings; the actual sounds live in SampleSound's SoundLibrary.
Senders of it:
AnonymousSoundMorph addToSoundLibrary {menu}
CodecDemoMorph wantsDroppedMorph:event: {dropping/grabbing}
PasteUpMorph prepareToBeSaved {misc}
RecordingControls saveButtonHit {button commands}
RecordingControlsMorph makeTile {button commands}
ScriptEditorMorphBuilder literal: {reconstituting scripting tiles }
SoundLibraryTool handMeATile {menu}
SoundType defaultArgumentTile {*Etoys-tiles}
StandardScriptingSystem removeFromSoundLibrary: {sound library}
StandardScriptingSystem renameSound:newName: {sound library}
SpeakerMorph
Morph subclass: #SpeakerMorph instanceVariableNames: 'bufferSize buffer lastConePosition sound' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-SoundInterface'
THIS CLASS HAS NO COMMENT!
Senders of it:
Player stopProgramatically {scripts-execution}
ScriptInstantiation presentScriptStatusPopUp {customevents-status control}
SpectrumAnalyzerMorph
AlignmentMorph subclass: #SpectrumAnalyzerMorph instanceVariableNames: 'soundInput statusLight levelMeter graphMorph sonogramMorph fft displayType' classVariableNames: '' poolDictionaries: '' category: 'Sound-Interface'
I am a tool for analyzing sound data from a microphone, CD, or other input source in real time. I have several display modes:
signal snapshots of the raw signal data as it arrives
spectrum frequency spectrum of the signal data as it arrives
sonogram scrolling plot of the frequency spectrum over time,
where the vertical axis is frequency, the horizontal
axis is time, and amount of energy at a given
frequency is shown as a grayscale value with
larger values being darker
To use this tool, be sure that you have selected the proper sound source using you host OS facilities. Set the desired sampling rate and FFT size (try 22050 samples/sec and an FFT size of 512) then click on the 'start' button. Use the slider to adjust the level so that the yellow level indicator peaks somewhere between the middle and the right edge at the maximum signal level.
Note that if the level meter peaks hit the right edge, you will get 'clipping', which creates a bunch of spurious high frequency noise in the frequency spectrum. If the display is set to 'signal' mode, you can actually see the tops and bottoms of the waveform being cut off when clipping occurs.
Many machines may not be able to perform spectrum analysis in real time, especially at higher sampling rates and larger FFT sizes. In both 'signal' and 'spectrum' modes, this tool will skip data to try to keep up with real time. However, in 'sonogram' mode it always processes all the data, even if it falls behind. This allows you to get a complete sonogram without dropouts even on a slower machine. However, as the sonogram display falls behind there will be a larger and larger time lag between when a sound is input and when it appears on the display.
The smaller the FFT size, the less frequency resolution you get. The lower the sampling rate, the less total frequency range you get. For an FFT size of N and a sampling rate of R, each of the N/2 'bins' of the frequency spectrum has a frequency resolution of R / N. For example, at a sampleing rate of 22050 samples/second, the total frequency range is 0 to 11025 Hz and an FFT of size 256 would divide this range into 128 bins (the output of an FFT of size N has N/2 bins), each of which covers a frequency band about 86 Hz wide.
To increase time resolution, increase the sampling rate and decrease the FFT size.
Senders of it:
There are no senders of SpectrumAnalyzerMorph.
SpeechBubbleMorph (v5)
Morph subclass: #SpeechBubbleMorph instanceVariableNames: 'type balloon tail target lastHash stepTime msgMorph' classVariableNames: '' poolDictionaries: '' category: 'Etoys-SpeechBubbles'
THIS CLASS HAS NO COMMENT!
Senders of it:
Morph showGraphic:inBubbleType: {*Etoys-SpeechBubbles}
Morph showMessage:inBubbleType: {*Etoys-SpeechBubbles}
Morph showObject:inBubbleType: {*Etoys-SpeechBubbles}
SpeechBubbleMorph class supplementaryPartsDescriptions {parts bin}
SquishedNameMorph
Morph subclass: #SquishedNameMorph instanceVariableNames: 'target getSelector setSelector' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Navigators'
THIS CLASS HAS NO COMMENT!
Senders of it:
InternalThreadNavigationMorph addButtons {initialization}
StackMorph
BookMorph subclass: #StackMorph instanceVariableNames: 'cards' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Stacks'
A book that is very much like a HyperCard stack.
Each book page represents a different background. The page stays while different cards are projected onto it.
The data for a single card is stored in a CardPlayer. There is a list of objects that only appear on this card (privateMorphs) and the card-specific text to be inserted into the background fields.
Item How it is stored
a background a page of the StackMorph
a card data is in an instance of a subclass of CardPlayer.
A list of CardPlayers is in the 'cards' inst var of the StackMorph.
a background field a TextMorph on a page of the StackMorph
a background picture a morph of any kind on a page of the StackMorph
script for bkgnd button method in Player. Button is its costume.
text in a background field value of inst var 'field1' in a CardPlayer.
(The CardPlayer is also pointed at by the #cardInstance
property of the bkgnd field (TextMorph))
text in a card field in the TextMorph in privateMorphs in the CardPlayer.
picture on a card a morph of any kind in privateMorphs in the CardPlayer.
script for card button method in the CardPlayer. Button is its costume.
See VariableDock.
Senders of it:
DSCPostscriptCanvas fullDrawBookMorph: {*Etoys-drawing}
Flaps class defaultsQuadsDefiningScriptingFlap {flaps registry}
Flaps class defaultsQuadsDefiningStackToolsFlap {flaps registry}
ImageSegment findStacks {read/write segment}
Morph abstractAModel {*Etoys-card in a stack}
Morph explainDesignations {*Etoys-card in a stack}
Morph insertAsStackBackground {*Etoys-card in a stack}
Morph isStackBackground {*Etoys-card in a stack}
Morph stack {*Etoys-card in a stack}
Morph stackDo: {*Etoys-card in a stack}
Morph wrapWithAStack {*Etoys-card in a stack}
Player stackEmbodied {slot getters/setters}
Project currentStack {project parameters}
StackMorph class registerInFlapsRegistry {class initialization}
StandardViewer
Viewer subclass: #StandardViewer instanceVariableNames: 'firstPanel' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
A structure that allows you to view state and behavior of an object; it consists of a header and then any number of CategoryViewers.
Senders of it:
Morph currentVocabulary {*Etoys}
Object offerViewerMenuForEvt:morph: {*Etoys-viewer}
PasteUpMorph allViewersInProject {olpc}
Presenter nascentPartsViewer {viewer}
Presenter nascentPartsViewerFor: {viewer}
StandardScriptingSystem reinvigorateThumbnailsInViewerFlapTabs {*Etoys-utilities}
TabbedPalette viewMorph: {*Etoys-viewer tab}
TileMorph currentVocabulary {macpal}
StarMorph
PolygonMorph subclass: #StarMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Widgets'
I am a very flexible star..
Grab me from the supplies flap or from the graphic objects.
Add my handles and you can move and resize me.
The up and down arrows increase or reduce the number of my sides.
The right and left arrows change to try out different amounts of pointiness.
Use the arrows right and left of my center or get stars with a specific amount of pointyness. The left side goes from fat to thin and then cycles around again. The right goes from thin to fat. Hold down the shift key if you wish to stop the cycling.
Use the arrows above and below my center or use the menu to change the number of sides if you would like a different number of points.
To add or remove just one side hold the shift key down as you use the arrows or use the menu items for that purpose.
If you add or remove just one point I will have an odd number of sides. When that happens I can only look like a regular polygon. Add or remove just one more side and you can shift drag the outer handle to restore my pointiness.
At some time you will probably shift drag the outer handle thru the center handle.
While I looked round as you shrunk me, I will look very much like an asterisk as you pull me away. What happens is that inside bend shrunk on the way down because it can never be larger than the outer point or it wouldn't be the innerbend would it.
But on the way out it is perfectly happy to remain small. So I look like an asterisk.
To fatten me up (if you haven't already figured this out by fooling around) is to hold the shift down an move the outer handle towards the center (but not quite all the way) then let the shift up and move the outer handle away. A couple of cycles like this and I'll be looking fat and jolly again. Or you can now just use the right arrow to make me fatter.
This is also the reason I don't let the inside bend get larger than the outer point.
If I did the same process that fattened me when I was an asterisk would also grow an asterisk so large squeak would complain about not having enough memory.
Historical note:
The former star had two bugs that are fixed here.
The outer handle now no longer jumps from one point to another.
The other bug prevented some higher order stars from looking right.
Which is why the former star didn't allow you to change the number of points.
Senders of it:
EventRecordingSpace sugarPartsBinQuads {sugar flaps}
Flaps class defaultsQuadsDefiningPlugInSuppliesFlap {predefined flaps}
Flaps class defaultsQuadsDefiningSuppliesFlap {flaps registry}
Flaps class newLoneSuppliesFlap {predefined flaps}
MorphExample initialize {initialization}
StarMorph class registerInFlapsRegistry {class initialization}
StaticTextMorph
TextMorph subclass: #StaticTextMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Basic'
A TextMorph that is unwilling to be edited or rotated.
Senders of it:
EToyProjectDetailsMorph popUpEntryNamed: {utilities}
EToyProjectDetailsMorph popUpEntryNamed:menuTitle: {utilities}
StickyPadMorph
RectangleMorph subclass: #StickyPadMorph instanceVariableNames: '' classVariableNames: 'Colors LastColorIndex' poolDictionaries: '' category: 'MorphicExtras-Demo'
A custom item for the Squeakland Supplies bin, as defined by Kim Rose and BJ Con.A parts bin will deliver up translucent, borderless Rectangles in a sequence of 6 colors. It offers some complication to the parts-bin protocols in two ways::
* The multi-colored icon seen in the parts bin is not a thumbnail of any actual instance, all of which are monochrome
* New instances need to be given default names that are not the same as the name seen in the parts bin.
Senders of it:
Flaps class possiblyReplaceEToyFlaps {construction support}
Flaps class twiddleSuppliesButtonsIn: {predefined flaps}
StickyPadMorph class registerInFlapsRegistry {as yet unclassified}
StickySketchMorph
SketchMorph subclass: #StickySketchMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Support'
THIS CLASS HAS NO COMMENT!
Senders of it:
PasteUpMorph backgroundSketch: {*Etoys-playfield}
PasteUpMorph findWindow: {world menu}
StoryboardBookMorph
BookMorph subclass: #StoryboardBookMorph instanceVariableNames: 'alansSliders panAndTiltFactor zoomFactor zoomController' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Books'
A BookMorph variant whose pages are instances of ZoomAndScrollMorph. I have a control area where the user may pan, tilt and zoom over the image shown in the page.
- drag up and down to zoom in and out
- drag left and right to pan
- shift-drag up and down to tilt.
Senders of it:
ZoomAndScrollControllerMorph turnToPage:position:scale:transition: {as yet unclassified}
StretchyImageMorph
AlignmentMorphBob1 subclass: #StretchyImageMorph instanceVariableNames: 'form cache' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Experimental'
I draw a form to fill whatever bounds I have.
Senders of it:
EToyProjectHistoryMorph rebuild {as yet unclassified}
StringButtonMorph
StringMorph subclass: #StringButtonMorph instanceVariableNames: 'target actionSelector arguments actWhen oldColor' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of StringButtonMorph.
StringMorph
Morph subclass: #StringMorph instanceVariableNames: 'font emphasis contents hasFocus usePango' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Basic'
StringMorph is a "lightweight" Morph to display a String. It supports only a single font, color, and emphasis combination. For multiple text styles, use TextMorph.
Structure:
instance var Type Description
font StrikeFont (normally nil; then the accessor #font gives back TextStyle
or nil defaultFont)
emphasis SmallInteger bitmask determining character attributes (underline, bold, italics, narrow, struckout)
contents String The text that will be displayed.
hasFocus Boolean Do I have the keyboard focus or not?
If you shift-click on a StringMorph you can edit its string. This is accomplished the following way: StringMorph can launch a StringMorphEditor if it receives a #mouseDown event.
A StringMorph may also be used like a SimpleButtonMorph to do an action when clicked. Use the menu 'extras' / 'add mouseUpAction'.
The following propery will be defined:
aStringMorph valueOfProperty: #mouseUpCodeToRun
Senders of it:
215 methods
StringMorphEditor
TextMorph subclass: #StringMorphEditor instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Text Support'
I am a textMorph used as a pop-up editor for StringMorphs. I present a yellow background and I go away when a CR is typed or when the user clicks elsewhere.
Senders of it:
StringMorph launchMiniEditor: {editing}
UpdatingStringMorph doneWithEdits {editing}
StringReadoutTile
TileMorph subclass: #StringReadoutTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
THIS CLASS HAS NO COMMENT!
Senders of it:
DataType newReadoutTile {*Etoys-tiles}
SugarButton
ThreePhaseButtonMorph subclass: #SugarButton instanceVariableNames: 'mouseDownTime didMenu labelName highLightColor disabledImage' classVariableNames: '' poolDictionaries: '' category: 'Sugar'
THIS CLASS HAS NO COMMENT!
Senders of it:
SugarLibrary makeButton:balloonText:for:target:baseColor:highLightColor: {icon images}
SugarListenerMorph
EToyListenerMorph subclass: #SugarListenerMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Sugar'
THIS CLASS HAS NO COMMENT!
Senders of it:
EToyIncomingMessage class handleNewMorphFrom:sentBy:ipAddress: {handlers}
PasteUpMorph deleteListeners {misc}
SugarNavigatorBar startP2P {sharing}
SugarNavigatorBar
ProjectNavigationMorph subclass: #SugarNavigatorBar instanceVariableNames: 'sugarLib highLightColor paintButton undoButton shareButton stopButton supplies listener suppliesFlap projectNameField isSugar' classVariableNames: '' poolDictionaries: '' category: 'Sugar'
THIS CLASS HAS NO COMMENT!
Senders of it:
Flaps class newSugarNavigatorFlap {predefined flaps}
HelpFlap spanContainerVertically: {geometry}
Project class enterNewWithInitialBalloons {instance creation}
StandardScriptingSystem customizeForEToyUsers: {utilities}
SugarLauncher invite: {commands}
SugarLauncher joinSharedActivity {presence}
SugarLauncher startUp {running}
SugarNavigatorBar class configureCurrentForSqueakland {utilitity}
SugarNavigatorBar class current {instance creation}
SugarNavigatorBar class putUpInitialBalloonHelp {utilitity}
SugarNavigatorBar class supplementaryPartsDescriptions {utilitity}
SugarNavTab nonStandardMorphs {initialization}
TheWorldMenu offerScalingMenu {menu}
SugarNavTab
FlapTab subclass: #SugarNavTab instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Sugar'
THIS CLASS HAS NO COMMENT!
Senders of it:
EventRecordingSpace sugarSuppliesFlapTab {sugar flaps}
Flaps class newSugarNavigatorFlap {predefined flaps}
PasteUpMorph sissWriteValue {*siss-interface}
PasteUpMorph sugarAllowance {world state}
PasteUpMorph toggleFullScreen {menu}
Player hideNavigationBar {misc}
Player showNavigationBar {misc}
Project finalEnterActions {menu messages}
SketchMorph collapse {menus}
SugarNavigatorBar checkForResize {morphic interaction}
ViewerFlapTab spanWorld {positioning}
SugarRoundedField
Morph subclass: #SugarRoundedField instanceVariableNames: 'label mask backgroundColor' classVariableNames: '' poolDictionaries: '' category: 'Sugar'
THIS CLASS HAS NO COMMENT!
Senders of it:
SugarNavigatorBar makeProjectNameLabel {the actions}
SugarSuppliesTab
FlapTab subclass: #SugarSuppliesTab instanceVariableNames: 'sugarNavTab' classVariableNames: '' poolDictionaries: '' category: 'Sugar'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of SugarSuppliesTab.
SymbolListTile
TileMorph subclass: #SymbolListTile instanceVariableNames: 'choices dataType' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
Instances of SymbolListTile are literal tiles whose literals are choosable from a finite list.
Senders of it:
ConnectorArrowNameType class updateNames {as yet unclassified}
ScriptEditorMorphBuilder literal: {reconstituting scripting tiles }
StandardScriptingSystem addUserCustomEventNamed:help: {*Etoys-customevents-custom events}
StandardScriptingSystem removeUserCustomEventNamed: {*Etoys-customevents-custom events}
SymbolListType defaultArgumentTile {*Etoys-tiles}
SymbolListType newReadoutTile {*Etoys-tiles}
Vocabulary class addArrowNamesVocabulary {*connectors}
Vocabulary class addCustomEventsVocabulary {*eToys-customevents-custom events}
SyntaxMorph
AlignmentMorph subclass: #SyntaxMorph instanceVariableNames: 'parseNode markerMorph' classVariableNames: 'AllSpecs ContrastFactor DownRightArrow SelfTile SizeScaleFactor' poolDictionaries: '' category: 'Etoys-Tile Scriptors'
A single class of morph that holds any piece of Smalltalk syntax, and allows it to be a tile. Tiles can be dragged in or out of a method.
In the message list pane of a Browser, choose 'tile scriptor'. Bring up a second one to steal parts from. If you use a Protocol Browser, and choose tiles, there will be two buttons that bring up menus with many tiles on them.
Clicking multiple times selects enclosing phrases of code. Dragging lets you take away a copy. Any tile may be replaced by dropping on it. Shift-click to edit the text of any tile. Change variable and message names, but do not change the part-of-speech (objects to selector).
Each SyntaxMorph holds a ParseNode. After editing, the parseNode is only good as a part-of-speech indicator. Only the Class of a parseNode is important. It's state is not kept up to date with the tile edits (but maybe it should be). (For MessageNodes, whether the receiver slot is nil is significant.)
The correspondence between SyntaxMorphs and parseNodes in the real parse tree is not one-to-one. Several extra levels of SyntaxMorph were added as aligners to make the horizontal and vertical layout right. These sometimes have nil for the parseNode.
When accept the method, we pass over the tree of SyntaxMorphs, gathering their printStrings and inserting punctuation. See (SyntaxMorph>>printOn:indent:). We send the result to the compiler. (We do not use the parse tree we already have.)
To turn on type checking:
Preferences enable: #eToyFriendly
or for testing: World project projectParameters at: #fullCheck put: true.
Colors of tiles: Each tile has a current color (inst car color) and a deselectedColor (a property). The deselectedColor may be governed by the part of speech, or not. (translateColor: is only used when a tile is created, to set deselectedColor.) From deselectedColor (set by #setDeselectedColor), the color changes to:
lightBrown when selected (not the submorphs) in #select
translucent when held in the hand (allMorphs) in #lookTranslucent
green when a drop target (allMorphs) (change the owners back) #dropColor,
#trackDropZones
deselectedColor is moderated by the darkness setting, #scaleColorByUserPref:. (as it is put into color in #color:)
Code to produce an individual tile is:
(SyntaxMorph new) attachTileForCode: '''abc''' nodeType: LiteralNode.
see offerTilesMenuFor:in: for many other phrases that produce useful tiles.
AssignmentNode: If three submorphs, is a statement, and is a noun. If one submorph, is just the left arrow. When dropped on a variable, it creates a new assignment statement.
Senders of it:
CodeHolder installTilesForSelection {tiles}
Debugger createSyntaxMorph {code pane}
Lexicon acceptTiles {*Etoys-tiles}
Lexicon installTilesForSelection {tiles}
Lexicon tilesMenu {*Etoys-tiles}
Lexicon varTilesMenu {*Etoys-tiles}
MessageSend asTilesIn: {*Etoys-tiles}
MessageSend asTilesIn:globalNames: {*Etoys-tiles}
Morph methodCommentAsBalloonHelp {accessing}
ParseNode addCommentToMorph: {*Etoys-tiles}
Player newScriptorAround: {viewer}
Player class tilesFrom: {scripts}
PluggableTileScriptorMorph syntaxMorph {as yet unclassified}
Presenter cacheSpecs: {viewer}
ScriptEditorMorph insertUniversalTilesForClass:selector: {other}
ScriptEditorMorph scriptTitle {buttons}
StringHolder openSyntaxView {*Etoys-tiles}
SyntaxMorph actualObject {accessing}
SyntaxMorph color: {accessing}
SyntaxMorph foldMessage {layout}
SyntaxMorph foldMessageOneArg {layout}
SyntaxMorph instVarTile: {new tiles}
SyntaxMorph morphToDropInPasteUp: {dropping/grabbing}
SyntaxMorph string:toTilesIn: {new tiles}
SyntaxMorph class testAll {as yet unclassified}
SyntaxMorph class testAllMethodsOver: {as yet unclassified}
SyntaxMorph class testClass:andMethod: {as yet unclassified}
SyntaxTestMethods
PasteUpMorph subclass: #SyntaxTestMethods instanceVariableNames: 'letterActors wild leftMargin rightMargin switch current jumpSwitch hotIndex' classVariableNames: 'Goal' poolDictionaries: '' category: 'Etoys-Tile Scriptors'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of SyntaxTestMethods.
SyntaxUpdatingStringMorph
UpdatingStringMorph subclass: #SyntaxUpdatingStringMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Tile Scriptors'
THIS CLASS HAS NO COMMENT!
Senders of it:
SyntaxMorph anUpdatingStringMorphWith:special: {alans styles}
SystemProgressBarMorph
RectangleMorph subclass: #SystemProgressBarMorph instanceVariableNames: 'barSize' classVariableNames: 'BarHeight BarWidth FillColor' poolDictionaries: '' category: 'Morphic-Widgets'
Instances of this morph get used by SystemProgressMoprh to quickly display a progress bar.
Senders of it:
SystemProgressMorph nextSlotFor: {private}
SystemProgressMorph nextSlotUnifiedFor: {private}
SystemProgressMorph
RectangleMorph subclass: #SystemProgressMorph instanceVariableNames: 'activeSlots bars labels font lock' classVariableNames: 'BarHeight BarWidth UniqueInstance' poolDictionaries: '' category: 'Morphic-Widgets'
An single instance of this morph class is used to display progress while the system is busy, eg. while it receives code updates or does a fileIn. To give the user progress information you don't deal directly with SystemProgressMorph. You keep on using the well established way of progress notification, that has been a long time in the system, is widely used and does not depend on the existence of SystemProgressMorph. For more information on this look at the example in this class or look at the comment of the method displayProgressAt:from:to:during: in class String.
SystemProgressMorph is not meant to be used as a component inside other morphs.
You can switch back to the old style of progress display by disabling the morphicProgressStyle setting in the morphic section of the preferences.
Senders of it:
ProgressInitiationException defaultMorphicAction {as yet unclassified}
SystemQueryPhrase
PhraseTileMorph subclass: #SystemQueryPhrase instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
THIS CLASS HAS NO COMMENT!
Senders of it:
Presenter systemQueryPhraseWithActionString:labelled: {palette & parts bin}
StandardScriptingSystem tilesForQuery:label: {*Etoys-parts bin}
SystemWindow
MorphicModel subclass: #SystemWindow instanceVariableNames: 'labelString stripes label closeBox collapseBox activeOnlyOnTop paneMorphs paneRects collapsedFrame fullFrame isCollapsed menuBox mustNotClose labelWidgetAllowance updatablePanes allowReframeHandles labelArea expandBox' classVariableNames: 'CloseBoxImage CollapseBoxImage TopWindow' poolDictionaries: '' category: 'Morphic-Windows'
SystemWindow is the Morphic equivalent of StandardSystemView -- a labelled container for rectangular views, with iconic facilities for close, collapse/expand, and resizing.
The attribute onlyActiveOnTop, if set to true (and any call to activate will set this), determines that only the top member of a collection of such windows on the screen shall be active. To be not active means that a mouse click in any region will only result in bringing the window to the top and then making it active.
Senders of it:
95 methods
Arrow Editor, Attachment Adjuster are implemented in this class.
SystemWindowWithButton
SystemWindow subclass: #SystemWindowWithButton instanceVariableNames: 'buttonInTitle' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Windows'
A SystemWindow with a single extra button in its title bar.
Senders of it:
Preferences class annotationEditingWindow {parameters}
TabbedPalette
BookMorph subclass: #TabbedPalette instanceVariableNames: 'tabsMorph' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Palettes'
A structure of tabs and associated books. Pressing a tab brings into focus the associated book. Some tabs can have simple actions rather than books as their focus -- in this case, the palette is cleared and the action taken.
Senders of it:
Flaps class defaultsQuadsDefiningSuppliesFlap {flaps registry}
Flaps class newLoneSuppliesFlap {predefined flaps}
PartsBin class reconstructAllPartsIcons {thumbnail cache}
Preferences class initializePreferencePanel:in: {preferences panel}
PreferencesPanel findPreferencesMatching: {initialization}
PreferencesPanel switchToCategoryNamed:event: {category switch}
PreferencesPanel class isAPreferenceViewToKill: {cleanup}
ReferenceMorph tabSelected {events}
StandardViewer dismiss {user interface}
TabMorph tabSelected {as yet unclassified}
TabMorph
StringButtonMorph subclass: #TabMorph instanceVariableNames: 'morphToInstall' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Palettes'
A tab in a palette. The contents is the name to be shown. If it represents a book, that book is pointed to in my morphToInstall.
Senders of it:
IndexTabs tabMorphs {tabs}
TabSorterMorph
BookPageSorterMorph subclass: #TabSorterMorph instanceVariableNames: 'originalTabs' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Palettes'
A sorter for the tabs of a TabbedPalette
Senders of it:
TabbedPalette sortTabs: {misc menu items}
TestInWorldMorph (v4 but not v5)
Morph subclass: #TestInWorldMorph instanceVariableNames: 'intoWorldCount outOfWorldCount' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Kernel-Tests'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of TestInWorldMorph.
Tetris
AlignmentMorph subclass: #Tetris instanceVariableNames: 'board scoreDisplay' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Games'
This is a port of JTetris.java 1.0.0.
How to start:
choose new morph.../Games/Tetris
How to play:
1) using buttons
2) using keyboard:
drop - spacebar
move to left - left arrow
move to right - right arrow
rotate clockwise - up arrow
rotate anticlockwise - down arrow
NOTE: mouse must be over Tetris
Senders of it:
TetrisBlock defaultColor {initialization}
TetrisBlock
Morph subclass: #TetrisBlock instanceVariableNames: 'angle shapeInfo board baseCellNumber' classVariableNames: 'ShapeChoices' poolDictionaries: '' category: 'Morphic-Games'
THIS CLASS HAS NO COMMENT!
Senders of it:
TetrisBoard step {stepping and presenter}
TetrisBoard
PasteUpMorph subclass: #TetrisBoard instanceVariableNames: 'paused gameOver delay score currentBlock game' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Games'
THIS CLASS HAS NO COMMENT!
Senders of it:
Tetris initialize {initialization}
TextComponent
PluggableTextMorph subclass: #TextComponent instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Components'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of TextComponent.
TextFieldMorph
RectangleMorph subclass: #TextFieldMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Text Support'
Act as a field in a HyperCard-like setting. Has both properties of a Rectangle, and exposes some proteries of the TextMorph it owns.
Senders of it:
Flaps class defaultsQuadsDefiningScriptingFlap {flaps registry}
Player append: {scripts-standard}
Player includeAtCursor: {scripts-standard}
Player prepend: {scripts-standard}
TextFieldMorph class registerInFlapsRegistry {class initialization}
TextMorph
RectangleMorph subclass: #TextMorph instanceVariableNames: 'textStyle text wrapFlag paragraph editor container predecessor successor backgroundColor margins fillStyle usePango' classVariableNames: 'CaretForm' poolDictionaries: '' category: 'Morphic-Basic'
TextMorphs support display of text with emphasis. They also support reasonable text-editing capabilities, as well as embedded hot links, and the ability to embed submorphs in the text.
Late in life, TextMorph was made a subclass of BorderedMorph to provide border and background color if desired. In order to keep things compatible, protocols have been redirected so that color (preferably textColor) relates to the text, and backgroundColor relates to the inner fill color.
Text display is clipped to the innerBounds of the rectangle, and text composition is normally performed within a rectangle which is innerBounds inset by the margins parameter.
If text has been embedded in another object, one can elect to fill the owner's shape, in which case the text will be laid out in the shape of the owner's shadow image (including any submorphs other than the text). One can also elect to have the text avoid occlusions, in which case it will avoid the bounds of any sibling morphs that appear in front of it. It may be necessary to update bounds in order for the text runaround to notice the presence of a new occluding shape.
The optional autoFitContents property enables the following feature: if the text contents changes, then the bounds of the morph will be adjusted to fit the minimum rectangle that encloses the text (plus any margins specified). Similarly, any attempt to change the size of the morph will be resisted if this parameter is set. Except...
If the wrapFlag parameter is true, then text will be wrapped at word boundaries based on the composition width (innerBounds insetBy: margins) width. Thus an attempt to resize the morph in autofit mode, if it changes the width, will cause the text to be recomposed with the new width, and then the bounds will be reset to the minimum enclosing rectangle. Similarly, if the text contents are changed with the wrapFlag set to true, word wrap will be performed based on the current compostion width, after which the bounds will be set (or not), based on the autoFitcontents property.
Note that fonts can only be applied to the TextMorph as a whole. While you can change the size, color, and emphasis of a subsection of the text and have it apply to only that subsection, changing the font changes the font for the entire contents of the TextMorph.
Still a TextMorph can be composed of several texts of different fonts
| font1 font2 t1 t2 tMorph|
tMorph _ TextMorph new.
font1 _ (TextFontReference toFont: (StrikeFont familyName: 'Atlanta' size: 22)).
font2 _ (TextFontReference toFont: (StrikeFont familyName: 'Atlanta' size: 11)).
t1 _ 'this is font1' asText addAttribute: font1.
t2 _ ' and this is font2' asText addAttribute: font2.
tMorph contents: (t1,t2).
tMorph openInHand.
Yet to do:
Make a comprehensive control for the eyedropper, with border width and color, inner color and text color, and margin widths.
Senders of it:
76 methods
TextMorphForEditView
TextMorph subclass: #TextMorphForEditView instanceVariableNames: 'editView acceptOnCR' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Text Support'
THIS CLASS HAS NO COMMENT!
Senders of it:
ParagraphEditor changeEmphasis: {editing keys}
PluggableTextMorph textMorphClass {private}
TextPlusMorph
TextMorph subclass: #TextPlusMorph instanceVariableNames: 'scrollerOwner ignoreNextUp' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-GeeMail'
THIS CLASS HAS NO COMMENT!
Senders of it:
SmartRefStream alansTextPlusMorphbosfcebbmsopssrsggshtt0 {conversion}
SmartRefStream initKnownRenames {read write}
TextPlusPasteUpMorph acceptDroppingMorph:event: {layout}
TextPlusPasteUpMorph allTextPlusMorphs {as yet unclassified}
TextPlusPasteUpMorph initialize {initialization}
TextPlusPasteUpMorph
category: 'MorphicExtras-GeeMail'
THIS CLASS HAS NO COMMENT!
Senders of it:
GeeMailMorph initializeThePasteUp {initialization}
Morph addMiscExtrasTo: {*MorphicExtras-menus}
TextAnchorPlus emphasizeScanner: {as yet unclassified}
TextPropertiesMorph
GenericPropertiesMorph subclass: #TextPropertiesMorph instanceVariableNames: 'activeTextMorph applyToWholeText lastGlobalColor selectionInterval' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Experimental'
A custom property-sheet for use with TextMorphs. Initially implemented in 2001 by Bob Arning, for Alan Kay.
In this current version, circa May 2007, for an early version of etoys on the olpc, the inboard copy of the text is dispensed with, as are some of the checkboxes, and all operations are reflected directly on the actual TextMorph under edit. The last manual selection the user made in the TextMorph determines the scope of the edits in the property-sheet. After property-sheet edits, the selection highlighting is also dispensed with, so that the user can judge the text's appearance better.
Note that unlike other property-sheet-morphs, the thingsToRevert here is an ordered-collection rather than a dictionary... this is so we can control the order of execution of the restorations.
Senders of it:
Morph openATextPropertySheet {meta-actions}
TextMorph openATextPropertySheet {property sheet}
TextualEventSequenceDisplayer
AlignmentMorph subclass: #TextualEventSequenceDisplayer instanceVariableNames: 'mouseEventSequenceMorph' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
A tool that displays the events comprising a mouse-event-sequence in a scrolling textual list. This is not an editor, not yet anyway... Consider it a tantalizing loose end at the moment.
Senders of it:
MouseEventSequenceMorph openExpandedView: {menu}
MouseEventSequenceMorph openTextualView {menu}
ThreadNavigationMorph
AlignmentMorphBob1 subclass: #ThreadNavigationMorph instanceVariableNames: 'listOfPages currentIndex loadedProject' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Navigators'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of ThreadNavigationMorph.
ThreePhaseButtonMorph
ImageMorph subclass: #ThreePhaseButtonMorph instanceVariableNames: 'offImage pressedImage state target actionSelector arguments actWhen' classVariableNames: 'AuthorModeOwner' poolDictionaries: '' category: 'Morphic-Widgets'
A button morph with separate images for on, off, and pressed with the mouse.
When the event actWhen occurs, send actionSelector with 'arguments' to target. For other events, default to my eventHandler. The current event is not supplied in the arguments to the actionSelector.
image (a.k.a. onImage) may not be nil. offImage and pressedImage may be nil. nil there means be transparent and show the underlying object.
actWhen = #buttonDown :
state is never changed when mouse pressed or released. doButtonAction:
actWhen = #buttonUp :
state is #pressed when mouse pressed.
state is #on when mouse released and the focus is in the button. doButtonAction:
state is #off when mouse released and the focus is out of the button.
actWhen = #whilePressed :
state is #pressed when mouse pressed. doButtonAction:
state is #off when mouse released.
Tools for debugging:
Display the images momentarily under program control (for positioning) (self is an instance).
self state: #on. self state: #off.
self state: #pressed. self state: #off.
Display a rectangle where the button is.
Display fillWithColor: bounds + (self world viewBox origin).
self invalidRect: bounds.
Senders of it:
29 methods
Thumbnail
SketchMorph subclass: #Thumbnail instanceVariableNames: 'maximumWidth minimumHeight' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-PartsBin'
A morph that serves as a thumbnail of a given form.
Senders of it:
GraphicalDictionaryMenu initializeFor:fromDictionary: {initialization}
GraphicalMenu initializeFor:withForms:coexist: {initialization}
IconicButton initializeToShow:withLabel:andSend:to: {*MorphicExtras-initialization}
NCButtonBar class emptyButtonThumbnail {instance creation}
NCMakerButton generateThumbnail {submorphs-add/remove}
PartsBin class cacheSpecialThumbnails {thumbnail cache}
PartsBin class thumbnailForInstanceOf: {thumbnail cache}
PartsBin class thumbnailForPartsDescription: {thumbnail cache}
PartsBin class thumbnailForQuad:color: {thumbnail cache}
VideoMorph class initialize {class initialization}
ThumbnailForAllPlayersTool
ThumbnailMorph subclass: #ThumbnailForAllPlayersTool instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
A thumbnail for use in an All-Players tool
Senders of it:
PlayerSurrogate rebuildRow {accessing}
ThumbnailMorph
RectangleMorph subclass: #ThumbnailMorph instanceVariableNames: 'objectToView viewSelector lastSketchForm lastFormShown drawTime' classVariableNames: 'EccentricityThreshhold RecursionDepth RecursionMax' poolDictionaries: '' category: 'MorphicExtras-Widgets'
A Morph that views another morph, its objectToView.
Senders of it:
GraphicTile useForm: {initialization}
GraphicType updatingTileForTarget:partName:getter:setter: {*Etoys-tiles}
PasteUpMorph restoreMorphicDisplay {world state}
Presenter startRunningScripts {stop-step-go buttons}
StandardScriptingSystem reinvigorateThumbnailsInViewerFlapTabs {*Etoys-utilities}
StandardScriptingSystem spaceReclaimed {*Etoys-utilities}
StandardViewer addHeaderMorphWithBarHeight:includeDismissButton: {initialization}
ViewerFlapTab graphicalMorphForTab {menu}
TickIndicatorMorph
EllipseMorph subclass: #TickIndicatorMorph instanceVariableNames: 'stepTime corners index range isTicking lastTick' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
ScriptStatusControl assurePauseTickControlsShow {initialization}
TileCommandWithArgumentMorph
TileMorph subclass: #TileCommandWithArgumentMorph instanceVariableNames: 'playerTile stringName' classVariableNames: '' poolDictionaries: '' category: 'EToys-Kedama'
THIS CLASS HAS NO COMMENT!
Senders of it:
PhraseTileMorph operatorNodeWith: {code generation}
PhraseTileMorph setAngleToOperator:type:rcvrType:argType: {initialization}
PhraseTileMorph setBounceOnOperator:type:rcvrType:argType: {initialization}
PhraseTileMorph setDistanceToOperator:type:rcvrType:argType: {initialization}
PhraseTileMorph setGetPixelOperator:type:rcvrType:argType: {initialization}
PhraseTileMorph setTurtleOfOperator:type:rcvrType:argType: {initialization}
PhraseTileMorph setUpHillOperator:type:rcvrType:argType: {initialization}
PhraseTileMorph sexpOperatorWith: {code generation}
PhraseTileMorph updatingOperatorNodeWith: {code generation}
Viewer angleToPhrase {special phrases}
Viewer bounceOnPhrase {special phrases}
Viewer distanceToPhrase {special phrases}
Viewer patchUphillPhrase {special phrases}
Viewer patchValuePhrase {special phrases}
Viewer turtleOfPhrase {special phrases}
TileLikeMorph
AlignmentMorph subclass: #TileLikeMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
THIS CLASS HAS NO COMMENT!
Senders of it:
ScriptEditorMorph nextTile {*etoys-debugger}
TileMorph
RectangleMorph subclass: #TileMorph instanceVariableNames: 'type slotName literal operatorOrExpression actualObject downArrow upArrow suffixArrow typeColor lastArrowTick nArrowTicks operatorReadoutString possessive retractArrow vocabulary vocabularySymbol' classVariableNames: 'DownPicture EqualityOperators RetractPicture SuffixArrowAllowance SuffixPicture UpArrowAllowance UpdatingOperators UpPicture' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
A tile with up, down and suffix arrows.
To install new Forms for the arrows, just nil out UpPicture, DownPicture,
or SuffixPicture.
Create actors with the picture you want and write it out with these file names:
'tile inc arrow.morph' 'tile dec arrow.morph' 'tile suffix
arrow.morph'. Make sure that file is in the same directory as the image.
Open an EToy.
Properties for pop up arrow
#previousLiteral : Object -- last literal.
#previousPoint : Point -- last mouse position to use dragging arrow.
#isPopArrowNeeded : Boolean -- true if arrows are needed.
#popArrows (of HandMorph) : An array of Morph -- It points arrows for each hand.
Senders of it:
72 methods
TilePadMorph
Morph subclass: #TilePadMorph instanceVariableNames: 'type' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
The drop target for colored tiles. Landing pad. In the hierarchy, but not a tile itself. Would like to eliminate this, but an attempt at it failed.
Senders of it:
52 methods
TimesRepeatMorph
CompoundTileMorph subclass: #TimesRepeatMorph instanceVariableNames: 'numberOfTimesToRepeatPart whatToRepeatPart' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
This class is not used anymore. We keep it to let old projects work.
If we added code to auto-convert old instances of this classs[sic] to TimesRepeatTile instances, we could delete it for good.
Senders of it:
There are no senders of TimesRepeatMorph.
TimesRepeatTile
CompoundTileMorph subclass: #TimesRepeatTile instanceVariableNames: 'timesRow whatToRepeatPart' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
A variant on the CompoundTileMorph that allows a section of code to be executed as many times as a numeric-control-field indicates. For reasons of sharing and history, the CompoundTileMorph continues to be the one for test/yes/no, and this subclass disregards those three areas and adds two of its own. An associated class is the TimesRow -- see its class comment.
Senders of it:
PhraseTileForTimesRepeat mouseDown: {mouse}
ScriptEditorMorph handUserTimesRepeatTile {other}
ScriptEditorMorph sissComeFullyUpOnReloadFrom:to: {serializations}
ScriptEditorMorphBuilder loop: {reconstituting scripting tiles }
StandardScriptingSystem timesRepeatComplexOfTiles {gold box}
TileMorph showSuffixChoices {arrows}
TimesRow
AlignmentMorph subclass: #TimesRow instanceVariableNames: 'timesPad' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
A custom alignment morph that holds the "times' portion of a Times/Repeat complex
Senders of it:
TileMorph couldAddSuffixArrow {arrows}
TimesRepeatTile initialize {initialization}
TinyPaint
SketchMorph subclass: #TinyPaint instanceVariableNames: 'brush brushSize brushColor lastMouse' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of TinyPaint.
TransferMorph
Morph subclass: #TransferMorph instanceVariableNames: 'transferType passenger draggedMorph source dropNotifyRecipient accepted resultRecipient copy' classVariableNames: 'CopyPlusIcon' poolDictionaries: '' category: 'Morphic-Support'
This is a Morph that is used to visually indicate the progress of a drag operation, and also as a container for various bits of drag state information.
It polls the shift state in its step method to update its copy state (shift pressed = should copy).
And if you hit the Escape key while dragging, it aborts the drag operation.
Senders of it:
FileList wantsDroppedMorph:event:inMorph: {drag'n'drop}
PluggableListMorph startDrag: {drag and drop}
SimpleHierarchicalListMorph startDrag: {event handling}
TransferMorphAnimation
Morph subclass: #TransferMorphAnimation instanceVariableNames: 'transferMorph' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Support'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of TransferMorphAnimation.
TransferMorphLineAnimation
TransferMorphAnimation subclass: #TransferMorphLineAnimation instanceVariableNames: 'polygon' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Support'
THIS CLASS HAS NO COMMENT!
Senders of it:
Browser dragAnimationFor:transferMorph: {drag and drop}
TransformationB2Morph
TransformationMorph subclass: #TransformationB2Morph instanceVariableNames: 'worldBoundsToShow useRegularWarpBlt' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Demo'
A transformation which:
- is content to let someone else decide my bounds (I do not try to minimally enclose my submorphs)
- can use bi-linear interpolation
Senders of it:
ZoomAndScrollMorph createInteriorTransform {initialization}
TransformationMorph
TransformMorph subclass: #TransformationMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Basic'
A TransformationMorph is like a transformMorph, except that it does not clip, and its bounds include its entire submorph. TransformationMorphs are assumed to have only one submorph -- the idea is that it is a wrapper that enables its submorph to scale and rotate. A TMorph may come to have more than one submorph if, eg, a menu sprouts a sub menu, using the transformationMorph temporarily as its world, but this ability is only sparsely supported (as in layoutChanged).
Senders of it:
EmbeddedWorldBorderMorph myTransformation {as yet unclassified}
EnvelopeEditorMorph buildScalesIn: {editing}
Morph color:sees: {geometry eToy}
Morph newTransformationMorph {rotate scale and flex}
Morph slideBackToFormerSituation: {dropping/grabbing}
Morph touchesColor: {geometry eToy}
PasteUpMorph attemptCleanupReporting: {*Etoys-world menu}
SystemWindow class windowsIn:satisfying: {top window}
TransformationMorph flexing:byTransformation: {initialization}
TransformMorph
Morph subclass: #TransformMorph instanceVariableNames: 'transform smoothing localBounds' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Basic'
A TransformMorph introduces a 2-D transformation between its (global) coordinates and the (local) coordinates of its submorphs, while also clipping all display to its bounds. Specifically, with no offset, angle or scaling, a submorph with coordinates (0@0) will appear exactly at the topLeft of the windowMorph (its position). Rotation and scaling are relative to the local origin, (0@0).
instance var type description
transform MorphicTransform The coordinate transform between my coordinates and the
local coordinates of my submorphs.
smoothing Boolean Perform smoothing of my contents during drawing
localBounds Rectangle or nil caches the value of #localSubmorphBounds for performance
TransformMorphs operate with two different display strategies, depending on whether the transformation is a pure translation or not. If so, then they simply use a clipping canvas and display their submorphs with the appropriate offset. If the transformation includes scaling or rotation, then a caching canvas is used, whose active area covers the fullBounds of the submorphs intersected with the source quadrilateral corresponding to the window bounds.
Senders of it:
Lexicon acceptTiles {*Etoys-tiles}
PasteUpMorph modelWakeUp {user interface}
Player getRotationCenter {slots-bonus for geometry}
Player setRotationCenter: {slots-bonus for geometry}
PluggableTileScriptorMorph syntaxMorph {as yet unclassified}
ScrollPane initializeScrollBars {initialization}
SyntaxMorph enclosingPane {accessing}
TwoWayScrollPane createScroller {initialization}
TransitionMorph
Morph subclass: #TransitionMorph instanceVariableNames: 'startMorph endMorph startBlock completionBlock stepNumber nSteps stepTime startForm endForm effect direction' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Widgets'
A transitionMorph inserts itself in the morphic object structure during a visual transition. It has a stepNumber that runs from 1 to nSteps. This class handles a large family of wipe-like transitions by itself. Subclasses may implement other transitions such as dissolves and zooms.
Senders of it:
BookMorph goToPageMorph:transitionSpec: {navigation}
BookMorph goToPageMorph:transitionSpec:runTransitionScripts: {navigation}
BookMorph menuPageVisualFor:event: {menu}
ZASMCameraMarkMorph menuPageVisualFor:event: {as yet unclassified}
ZASMCameraMarkMorph setTransition: {as yet unclassified}
TranslucentProgessMorph
Morph subclass: #TranslucentProgessMorph instanceVariableNames: 'opaqueBackgroundColor' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Windows'
THIS CLASS HAS NO COMMENT!
Senders of it:
ComplexProgressIndicator withProgressDo: {as yet unclassified}
TrashCanMorph
ThreePhaseButtonMorph subclass: #TrashCanMorph instanceVariableNames: '' classVariableNames: 'TrashPic TrashPicOn' poolDictionaries: '' category: 'MorphicExtras-AdditionalWidgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
EventRecordingSpace sugarPartsBinQuads {sugar flaps}
Flaps class defaultsQuadsDefiningPlugInSuppliesFlap {predefined flaps}
Flaps class defaultsQuadsDefiningScriptingFlap {flaps registry}
Flaps class defaultsQuadsDefiningWidgetsFlap {flaps registry}
Flaps class newLoneSuppliesFlap {predefined flaps}
Flaps class newSqueakFlap {predefined flaps}
HaloMorph mouseDownInDimissHandle:with: {private}
Morph dismissViaHalo {submorphs-add/remove}
Morph slideToTrash: {dropping/grabbing}
Morph vanishAfterSlidingTo:event: {dropping/grabbing}
PasteUpMorph onceAgainDismiss: {undo}
Presenter addTrashCan {button creation}
SystemDictionary discardSoundSynthesis {shrinking}
TrashCanMorph class registerInFlapsRegistry {class initialization}
TTSampleFontMorph
BorderedMorph subclass: #TTSampleFontMorph instanceVariableNames: 'font transform smoothing' classVariableNames: '' poolDictionaries: '' category: 'Morphic-TrueType'
An example for using TrueType fonts.
Senders of it:
NCGlyphEditor font: {accessing}
TTFontDescription asMorph {*Morphic-TrueType}
TTSampleStringMorph
TTSampleFontMorph subclass: #TTSampleStringMorph instanceVariableNames: 'string ttBounds' classVariableNames: '' poolDictionaries: '' category: 'Morphic-TrueType'
I allow the display of a string in a TrueType font as a stand-alone morph.
Morph's color changes the inside of the characters.
Morph's borderColor changes the outline.
Many free fonts are stored at www.FontGuy.com.
Use a normal web browser (not our Scamper) and go there.
Choose 'categories' and browse to a font you like.
Hold the mouse down on the example text in that font.
When the menu comes up, choose "Copy this link location".
Come back into Squeak, choose "load font from web..."
from my menu, and paste in the url.
Senders of it:
TTSampleFontMorph createSample {menu}
TTSampleFontMorph font: {accessing}
TwoWayScrollPane
ComponentLikeModel subclass: #TwoWayScrollPane instanceVariableNames: 'getMenuSelector getMenuTitleSelector xScrollBar yScrollBar scroller' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Obsolete'
TwoWayScrollPane is now obsolete. You should be able to use ScrollPane to do both vertical and horizontal scrolling.
As an example, see Morph>>inATwoWayScrollPane and change the first line to create a ScrollPane instead of a TwoWayScrollPane. It will still work.
(EllipseMorph new extent: 200@150) inATwoWayScrollPane openInWorld
Note that user preferences for ScrollPane may be geared toward text scrolling, so that the horizontal scrollbar may be hidden when not needed, while the vertical scrollbar is always shown. Use ScrollPane>>alwaysShowHScrollbar: or its variants to adjust this if you want the vertical & horizontal scrollbars to be shown consistently.
Senders of it:
Morph inATwoWayScrollPane {initialization}
NCScrolledCompositeStateMorph addScrollerTo: {initialization}
Player newScriptorAround: {viewer}
ScriptEditorMorph autoFitOnOff {menu}
ScriptEditorMorph extent: {other}
ScriptEditorMorph hibernate {other}
SyntaxMorph enclosingPane {accessing}
SyntaxMorph class setSize:andMakeResizable: {as yet unclassified}
WorldWindow class test2 {as yet unclassified}
TypeListTile
SymbolListTile subclass: #TypeListTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
A tile that offers a list of supported data types.
Senders of it:
ScriptEditorMorph buttonRowForEditor {buttons}
UndescribedTile
TileMorph subclass: #UndescribedTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
THIS CLASS HAS NO COMMENT!
Senders of it:
UndefinedObject newTileMorphRepresentative {*Etoys-tiles}
UpdatingBooleanStringMorph
UpdatingStringMorph subclass: #UpdatingBooleanStringMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
A customized updating-string-morph used for displaying and editing boolean values; mouse-down on one of these is inerpreted as a request to toggle.
Senders of it:
There are no senders of UpdatingBooleanStringMorph.
UpdatingMenuItemMorph
MenuItemMorph subclass: #UpdatingMenuItemMorph instanceVariableNames: 'wordingProvider wordingSelector enablementSelector wordingArgument' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Menus'
A menu item whose textual label and whose enablement are updatable. The wordingProvider provides the current wording, upon being being sent the wordingSelector.
The item can also dynamically update whether or not it should be enabled; to do this, give it an enablementSelector, which is also sent to the wordingProvider..
Senders of it:
MenuMorph addUpdating:enablementSelector:target:selector:argumentList: {construction}
MenuMorph addUpdating:target:selector:argumentList: {construction}
MenuMorph addUpdating:target:selector:argumentList:extraIcon: {construction}
MenuMorph addWithLabel:enablementSelector:target:selector:argumentList: {construction}
MenuMorph popUpAt:forHand:in:allowKeyboard: {control}
UpdatingMenuMorph
MenuMorph subclass: #UpdatingMenuMorph instanceVariableNames: 'updater updateSelector' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Menus'
THIS CLASS HAS NO COMMENT!
Senders of it:
PasteUpMorph reformulateUpdatingMenus {menu & halo}
Preferences class fontConfigurationMenu {fonts}
TheWorldMenu flapsMenu {*MorphicExtras-windows & flaps menu}
UpdatingNumericStringMorph
UpdatingStringMorph subclass: #UpdatingNumericStringMorph instanceVariableNames: 'min max' classVariableNames: '' poolDictionaries: '' category: 'VideoForSqueak-Morphic'
Similar to UpdatingStringMorph, but adds some new features for handling numbers.
Senders of it:
ParameterDescription asExtentMorph {creation}
UpdatingRectangleMorph
RectangleMorph subclass: #UpdatingRectangleMorph instanceVariableNames: 'target lastValue getSelector putSelector contents' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Support'
Intended for use as a color swatch coupled to a color obtained from the target, but made just slightly more general than that.
Senders of it:
ColorPickerMorph allowsTranslucency {event handling}
ColorType updatingTileForTarget:partName:getter:setter: {*Etoys-tiles}
PhraseTileMorph replacePlayerInReadoutWith: {kedama}
PhraseTileMorph replacePlayerWith: {kedama}
ViewerLine replacePlayerInReadoutWith: {access}
UpdatingSimpleButtonMorph
SimpleButtonMorph subclass: #UpdatingSimpleButtonMorph instanceVariableNames: 'wordingProvider wordingSelector font' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
Adds to SimpleButtonMorph the ability to keep its own wording up to date by send a given message (indicated by its wordingSelector) to a given object (indicated by its wordingTarget, and normally the same as its target.)
Senders of it:
CodeHolder codePaneProvenanceButton {controls}
Lexicon mostGenericButton {control buttons}
NCAttachmentPointAdjusterWindow standardButton {buttons}
ParameterDescription asOptionMorph {creation}
Presenter reinvigorateAllScriptsTool: {playerList}
ProjectNavigationMorph makeUpdatingButtonWithBalloonText:actionSelector:wordingSelector: {as yet unclassified}
ScriptInstantiation statusControlRowIn: {misc}
ScriptStatusControl initializeFor: {initialization}
Utilities class windowMenuWithLabels:colorPattern:targets:selections:wordingSelectors:title: {durable menus}
UpdatingStringMorph
StringMorph subclass: #UpdatingStringMorph instanceVariableNames: 'format target lastValue getSelector putSelector floatPrecision growable stepTime autoAcceptOnFocusLoss minimumWidth maximumWidth decimalPlaces' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
A StringMorph that constantly tries to show the current data from the target object. When sent #step, it shows what the target objects has (target perform: getSelector). When edited (with shift-click), it writes back to the target.
floatPrecision = 1. to round to integer.
floatPrecision = .1 to round to 1 decimal place, etc.
Even when ((target == nil) or: [getSelector == nil]), the user would still like to edit the string with shift-click.
Senders of it:
62 methods
UpdatingStringMorphWithArgument
UpdatingStringMorph subclass: #UpdatingStringMorphWithArgument instanceVariableNames: 'argumentTarget argumentGetSelector' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of UpdatingStringMorphWithArgument.
UpdatingTextMorph
TextMorph subclass: #UpdatingTextMorph instanceVariableNames: 'target getSelector growable stepTime' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
A TextMorph that constantly tries to show the current data from the target object. When sent #step, it shows what the target objects has (target perform: getSelector).
Senders of it:
There are no senders of UpdatingTextMorph.
UpdatingThreePhaseButtonMorph
ThreePhaseButtonMorph subclass: #UpdatingThreePhaseButtonMorph instanceVariableNames: 'getSelector getArgument' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Widgets'
THIS CLASS HAS NO COMMENT!
Senders of it:
AllScriptsTool addSecondLineOfControls {initialization}
AllScriptsTool openUpButton {toggles}
BooleanPreferenceView representativeButtonWithColor:inPanel: {user interface}
CodeHolder diffButton {diffs}
CodeHolder prettyDiffButton {diffs}
CodeHolder regularDiffButton {diffs}
Command class undoRedoButtons {dog simple ui}
EventRecordingSpace makeStatusButtons {initialization}
HaloThemePreferenceView haloThemeRadioButtons {user interface}
HtmlInput addCheckBoxButtonToFormatter: {formatting}
HtmlInput addRadioButtonToFormatter: {formatting}
Lexicon searchToggleButton {control buttons}
PreferencesPanel class deleteAllPreferencesPanels {cleanup}
ProjectSorterMorph addControls {initialization}
URLMorph
BasicButton subclass: #URLMorph instanceVariableNames: 'url page isBookmark book' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-SqueakPage'
This morph represents a URL for a SqueakPage. It displays the thumbnail for the associated page, if available. Used in page sorters and for bookmarks.
This morph has several options:
a. It can act like a thumbnail for sorting (in which case it can be picked up and dragged) or it acts as a bookmark (in which case shift clicking on it activates it).
b. If it has book set to true, it is a page in a book. Clicking fetches the index of the book, opens it to the first page, and puts it in the hand.
A thumbnail on a known book:
(URLMorph grabURL: 'ftp://doltest1.disney.com/squeak/test/p1.sp')
book: true.
A thumbnail on a single PasteUpMorph:
Make a PasteUpMorph with any morphs in it.
Decide where it should live, make a url string, and copy it.
'file://HardDisk/books/book1/myPage.sp'
'ftp://doltest1.disney.com/squeak/test/p1.sp'
Choose 'Save as Web Morph'
Paste in the url.
Drop the resulting thumbnail into some morph.
See SqueakPage's comment for the stages of in/out.
url
page A SqueakPage
isBookmark Boolean
book A Boolean -- whether I represent a whole book or a page.
Senders of it:
BookMorph bookmarkForThisPage {menu}
BookMorph saveAsNumberedURLs {menu}
BookMorph savePagesOnURL {menu}
Morph saveOnURL {fileIn/out}
SqueakPage postChangeNotification {private}
SqueakPageCache class deleteUnreferencedPages {housekeeping}
URLMorph class grabForBook: {instance creation}
UserText
TextMorph subclass: #UserText instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Basic'
A text object intended to carry user-created textual content. The default mode is to be non-wrapping, so that the only wrapping that takes place will be that imposed by explicit carriage-returns in the text. The user can manually (from menu) change the wrap setting, and it is also automatically switched to wrap-mode if the user manually resizes the text-object (with the halo) and also if the user, by typing, makes the text object extend off the right edge of the screen.
Senders of it:
SpeechBubbleMorph keyStroke:morph: {event handling}
SpeechBubbleMorph string {accessing}
SpeechBubbleMorph class string:type: {instance creation}
TextMorph class nonwrappingPrototype {scripting}
VariableSpacer
AlignmentMorph subclass: #VariableSpacer instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Basic'
A transparent, space-filling, halo-shy morph, for use in alignment structures.
Senders of it:
AlignmentMorph class newVariableTransparentSpacer {instance creation}
CategoryViewer phraseForVariableFrom: {entries}
VerticalNumberLineMorph (v5)
NumberLineMorph subclass: #VerticalNumberLineMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Charts'
A number line vertically oriented.
Senders of it:
GraphPaperPanel class classicCartesianGraph {examples}
Player getYOnGraph {*morphicExtras-Charts}
Player setYOnGraph: {*morphicExtras-Charts}
VeryPickyMorph
Morph subclass: #VeryPickyMorph instanceVariableNames: 'passengerMorph' classVariableNames: '' poolDictionaries: '' category: 'Tools-Explorer'
Contributed by Bob Arning as part of the ObjectExplorer package.
Senders of it:
There are no senders of VeryPickyMorph.
VideoMorph
RectangleMorph subclass: #VideoMorph instanceVariableNames: 'videoSource form resolution autoExtent configurationDialog showStatistics frameCount timeToCaptureFrames statisticsCounter' classVariableNames: '' poolDictionaries: '' category: 'VideoForSqueak-Morphic'
THIS CLASS HAS NO COMMENT!
Senders of it:
ImageResolutionType initialize {initialization}
Project enter:revert:saveForRevert: {enter}
VideoPropertiesMorph paneForVideoParameters {building}
VideoMorphConfiguration
AlignmentMorph subclass: #VideoMorphConfiguration instanceVariableNames: 'target parameters' classVariableNames: '' poolDictionaries: '' category: 'VideoForSqueak-Morphic'
THIS CLASS HAS NO COMMENT!
Senders of it:
VideoMorph createConfigurationDialog {configuration}
VideoPropertiesMorph
ObjectPropertiesMorph subclass: #VideoPropertiesMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'VideoForSqueak-Morphic'
THIS CLASS HAS NO COMMENT!
Senders of it:
VideoMorph openAppropriatePropertySheet {meta-actions}
Viewer
AlignmentMorph subclass: #Viewer instanceVariableNames: 'scriptedPlayer' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting'
An abstract superclass for both CategoryViewer and StandardViewer. A viewer is always associated with a particular 'scriptedPlayer' -- the object whose protocol it shows in tile form.
Senders of it:
CategoryViewer outerViewer {support}
CompoundTileMorph justDroppedInto:event: {miscellaneous}
Morph objectViewed {e-toy support}
PasteUpMorph sissWriteValue {*siss-interface}
PhraseTileMorph duplicate {kedama}
PhraseTileMorph justDroppedInto:event: {dropping/grabbing}
PhraseTileMorph sproutNewScriptor {miscellaneous}
Presenter viewMorph: {stubs}
Presenter viewObjectDirectly: {stubs}
TabbedPalette viewMorph: {*Etoys-viewer tab}
TileMorph selectorTile:in: {tiles from method}
UpdatingRectangleMorph defaultBorderColor {initialization}
Viewer retargetFrom:to: {transition}
ViewerFlapTab hibernate {transition}
ViewerFlapTab lazyUnhibernate {transition}
ViewerEntry
AlignmentMorph subclass: #ViewerEntry instanceVariableNames: 'helpPane' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of ViewerEntry.
ViewerFlapTab
FlapTab subclass: #ViewerFlapTab instanceVariableNames: 'scriptedPlayer beingOpened' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Flaps'
ViewerFlapTab are flap tabs for etoy scripting viewers.
Senders of it:
Morph removeViewersOnSubsIn: {e-toy support}
PasteUpMorph abandonVocabularyPreference {*Protocols}
PasteUpMorph allViewersInProject {olpc}
PasteUpMorph closedViewerFlapTabs {misc}
PasteUpMorph hideViewerFlaps {misc}
PasteUpMorph hideViewerFlapsOtherThanFor: {misc}
PasteUpMorph installVectorVocabulary {*Protocols}
PasteUpMorph recreateScripts {*Etoys-support}
PasteUpMorph relaunchAllViewers {*Etoys-support}
PasteUpMorph removeAllViewers {world menu}
PasteUpMorph viewerFlapTabFor: {*Etoys-playfield}
Player noteDeletionOf:fromWorld: {customevents-misc}
Player viewerFlapTab {misc}
Project setFlaps {language}
StandardScriptingSystem reinvigorateThumbnailsInViewerFlapTabs {*Etoys-utilities}
ViewerLine
AlignmentMorph subclass: #ViewerLine instanceVariableNames: 'elementSymbol' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
Serves as a wrapper around a line in a Viewer, enforcing the desired layout properties.
Senders of it:
CategoryViewer phraseForCommandFrom: {entries}
CategoryViewer phraseForTest {entries}
CategoryViewer phraseForTimesRepeat {entries}
CategoryViewer phraseForVariableFrom: {entries}
CategoryViewer universalTilesPhraseForVariableFrom: {entries}
KedamaCategoryViewer replaceTargetWith: {support}
ScriptEditorMorph viewerTile {access}
TileMorph acceptNewLiteral {code generation}
ViewerRow
AlignmentMorph subclass: #ViewerRow instanceVariableNames: 'elementSymbol' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Tiles'
THIS CLASS HAS NO COMMENT!
Senders of it:
There are no senders of ViewerRow.
WatcherWrapper
AlignmentMorph subclass: #WatcherWrapper instanceVariableNames: 'player variableName' classVariableNames: '' poolDictionaries: '' category: 'Etoys-Scripting Support'
A wrapper around either kind of watcher. My primary raison d'etre is so that I can automatically change names when my player changes names.
Senders of it:
BooleanScriptEditor wantsDroppedMorph:event: {dropping/grabbing}
Morph handUserGraphLocationPlotter {*MorphicExtras-accessing}
PhraseTileMorph morphToDropInPasteUp: {mouse}
Player changeTypesInWatchersOf: {translation}
Player fancyWatcherFor: {slots-user}
Player noteDeletionOf:fromWorld: {customevents-misc}
Player removeWatchersOfSlotNamed: {translation}
Player renameSlotInWatchersOld:new: {translation}
Player tearOffFancyWatcherFor: {slots-user}
Player tearOffUnlabeledWatcherFor: {slots-user}
TileMorph grabMorph: {event handling}
TilePadMorph canAccept: {mouse}
TilePadMorph morphToDropFrom: {miscellaneous}
WatchMorph
EllipseMorph subclass: #WatchMorph instanceVariableNames: 'fontName cColor handsColor romanNumerals antialias' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Demo'
This class is a representation of a watch.
The labels' font is changeble. Labels' font size increase or decrease when resizing me.
WatchMorph new openInWorld
(WatchMorph fontName: 'ComicPlain' bgColor: Color transparent centerColor: Color transparent) openInWorld " transparent "
(WatchMorph fontName: 'ComicBold' bgColor: Color white centerColor: Color black) openInWorld
Structure:
fontName String -- the labels' font name
cColor Color -- center color
handsColor Color
romanNumerals Boolean
antialias Boolean
Senders of it:
There are no senders of WatchMorph.
WaveEditor
AlignmentMorph subclass: #WaveEditor instanceVariableNames: 'graph samplingRate perceivedFrequency loopEnd loopLength loopCycles possibleLoopStarts keyboard' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-SoundInterface'
This tool was created to aid in the preparation of LoopedSampledSound objects. It includes support for finding good loop points with a little help from the user. Namely, the user must identify a good ending point for the loop (typically just before the decay phase begins) and identify one cycle of the waveform. After that, the "choose loop point" menu command can be invoked to search backwards to find and rank all possible loop starting points. Some experimentation is usually required to find a loop that "breaths" in a natural way.
This tool can also be used as a general viewer of numerical sequences of any kind, such as time-varying functions, FFT data, etc.
Senders of it:
AbstractSound viewSamples {playing}
AIFFFileReader edit {other}
AnonymousSoundMorph openWaveEditorOnSound {menu}
GraphMorph openWaveEditor {*sound}
LoopedSampledSound edit {other}
RecordingControls showEditor {menu commands}
RecordingControlsMorph showEditor {button commands}
SoundLibraryTool edit {menu}
WaveEditor showEnvelope {menu}
WaveEditor showFFTAtCursor {menu}
WebCamMorph (v5)
RectangleMorph subclass: #WebCamMorph instanceVariableNames: 'camNum camIsOn frameExtent displayForm resolution useFrameSize captureDelayMs' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-WebCam'
INTRODUCTION
=========
WebCamMorph together with CameraPlugin (originally from MIT Scratch) provides an easy and cross platform way to use webcam input in Squeak and Etoys. The first version has been created specifically with Etoys in mind. To view a live feed simply drag a "WebCam" tile from the "WebCam" category in the objects tool. Open up a viewer on the morph and display the "camera settings" category to explore the following basic settings:
"camera is on": turn the camera on/off.
"camera number": usually the default of "1" is ok but if you have more than one camera connected then adjust between 1 and 9 for other instances of WebCamMorph.
"max fps": leave as is for now. It is unusual for webcams to capture at higher than 30fps. See later for further explanation of how fps is controlled.
"actual fps": read-only. Indicates the actual fps being achieved which can depend significantly on lighting conditions and capture resolution...
"resolution": webcams can have a range of resolutions but for simplicity three are supported: "low" (160x120), "medium" (320x240) and "high" (640x480). Adjust in good lighting to see if "actual fps" increases.
"use frame size": the resolution used for capturing can differ from the resolution used for display. If this setting is true then WebCamMorph is resized to match the camera resolution. If false then you are free to resize it however you want (via the "resize" halo button, use shift to preserve aspect ratio)
Beyond viewing a live feed WebCamMorph has been designed to support different uses including simple effects, time-lapse photography, stop-motion animation, character recognition, motion detection and more complex processing of every frame for feature detection. The following information is to help you understand how and why WebCamMorph operates so you can adjust it for your particular needs.
"FRAMES PER SECOND", LIGHTING & CAMERA RESOLUTION
==================================
The maximum possible frame rate depends on many factors, some of which are outside of our control. Frame rates differ between cameras and usually depend significantly on chosen resolution and lighting conditions. To ensure a balance between capturing every available frame and keeping everything else responsive, WebCamMorph dynamically adjusts the delay between capturing one frame and the next (does not apply when in "manual capture" mode, see later).
WebCams often include automatic compensation for lighting conditions. In low lighting it takes significantly more time for the camera to get a picture than it does in good lighting conditions. For example 30fps may be possible with good lighting compared to 7fps in low lighting. So for best capture rates ensure you have good lighting!
Cameras have a "native" resolution at which frame rates are usually better than for other resolutions. Note though that the native resolution might be *higher*
than the *minimum* resolution available. It pays to experiment with different resolutions to find which one results in the highest frame rate. Use good lighting conditions when experimenting with resolutions.
"MANUAL CAPTURE" MODE
===============
In simply usage WebCamMorph automatically captures a frame and displays it. To support Etoys scripting a "manual capture" mode is provided where you or your script determines when to capture, when to apply effects (or not) and when to update the display. In between these steps you can do anything you want. Note that frames rates will be lower than that in automatic capture mode and that "skip frames" (described next) will need adjusting at very low capture rates.
Tip: In manual mode the camera can be turned off. It will be turned on automatically when required and return to it's previous state after a frame has been captured. For capture periods of five seconds or more turning the camera off may save power, which can especially useful when running off batteries. For smaller periods leaving the camera on will avoid some delays and could help speed up webcam related scripts.
"SKIP FRAMES"
========
Webcams and their drivers are typically designed for streaming live video and use internal buffering to help speed things up. At low capture rates the picture can appear to lag real-time because what you see is the next available buffer not the *latest* buffer. So for example if you capture a frame every ten seconds and there are three buffers being used then what you actually see may be thirty seconds old. We have little/no control over the number of buffers used and the actual number can vary between cameras and under different circumstances for the same camera. "skip frames" is provided to compensate for buffering so increase it when doing "manual" capturing until you see what you expect to see. Typically a setting of 8 is enough but I have had to use 20 with one particular camera in low lighting.
"SNAPSHOTS"
========
Where as "capturing" is the process of getting an image from the Camera into Squeak/Etoys, a "snapshot" preserves whatever is currently displayed (which may be the captured image after effects have been applied). To store snapshots you need to designate a "holder" which at the moment can be either a "holder" morph or a "movie" morph. Create one of these before proceeding. To assign a holder open up a viewer for WebCamMorph, display the "snapshot" category and click in the box at the right of the entry called "snapshot holder". The cursor will now resemble a cross-hair and can be clicked on the target holder/movie morph. To take a single snapshot at any time click (!) on the left of "take snapshot". In auto-capture mode WebCamMorph can also be set to take multiple consecutive snapshots . First, before turning the camera on, set a sensible limit using "snapshot limit" (to avoid using all the computers memory) then set "auto snapshot" to true. When the camera is next turned on then snapshots are taken for every frame until "snapshot limit" becomes zero. "snapshot limit" is automatically decremented but not reset to avoid problems (although you are free to reset it manually or via a script).
"EFFECTS" - WIP
=========
Similar to snapshots, a holder can be designated as the "effects holder". This holder is intended to be populated with "fx" morphs (coming soon) which will operate on captured frames prior to displaying. Stay tuned ;-)
CLEARING SNAPSHOT & EFFECTS HOLDERS
=========================
Keeping a link to snapshot or effects holders can tie up resources even after the target holders have been deleted and are no longer visible. To ensure this does not happen designate the WebCamMorph itself as the holder (for method see "snapshots" section above).
COMING SOON!
=========
- Built-in basic effects such as brightness, contrast and hue.
- Image "fx" morphs for effects such as those found in MIT Scratch and many other types of effects/ image processing.
- More snapshot options, eg, store to file
- Demo projects
Senders of it:
There are no senders of WebCamMorph.
WeekMorph
AlignmentMorph subclass: #WeekMorph instanceVariableNames: 'week month tileRect' classVariableNames: '' poolDictionaries: '' category: 'Morphic-PDA'
Shows the current week as a row of buttons with numbers on. See MonthMorph
Senders of it:
MonthMorph initializeHeader {initialization}
MonthMorph initializeWeeks {initialization}
MonthMorph selectedDates {access}
WheelMorph (v5)
BorderedMorph subclass: #WheelMorph instanceVariableNames: 'target actionSelector factor circular old angle maxAngle lastRedraw' classVariableNames: '' poolDictionaries: '' category: 'DrGeoII-Core-UI'
A thumb wheel widget control
Senders of it:
DrGeoPresenter horizontalWheel {UI definition}
DrGeoPresenter verticalWheel {UI definition}
DrGeoPresenter zoomWheel {UI definition}
WireMorph
PolygonMorph subclass: #WireMorph instanceVariableNames: 'pins' classVariableNames: 'InputPinForm IoPinForm OutputPinForm' poolDictionaries: '' category: 'Morphic-Components'
THIS CLASS HAS NO COMMENT!
Senders of it:
PinMorph startWiring: {wires}
WiWPasteUpMorph
PasteUpMorph subclass: #WiWPasteUpMorph instanceVariableNames: 'parentWorld hostWindow pendingEvent displayChangeSignatureOnEntry' classVariableNames: 'Debug' poolDictionaries: '' category: 'Morphic-Worlds'
This subclass of PasteUpMorph provides special support for viewing of a world in an inner window (WorldWindow).
Senders of it:
WorldWindow class test1 {as yet unclassified}
WorldWindow class test2 {as yet unclassified}
WordGameLetterMorph
BorderedMorph subclass: #WordGameLetterMorph instanceVariableNames: 'letter originalLetter idString linkedLetters predecessor successor indexInQuote lineMorph letterMorph style' classVariableNames: 'IDFont IDHeight LetterFont LetterHeight' poolDictionaries: '' category: 'Morphic-Games'
WordGameLetterMorph implements letter boxes for type-in and display of letter in word games. Several variant displays are supported, depending on the setting of style, and blanks can be displayed as black boxes or empty letter boxes.
Default support for type-in is distributed between this class and WordGamePaneMorph
letter the Character stored in this morph.
Can be either blank or nil as well as a letter.
indexInQuote a retained copy of the index of this character
Facilitates responses to, eg, clicking or typing in this box.
If indexInQuote==nil, then this is displayed as a black box
predecessor another LetterMorph or nil
Used for linked typing and, eg, word selection
successor another LetterMorph or nil
Used for linked typing and, eg, word selection
style a Symbol, one of #(plain boxed underlined)
Boxed and underlined display further depends on whether
the id strings are nil or not.
Each format has an associated default size
The following two variables are also submorphs, as are the id strings if present.
letterMorph a StringMorph for displaying the letter
Used when changing the letter to be displayed
lineMorph a PolygonMorph used to display the underline
and also to place the id string in underlined format
Senders of it:
CipherPanel encodedQuote: {initialization}
CrosticPanel quote:clues:answers:quotePanel: {initialization}
CrosticQuotePanel quote:answers:cluesPanel: {initialization}
Worldlet
PasteUpMorph subclass: #Worldlet instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Mentoring'
An area with a private Presenter, viz, for which the scope of its stop-step-go buttons is limited to the area's interior.
Senders of it:
EventRecordingSpace initialize {initialization}
EventRecordingSpaceNavigator doNewPainting {the actions}
InteriorSolidSugarSuppliesTab mouseMove: {event handling}
InteriorSugarNavBar doNewPainting {buttons}
Morph stagingArea {geometry}
WorldWindow
SystemWindow subclass: #WorldWindow instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Morphic-Worlds'
A WorldWindow is a SystemWindow whose central area presents an inner Morphic world.
WorldWindows have a red title bar when the world inside is inactive. This changes to green when the world becomes the active world. The world inside becomes activated by clicking in it. When you click outside this world, the parent world resumes control. While its world is inactive, the WorldWindow may be moved and resized like any other.
It would be nice to make the world inside active whenever the WorldWindow was active, but this presents difficulties in moving and resizing, probably related to use of the global World instead of self world in many methods.
This facility is mainly the work of Bob Arning, with a number of tweaks by DI.
Senders of it:
WorldWindow class test1 {as yet unclassified}
WorldWindow class test2 {as yet unclassified}
WsGraphMorph
ImageMorph subclass: #WsGraphMorph instanceVariableNames: 'graphType dataType model data dataColor cursor cursorColor cursorColorAtZeroCrossings startIndex relativeScale minVal maxVal imageFormValid' classVariableNames: '' poolDictionaries: '' category: 'WS-Sound-Interface'
THIS CLASS HAS NO COMMENT!
Senders of it:
WsWorldStethoscopeMorph addSignalGraph {menus}
WsWorldStethoscopeMorph addSpectrumGraph {menus}
WsPhonePadMorph
ImageMorph subclass: #WsGraphMorph instanceVariableNames: 'graphType dataType model data dataColor cursor cursorColor cursorColorAtZeroCrossings startIndex relativeScale minVal maxVal imageFormValid' classVariableNames: '' poolDictionaries: '' category: 'WS-Sound-Interface'
THIS CLASS HAS NO COMMENT!
Senders of it:
WsWorldStethoscopeMorph addSignalGraph {menus}
WsWorldStethoscopeMorph addSpectrumGraph {menus}
WsSignalGraphMorph
WsGraphMorph subclass: #WsSignalGraphMorph instanceVariableNames: 'capacity mouseDown' classVariableNames: '' poolDictionaries: '' category: 'WS-Sound-Interface'
THIS CLASS HAS NO COMMENT!
Senders of it:
WsWorldStethoscopeMorph addDataGraph {menus}
WsSonogram
ImageMorph subclass: #WsSonogram instanceVariableNames: 'model dataColor lastX scrollDelta pixValMap allOne words' classVariableNames: '' poolDictionaries: '' category: 'WS-Sound-Interface'
THIS CLASS HAS NO COMMENT!
Senders of it:
WsWorldStethoscopeMorph addSonogram {menus}
WsSonogram is implemented in this WsSonogram class.
WsWorldStethoscopeMorph
AlignmentMorph subclass: #WsWorldStethoscopeMorph instanceVariableNames: 'statusLight model directModeLight biasModeLight' classVariableNames: '' poolDictionaries: '' category: 'WS-Sound-Interface'
THIS CLASS HAS NO COMMENT!
Senders of it:
WsWorldStethoscopeMorph class registerInFlapsRegistry {class initialization}
WorldStethoscope is implemented in this WsWorldStethoscopeMorph class.
WorldStethoscope is implemented in this WsWorldStethoscopeMorph class.
ZASMCameraMarkMorph
AbstractMediaEventMorph subclass: #ZASMCameraMarkMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Demo'
THIS CLASS HAS NO COMMENT!
Senders of it:
ZASMScriptMorph compileScript {as yet unclassified}
ZASMScriptMorph decompileScript:named:for: {as yet unclassified}
ZASMScriptMorph fixup {as yet unclassified}
ZASMScriptMorph wantsDroppedMorph:event: {dropping/grabbing}
ZoomAndScrollControllerMorph grabCameraPositionEvent:morph: {as yet unclassified}
ZASMCameraMark is implemented in this ZASMCameraMarkMorph class. It is created in a playfield.
ZASMScriptMorph
PasteUpMorph subclass: #ZASMScriptMorph instanceVariableNames: 'somethingChanged' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Demo'
THIS CLASS HAS NO COMMENT!
Senders of it:
ZASMCameraMarkMorph justDroppedInto:event: {dropping/grabbing}
ZoomAndScrollControllerMorph editAScript {as yet unclassified}
ZASMScriptMorph new openInHand. produce a Playfield.
ZASMStepsMorph
StringMorph subclass: #ZASMStepsMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Demo'
THIS CLASS HAS NO COMMENT!
Senders of it:
ZASMScriptMorph compileScript {as yet unclassified}
ZASMScriptMorph decompileScript:named:for: {as yet unclassified}
ZASMScriptMorph fixup {as yet unclassified}
ZASMSteps is implemented in this ZASMStepsMorph class.
ZoomAndScrollControllerMorph
RectangleMorph subclass: #ZoomAndScrollControllerMorph instanceVariableNames: 'mouseDownPoint mouseMovePoint panAndTiltFactor zoomFactor target hasFocus currentKeyDown upDownCodes changeKeysState programmedMoves' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Demo'
THIS CLASS HAS NO COMMENT!
Senders of it:
StoryboardBookMorph initialize {initialization}
ZoomAndScrollController is implemented in this ZoomAndScrollControllerMorph class.
ZoomAndScrollMorph
RectangleMorph subclass: #ZoomAndScrollControllerMorph instanceVariableNames: 'mouseDownPoint mouseMovePoint panAndTiltFactor zoomFactor target hasFocus currentKeyDown upDownCodes changeKeysState programmedMoves' classVariableNames: '' poolDictionaries: '' category: 'MorphicExtras-Demo'
THIS CLASS HAS NO COMMENT!
Senders of it:
StoryboardBookMorph initialize {initialization}
ZoomAndScrollMorph new openInHand. results in a Playfield.
Object Implementation Notes
The following Etoys objects are described in the Objects and More Objects chapters. For each one, basic information is given below on its implementation in Squeak, including the class, superclass, and category of its Player and the Morph it wears as a costume. Some objects, such as games with boards and pieces, are implemented using even more classes, which is noted where it is the case.
How are objects created from the Object Catalog? How are objects created from a menu selection?
Morphs can mostly be instantiated using the syntax
Morph new openInHand.
or
Morph new openInWorld.
Where this is not the case some other method is provided.
All Scripts (Scripting category)
AllScriptsTool<All Scripts>
- AlignmentMorph
- ThreePhaseButton
- Script controls
- Stop Button
- Step Button
- Go Button
- UpdatingThreePhaseButton
AND Gate (eToyFriendly off, no category)
NCCurveMorph<AND Gate>
NCCurveMorph andGate openInHand.
Arrow (Graphics category)
PolygonMorph<Arrow>
Arrow (not in Object Catalog)
Accessed in Etoys via the Connector Button (Connectors category)
NCAAConnectorMorph<Arrow2>
NCAAConnectorMorph basicArrow
Arrow Editor (Connectors category)
The Arrow Editor is a GlyphEditor in a SystemWindow. The GlyphEditor toolbar contains nine Buttons and an UpdatingString.
SystemWindow<Arrow Editor>
- AlignmentMorph
- IconicButtons
- StringMorphs
- RectangleMorphs
- NCGlyphEditor
- TTSampleFont(Bitstream Vera Sans)
Arrow Editor is implemented in the newStandAlone method of NCGlyphEditor, which creates both the Arrow Editor and the SystemWindow.
Attachment Adjuster (Connectors category)
SystemWindow<Attachment Adjuster>
- AlignmentMorphs
- SketchMorphs
- IconicButtons
- StringMorphs
- RectangleMorphs
- UpdatingSimpleButtonMorphs
- VariableSpacers
- JoystickMorph
- NCAttachmentPointAdjusterWindow
SystemWindow<Attachment Adjuster>
NCAttachmentPointAdjusterWindow adjusterWindow openInHand.
Badge (no category)
EToySenderMorph<Badge>
How is this invoked? EToySenderMorph new initializeToStandAlone openInHand. creates an ETofSender that looks exactly like a Badge.
Balloon (not in Object Catalog)
BalloonMorph<Balloon>
Book (Multimedia Category)
BookMorph<Book>
Submorphs:
- AlignmentMorph
- PasteUpMorph
- Pages: an OrderedCollection(a PasteUpMorph)
- AlignmentMorph<PageControls>
- ThreePhaseButtons
- Morph
- VariableSpacers
- UpdatingStringMorph
Bordered (not in Object Catalog)
BorderedMorph<Bordered>
Bordered is used in CategoryViewer, Chess, FileList2, Flaps, Glyph Editor, Object Properties, PaintBox, SelectionMorph, and SyntaxMorph.
Bouncing Atoms (Just for Fun category)
BouncingAtomsMorph<BouncingAtoms>
- PasteUpMorphs
- AtomMorphs
Broom (Graphics category)
BroomMorph<Broom>
When dragged, BroomMorph changes shape to one of the following, depending on the initial direction of dragging. Each of these Morphs can stretch sideways when the mouse is dragged sideways.
- BroomMorphDown
- BroomMorphLeft
- BroomMorphRight
- BroomMorphUp
When clicked and dragged, it changes to one of the following, depending on the initial direction of dragging.
- CenterBroomMorphDown
- CenterBroomMorphLeft
- CenterBroomMorphRight
- CenterBroomMorphUp
Button (Scripting category)
ScriptableButton<Button>
ButtonBar (Connectors category)
NCButtonBar<ButtonBar>
ButtonDown? (Scripting category)
SystemQueryPhrase<ButtonDown?>
- BooleanTile
- StringMorph
Button Flap (Connectors category)
FlapTab<Button Flap>
- ViewerFlapTabs
- FlapTab
- SystemWindows
- ObjectsTool
- SolidSugarSuppliesTab
- AlignmentMorph
- ScrollableField
- ClipboardMorph
- TrashCanMorph
- SugarNavTab
ButtonUp? (Scripting category)
SystemQueryPhrase<ButtonDown?>
- BooleanTile
- StringMorph
Calendar (Just for Fun category, v 5.0)
CalendarMorph<Calendar>
- AlignmentMorphs
- SimpleButtonMorphs
- VariableSpacers
- StringMorphs
- TextMorphs
Camera (Multimedia Category)
WebCamMorph<Camera>
CategoryViewer (not in Object Catalog)
CategoryViewer is used in the Viewer for object scripting to hold groups of scripting tiles.
CategoryViewer<CategoryViewer>
- AlignmentMorphs
- ThreePhaseButtons
- Morphs
- BorderedMorph
- ImageMorphs
- StringMorphs
- PhraseTileMorph
- TilePadMorphs
- TileMorphs
- SoundTile
- UpdatingStringMorph
- IconicButton
- NumericReadotTile
- StringReadoutTile
Chess (Games category)
ChessMorph<Chess>
A ChessMorph contains more than a hundred submorphs.
Chess is implemented primarily in Squeak, using the following objects in the Morphic-Games-Chess category:
- ChessBoard
- ChessConstants
- ChessHistoryTable
- ChessMorph
- ChessMove
- ChessMoveGenerator
- ChessMoveList
- ChessPieceMorph
- ChessPlayer
- ChessPlayerAI
- ChessTranspositionTable
- ChessTTEntry
Chinese Checkers (Games category)
Chinese Checkers is implemented using the ChineseCheckersPiece and ChineseCheckers classes in the Morphic-Games category in Squeak.
Cipher (Games category)
Cipher is implemented using WordGameLetter objects for the initially blank cells of the plaintext message, and Strings for the letters of the cipher message. About the Cipher Panel and Some Useful Statistics are PluggableText objects. FillInTheBlank, used for entering new cipher text, is made of a Query (with text held in query's characters, an extra tile in the Basic category), a textPane, and a Morph holding accept and cancel Buttons. When clearing typing, the message Are you sure you want to discard all typing? appears in an MVCMenu, with the choices Yes or No.
Circle (Graphics category)
CircleMorph<Circle>
CircleCurve (eToyFriendly off, no category)
NCCurveMorph<CircleCurve>
- NCGrabbableDisplayTextMorph
Class (eToyFriendly off, no category)
NCUMLDiagramMorph<Class>
- NCGrabbableDiagramMorph
ClassButtonBar (eToyFriendly off)
NCButtonBar<Class ButtonBar>
- NCDisplayTextMorph
- NCMakerButtons
- SimpleButtonMorph
- StringMorph
Class diagram Flap [sic] (eToyFriendly off, no category)
NCButtonBar<Class ButtonBar>
- NCPartsBin<parts bin>
- NCMakerButtons
- SketchMorphs
Clipboard (no category)
ClipboardMorph<Clipboard>
Clock (Just for Fun category)
WatchMorph<Clock>
- StringMorphs
ColorPicker (not in Object Catalog)
Column (no category)
AlignmentMorph<Column>
- Morphs named red, yellow, and green
Composite State (eToyFriendly off)
NCCompositeStateMorph<Composite State>
- AlignmentMorph
- NCTextRectangleMorph<TextRectangle>
- NCGrabbableDisplayTextMorph<Text>
- NCBasicShapeMorph<BasicShape>
- PasteUpMorph
Connector (Connectors category)
NCAAConnectorMorph<Connector>
- NCLineEndConstraintMorphs
- NCLineMorph
Connector Arrow (Connectors category)
NCAAConnectorMorph<ConnectorArrow>
- NCLineEndConstraintMorphs
- NCLineMorph
Connector Broom (Connectors category)
NCBroomMorph<Connector Broom>
Like Broom, this changes shape depending on the direction in which it is dragged.
Connector Button (Connectors category)
NCMakerButton<Connector Button>
- SketchMorph<Sketch>
Connectors Flap (Connectors category)
FlapTab<Connectors Flap>
- TextMorph
- NCPartsBin<parts bin>
- NCMakerButtons
- SketchMorphs
Crostic (Games category)
CrosticPanel<Crostic>
- Alignment Morphs
- CrosticQuotePanel
- SumpleButtonMorphs
- StringMorphs
- Morphs
- WordGameLetterMorphs
- PolygonMorphs
- Buttons
Curve (Basic category, Graphics category)
PolygonMorph<Curve>
Curvy Arrow (Graphics category)
PolygonMorph<Curvy Arrow>
CurveMorph arrowPrototype openInHand.
Curvy Connector (Connectors category)
NCAAConnectorMorph<Curvy Connector>
- NCLineEndConstraintMorphs
- NCLineMorph
NCAAConnectorMorph newCurvyConnector openInHand.
Curvy ConnectorArrow (Connectors category)
NCAAConnectorMorph<Curvy ConnectorArrow>
- NCLineEndConstraintMorphs
- NCLineMorph
NCAAConnectorMorph newCurvyArrow openInHand.
Diamond (eToyFriendly off, no category)
NCCurveMorph<Diamond>
- NCGrabbableDisplayTextMorph
NCCurveMorph diamond openInHand
Digital Clock (Just for Fun category)
ClockMorph<Digital Clock>
DoubleClick (no category)
DoubleClickExample<DoubleClick>Dr. Geo (Tools category)
DrGeo is implemented in many classes in the DrGeoII-* categories. The active window for DrGeo is a DrGService.
DrGService<Dr. Geo>
- WheelMorphs
- DrGDrawable
DrGeo new openInHand.
Ellipse (Basic category, Graphics category)
Ellipse is implemented in this EllipseMorph class.
EndState (eToyFriendly off, no Category)
NCEllipseMorph<End State>
NCEllipseMorph newEndState openInHand.
Available from FSM ButtonBar and FSM Flap, both in the Object Catalog (eToyFriendlyOff, no category).
Enhanced Text (Connectors category)
NCDisplayTextMorph<Enhanced Text>
NCDisplayTextMorph authoringPrototype openInHand. '24 point Bitstream Vera Sans'
EtoyUpdatingThreePhaseButton (not in Object Catalog)
EtoyUpdatingThreePhaseButtonMorph
Used to create radio buttons, check boxes, and buttons bearing arrowheads. For example, the Fridge object contains a check bok implemented as an EtoyUpdatingThreePhaseButton.
Event Theatre (Multimedia category)
EventRecordingSpace<Event Theatre>
- Worldlet
- InteriorSugarNavBar<NavigatorFlap>
- Morphs
- ThreePhaseButtons
- SugarRoundedField
- UpdatingStringMorph
- VariableSpacers
- Alignment
- IconicButton
- SimpleButtonMorph
- StringMorph
- SketchMorph
EventRecordingSpace open.
File Dialog (Scripting category)
OLPCHelpDisplayer<File Dialog>
- AlignmentMorphs
- ThreePhaseButton
- Morph
- StringMorph
- SimpleButtonMorphs
- StringMorphs
- SimpleHierarchicalListMorph
- Scrollbars
- RectangleMorphs
- TransformMorph
- IndentingListItemMorphs
Fish Eye (no category)
FishEyeMorph<FishEye>
Flap (Scripting category)
Closed
FlapTab<Flap>
- TextMorph
Open
PasteUpMorph<flap>
Contains whatever objects are dropped into it.
Flaps
Object subclass: #Flaps instanceVariableNames: '' classVariableNames: 'FlapsQuads SharedFlapsAllowed SharedFlapTabs' poolDictionaries: '' category: 'MorphicExtras-Flaps'
ClassVariables
FlapsQuads quads defining predefined flaps
default flaps are: 'PlugIn Supplies', 'Stack Tools', 'Supplies', 'Tools', 'Widgets' and 'Scripting'
SharedFlapTabs an array of flaps shared between squeak projects
SharedFlapsAllowed boolean
addStandardFlaps "Initialize the standard default out-of-box set of global flaps. This method creates them and places them in my class variable #SharedFlapTabs, but does not itself get them displayed. " SharedFlapTabs ifNil: [SharedFlapTabs := OrderedCollection new]. SharedFlapTabs add: self newSqueakFlap. SharedFlapTabs add: self newSuppliesFlap. SharedFlapTabs add: self newToolsFlap. SharedFlapTabs add: self newWidgetsFlap. SharedFlapTabs add: self newStackToolsFlap. SharedFlapTabs add: self newNavigatorFlap. SharedFlapTabs add: self newPaintingFlap. SharedFlapTabs add: self newObjectsFlap. self disableGlobalFlapWithID: 'Stack Tools' translated. self disableGlobalFlapWithID: 'Painting' translated. self disableGlobalFlapWithID: 'Navigator' translated. self disableGlobalFlapWithID: 'Objects' translated. ^ SharedFlapTabs
Flasher (Just for Fun category)
Flasher<Flasher>
Flasher new initializeToStandAlone openInHand.
Frame Rate (Just for Fun category)
FrameRateMorph<FrameRate>
FrameRateMorph authoringPrototype openInHand.
FreeCell (Games category)
FreeCell<FreeCell>- FreeCellBoard
- CardDecks
- cards in the form number of #suit
- Alignments
- VariableSpacers
- SimpleButtonMorphs
- StringMorphs
- LedMorphs
- LedDigitMorphs
- LedTimerMorph
Fridge (no category)
EToyFridgeMorph<Fridge>
- Alignments
- Morph
- StringMorph
- EtoysUpdatingThreePhaseButton<3PButton>
FSM ButtonBar (eToyFriendly off, no category)
NCButtonBar<FSM ButtonBar>
- NCDisplayTextMorph
- NCMakerButtons
- SketchMorphs
- SimpleButtonMorph
- StringMorph
FSM Flap (eToyFriendly off, no category)
Closed
FlapTab<FSM Flap>
- TextMorph
Open
NCPartsBin<parts bin>
- NCMakerButtons
- SketchMorphs
Gee-Mail
GeeMailMorph<Gee-Mail>
- ScrollBar
- RectangleMorphs
- TransformMorph
- TextPlusPasteUpMorph
- TextPlusMorphs
GlyphEditor (not in Object Catalog)
GlyphEditor is a component of Arrow Editor.
NCGlyphEditor<GlyphEditor>
- TTSampleFont
- Alignment
- SimpleButtonMorphs
- StringMorphs
- UpdatingStringMorph
Grab Patch (Graphics category)
Grab Patch is implemented in the GrabPatchMorph class. It is not a Morph, but an action that produces a SketchMorph, so it cannot be dropped into a World and examined through a viewer.
GrabPatchMorph new initializeToStandAlone openInHand.
Gradient (no category)
RectangleMorph<Gradient>
Gradient's gradient fill = true
RectangleMorph gradientPrototype openInWorld.
Gradient (slanted) (no category)
RectangleMorph<Gradient>
Gradient's gradient fill = true
RectangleMorph diagonalPrototype openInWorld.
Graph (no category)
GraphMorph<Graph>
graph paper (eToyFriendly off, Graphing category)
GraphPaper is implemented as a PasteUpMorph.
GraphPaperPanel
GraphPaperPanel is accessed from the halo menu of graph paper, in the make graph paper... option of the playfield options... option.
GraphPaperPanel<GraphPaperPanel>
- AlignmentMorphBob1s
- StringMorphs
- CorolPickerMorphs
- EllipseMorphs
- Morphs
- UpdatingStringMorphs
- SimpleSliderMorphs
- RectangleMorphs
- ThreePhaseButtons
- SimpleButtonMorph
GStreamerPlayer (Multimedia category, v4 but not v5)
GStreamerMoviePlayerMorph<GStreamerPlayer>
- GStreamerDisplayMorph
- GStreamerMoviePlayer
- SimpleButtonMorphs
- StringMorphs
- SimpleSliderMorphs
- RectangleMorphs
GStreamerMoviePlayerMorph authoringPrototype openInHand.
H Number Line (Graphing category, v5)
HorizontalNumberLineMorph<H number line>
- StringMorphs
- Morphs
- PolygonMorph<Arrow>
The command
HorizontalNumberLineMorph new openInHand.
creates an H Number Line with ticks 0 5 10, whereas the version in the object catalog has ticks from -10 to 8. I don't know how to produce that.
Halo (not in Object Catalog)
Halo is implemented in the HaloMorph, HaloSpec, and NameStringInHalo classes. It is not possible to create a halo without a target morph, and it is not possible to open a viewer or inspector on most haloes visually, except for the World halo. This is its structure.
HaloMorph<Halo>
- NameStringInHalo
- ThreePhaseButtons
Hand Magnifier (no category)
MagnifierMorph<Hand Magnifier>
Happy face (eToyFriendly off)
NCCurveMorph<Happy face>
- NCGrabbableDisplayTextMorph
NCCurveMorph happyFace openInHand.
Holder (Scripting category)
PasteUpMorph<Holder>
ScriptingSystem prototypicalHolder openInHand.
Iconic Button (not in Object Catalog)
Used in the standard viewer for menu icons on variable entries, and for the Gold Box icon in a Script Editor, among many other things. See senders of it.
ScriptingSystem prototypicalHolder openInHand.
- SketchMorph
Image (no category)
ImageMorph<Image>
Joystick (Basic category)
JoystickMorph<Joystick>
- EllipseMorph
Key press (Just for Fun category, v 5)
KeyPressMorph<Key press>
- StringMorphs
- SimpleButtonMorph
Label (eToyFriendly off)
NCLabelMorph<Label>
- NCGrabbableDisplayTextMorph
NCLabelMorph newStandAlone openInHand.
Lasso (Graphics category)
LassoPatchMorph
This is an action, not a costumed player, so it is impossible to open a viewer on it in a Halo.
Led (Not in Object Catalog)
Leds are used for numeric display in several Morphs.
LedMorph<Led>
- LedDigitMorph
LedDigit (Not in Object Catalog)
LedDigitMorphs occur as components of LedMorphs.
LedDigitMorph<LedDigit>
Line (Graphics category)
PolygonMorph<Line>
LineMorph is a subclass of PolygonMorph.
LineMorph newStandAlone openInHand.
Magnifier (Just for Fun category)
MagnifierMorph<Magnifier>
Maker Button (Connectors category)
NCMakerButton<Maker Button>
- SketchMorph
Menu (not in Object Catalog)
MenuMorph<Menu>
- MenuItem
- MenuLine
Menus are normally created by clicking buttons in objects or object Halos. The following expressiongenerates a menu that can be placed in the World temporarily by right-clicking.
MenuMorph example openInHand.
It is possible to invoke its Halo, but if one brings up its viewer and clicks to get the category menu, this MenuMorph is dismissed, and the viewer also vanishes, leaving the user holding the category menu, which then has no effect.
If one collapses the menu with the tan Halo handle, it becomes a persistent object that can be examined in the normal way. However, this is not very informative.
CollapsedMorph<Menu>
This example is supposed to include a button for keeping the menu fixed in the workspace, using the addStayUpItem method, but it does not work.
Mines (Games category)
Mines<Mines>
Mines is implemented in this Mines class, and in the MinesBoard and MinesTile classes.
- MinesBoard
- MinesTiles
- StringMorphs
- AlignmentMorphs
- LedTimerMorph
- LedDigitMorphs
- SimpleButtonMorph
- SimpleSwitchMorph
Morph
Morph<Morph>
Movie Player (not in Object Catalog)
Almost identical to MPEGPlayer, below.
Moving Eye (Just for Fun category)
MovingEyeMorph<MovingEye>
- EllipseMorphs
MPEGPlayer (Multimedia category)
MPEGMoviePlayerMorph<MPEGPlayer>
MPEGPlayer is implemented in this MPEGPlayer class, and in other classes in the Movies-Kernel and Movies-Player categories.
- MPEGDisplayMorph
- MPEGSubtitlesDisplayer
- AlignmentMorph
- SimpleButtonMorphs
- StringMorphs
- Morphs
- SimpleSliderMorph
- RectangleMorphs
MVCMenu (not in Object Catalog)
MVCMenu is implemented in this MVCMenuMorph class. It is used to implement menus in several classes. For example, when a search in a Standard Viewer fails, the error dialog is presented in an MVCMenu. It is not possible to use the category menu in a standard viewer on an MVCMenu, nor is it possible to open the debug menu on on MVCMenu.
MVCMenuMorph<MVCMenu>
Navigator Flap (not in Object Catalog)
Flaps newNavigatorFlap openInHand.
NebraskaServer (no category)
ScriptableButton<NebraskaServer>
- StringMorph
New Button Flap (not in Object Catalog)
What is this, and where does it occur?
Next Page (Multimedia category)
3PButton(#nextOwnerPage <number>)
Note (no category)
NCNoteMorph<Note>
- NCGrabbableDisplayTextMorph
Object Catalog (no category)
On the World menu. Ctrl-o/cmd-o on the keyboard.
ObjectsTool<Object Catalog> (version from SugarNavigatorBar)
ObjectsTool<Objects>(version from ObjectsCatalog)
ObjectsTool new initializeToStandAlone openInHand.
ObjectProperties
ObjectPropertiesMorph<ObjectProperties>
- AlignementMorphBob1s
- StringMorphs
- ColorPickerMorph
- EllipseMorph
- Morphs
- SimpleButtonMorphs
The command
ObjectPropertiesMorph new openInHand.
opens an ObjectPropertiesMorph on a Rectangle. Commands in the form
x =: <AnyMorph> new openInHand.
x openAPropertySheet.
with any Morph name in place of AnyMorph open an ObjectPropertiesMorph on the given Morph.
There is a way to get a more complex, multi-paned ObjectPropertiesMorph from a Morph, but I don't know what it is.
Objects Flap
FlapTab<Objects>
- TextMorph
ObjectsTool<Objects>
- PartsBin
- IconicButtonWithLabels
- SketchMorphs
- Morphs
- StringMorphs
- SimpleButtonMorphs
Flaps newObjectsFlap openInHand.
OR Gate (eToyFriendly off)
NCCurveMorph<OR Gate>
- NCGrabbableDisplayTextMorph
NCCurveMorph orGate openInHand.
Page (not in Object Catalog)
PasteUpMorph<page>
When a book is created, it contains an OrderedCollection of PasteUpMorphs, accessible with the pages method from the instance variable pages. Pages are implemented entirely internally to BookMoph and PasteUpMorph, not as a separate Class.
Page Controls (not in Object Catalog)
AlignmentMorph<Page Controls>
- AlignmentMorph
- 3PButtons
- Buttons
- Morphs
- VariableSpacers
- UpdatingStringMorph
Paint/PaintBox
TransformationMorph<PaintBox>
- PaintBoxMorph
- BorderedMorphs
- ImageMorphs
- 3PButtons
- ColorPicker
PaintBox appears as a component of Paint. While it is possible to create a PaintBox without a SketchEditor to paint in, there is no point in doing so. The correct method is
PaintInvokingMorph authoringPrototype openInHand.
Painting Flap
FlapTab<Painting>
- BorderedMorph
- ImageMorph
Flaps newPaintingFlap openInHand.
Parameters (not in Object Catalog)
SystemWindow<Parameters>
- AlignmentMorph
- IconicButtons
- SketchMorphs
- StringMorphs
- RectangleMorphs
- PluggableListMorph
- PluggableTextMorphs
- ScrollBars
- TransformMorphs
- TextMorphForEditViews
Particles (Basic category)
KedamaMorph<KedamaWorld>
KedamaPatchMorph<patch>
KedamaTurtleMorph<turtle1>
Particles is implemented in various Kedama* classes, mainly KedamaMorph, KedamaPatchMorph, and KedamaTurtleMorph.
parts bin (not in Object Catalog)
NCPartsBin<parts bin>
- NCMakerButtons
PDA (no category)
PDAMorph<PDA>
- AlignmentMorphs
- IconicButtons
- SketchMorphs
- StringMorphs
- RectangleMorphs
- PluggableListMorphs
- PDAChoiceMorph
- MonthMorph
- PDAClockMorph
- ScrollBars
- TransformMorph
- LazyListMorph
- SimpleButtonMorphs
- Morphs
- WeekMorphs
- SimpleSwitchMorphs
PhonePad (no category)
WsPhonePadMorph<PhonePad>
- AlignmentMorphs
- SimpleButtonMorphs
- StringMorphs
PhraseTile
PhraseTileMorph<PhraseTile>
- TilePadMorph
- TileMorphs
- StringMorphs
- various tile types to hold values, such as a SoundTile, a numeric value, and so on.
PianoKeyboard (Multimedia category)
PianoKeyboardMorph<PianoKeyboard>
- RectangleMorphs
- Morphs
Pin (Connectors category)
NCPinMorph<Pin>
NCPinMorph newPin openInHand.
Player (not in Object Catalog)
Player is implemented in the Player class, a subclass of Model, in the Etoys-Scripting category in Squeak. New Etoys objects with no scripts defined are Unscripted Players wearing various costumes, and objects with scripts each have a subclass of Player, again wearing some costume. One can create a player without a costume in Squeak in the usual manner.
x := Player new.
Printing the value of x then gives an answer in this form, where the number in parentheses indicates which subclass of Player x is in.
a Player (277) (with nil costume)
However, there is nothing one can do with it in Etoys without giving it a costume first, using the wearCostumeOf: anotherPlayer or wearCostumeOfName: aName methods of Player.
Players (Scripting category)
AllPlayersTool<Players>
- AlignmentMorphs
- 3PButtons
- StringMorph
- Morph
- ScrollPane
- Scrollbars
- RectangleMorphs
- TransformationMorph
- PlayerSurrogates
- IconicButtons
- SketchMorphs
- ThumbnailForAllPlayersTool
AllPlayersTool newStandAlone openInHand.
Playfield (Basic category)
PasteUpMorph<Playfield>
PasteUpMorph authoringPrototype openInHand.
Pluggable Button (not in Object Catalog)
PluggableButtonMorph<PluggableButton>
- AlignmentMorph
- StringMorph
PluggableButtonMorph example openInWorld
Pluggable List (not in Object Catalog)
PluggableListMorph<PluggableList>
- Scrollbars
- RectangleMorphs
- LazyListMorph
- TransformMorph
How is this accessed?
Pointing Hand (eToyFriendly off)
NCCurveMorph<Pointing Hand>
- NCGrabbableDisplayTextMorph
NCCurveMorph pointingHand openInHand.
Pointing Hand2 (eToyFriendly off)
NCCurveMorph<Pointing Hand2>
- NCGrabbableDisplayTextMorph
NCCurveMorph pointingHand2 openInHand.
Polygon (Basic category, Graphics category)
PolygonMorph<Polygon>
Preferences (no category)
SystemWindow<Preferences>
- AlignmentMorphs
- IconicButtons
- StringMorph
- RectangleMorphs
- PasteUpMorph
- TabbedPalette
- IndexTabs
- ReferenceMorphs
- StringMorphs
Preferences is implemented in the following classes.
- Preference class, a subclass of Object, in the System-Preferences category in Squeak.
- Preferences class, a subclass of Object, in the System-Preferences category in Squeak. This includes methods for accessing preference values by name.
- PreferencesPanel, a subclass of Model, in the System-Support category in Squeak.
- SystemWindow, a subclass of MorphicModel, in the Morphic-Windows category in Squeak.
Preferences are listed in DictionaryOfPreferences (a class variable of Preferences), and there is a get/set protocol in Preferences on the class side. For example:
Preferences disable: #eToyFriendly. Preferences enable: #eToyFriendly.
Previous Page (Multimedia category)
3PButton(#previousOwnerPage <number>)
ProjectHistory (no category)
EToyProjectHistoryMorph<ProjectHistory>
- AlignmentMorphs
- StringMorphs
- StretchyImageMorphs
Random (Scripting category)
FunctionTile<Random>
- FunctionNameTile
- Morphs
- StringMorph
- ImageMorphs
- TilePadMorph
- TileMorph
- UpdatingStringMorph
FunctionTile randomNumberTile openInHand.
Random Connectors (Connectors category)
NCMakerButton<Random Connectors>
- SketchMorph
Random Connectors is implemented as a special case of the NCMakerButton class.
NCAAConnectorMorph newRandomButton openInHand.
Its target (the morph it creates when clicked) is an NCAAConnectorMorph.
NCAAConnectorMorph new startWiringRandomly openInHand.
Rectangle (Basic category, Graphics category)
RectangleMorph<Rectangle>
RoundGlass (no category)
ScreeningMorph<RoundGlass>
- EllipseMorph
- MagnifierMorph
((MagnifierMorph newRound) setNameTo: 'RoundGlass') openInHand.
RoundRect (Basic category, Graphics category)
RectangleMorph<RoundRect>
RectangleMorph roundRectPrototype openInHand.
Row (no category)
AlignmentMorph<Row>
- EllipseMorphs
AlignmentMorph rowPrototype openInHand.
Ruler (no category)
RulerMorph<Ruler>
Sad face (eToyFriendly off)
NCCurveMorph<Sad face>
((NCCurveMorph sadFace) setNameTo: 'Sad face') openInHand.
Same (Games category)
Same is implemented in the
- SameGame class, a subclass of AlignmentMorph, in the Morphic-Games category
- SameGameBoard class, a subclass of AlignmentMorph, in the Morphic-Games category
- SameGameTile class, a subclass of SimpleSwitchMorph, in the Morphic-Games category
in Squeak.
SameGame<Same>
- SameGameBoard
- SameGameTiles
- StringMorphs
- AlignmentMorphs
- LedMorphs
- LedDigitMorphs
- SimpleButtonMorphs
- SimpleSwitchMorph
SameGame new newGame openInHand.
Schematic Connector (Connectors Category)
NCSchematicConnectorMorph<Schematic Connector>
- NCLineEndConstraintMorphs
- NCLineMorph
ScorePlayer (Multimedia category)
ScorePlayerMorph<ScorePlayer>
- AlignmentMorphs
- SimpleButtonMorphs
- Morphs
- SimpleSwitchMorphs
- StringMorphs
- SimpleSliderMorphs
- RectangleMorphs
ScorePlayer is implemented in the ScorePlayerMorph class and the ScorePlayer class.
Scratch Client (Scratch category, v5)
ScratchClientMorph<Scratch Client>
- AlignmentMorphs
- SketchMorph
Scratch Client is implemented in this ScratchClientMorph class, and also ScratchPlugin.
Scripting (Scripting category)
PasteUpMorph<Scripting>
- PasteUpMorph<playfield>
- TrashCanMorph
- ImageMorph<dot>
- AlignmentMorph<script controls>
StandardScriptingSystem new newScriptingSpace2 openInHand.
Scripting Tile Holder (not in Object Catalog)
ScriptingTileHolder<ScriptingTileHolder>
Scrolled State (eToyFriendly off)
NCScrolledCompositeStateMorph<Scrolled State>
- AlignmentMorph
- NCTextRectangleMorph
- NCGrabbableDisplayTextMorph
- NCBasicShapeMorph
- TransformMorph
- ScrollBars
- RectangleMorphs
NCScrolledCompositeStateMorph new openInHand.
Scrolling Text (Basic category)
ScrollableField<Scrolling Text1>
- ScrollBar
- Rectangles
- TransformMorph
- TextMorphForEditView
ScrollableField new initializeToStandAlone openInHand.
Search Pane (not in Object Catalog)
TextMorph<SearchPane>
ObjectsTool new newSearchPane openInHand.
SearchingViewer (not in Object Catalog)
SearchingViewer<SearchingViewer>
- AlignmentMorph
- 3PButton
- Morphs
- SimpleButtonMorph
- PasteUpMorph
- UpdatingStringMorph
Sector (Graphics category, v5)
SectorMorph<Sector>
SimpleHierarchicalList (not in Object Catalog)
SystemWindow<a SimpleHierarchicalListMorph
SimpleHierarchicalListMorph submorphsExample.
Sketch (not in Object Catalog)
SketchMorph<Sketch>
Sketches are normally created by painting, as with the Paint tool or this command, both of which open a PaintBox and SketchEditor.
SketchMorph openEditor.
The stock command
SketchMorph new openInHand.
creates a default sketch of a painter's palette.
SketchEditor (not in Object Catalog)
SketchEditorMorph<SketchEditor>
Creating a standalone SketchEditor without a PaintBox results in a cascade of errors. See Paint/Paintbox.
Slider (Basic category)
SimpleSliderMorph<Slider>
- RectangleMorphs
Smart Label (eToyFriendly off)
NCSmartLabelMorph<Smart Label>
- NCGrabbableDisplayTextMorph
NCSmartLabelMorph newStandAlone openInHand.
Sound Library (Multimedia category)
SoundLibraryTool<Sound Library>
- AlignmentMorphs
- 3PButtons
- VariableSpacers
- StringMorph
- SimpleButtonMorphs
- PluggableMultiColumnListMorph
- ScrollBar
- Rectangles
- TransformMorph
- MultiColumnLazyListMorph
SoundLibraryTool newInHand.
Sound Recorder (Multimedia category)
RecordingControls<SoundRecorder>
- EllipseMorph
- Morphs
- SimpleButtonMorphs
- IconicButton
RecordingControls new openInHand.
Spectrum Analyzer (Multimedia category)
SpectrumAnalyzerMorph<Spectrum Analyzer>
- Alignmentmorphs
- SimpleButtonMorphs
- Morphs
- RectangleMorph
- StringMorphs
- SimpleSliderMorph
- RectangleMorphs
- Sonogram
Speech Bubble (Just for Fun category, v5)
SpeechBubbleMorph<Speech bubble>
- UserText
- SketchMorphs
SpeechBubbleMorph speechPrototype openInHand.
Speech Bubble (graphic) (Just for Fun category, v5)
SpeechBubbleMorph<Speech bubble (graphic)>
Speech Bubble (graphic) is implemented in this SpeechBubbleMorph class.
(SpeechBubbleMorph speechGraphicPrototype setNameTo: 'Speech bubble (graphic)') openInHand.
Squeak Flap
FlapTab<Squeak>
- TextMorph
PasteUpMorph<flap>
- ClockMorph
- SimpleButtonMorphs
- StringMorphs
Flaps newSqueakFlap openInHand.
StandardViewer (not in Object Catalog)
StandardViewer<StandardViewer>
- Alignments
- 3PButtons
- Morphs
- UpdatingStringMorphs
- ImageMorphs
- SearchingViewer
- CategoryViewers
- SimpleButtonMorphs
- PasteUpMorph
- BorderedMorphs
- IconicMorphs
- VariableSpacers
- PhraseTileMorphs
- TilePadMorphs
- TileMorphs
- SoundTile
- NumericReadoutTile
- Other tile types
AMorph openViewerForArgument.
Stack Tools Flap
FlapTab<Stack Tools>
- TextMorph
PartsBin<parts bin>
- IconicButtonWithLabels
- AlignmentMorphs
- SketchMorphs
- Morphs
- StringMorphs
Flaps newStackToolsFlap openInHand.
Star (Graphics category)
StarMorph<Star>
Start State (eToyFriendly off, no category)
NCEllipseMorph<Start State>
NCEllipseMorph newStartState openInHand.
State (eToyFriendly off, no category)
NCUMLDiagramMorph<State>
- NCGrabbableDisplayTextMorph
NCUMLDiagramMorph newStateSymbol openInHand.
Status (no category)
TransformationMorph<Status>
- AlignmentMorph
- 3PButtons
DescriptionForPartsBin formalName: 'Status' translatedNoop categoryList: #() documentation: 'Buttons to run, stop, or single-step scripts' translatedNoop globalReceiverSymbol: #ScriptingSystem nativitySelector: #scriptControlButtons.
ScriptingSystem scriptControlButtons openInHand.
STClass (eToyFriendly off)
NCSTUMLDiagramMorph<STClass>
- NCGrabbableDisplayTextMorph
(NCSTUMLDiagramMorph newUMLClassSymbol setNameTo: 'STClass') openInHand.
Sticky Pad (Just for Fun category)
This appears in the Object Catalog, but I do not know how to create one in the World. We can make an IconicButton in the World that performs this function, by duplicating the one in the Object Catalog, but I do not have the code to make one from scratch.
Clicking it creates tear offs in a sequence of six colors. One can place these tear offs in the World.
StickyPadMorph<tear off>
Code to create tear offs is
StickyPadMorph newStandAlone openInHand.
Storyboard (no category)
StoryboardBookMorph<Storyboard>
- AlignmentMorph
- 3PButtons
- Morphs
- VariableSpacer
- UpdatingStringMorph
- ZoomAndScrollMorph
- TransformationB2Morph
- PasteUpMorph
String (no category)
StringMorph<String>
Sugar Navigator Flap
This is unusable. Attempting to place it in the World crashes Etoys.
Flaps newSugarNavigatorFlap openInHand.
Tab Pane
AlignmentMorph<TabPane>
- SimpleButtonMorphs
- StringMorphs
I have not found working code to create this. It should use the alphabeticTabs method, which recommends
ObjectsTool new tabsForMorphicCategories.
There is no such method as tabsForMorphicCategories. The tabsForCategories method does exist, but results in errors.
Tetris (no category)
Tetris<Tetris>
- AlignmentMorphs
- SimpleButtonMorphs
- StringMorphs
- LedMorph
- LedDigitMorphs
- TetrisBoard
- Tetris Block
- RectangleMorphs
Text (Basic category)
UserText<Text>
How do we make the text area fit the text? There are autoFit and fit methods, but I see no effect from using them.
(UserText new fontName: 'BitstreamVeraSans' pointSize: 36) openInHand.
Text (border) (no category)
UserText<Text (border)>
((UserText new fontName: 'BitstreamVeraSans' pointSize: 24) borderWidth: 1) openInHand.
Text chat (no category)
EToyChatMorph<Text chat>
- AlignmentMorph
- 3PButton
- StringMorphs
- PluggableTextMorph
- RectangleMorphs
Text chat+ (no category)
EToyMultiChatMorph<Text chat+>
- AlignmentMorphs
- 3PButton
- StringMorphs
- PluggableTextMorph
- ScrollBar
- RectangleMorphs
- TransformMorph
- TextMorphForEditView
Text Ellipse (Connectors category)
NCEllipseMorph<Text Ellipse>
- NCGrabbableDisplayTextMorph
Text Properties (not in Object Catalog)
TextPropertiesMorph<TextProperties>
- AlignmentMorphBob1s
- StringMorphs
- ColorPickerMorph
- EllipseMorph
- Morphs
- 3PButton
- SimpleButtonMorphs
For text objects such as UserText, TextMorph, and so on, this is the way to open a property sheet on such an object.
UserText new openATextPropertySheet openInHand.
Text Rectangle (Connectors category)
NCTextRectangleMorph<Text Rectangle>
- NCGrabbableDisplayTextMorph
Thought Bubble (Just for Fun category, v5)
SpeechBubbleMorph<Thought bubble>
- UserText
- SketchMorphs
(SpeechBubbleMorph thoughtPrototype setNameTo: 'Thought bubble') openInHand.
Thought Bubble (graphic) (Just for Fun category, v5)
SpeechBubbleMorph<Thought bubble (graphic)>
- SketchMorphs
(SpeechBubbleMorph thoughtGraphicPrototype setNameTo: 'Thought bubble (graphic)') openInHand.
Thread Navigator (Multimedia category)
InternalThreadNavigationMorph<ThreadNavigator>
- ASquishedNameMorph
- EllipseMorph
- ImageMorphs
Three Phase Button (not in Object Catalog)
3PButton(#try <number>)
ThreePhaseButtonMorph radioButton openInHand. ThreePhaseButtonMorph blackTriangularOpener openInHand. ThreePhaseButtonMorph checkBox openInHand.
Tick Indicator (not in Object Catalog)
TickIndicatorMorph<TickIndicator>
Tile (not in Object Catalog)
TileMorph<Tile>(4065) - #objRef op= ''
- StringMorph
Tiles are components of StandardViewers and Scripts. There is normally no need to create them in isolation under program control.
TilePad (not in Object Catalog)
TilePadMorph<TilePad>
- TileMorph
- StringMorph
TilePads are components of StandardViewers and Scripts. There is normally no need to create them in isolation under program control.
Title (Connectors category)
NCGrabbableDisplayTextMorph<Title>
NCGrabbableDisplayTextMorph authoringPrototype openInHand.
Tools Flap (not in Object Catalog)
NCGrabbableDisplayTextMorph<Title>
- TextMorph
PartsBin<parts bin>
- IconicButtonWithLabels
Flaps newToolsFlap openInHand.
Trash (Basic category)
TrashCanMorph
Triangle (Graphics category)
PolygonMorph<Triangle>
- PolygonMorphs
- EllipseMorphs
TrueType banner (no category)
TTSampleString(Bitstream Vera Sans)
TTSampleStringMorph new initializeToStandAlone openInHand.
TTSampleFont (not in Object Catalog)
TTSampleFont(Bitstream Vera Sans)
I don't see how to create one of these.
UML Package (eToyFriendly off)
NCCompositeStateMorph<UML Package>
- AlignmentMorph
- NCTextRectangleMorph
- NCBasicShapeMorph
- PasteUpMorph
UpdatingString (not in Object Catalog)
UpdatingStringMorph<UpdatingString>
(UpdatingStringMorph new contents: 'Text') openInHand.
V Number Line (Graph category, v5)
VerticalNumberLineMorph<V number line>
- StringMorphs
- Morphs
- PolygonMorph
VideoCamera (Multimedia category, v5)
VideoMorph<VideoCamera>
VideoMorph newStandAlone openInHand.
ViewerLine (not in Object Catalog)
ViewerLine<ViewerLine>
- 3PButton
- Morph
- PhraseTileMorph
- TilePadMorphs
- TileMorph
- Other tile types
ViewerLines occur as components of StandardViewer, and are not normally created under user program control.
WaveEditor (Multimedia category)
WaveEditor<WaveEditor>
- AlignmentMorphs
- SimpleButtonMorphs
- Morphs
- StringMorphs
- UpdatingStringMorphs
- SimpleSliderMorph
- RectangleMorphs
- GraphMorph
- PianoKeyboardMorph
Welcome (no category)
EToyMorphsWelcomeMorph<Welcome>
- AlignmentMorph
- TextMorph
Widgets Flap (not in Object Catalog)
FlapTab<Widgets>
- TextMorph
PartsBin<parts bin>
- IconicButtonWithLabels
Flaps newWidgetsFlap openInHand.
Workspace (eToyFriendly off, no category)
SystemWindow<Workspace>
- PluggableTextMorph
- ScrollBar
- RectangleMorphs
- TransformMorph
- TextMorph
Workspace open.
World (not in Object Catalog)
PasteUpMorph<world>
Any objects in use will appear as submorphs of world.
World is created automatically when a new project is created, and should not normally be created in any other way under user program control.
World Stethoscope (Multimedia category)
WsWorldStethoscopeMorph<WorldStethoscope>
- SimpleButtonMorphs
- Morphs
- StringMorphs
- SimpleSliderMorph
- RectangleMorphs
x-y Plane (Graphing category, v5)
PasteUpMorph<x-y plane>
- HorizontalNumberLineMorph
- StringMorphs
- Morphs
- PolygonMorph
- VerticalNumberLineMorph
GraphPaperPanel classicCartesianGraph openInHand.
XOR Gate (eToyFriendly off, no category)
NCCurveMorph<XOR Gate>
- NCGrabbableDisplayTextMorph
NCCurveMorph xorGate openInHand
Zip Tool (no category)
ArchiveViewer<Zip Tool>
- AlignmentMorph
- IconicButtons
- SketchMorphs
- StringMorph
- RectangleMorphs
The Object Catalog
Viewer Category Definitions
EToyVocabulary setCategoryDocumentationStrings "Initialize the documentation strings associated with the old etoy categories, in English" self setCategoryStrings: #( (basic 'basic' 'a few important things') (#'book navigation' 'book navigation' 'relating to book, stacks, etc') (button 'button' 'for thinking of this object as a push-button control') (collections 'collections' 'for thinking of this object as a collection') (fog 'fog' '3D fog') (geometry 'geometry' 'measurements and coordinates') (#'color & border' 'color & border' 'matters concerning the colors and borders of objects') (graphics 'graphics' 'for thinking of this object as a picture') (variables 'variables' 'variables added by this object') (joystick 'joystick' 'the object as a Joystick') (miscellaneous 'miscellaneous' 'various commands') (motion 'motion' 'matters relating to moving and turning') (paintbox 'paintbox' 'the painting palette') (#'pen trails' 'pen trails' 'relating to trails put down by pens') (#'pen use' 'pen use' 'use of an object''s "pen"') (playfield 'playfield' 'the object as a container for other visible objects') (sampling 'sampling' 'sampling') (scripting 'scripting' 'commands to start and stop scripts') (scripts 'scripts' 'methods added by this object') (slider 'slider' 'functions useful to sliders') (speaker 'speaker' 'the object as an audio Speaker') (#'stack navigation' 'stack navigation' 'navigation within a stck') (storyboard 'storyboard' 'storyboard') (tests 'tests' 'yes/no tests, to use in "Test" panes of scripts') (text 'text' 'The object as text') (vector 'vector' 'The object as a vector') (viewing 'viewing' 'matters relating to viewing') )
EToyVocabulary class masterOrderingOfCategorySymbols
"Answer a dictatorially-imposed presentation list of category symbols.
This governs the order in which available vocabulary categories are presented in etoy viewers using the etoy vocabulary.
The default implementation is that any items that are in this list will occur first, in the order specified here; after that, all other items will come, in alphabetic order by their translated wording."
EToyVocabulary class decompile: #masterOrderingOfCategorySymbols.
self flag: #(
('scripts' translatedNoop)
('variables' translatedNoop)
('as object' translatedNoop)).
^ {
'basic' translatedNoop.
'color' translatedNoop.
'geometry' translatedNoop.
'more geometry' translatedNoop.
'pen use' translatedNoop.
'tests' translatedNoop.
'motion' translatedNoop.
'fill & border' translatedNoop.
'scripting' translatedNoop.
'sound' translatedNoop.
'observation' translatedNoop.
'button' translatedNoop.
'layout' translatedNoop.
'drag & drop' translatedNoop.
'search' translatedNoop.
'miscellaneous' translatedNoop}
collect: [:each | each asSymbol]
additionsToViewerCategorySpeechBubbles ^#( #'speech bubbles' ( (command sayText: 'Show a text in a speech bubble' String) (command thinkText: 'Show a text in a thought bubble' String) (command sayNumber: 'Show a number in a speech bubble' Number) (command thinkNumber: 'Show a number in a thought bubble' Number) (command sayGraphic: 'Show a picture in a speech bubble' Graphic) (command thinkGraphic: 'Show a picture in a thought bubble' Graphic) (command sayObject: 'Show an object in a speech bubble' Player) (command thinkObject: 'Show an object in a thought bubble' Player) (command stopSayingOrThinking 'Erase all speech bubbles attached to this object, if any') (slot bubble 'The bubble currently attached to this object' Player readOnly Player getBubble Player unused) ))
Morph allAdditionsToViewerCategories. an IdentityDictionary(#'as object'->an OrderedCollection( #(#slot #size 'My physical size' #Number #readOnly #Player #getObjectSize #unused #unused) #(#slot #name 'The name by which I am known' #String #readWrite #Player #getName #Player #setName:) #(#slot #hash 'My hash value' #Number #readOnly #Player #getHash #unused #unused) #(#command #explore 'Open up an Explorer on this object') #(#command #halt: 'Put up a pre-debug notifier' #String) #(#slot #printString 'A string rendition of myself' #String #readOnly #Player #getPrintString #unused #unused) #(#command #inform: 'Put up message box for the user' #String) #(#command #printInTranscript 'Prints a description of the object to the Transcript') #(#command #printDirectlyToDisplay 'Prints a description of the object directly to the screen') #(#slot #className 'The name of the class of the object' #String #readOnly #player #getClassName #unused #unused)) #basic->an OrderedCollection(#(#slot #x 'The x coordinate' #Number #readWrite #Player #getX #Player #setX:) #(#slot #y 'The y coordinate' #Number #readWrite #Player #getY #Player #setY:) #(#slot #heading 'Which direction the object is facing. 0 is straight up' #Number #readWrite #Player #getHeading #Player #setHeading:) #(#command #forward: 'Moves the object forward in the direction it is heading' #Number) #(#command #turn: 'Change the heading of the object by the specified amount' #Number) #(#command #beep: 'Make the specified sound' #Sound)) #color->an OrderedCollection(#(#slot #color 'The color of the object' #Color #readWrite #Player #getColor #Player #setColor:) #(#slot #red 'Red value of my color from 0 to 100' #Number #readWrite #Player #getRed #Player #setRed:) #(#slot #green 'Green value of my color from 0 to 100' #Number #readWrite #Player #getGreen #Player #setGreen:) #(#slot #blue 'Blue value of my color from 0 to 100' #Number #readWrite #Player #getBlue #Player #setBlue:) #(#slot #alpha 'Alpha value of my color from 0 to 100' #Number #readWrite #Player #getAlpha #Player #setAlpha:) #(#slot #hue 'Hue value of my color from -180 to 180' #Number #readWrite #Player #getHue #Player #setHue:) #(#slot #saturation 'Saturation value of my color from 0 to 100' #Number #readWrite #Player #getSaturation #Player #setSaturation:) #(#slot #brightness 'Brightness value of my color from 0 to 100' #Number #readWrite #Player #getBrightness #Player #setBrightness:)) #'connections to me'->an OrderedCollection(#(#command #tellAllPredecessors: 'Send a message to all graph predecessors' #ScriptName) #(#command #tellAllSuccessors: 'Send a message to all graph successors' #ScriptName) #(#command #tellAllIncomingConnections: 'Send a message to all the connectors whose destination end is connected to me' #ScriptName) #(#command #tellAllOutgoingConnections: 'Send a message to all the connectors whose source end is connected to me' #ScriptName) #(#slot #incomingConnectionCount 'The number of connectors whose destination end is connected to me' #Number #readOnly #Player #getIncomingConnectionCount #unused #unused) #(#slot #outgoingConnectionCount 'The number of connectors whose source end is connected to me' #Number #readOnly #Player #getOutgoingConnectionCount #unused #unused)) #'drag & drop'->an OrderedCollection(#(#slot 'drop enabled' 'Whether drop is enabled' #Boolean #readWrite #Player #getDropEnabled #Player #setDropEnabled:) #(#slot 'resist being picked up' 'Whether a simple mouse-drag on this object should allow it to be picked up' #Boolean #readWrite #Player #getSticky #Player #setSticky:) #(#slot 'resist deletion' 'Whether this is resistant to easy removal via the pink X halo handle.' #Boolean #readWrite #Player #getResistsRemoval #Player #setResistsRemoval:) #(#slot 'be locked' 'Whether this object should be blind to all input' #Boolean #readWrite #Player #getIsLocked #Player #setIsLocked:)) #embeddings->an OrderedCollection(#(#slot #containingObject 'Me or my outermost container' #Player #readOnly #Player #getRootOwner #unused #unused) #(#slot #pinCount 'A count of my embedded objects that want to act as pins for connections' #Number #readOnly #Player #getPinCount #unused #unused) #(#slot #wantsConnectionWhenEmbedded 'Whether I should be act as a pin for connections when embedded in another object' #Boolean #readWrite #Player #getWantsConnectionWhenEmbedded #Player #setWantsConnectionWhenEmbedded:) #(#slot #allowsConnectionToEmbeddedPins 'Whether objects embedded in me may be used as connection pins' #Boolean #readWrite #Player #getAllowsConnectionToEmbeddedPins #Player #setAllowsConnectionToEmbeddedPins:) #(#command #tellAllPins: 'Send a message to all of my embedded objects that want to act as pins for connections' #ScriptName) #(#command #tellAllEmbeddedObjects: 'Send a message to all of my embedded objects' #ScriptName)) #'fill & border'->an OrderedCollection(#(#slot #color 'The color of the object' #Color #readWrite #Player #getColor #Player #setColor:) #(#slot #borderStyle 'The style of the object''s border' #BorderStyle #readWrite #Player #getBorderStyle #player #setBorderStyle:) #(#slot #borderColor 'The color of the object''s border' #Color #readWrite #Player #getBorderColor #Player #setBorderColor:) #(#slot #borderWidth 'The width of the object''s border' #Number #readWrite #Player #getBorderWidth #Player #setBorderWidth:) #(#slot #roundedCorners 'Whether corners should be rounded' #Boolean #readWrite #Player #getRoundedCorners #Player #setRoundedCorners:) #(#slot #gradientFill 'Whether a gradient fill should be used' #Boolean #readWrite #Player #getUseGradientFill #Player #setUseGradientFill:) #(#slot #secondColor 'The second color used when gradientFill is in effect' #Color #readWrite #Player #getSecondColor #Player #setSecondColor:) #(#slot #radialFill 'Whether the gradient fill, if used, should be radial' #Boolean #readWrite #Player #getRadialGradientFill #Player #setRadialGradientFill:) #(#slot #dropShadow 'Whether a drop shadow is shown' #Boolean #readWrite #Player #getDropShadow #Player #setDropShadow:) #(#slot #shadowColor 'The color of the drop shadow' #Color #readWrite #Player #getShadowColor #Player #setShadowColor:)) #geometry->an OrderedCollection(#(#slot #x 'The x coordinate' #Number #readWrite #Player #getX #Player #setX:) #(#slot #y 'The y coordinate' #Number #readWrite #Player #getY #Player #setY:) #(#slot #heading 'Which direction the object is facing. 0 is straight up' #Number #readWrite #Player #getHeading #Player #setHeading:) #(#slot #scaleFactor 'The factor by which the object is magnified' #Number #readWrite #Player #getScaleFactor #Player #setScaleFactor:) #(#slot #left 'The left edge' #Number #readWrite #Player #getLeft #Player #setLeft:) #(#slot #right 'The right edge' #Number #readWrite #Player #getRight #Player #setRight:) #(#slot #top 'The top edge' #Number #readWrite #Player #getTop #Player #setTop:) #(#slot #bottom 'The bottom edge' #Number #readWrite #Player #getBottom #Player #setBottom:) #(#slot #forwardDirection 'The angle of my forward direction without rotating myself' #Number #readWrite #Player #getForwardDirection #Player #setForwardDirection:)) #graphing->an OrderedCollection(#(#slot #xOnGraph 'If there is a horizontal axis present, gives the horizontal coordinate of the center of this object with respect to that axis ' #Number #readWrite #Player #getXOnGraph #Player #setXOnGraph:) #(#slot #yOnGraph 'If there is a vertical axis present, gives the vertical coordinate of the center of this object with respect to that axis ' #Number #readWrite #Player #getYOnGraph #Player #setYOnGraph:) #(#slot #locationOnGraph 'If there is are axes present, gives the coordinate of the center of this object with respect to those axes ' #Point #readWrite #Player #getLocationOnGraph #Player #setLocationOnGraph:)) #input->an OrderedCollection(#(#slot #lastKeystroke 'The last unhandled keystroke' #String #readWrite #Player #getLastKeystroke #Player #setLastKeystroke:)) #layout->an OrderedCollection(#(#slot #clipSubmorphs 'Whether or not to clip my submorphs' #Boolean #readWrite #Player #getClipSubmorphs #Player #setClipSubmorphs:)) #miscellaneous->an OrderedCollection(#(#command #doMenuItem: 'do the menu item' #Menu) #(#command #show 'make the object visible') #(#command #hide 'make the object invisible') #(#command #fire 'trigger any and all of this object''s button actions') #(#slot #copy 'returns a copy of this object' #Player #readOnly #Player #getNewClone #unused #unused) #(#slot #elementNumber 'my index in my container' #Number #readWrite #Player #getIndexInOwner #Player #setIndexInOwner:) #(#slot #holder 'the object''s container' #Player #readOnly #Player #getHolder #Player #setHolder:) #(#command #stamp 'add my image to the pen trails') #(#command #erase 'remove this object from the screen') #(#command #stampAndErase 'add my image to the pen trails and go away')) #'more geometry'->an OrderedCollection(#(#slot #location 'The position of the object, expressed as a point' #Point #readWrite #Player #getLocationRounded #Player #setLocation:) #(#slot #length 'The length' #Number #readWrite #Player #getLength #Player #setLength:) #(#slot #width 'The width' #Number #readWrite #Player #getWidth #Player #setWidth:) #(#slot #headingTheta 'The angle, in degrees, that my heading vector makes with the positive x-axis' #Number #readWrite #Player #getHeadingTheta #Player #setHeadingTheta:) #(#slot #distance 'The length of the vector connecting the origin to the object''s position' #Number #readWrite #Player #getDistance #Player #setDistance:) #(#slot #theta 'The angle between the positive x-axis and the vector connecting the origin to the object''s position' #Number #readWrite #Player #getTheta #Player #setTheta:) #(#slot #rotationCenterX 'The x coordinate of rotation center in parent''s coordinate system.' #Number #readWrite #Player #getRotationCenterX #Player #setRotationCenterX:) #(#slot #rotationCenterY 'The y coordinate of rotation center in parent''s coordinate system.' #Number #readWrite #Player #getRotationCenterY #Player #setRotationCenterY:)) #motion->an OrderedCollection(#(#slot #x 'The x coordinate' #Number #readWrite #Player #getX #Player #setX:) #(#slot #y 'The y coordinate' #Number #readWrite #Player #getY #Player #setY:) #(#slot #heading 'Which direction the object is facing. 0 is straight up' #Number #readWrite #Player #getHeading #Player #setHeading:) #(#command #forward: 'Moves the object forward in the direction it is heading' #Number) #(#slot #obtrudes 'whether the object sticks out over its container''s edge' #Boolean #readOnly #Player #getObtrudes #unused #unused) #(#command #turnToward: 'turn toward the given object' #Player) #(#command #moveToward: 'Move toward the given object. If the object has an instance variable named speed, the speed of the motion will be governed by that value' #Player) #(#command #turn: 'Change the heading of the object by the specified amount' #Number) #(#command #bounce: 'bounce off the edge if hit' #Sound) #(#command #wrap 'wrap off the edge if appropriate') #(#command #followPath 'follow the yellow brick road') #(#command #goToRightOf: 'place this object to the right of another' #Player)) #observation->an OrderedCollection(#(#slot #colorUnder 'The color under the center of the object' #Color #readOnly #Player #getColorUnder #unused #unused) #(#slot #brightnessUnder 'The brightness under the center of the object' #Number #readOnly #Player #getBrightnessUnder #unused #unused) #(#slot #luminanceUnder 'The luminance under the center of the object' #Number #readOnly #Player #getLuminanceUnder #unused #unused) #(#slot #saturationUnder 'The saturation under the center of the object' #Number #readOnly #Player #getSaturationUnder #unused #unused) #(#slot #distanceToPlayer 'The distance to another object' #Number #readOnly #Player #distanceToPlayer: #unused #unused) #(#slot #bearingTo 'The heading I would need to have to face directly toward another object' #Number #readOnly #Player #bearingTo: #unused #unused)) #'pen use'->an OrderedCollection(#(#slot #penColor 'the color of ink used by the pen' #Color #readWrite #Player #getPenColor #Player #setPenColor:) #(#slot #penSize 'the width of the pen' #Number #readWrite #Player #getPenSize #Player #setPenSize:) #(#slot #penDown 'whether the pen is currently down' #Boolean #readWrite #Player #getPenDown #Player #setPenDown:) #(#slot #trailStyle 'determines whether lines, arrows, arrowheads, or dots are used when I put down a pen trail' #TrailStyle #readWrite #Player #getTrailStyle #Player #setTrailStyle:) #(#slot #dotSize 'diameter of dot to use when trailStyle is dots' #Number #readWrite #Player #getDotSize #Player #setDotSize:) #(#command #clearOwnersPenTrails 'clear all pen trails in my containing playfield')) #scripting->an OrderedCollection(#(#command #triggerCustomEvent: 'trigger a user-defined (global) event' #CustomEvents) #(#slot #triggeringObject 'the object that is triggering an event, either user-defined or pre-defined' #Player #readOnly #Player #getTriggeringObject #unused #unused) #(#command #startScript: 'start the given script ticking' #ScriptName) #(#command #pauseScript: 'make the given script be "paused"' #ScriptName) #(#command #stopScript: 'make the given script be "normal"' #ScriptName) #(#command #startAll: 'start the given script ticking in the object and all of its siblings.' #ScriptName) #(#command #pauseAll: 'make the given script be "paused" in the object and all of its siblings' #ScriptName) #(#command #stopAll: 'make the given script be "normal" in the object and all of its siblings' #ScriptName) #(#command #doScript: 'run the given script once, on the next tick' #ScriptName) #(#command #tellSelfAndAllSiblings: 'run the given script in the object and in all of its siblings' #ScriptName) #(#command #tellAllSiblings: 'send a message to all siblings' #ScriptName)) #scripts->an OrderedCollection(#(#command #emptyScript 'an empty script')) #sound->an OrderedCollection(#(#command #playSound: 'play sound' #Number) #(#command #setSound: 'select a sound' #Sound) #(#command #stopSound 'stop sound') #(#command #beep: 'Make the specified sound' #Sound)) #'speech bubbles'->an OrderedCollection(#(#command #sayText: 'Show a text in a speech bubble' #String) #(#command #thinkText: 'Show a text in a thought bubble' #String) #(#command #sayNumber: 'Show a number in a speech bubble' #Number) #(#command #thinkNumber: 'Show a number in a thought bubble' #Number) #(#command #sayGraphic: 'Show a picture in a speech bubble' #Graphic) #(#command #thinkGraphic: 'Show a picture in a thought bubble' #Graphic) #(#command #sayObject: 'Show an object in a speech bubble' #Player) #(#command #thinkObject: 'Show an object in a thought bubble' #Player) #(#command #stopSayingOrThinking 'Erase all speech bubbles attached to this object, if any') #(#slot #bubble 'The bubble currently attached to this object' #Player #readOnly #Player #getBubble #Player #unused)) #tests->an OrderedCollection(#(#slot #isOverColor 'whether any part of the object is over the given color' #Boolean #readOnly #Player #seesColor: #unused #unused) #(#slot #isUnderMouse 'whether the object is under the current mouse position' #Boolean #readOnly #Player #getIsUnderMouse #unused #unused) #(#slot #colorSees 'whether the given color sees the given color' #Boolean #readOnly #Player #color:sees: #unused #unused) #(#slot #overlaps 'whether I overlap a given object' #Boolean #readOnly #Player #overlaps: #unused #unused) #(#slot #overlapsAny 'whether I overlap a given object or one of its siblings or similar objects' #Boolean #readOnly #Player #overlapsAny: #unused #unused) #(#slot #touchesA 'whether I overlap any Sketch that is showing the same picture as a particular prototype.' #Boolean #readOnly #Player #touchesA: #unused #unused) #(#slot #obtrudes 'whether the object sticks out over its container''s edge' #Boolean #readOnly #Player #getObtrudes #unused #unused)) #'world geometry'->an OrderedCollection(#(#slot #length 'The length' #Number #readWrite #Player #getLength #Player #setLength:) #(#slot #width 'The width' #Number #readWrite #Player #getWidth #Player #setWidth:) #(#slot #left 'The left edge' #Number #readWrite #Player #getLeft #Player #setLeft:) #(#slot #right 'The right edge' #Number #readWrite #Player #getRight #Player #setRight:) #(#slot #top 'The top edge' #Number #readWrite #Player #getTop #Player #setTop:) #(#slot #bottom 'The bottom edge' #Number #readWrite #Player #getBottom #Player #setBottom:)) )
As Object
Morph class additionsToViewerCategoryAsObject
additionsToViewerCategoryAsObject
"Answer viewer additions for the 'as object' category. Just priming the pump at this point."
^#(
#'as object'
(
(slot size 'My physical size' Number readOnly Player getObjectSize unused unused)
(slot name 'The name by which I am known' String readWrite Player getName Player setName:)
(slot hash 'My hash value' Number readOnly Player getHash unused unused)
(command explore 'Open up an Explorer on this object')
(command halt: 'Put up a pre-debug notifier' String)
(slot printString 'A string rendition of myself' String readOnly Player getPrintString unused unused)
(command inform: 'Put up message box for the user' String)
(command printInTranscript 'Prints a description of the object to the Transcript')
(command printDirectlyToDisplay 'Prints a description of the object directly to the screen')
(slot className 'The name of the class of the object' String readOnly player getClassName unused unused)
))
PasteUpMorph class additionsToViewerCategoryAsObject
additionsToViewerCategoryAsObject
"Answer viewer additions for the 'as object' category. Just priming the pump at this point."
^#(
#'as object'
(
(command useBlueprintCanvas 'Display the world as a blueprint' )
(command useNormalCanvas 'Display the world normally')))
Basic
Morph class additionsToViewerCategoryBasic
additionsToViewerCategoryBasic
"Answer viewer additions for the 'basic' category"
^#(
basic
(
(slot x 'The x coordinate' Number readWrite Player getX Player setX:)
(slot y 'The y coordinate' Number readWrite Player getY Player setY:)
(slot heading 'Which direction the object is facing. 0 is straight up' Number readWrite Player getHeading Player setHeading:)
(command forward: 'Moves the object forward in the direction it is heading' Number)
(command turn: 'Change the heading of the object by the specified amount' Number)
(command beep: 'Make the specified sound' Sound)
)
)
Bubble
SpeechBubbleMorph class additionsToViewerCategoryBubble
additionsToViewerCategoryBubble
"Answer viewer additions for the 'bubble' category"
^#(
bubble
(
(command attachTo: 'Make the bubble follow an object' Player)
(command stopAttaching 'Free the bubble from following an object')
(slot attachment 'The object this bubble is currently following' Player readOnly Player getAttachment Player unused)
)
)
Color
Morph class additionsToViewerCategoryColor
additionsToViewerCategoryColor
"Answer viewer additions for the 'color' category"
^#(
color
(
(slot color 'The color of the object' Color readWrite Player getColor Player setColor:)
(slot red 'Red value of my color from 0 to 100' Number readWrite Player getRed Player setRed:)
(slot green 'Green value of my color from 0 to 100' Number readWrite Player getGreen Player setGreen:)
(slot blue 'Blue value of my color from 0 to 100' Number readWrite Player getBlue Player setBlue:)
(slot alpha 'Alpha value of my color from 0 to 100' Number readWrite Player getAlpha Player setAlpha:)
(slot hue 'Hue value of my color from -180 to 180' Number readWrite Player getHue Player setHue:)
(slot saturation 'Saturation value of my color from 0 to 100' Number readWrite Player getSaturation Player setSaturation:)
(slot brightness 'Brightness value of my color from 0 to 100' Number readWrite Player getBrightness Player setBrightness:)
)
)
Color and Border
NCAAConnectorMorph class additionsToViewerCategoryColorAndBorder
additionsToViewerCategoryColorAndBorder
"Answer viewer additions for the 'color & border' category"
^#(
#'color & border'
(
(slot lineWidth 'The width of the main part of the Connector' Number readWrite Player getLineWidth Player setLineWidth:)
)
)
Connection
Morph class additionsToViewerCategoryConnection
additionsToViewerCategoryConnection
"Answer viewer additions for the 'connection' category"
"Vocabulary initialize"
^{
#'connections to me'.
#(
(command tellAllPredecessors: 'Send a message to all graph predecessors' ScriptName)
(command tellAllSuccessors: 'Send a message to all graph successors' ScriptName)
(command tellAllIncomingConnections: 'Send a message to all the connectors whose destination end is connected to me' ScriptName)
(command tellAllOutgoingConnections: 'Send a message to all the connectors whose source end is connected to me' ScriptName)
(slot incomingConnectionCount 'The number of connectors whose destination end is connected to me' Number readOnly Player getIncomingConnectionCount unused unused)
(slot outgoingConnectionCount 'The number of connectors whose source end is connected to me' Number readOnly Player getOutgoingConnectionCount unused unused)
)
}
NCAAConnectorMorph class
additionsToViewerCategoryConnection
"Answer viewer additions for the 'connection' category"
"Vocabulary initialize"
^#(
connector
(
(slot source 'The Player at my first end' Player readWrite Player getSourcePlayer Player setSourcePlayer:)
(slot destination 'The Player at my second end' Player readWrite Player getDestinationPlayer Player setDestinationPlayer:)
(slot orthogonal 'Whether I am limited to horizontal and vertical segments' Boolean readWrite Player getOrthogonal Player setOrthogonal:)
(slot smoothCurve 'Whether I am drawn as a smooth curve' Boolean readWrite Player getSmoothCurve Player setSmoothCurve:)
(slot sourceArrowName 'The name of the arrow at my first end' ArrowNames readWrite Player getSourceArrowName Player setSourceArrowName:)
(slot destinationArrowName 'The name of the arrow at my second end' ArrowNames readWrite Player getDestinationArrowName Player setDestinationArrowName:)
(command straighten 'remove all my bends' unused)
(command addLabel: 'add a label at my middle' String)
(command removeLabels 'remove all my labels' unused)
)
)
Display
PasteUpMorph class additionsToViewerCategoryDisplay
additionsToViewerCategoryDisplay
"Answer display additions"
^ #(display(
(command showNavigationBar 'Show the navigation bar at the top of the screen')
(command hideNavigationBar 'Hide the navigation bar at the top of the screen')
(command useBlueprintCanvas 'Display the world as a blueprint' )
(command useNormalCanvas 'Display the world normally' Boolean)))
Drag and Drop
Morph class additionsToViewerCategoryDragAndDrop
additionsToViewerCategoryDragAndDrop
"Answer viewer additions for the 'drag & drop' category"
^#(
#'drag & drop'
(
(slot 'drop enabled' 'Whether drop is enabled' Boolean readWrite Player getDropEnabled Player setDropEnabled:)
(slot 'resist being picked up' 'Whether a simple mouse-drag on this object should allow it to be picked up' Boolean readWrite Player getSticky Player setSticky:)
(slot 'resist deletion' 'Whether this is resistant to easy removal via the pink X halo handle.' Boolean readWrite Player getResistsRemoval Player setResistsRemoval:)
(slot 'be locked' 'Whether this object should be blind to all input' Boolean readWrite Player getIsLocked Player setIsLocked:)
))
DrGeo
DrGPointMorph class additionsToViewerCategoryDrGeo
additionsToViewerCategoryDrGeo
^ # (drgeo (
(slot curveAbscissa 'The abscissa of this point on the curve' Number readWrite Player getCurveAbscissa Player setCurveAbscissa:)
(slot Xw 'The x coordinate in the DrGeoII world coordinate system' Number readWrite Player getWorldX Player setWorldX:)
(slot Yw 'The y coordinate in the DrGeoII world coordinate system' Number readWrite Player getWorldY Player setWorldY:)
))
DrGValueMorph class additionsToViewerCategoryDrGeo
additionsToViewerCategoryDrGeo
^ #(drgeo (
(slot value 'The math item value' Number readWrite Player getMathItemValue Player setMathItemValue:)
))
Embeddings
Morph class additionsToViewerCategoryEmbeddings
additionsToViewerCategoryEmbeddings
"Answer viewer additions for the 'embeddings' category"
"Vocabulary initialize"
^#(
embeddings
(
(slot containingObject 'Me or my outermost container' Player readOnly Player getRootOwner unused unused)
(slot pinCount 'A count of my embedded objects that want to act as pins for connections' Number readOnly Player getPinCount unused unused)
(slot wantsConnectionWhenEmbedded 'Whether I should be act as a pin for connections when embedded in another object' Boolean readWrite Player getWantsConnectionWhenEmbedded Player setWantsConnectionWhenEmbedded:)
(slot allowsConnectionToEmbeddedPins 'Whether objects embedded in me may be used as connection pins' Boolean readWrite Player getAllowsConnectionToEmbeddedPins Player setAllowsConnectionToEmbeddedPins:)
(command tellAllPins: 'Send a message to all of my embedded objects that want to act as pins for connections' ScriptName)
(command tellAllEmbeddedObjects: 'Send a message to all of my embedded objects' ScriptName)
)
)
Fill and Border
Morph class additionsToViewerCategoryFillAndBorder
additionsToViewerCategoryFillAndBorder
"Answer viewer additions for the 'color & border' category"
^#(
#'fill & border'
(
(slot color 'The color of the object' Color readWrite Player getColor Player setColor:)
(slot borderStyle 'The style of the object''s border' BorderStyle readWrite Player getBorderStyle player setBorderStyle:)
(slot borderColor 'The color of the object''s border' Color readWrite Player getBorderColor Player setBorderColor:)
(slot borderWidth 'The width of the object''s border' Number readWrite Player getBorderWidth Player setBorderWidth:)
(slot roundedCorners 'Whether corners should be rounded' Boolean readWrite Player getRoundedCorners Player setRoundedCorners:)
(slot gradientFill 'Whether a gradient fill should be used' Boolean readWrite Player getUseGradientFill Player setUseGradientFill:)
(slot secondColor 'The second color used when gradientFill is in effect' Color readWrite Player getSecondColor Player setSecondColor:)
(slot radialFill 'Whether the gradient fill, if used, should be radial' Boolean readWrite Player getRadialGradientFill Player setRadialGradientFill:)
(slot dropShadow 'Whether a drop shadow is shown' Boolean readWrite Player getDropShadow Player setDropShadow:)
(slot shadowColor 'The color of the drop shadow' Color readWrite Player getShadowColor Player setShadowColor:)
)
)
Geometry
Morph class
additionsToViewerCategoryGeometry
"answer additions to the geometry viewer category"
^ #(geometry
(
(slot x 'The x coordinate' Number readWrite Player getX Player setX:)
(slot y 'The y coordinate' Number readWrite Player getY Player setY:)
(slot heading 'Which direction the object is facing. 0 is straight up' Number readWrite Player getHeading Player setHeading:)
(slot scaleFactor 'The factor by which the object is magnified' Number readWrite Player getScaleFactor Player setScaleFactor:)
(slot left 'The left edge' Number readWrite Player getLeft Player setLeft:)
(slot right 'The right edge' Number readWrite Player getRight Player setRight:)
(slot top 'The top edge' Number readWrite Player getTop Player setTop:)
(slot bottom 'The bottom edge' Number readWrite Player getBottom Player setBottom:)
(slot forwardDirection 'The angle of my forward direction without rotating myself' Number readWrite Player getForwardDirection Player setForwardDirection: )
)
)
Graphing
Morph class additionsToViewerCategoryGraphing
additionsToViewerCategoryGraphing
"answer additions to the graphing viewer category"
^ #(graphing
(
(slot xOnGraph 'If there is a horizontal axis present, gives the horizontal coordinate of the center of this object with respect to that axis ' Number readWrite Player getXOnGraph Player setXOnGraph:)
(slot yOnGraph 'If there is a vertical axis present, gives the vertical coordinate of the center of this object with respect to that axis ' Number readWrite Player getYOnGraph Player setYOnGraph:)
(slot locationOnGraph 'If there is are axes present, gives the coordinate of the center of this object with respect to those axes ' Point readWrite Player getLocationOnGraph Player setLocationOnGraph:)))
Input
Morph class additionsToViewerCategoryInput
additionsToViewerCategoryInput
"Answer a list of (<categoryName> <list of category specs>) pairs that characterize the phrases this kind of morph wishes to add to various Viewer categories."
^ #(input (
(slot lastKeystroke 'The last unhandled keystroke' String readWrite Player getLastKeystroke Player setLastKeystroke:)
))
PasteUpMorph class additionsToViewerCategoryInput
additionsToViewerCategoryInput
"Answer a list of (<categoryName> <list of category specs>) pairs that characterize the phrases this kind of morph wishes to add to various Viewer categories."
^ #(input (
(slot lastKeystroke 'The last unhandled keystroke' String readWrite Player getLastKeystroke Player setLastKeystroke:)
))
Layout
Morph class additionsToViewerCategoryLayout
additionsToViewerCategoryLayout
"Answer viewer additions for the 'layout' category"
^#(
layout
(
(slot clipSubmorphs 'Whether or not to clip my submorphs' Boolean readWrite Player getClipSubmorphs Player setClipSubmorphs:)
))
Miscellaneous
Morph class additionsToViewerCategoryMiscellaneous
additionsToViewerCategoryMiscellaneous
"Answer viewer additions for the 'miscellaneous' category"
^#(
miscellaneous
(
(command doMenuItem: 'do the menu item' Menu)
(command show 'make the object visible')
(command hide 'make the object invisible')
" (command wearCostumeOf: 'wear the costume of...' Player)"
(command fire 'trigger any and all of this object''s button actions')
(slot copy 'returns a copy of this object' Player readOnly Player getNewClone unused unused)
(slot elementNumber 'my index in my container' Number readWrite Player getIndexInOwner Player setIndexInOwner:)
(slot holder 'the object''s container' Player readOnly Player getHolder Player setHolder:)
(command stamp 'add my image to the pen trails')
(command erase 'remove this object from the screen')
(command stampAndErase 'add my image to the pen trails and go away')
)
)
More Geometry
Morph class additionsToViewerCategoryMoreGeometry
additionsToViewerCategoryMoreGeometry
"answer additions to the more geometry viewer category"
^ #(#'more geometry'
(
(slot location 'The position of the object, expressed as a point' Point readWrite Player getLocationRounded Player setLocation:)
(slot length 'The length' Number readWrite Player getLength Player setLength:)
(slot width 'The width' Number readWrite Player getWidth Player setWidth:)
(slot headingTheta 'The angle, in degrees, that my heading vector makes with the positive x-axis' Number readWrite Player getHeadingTheta Player setHeadingTheta:)
(slot distance 'The length of the vector connecting the origin to the object''s position' Number readWrite Player getDistance Player setDistance:)
(slot theta 'The angle between the positive x-axis and the vector connecting the origin to the object''s position' Number readWrite Player getTheta Player setTheta: )
(slot rotationCenterX 'The x coordinate of rotation center in parent''s coordinate system.' Number readWrite Player getRotationCenterX Player setRotationCenterX: )
(slot rotationCenterY 'The y coordinate of rotation center in parent''s coordinate system.' Number readWrite Player getRotationCenterY Player setRotationCenterY: )
"(command forceAxisToX: 'Force change x of axis for rotation' Number )
(command forceAxisToY: 'Force change y of axis for rotation' Number )"
)
)
Motion
Morph class
Number Line
numberLineMorph
additionsToViewerCategoryNumberLine
^ #('number line' (
" (command fitPlayfield 'extend or contract such that the line fits within the containing playfield.')"
(slot minVal 'smallest value shown on the axis' Number readWrite Player getMinVal Player setMinVal:)
(slot maxVal 'largest value shown on the axis' Number readWrite Player getMaxVal Player setMaxVal:)
(slot pixelsPerUnit 'number of screen pixels per unit on the number line' Number readWrite Player getPixelsPerUnit Player setPixelsPerUnit:)
(slot unitsPerMark 'number of units between tick marks on the number line' Number readWrite Player getUnitsPerMark Player setUnitsPerMark:)
(slot marksPerLegend 'number of ticks between successive legends' Number readWrite Player getMarksPerLegend Player setMarksPerLegend:)
(slot showZero 'whether to show the numeral 0 at the zero point on this axis' Boolean readWrite Player getShowZero Player setShowZero:)
(slot showNegativeArrowHead 'whether to show an arrow-head at the extreme lower end of the axis' Boolean readWrite Player getShowNegativeArrowHead Player setShowNegativeArrowHead:)) )
Observation
Morph class
Pen Trails
Pen Use
Morph class
Preferences
ScratchCommand
ScratchNetworking
Scripting
Morph class
Scripts
Morph class
Sound
Morph class
Speech Bubbles
Morph class
Tests
Morph class
Text
UserEvents
Morph class
WorldGeometry
Morph class
Playfield Options
additionsToViewerCategory: aCategoryName
EToyVocabulary initialize
"Initialize the receiver (automatically called when instances are created via 'new')"
| classes aMethodCategory selector selectors categorySymbols aMethodInterface |
super initialize.
self vocabularyName: #eToy.
self documentation: '"EToy" is a vocabulary that provides the equivalent of the 1997-2000 etoy prototype'.
categorySymbols _ Set new.
classes _ self class morphClassesDeclaringViewerAdditions.
classes do:
[:aMorphClass | categorySymbols addAll: aMorphClass unfilteredCategoriesForViewer].
self addCustomCategoriesTo: categorySymbols. "For benefit, e.g., of EToyVectorVocabulary"
categorySymbols asOrderedCollection do:
[:aCategorySymbol |
aMethodCategory _ ElementCategory new categoryName: aCategorySymbol.
selectors _ Set new.
classes do:
[:aMorphClass |
(aMorphClass additionsToViewerCategory: aCategorySymbol) do:
[:anElement |
aMethodInterface _ self methodInterfaceFrom: anElement.
selectors add: (selector _ aMethodInterface selector).
(methodInterfaces includesKey: selector) ifFalse:
[methodInterfaces at: selector put: aMethodInterface].
self flag: #deferred.
"NB at present, the *setter* does not get its own method interface. Need to revisit"].
(selectors copyWithout: #unused) asSortedArray do:
[:aSelector |
aMethodCategory elementAt: aSelector put: (methodInterfaces at: aSelector)]].
self addCategory: aMethodCategory].
self addCategoryNamed: ScriptingSystem nameForInstanceVariablesCategory.
self addCategoryNamed: ScriptingSystem nameForScriptsCategory.
self setCategoryDocumentationStrings.
(self respondsTo: #applyMasterOrdering)
ifTrue: [ self applyMasterOrdering ].
Squeak Definitions of Etoys Scripting Tiles
4.1 About Tiles
There are six kinds of Etoys scripting tile: commands, variables, watchers, tests, control structures, and expressions.
Commands
A command describes an action that can be carried out by clicking on the ! icon at the left, possibly with a constant, variable, or expression parameter. For any object type there is a predefined set of commands, visible in the object's viewer, and users can add more commands as scripts.
Command tiles are implemented in the CommandTilesMorph class in Squeak.
Variables
A variable holds a value, which can be of several object types.
- Boolean
- Color
- CustomEvents
- Graphic
- Number
- Player
- Point
- ScriptName
- Sound
- String
Within variable tiles and actions used in scripts, wherever a number appears, the number can be modified or edited into an expression.
Some variables are predefined as part of an object. Users can define their own variables for use in their scripts, using an icon on the viewer toolbar. The first step is to enter a variable name, and then to choose a variable type from a menu. This is the menu in Etoys v. 4.0.
And this is the version in v. 5.0.
These data types have different sets of values, and are managed and used in different ways. In general, a variable of a particular type can be dropped into a slot in a scripting tile that has a value of that type.
Boolean
Possible values are true (default) and false. Toggle between them by clicking the up or down triangle next to the current value.
Only the down arrow is active in v. 5.0.
BorderStyle
Default value: simple. Click to get a menu with nine options.
ButtonPhase
Default value: button down. Click to get a menu of three values, button down, button up, and while pressed.
Color
A 32-bit RGB-Alpha (Red Green Blue Transparency) color value. Click the color patch that shows the current color to get a color picker. Setting a color variable to display as text permits the color value to be set numerically, with 0-255 being mapped to the range 0.0-1.0.
CustomEvents
Defaults to no event. Clicking it brings up a menu of user-defined events.
To define an event, open a script editor and click on the clock icon to bring up the menu of options for when to run the script. On the submenu for more… is the choice define a new custom event. Clicking it asks for an event name and a description. The new event then appears on that submenu and on the menu for the scripting tile Object's trigger custom event EventName in the scripting category. Selecting a custom event in a script menu and running the trigger custom event tile runs the script.
But what can one do with an event-valued variable? Where can it be used?
Graphic
An image, defaulting to the Paintbox palette graphic. To change the image value, drag the variable out of the viewer to create a script, and drop a tile representing a different image into the variable tile over the current image. Running this script then changes the value.
ImageResolution
This type is misnamed. Resolution is the number of dots per linear unit. This is actually the image's color palette, which can be expressed in terms of the number of colors available, whether they are monochrome or color, and how m
any bits are used to represent them.
Default value: Original, that is, whatever an image is represented in. Click to get a menu with the options original, 256 colors (that would be 8 bits per pixel, but it seems to be 32 bits, with 8 bits each for the three RGB components, plus transparency), 256 grays (8 bits), 4 grays (2 bits), black and white (1 bit).
How can this be used? What tiles have this value type, so that they can accept a variable of this type?
Number
The initial value is a positive integer chosen at random in the range 1-6. By default, 0 decimal places are shown. Click the up or down arrow to increment or decrement the numeric value, or click it to edit it as text. Use the modify function or the decimal places function on the tile menu to set the number of decimal places.
Patch
Creating a patch-valued variable results in a MessageNotification: "An error has occurred; you should probably just hit 'abandon'. Sorry!"
When dragging Particles from the Object Catalog, one gets a KedamaWorld, a patch, and a turtle. The KedamaWorld has a predefined variable that points to the corresponding patch.
Where can this be used?
Player
An object currently active. Default value: dot. To change the value of this variable, put it in a script, drag a tile for another player over the dot, and run the script.
Clicking on a player in a variable tile turns the cursor to a crosshair. What is its purpose and what does it do?
Point
Default value: 0@0. Click to edit.
ScriptName
Default value: empty script. Click to get a menu of the scripts defined for all active objects. Scripting commands accept dropped tiles for ScriptName variables.
Sound
Default value: croak. Click the current sound to get a menu of available sounds.
String
Default value: 'abc'. Click to edit.
TrailStyle
Default value: lines. Clicking brings up a menu with the options lines, arrows, arrowheads, dots. These affect the appearance of the object's pen trails.
To place a variable in a script, it is necessary to click its leftward-pointing arrow and then drag it. Clicking elsewhere and dragging creates a watcher instead, an object that displays the changing values of the variable, and allows the user to edit the value.
Variables are implemented using the AssignmentTileMorph class in Squeak, together with the tiles for the expressions to generate the values to be assigned.
Watchers
Some tiles are very similar to variable watchers, but do not allow assignments of new values. They can be recognized by the lack of the left-pointing assignment arrow and the up and down pointing triangles for selecting or modifying values. Instead they only display values obtained elsewhere. In the viewer, they have a menu at the left for getting simple or detailed watchers.
Values
There are also tiles that represent values, for use in expressions, but do not display them. The menu at the left contains only an option for setting the number of decimal places to use.
Tests
Tests are provided with objects, and shown in the Test category of their viewers. Users can click on parameters, such as the blue color at the right of the block above, to modify them or get a menu of options to choose from.
Controls
Control tiles accept other tiles and determine when to run them. The test yes no tile and the repeat tile are available in the Gold Box menu on the toolbar of any Script, as shown below.
The Test Yes No tile accepts a test and two lists of actions. Choosing one of the action lists to perform depending whether the test evaluates to True or False. This is also known as a program branch.
The Repeat tile carries out the list of actions given it the number of times specified. That number can be a constant or the result of an expression. This is also known as a program loop
Etoys does not provide a scripting tile for the more general While loop, which repeats a list of actions until a test evaluates to False/No.
It is a fundamental theorem of Computer Science that any possible sequential program logic can be expressed using only branches and loops, although it is much preferable to include function calls (as with scripts calling other scripts) or, as in Object-Oriented Programming in Smalltalk, method calls, and to split programs into separate modules. Etoys also supports running tiles in endless loops (ticking), and provides parallel programming, running multiple scripts simultaneously, and allowing scripts to turn other scripts on and off using commands in the Scripting category in object viewers. These are extremely powerful tools, more than powerful enough to allow the user to get into a lot of trouble if used carelessly.
The test yes no tile is defined in the CompoundTileMorph class in Squeak. The repeat tile is defined in the TimesRepeatTile class in Squeak.
Expressions
The Gold Box menu on the toolbar of any Script, shown above, provides several tiles that are meant to be used as components in other tiles, or to accept other tiles as components. These include the math function tiles in the Gold Box menu (above) that default to random, abs (absolute value), and 5; the tests button up? and button down?; and a tile for the current object. Each can be dropped into the appropriate location within a tile containing an appropriate expression. Such component tiles are also available in other locations. Random is available in the Object Catalog. Object tiles are available from the object's viewer and from the tool Halo. Numbers and some functions can be added by editing an expression in a tile directly.
Tiles for components of expressions are defined in classes in the Etoys-Scripting Tiles category in Squeak.
4.2 Category Basic
The object will make the sound which is specified in the box at the right of the tile. Clicking the box brings up this menu.
You can choose between camera, chirp, chomp, click, clink, coyote, croak, horn, laugh, meow, motor, scratch, silence, splash, warble and sound tiles you create. You can add your own sound by recording it using the SoundRecorder from the Object Catalog.
Moves the object forward in the direction of its heading by the amount of pixels, which is given in the right-most portion of the tile. If you put in a negative number, the object will move backwards. If you use a very large number, your object might disappear from the screen. You can get it back by changing the values in the x- and y-tiles of the object or by choosing "grab this object" in the menu at the top of the viewer.
Changes the heading of the object in degrees by the specified amount. If you use positive numbers, the object will turn clockwise, for negative numbers it turns counter-clockwise. Clicking the up or down triangles before the numeric value increments or decrements the value. Clicking in the numeric field lets you enter a value. Clicking the rightward-pointing triangle extends the number into an expression.
The x coordinate of the object describes the location of the object's rotation center in its holder or the world. The value "0" for the x coordinate defaults to the left side of the object's holder or the world. The default origin of the x-y coordinate system is at the lower left corner of the holder or the world.
You can change an objects rotation center by clicking on it to display its Halo. A small yellow circle with a green arrow will be shown. If you place your mouse on the small yellow circle in the middle of the object, you can hold down the shift key and drag the rotation center to a different part of the object.
Pop Quiz: How can you change the orientation center to make a Baseball bat or Hammer appear to swing?
You can also change the origin point of the World's playfield (or any object with "playfield options..." as a menu item), by selecting "playfield options..." then selecting "origin-at-center". Another way to change a origin point is to click on "set grid spacing..." in "playfield options." The first option allows you to set a new origin point as x@y. These values are relative to the default origin of the lower left corner.
The y coordinate of the object describes the location of the objects rotation center in its holder or the world. The value "0" for the y coordinate defaults to the bottom side of the object's holder or the world. The origin of the x-y coordinate system is at the lower left corner of the holder or the world.
The heading is the direction the object is facing in degrees. 0 is straight up, 90 is to the right, 180 is straight down and 270 is to the left.
4.3 Category Color
The color of the object. You can change the color by clicking on the color box at the right side of the tile. A Color is made up of multiple attributes as shown in the color category of the viewer. When you set a color all those values are updated. A color picker appears and the color changes to the color you click.
The green value of the object's color from 0 to 100 as a floating point number. You can change the value at the right of the tile.
The blue value of the object's color from 0 to 100 as a floating point number. You can change the value at the right of the tile.
The alpha value of the object's color from 0 to 100 as a floating point number. You can change the value at the right of the tile.
The hue value of the object's color from -180 to 180 as a floating point number. You can change the value at the right of the tile.
The brightness value of the object's color from 0 to 100 as a floating point number. You can change the value at the right of the tile.
The saturation value of the object's color from 0 to 100 as a floating point number. You can change the value at the right of the tile.
4.4 Category Geometry
x
The x coordinate (see the basic category for more detail).
y
The y coordinate (see the basic category for more detail).
heading
Heading is the direction the object is facing (see the basic category for more detail).
The scale factor is the factor by which the object is magnified. It must be greater than zero, but may be less than 1. The maximum value is 10. It can be changed in the box at the right of the tile.
Left is the extreme left edge of the object in pixels. It can be changed in the box at the right of the tile.
Right is the extreme right edge of the object in pixels. It can be changed in the box at the right of the tile.
Top is the extreme top edge of the object in pixels. It can be changed in the box at the right of the tile.
Bottom is the extreme bottom edge of the object in pixels. It can be changed in the box at the right of the tile.
Forward direction is the angle in degrees of the object's forward direction without rotating it. It can be changed in the box at the right of the tile. If the forward direction is changed, the heading is changed by the same amount. If the heading is changed, the forward direction isn't changed.You can also change the forward direction by clicking on an object to see its halo, then hold down the <shift> key and click on the green arrow and drag it in the forward direction you want to set.
Pop Quiz: Why do you think the designers of Etoys added both "forward direction" and "heading"?
Lets say you draw a Sketch of a person with the head at the top. What will happen when you move it "forward 5"? How can you use forward direction to fix this? Will changing heading fix this?
4.5 Category More Geometry
The location is the position of the object, expressed as x,y coordinates in pixels with the @ between the x and y value. It can be changed in the box at the right of the tile.
Length is the greatest length of the object along its original y direction in pixels. It can be changed in the box at the right of the tile.
Width is the greatest width along the original x direction. It can be changed in the box at the right of the tile.
Theta is the angle between the positive x-axis and the vector connecting the origin to the object's position. It can be changed in the box at the right of the tile.
Distance is the length of the vector connecting the origin to the object's position. It can be changed in the box at the right of the tile.
Heading theta is the angle, in degrees, that my heading vector makes with the positive x-axis. It can be changed in the box at the right of the tile.
Rotation center x is the x coordinate in pixels of rotation center in parent's coordinate system. It can be changed in the box at the right of the tile.
Rotation center y is the y coordinate in pixels of rotation center in parent's coordinate system. It can be changed in the box at the right of the tile.
4.6 Category Pen Use
If run, this command clears all pen trails in the object's containing playfield.
This controls the diameter in pixels of dot to use when trailStyle is dots. It can be changed in the box at the right of the tile.
This shows the color of ink used by the pen in the box at the right of the tile. You can change the color by clicking on the color box at the right side of the tile. A color picker appears and the color changes to the color you click.
The pen is down/up if the Boolean choice at the right of the box is true/false. It can be changed in the box at the right of the tile.
This gives the width of the pen in pixels. It can be changed in the box at the right of the tile.
This determines whether lines, arrows, arrowheads, or dots are used when I put down a pen trail. The possibilities can be changed in the box at the right of the tile.
4.7 Category Tests
Getting into the habit of testing your ideas is a very powerful concept. While these tiles are not quite that powerful, they can test what is going on in your Etoys world. You can use the results of these tests to determine the attributes and behaviors of the objects in your world. Getting into the habit of testing your ideas or at least thinking about how you could test your ideas (and what other people tell you is true) is a wonderful "habit of the mind".
Once this tile is placed in a script, it has the three slots shown below into which you can place one or more tiles:
- Test: Any Boolean-valued variable or expression.
- Yes: Tiles placed in the "Yes" holder will be executed when the "Test" is true.
- No: Tiles placed in the "No" holder will be executed when the "Test" is false.
If the object's color (specified by the color on the left side of the tile) is over the given color (specified by the color on the left side of the tile), then the commands under yes in the test will be executed. If not, the commands under no will be executed. You can change the colors by clicking on the appropriate color. A color picker appears and the color changes to the color you click.
If any part of the object is over the given color, then the commands under yes in the test will be executed. If not, the commands under no will be executed. You can change the color by clicking on it. A color picker appears and the color changes to the color you click.
If the object is under the current mouse position, then the commands under yes in the test will be executed. If not, the commands under no will be executed.
If the object sticks out over its container's edge, then the commands under yes in the test will be executed. If not, the commands under no will be executed.
If the object overlaps a given object, then the commands under yes in the test will be executed. If not, the commands under no will be executed. The given object can be changed by dropping a tile for the desired object onto dot.
If the object overlaps a given object or one of its siblings or a similar object, then the commands under yes in the test will be executed. If not, the commands under no will be executed. The given object can be changed by dropping a tile for the desired object onto dot.
4.8 Category Motion
forward by
See the basic category for a description of this tile.
turn by
See the basic category for a description of this tile.
x
See the basic category for a description of this tile.
y
See the basic category for a description of this tile.
heading
See the basic category for a description of this tile.
If this tile is included in a script, the object will bounce off the edges of its container (ex: world or playfield) and make the sound selected at the right of the tile, when it hits its containers edge.
obtrudes
See the tests category for a description of this tile.
If this tile is included in a script, the object will turn toward the given object. The given object can be changed by dropping a tile for the desired object onto dot.
If the object has gone outside the bounds of its container, this tile will zap it over to the opposite edge of the container, providing a 'wrapping' impression.
Note: The fence of the container object, such as a playfield, must be disabled to make it work. If fence is enabled, the object will just bounce on the fence. To enable the fence, use the menu icon of the container and then "playfield options". See chapter.
4.9 Category Fill & Border
color
See the color category for a description of this tile.
If true is selected at the right of the tile, a gradient fill will be used.
This is the second color used when gradient fill is in effect.
If true is selected at the right of the tile, the gradient fill will be radial.
This determines the width of the border around the object in pixels. It can be changed in the box at the right of the tile.
This determines the color of the object. You can change the color by clicking on the color box at the right side of the tile. A color picker appears and the color changes to the color you click.
This determines the border style. You can select from simple, raised, inset, complex framed, complex raised, complex inset, complex alt framed, complex alt raised, and complex alt inset at the right of the tile.
If true/false, the corners are rounded or not. Select true/false at the right of the tile.
If true/false, a drop shadow is shown or not. Select true/false at the right of the tile.
This is the color of the drop shadow. You can change the color by clicking on the color box at the right side of the tile. A color picker appears and the color changes to the color you click.
4.10 Category Scripting
This starts the given script ticking. You can select from available scripts at the right of the tile.
This makes the given script be "paused". You can select from available scripts at the right of the tile. Note: If the script specified is the script containing this tile, the script will not pause until it finishes its current processing of the all the tiles in the script. For example, if you have a "Object forward 5" tile after a "Object pause script script1" tile in a script named "script1", the object will move forward 5.
This makes the given script stop or revert to "normal". You can select from available scripts at the right of the tile.
Note: If the script specified is the script containing this tile, the script will not stop until it finishes its current processing of the all the tiles in the script. For example, if you have a "Object forward 5" tile after a "Object stop script script1" tile in a script named "script1", the object will move forward 5.
This starts the given script and all of its siblings's scripts ticking in the object. You can select from available scripts at the right of the tile.
This makes the given script and all of its sibling's scripts be "paused" in the object. You can select from available scripts at the right of the tile.
Note: If the script specified is the script containing this tile, the script will not pause until it finishes its current processing of the all the tiles in the script. For example, if you have a "Object forward 5" tile after a "Object pause all script1" tile in a script named "script1", the object will move forward 5.
This make the given script and all of its sibling's scripts stop or revert to "normal" in the object. You can select from available scripts at the right of the tile.
Note: If the script specified is the script containing this tile, the script will not pause until it finishes its current processing of the all the tiles in the script. For example, if you have a "Object forward 5" tile after a "Object stop all script1" tile in a script named "script1", the object will move forward 5.
This sends a message to all siblings to run the given script once. The object that executes this will not have its script run, only its siblings will run the script once. You can select from available scripts at the right of the tile.
This runs the given script once, on the next tick. You can select from available scripts at the right of the tile.
This runs the given script in the object and in all of its sibling once. You can select from available scripts at the right of the tile.
4.11 Category Sound
make sound
See the basic category for a description of this tile.
This will play a sound of the frequency entered in the box at the right of the tile.
This command will stop the sound.
4.12 Category Observation
This tile goes into a test box to test the heading the object would need to have to face directly toward another object. The given object can be changed by dropping a tile for the desired object onto dot.
This tile returns the brightness under the center of the object. The brightness appears in a box at the right of the tile.
This tile returns the color under the center of the object. The color appears in a box at the right of the tile.
This tile goes into a test box to test a function of the distance to another object. The function can be selected at the left of the tile once it is in the test box. The given object can be changed by dropping a tile for the desired object onto dot.
This tile returns the luminance under the center of the object. The luminance appears in a box at the right of the tile.
This tile returns the saturation under the center of the object. The saturation appears in a box at the right of the tile.
4.13 Category Layout
A submorph is typically an object dropped onto another object with the property accept drops set to true. Submorphs can also be added to Morphs under program control. Submorphs can be placed so that they overlap the border of the main morph. This property is supposed to determine whether the portion of the submorph extending outside that border will be displayed (false, the default) or clipped (true).
It is important to understand that the clipping boundary of a Morph is its bounding rectangle, no matter what the visible shape of the Morph. Thus clipped submorphs can stick out well beyond the Morph. It is possible to rearrange the vertices of a Polygon so that a submorph is completely outside its visible boundary while still being completely inside the clipping rectangle.
4.14 Category Drag & Drop
If true/false, this object will be blind/or not to all input. Select true/false at the right of the tile. This is useful if you have text or other objects you don't want the user to accidentally move or change.
If true/false, drop is enabled/or not. Select true/false at the right of the tile. When true you can embed other objects in this this object. Once embedded when you move the object all objects embedded inside it will move with it.
Etoys Challenge:
- Use drop enabled to draw a person and ensure "drop enabled" is true.
- Then draw some clothes (some combination of shirts and shorts).
- Place the person and each piece of clothing in a "Maker Button" (this will allow you to make copies instantly just by clicking on the maker button and dragging onto the screen).
- Then see how many possible combinations of different outfits you can create.
- How can you prove you have all the possible combinations?
If true/false, a simple mouse-drag on this object will allow it to be picked up/or not. Select true/false at the right of the tile.
If true/false, the object is resistant to easy removal via the pink X halo handle/or not. Select true/false at the right of the tile.
4.15 Category Miscellaneous
Drag here to tear off a Repeat Times Do tile which you can drop into your script. This tile is also available from the Gold Box menu in the Scripting Editor. This Tile will execute all the tiles inside it the number of times specified as shown below.
This tile makes a copy of the object. The copy will not be visible, you need to include it in a playfield or holder first. An example would be "playfield include: object's copy". A difference is that for siblings, "copy" creates another sibling.
The menu at the left of the tile allows you to get a piece of data from the object which you can use in scripts. Also you can immediately make a copy of the object.
This tile allows you to do the menu item selected at the right of the tile. You can either click the yellow exclamation mark at the left of the tile or use the tile in a script. Clicking the up or down pointing triangle cycles through a set of commands. Clicking the command portion of the tile brings up this menu:
What version produces this menu?
Or this menu (Etoys v. 5, eToyFriendly on)
Or this (Etoys v. 5, eToyFriendly off)
Clicking more brings up this additional menu.
Each of these commands is on the Halo menu or one of its submenus, which are documented in the User Interface chapter of this manual. For each item listed, the menu where it appears is given below.
The following Halo menu commands do not appear here.
- show shadow on the drop shadow submenu.
- Commands on some layout submenus
- Commands on the debug submenu
A number of these commands set Booleans, but do not provide a way to reset them.
send to back Halo menu
bring to front Halo menu
embed… Halo menu. To undo, embed object in Desktop.
change color… fill style submenu
solid fill fill style submenu
gradient fill fill style submenu
bitmap fill fill style submenu
default fill fill style submenu
border color…border style… submenu
border width… border style… submenu
simple border style… submenu
shadow color…drop shadow submenu
shadow offset…drop shadow submenu
delete halo actions… submenu
collapse halo actions… submenu. Can only undo manually.
grab halo actions… submenu
resize halo actions… submenu
duplicate halo actions… submenu
make a sibling halo actions… submenu
property sheet halo actions… submenu
set color halo actions… submenu
viewer halo actions… submenu
tile browser halo actions… submenu
tile representing this object halo actions… submenu
inspect halo actions… submenu
change layout inset… layout submenu
change cell inset…layout submenu, table layout subsubmenu
change min cell size… layout submenu, table layout subsubmenu
change max cell size… layout submenu, table layout subsubmenu
resist being deleted Halo menu
resist being picked up Halo menu. Can set to True, but not to False.
be locked Halo menu. Can set to True, but not to False.
provide clipping Halo menu. Can set to True, but not to False.
direction arrow Halo menu. Can set to True, but not to False.
accept drops Halo menu. Can set to True, but not to False.
copy to paste buffer copy & print… submenu
copy text copy & print… submenu
copy Postscript copy & print… submenu
print Postscript to file… copy & print… submenu
make a sibling instance siblings… submenu
make multiple siblings… siblings… submenu
indicate all siblings siblings… submenu
BMP file export… submenu
GIF file export… submenu
JPEG file export… submenu
PNG file export… submenu
put in a window extras… submenu
adhere to edge… extras… submenu
add mouse up action extras… submenu
remove mouse up action extras… submenu
hand me tiles to fire this button extras… submenu
arrowheads on pen trails… extras… submenu
draw new path extras… submenu
follow existing path extras… submenu
delete existing path extras… submenu
graph-location plotter extras… submenu
graph-location follower extras… submenu
balloon help for this object extras… submenu
The number at the right is the object's index in its container (holder or world). The index can be changed at the right of the tile.
This removes this object from the screen. You can either click the yellow exclamation mark at the left of the tile or use the tile in a script.
This tile triggers any and all of this object's button actions. You can either click the yellow exclamation mark at the left of the tile or use the tile in a script.
This tile makes the object invisible. You can either click the yellow exclamation mark at the left of the tile or use the tile in a script.
This tile shows the object's container at the right of the tile. The menu at the left of the tile allows you to get a simple or detailed watcher or piece of data from the object's holder.
This tile makes the object visible. You can either click the yellow exclamation mark at the left of the tile or use the tile in a script.
This tile adds the objects image to the pen trails. You can either click the yellow exclamation mark at the left of the tile or use the tile in a script.
This tile adds the object's image to the pen trails and then goes away. You can either click the yellow exclamation mark at the left of the tile or use the tile in a script.
4.16 Category Graphics
This category appears in the Viewer for a Sketch but not for other Morphs.
This tile shows the picture currently being worn at the right of the tile.
This tile shows the picture originally painted for this object at the right of the tile, but can subsequently be changed via menu or script.
This tile allows the object to wear the costume of a second object, by default a dot object. The second object can be changed by dropping a tile for the desired object onto dot. You can either click the yellow exclamation mark at the left of the tile or use the tile in a script.
This command restores the object's costume be the one I remember in my baseGraphic. You can either click the yellow exclamation mark at the left of the tile or use the tile in a script.
This tile allows the user to select how the graphic should change when the heading is modified. It can be used in a test box to test for the rotation style.
4.17 Category Graphing
This tile is used to give or set the location of an object related to it's coordinate system. The world is the basic system with x and y starting with 0,0 in the lower left corner of the screen.
This tile gives access only to the x-axis of the coordinate system.
This tile gives access only to the y-axis of the coordinate system.
4.18 Category Input
This tile can be used in a test box to test for last unhandled keystroke.
4.19 Category Book Navigation (Book, Storyboard)
Go to the first page in the book.
Set the specified page as the current page, and display it. Although the default object specified is a dot, this tile has no effect unless the target is a page in a book.
Go to the last page in the book.
Go to the page after this one.
Watcher for the number of pages in the book.
Toggle whether the control bar is at the top or bottom of the page.
Toggle between limited and full sets of controls.
Show or hide controls.
The number of the currently-displayed page.
Go to the page before this one, if any.
Reverts to a saved version of a page, if any.
How does one save pages or books? There is a savePage method in BookMorph, but I don't see how to activate it in Etoys.
4.20 Category bubble
When a bubble is attached to an object, moving the object moves the bubble with it.
When the bubble is attached to an object, this tile references the object. It can be used in scripts as a substitute for a tile derived from the object.
Break the attachment between the bubble and the object. The bubble remains where it is, so there is no visible difference until the object is moved.
4.21 Category button
The background color on the button, set with a color picker.
The width of the colored border. Increasing this width expands the border inward, so that it can overlap the button's label. Increase the button's height to remove the overlap.
The color of the button's border, set with a color picker.
Boolean choice of rounded or square corners.
As with any three-phase button, a choice of button down, button up, or while pressed.
Run the action associated with the button. This is programmed via the Halo menu, in Squeak.
The height of the button, including its border.
The text that appears on the button. Use spaces on both ends of the label to adjust the button's width, for which there is no tile.
4.22 Category calendar
The date selected on the calendar as a text string in the current format.
The numeric day of the month.
The numeric month.
The number of the year, which can be 0 or negative. This does not match any historical calendar.
The name of the day of the week.
The name of the month.
A choice of mm/dd/yyyy (US), dd/mm/yyyy (UK and elsewhere), or yyyy/mm/dd (Japan; simplest to sort correctly).
Perhaps someone knowledgeable about date locales could add more information on this usage.
Set all variables to correspond to today's date.
The Julian day gives a uniform sequential value for days independent of any historical calendar. It is not related to the historical Julian calendar. Julian day 1 is nominally November 25, -4713, a date far outside the range of any European calendar and of most other historical calendars. This value can be 0 or negative.
4.23 Category camera
When camera is on, it shows the scene continuously. When camera is off, it shows the last image from when it was last on.
A source of tiles for various properties of the image taken by the camera. Select tiles to get… from the menu at the left. Choose a data type, then a variable of that type to get a tile.
I tried this with a graphic from the camera. I dropped the camera's last frame graphic tile into a sketch variable tile, and tried to run it to set the sketch's costume to the camera image. An error resulted. Requesting tiles of some types can crash Etoys with a cascade of error messages. Does anybody know how to use this? In particular, is there a way to ask the camera to take a picture and make it available in the workspace?
Choice of low (160 x 120), medium (320 x 240), or high (640 x 480).
When true, set the view size in proportion to the camera's resolution and resist manual resizing.
4.24 Category collections (graph paper, holder, playfield, x-y plane)
Number of items in this collection.
The index of the currently-selected item, according to some non-obvious internal calculation, or as set in this tile.
The first item in the internal list of collection contents. Placing an object with the mouse puts it at the head of the list, so a thumbnail of the object placed appears in this tile.
The image of the currently-selected item.
How is this used? What distinction can one make in Etoys between a player and its graphic? This looks identical to page's graphic at cursor. Presumably they have different effects when dropped into some other tiles, but which and what?
Add an object to the collection, and move it to the nearest location within the container.
Add an object to the collection, but do not show it.
The object is placed at the nearest point within the container, even though it is supposed to appear at the cursor location. Verified in Squeak definition which calls goHome. To be reported as bug. goHome | box | (owner isInMemory and: [owner notNil]) ifTrue: [self visible ifTrue: [box := owner. self left < box left ifTrue: [self position: box left @ self position y]. self right > box right ifTrue: [self position: (box right - self width) @ self position y]. self top < box top ifTrue: [self position: self position x @ box top]. self bottom > box bottom ifTrue: [self position: self position x @ (box bottom - self height)]]]
I have no idea what this is. There are no visible use cases; the help is most unhelpful. I can see the Squeak selector for setting this value, but I don't see where it can be used. There is no Squeak code that calls this method, only two instances.
How is this used? What distinction can one make in Etoys between a player and its graphic? This looks identical to page's graphic at cursor. Presumably they have different effects when dropped into some other tiles, but which and what?
Delete all of the objects in this container. They do not go into the Trash.
Randomly change the order of objects in the container, and renumber them
The page title, if any.
A script for controlling all objects in a container.
4.25 Category color & border
This is actually neither border nor color. The only variable in this group is for the width of the connector, including the line and any arrowheads. It can be set to 0, making the connector invisible when connected to objects at both ends.
4.26 Connections to Me
This category appears only for objects that have connectors attached to them.
The number of connector destinations attached to this object.
The number of connector sources attached to this object.
Apply the given script to objects at sources of connectors coming in to this object.
What kinds of script work? I tried this and got nothing.
Apply the given script to objects at destinations of connectors coming in to this object.
What kinds of script work? I tried this and got nothing.
Apply the given script to objects at sources of chains of connectors and objects coming in to this object.
What kinds of script work? I tried this and got nothing.
Apply the given script to objects at destinations of connectors and objects coming from this object.
What kinds of script work? I tried this and got nothing.
4.27 Category connector
Put a label on the middle of the connector with the given text.
The object at the destination end of the connector, or dot if there is none.
The name of the arrowhead applied to the destination end of the connector. Clicking the current name brings up this menu.
We should give examples of these arrowheads somewhere.
If true, the connector consists of horizontal and vertical segments. If false, the connector can contain segments at any angle.
Delete any label applied to this connector.
If true and the connector's orthogonal property is also true, segments are joined with smooth curves. If false, segments meet at sharp corners. If orthogonal is false,
The object at the source end of the connector, or a dot if there is none.
The name of an arrowhead to be applied to the connector, from the same menu as for destination arrow names.
If the connector has been modified into multiple straight line segments or curves,
4.28 Category embeddings (Pin)
The embeddings category appears in the viewers for pins, and for objects containing embedded pins, like the ellipse below, but not for objects containing other embedded objects. This category mixes functions for the embedded pins, for the objects containing them, and for any other embedded objects.
Objects with embedded pins also have variables referring to them.
The ellipse above has two pins embedded in it, as reflected in Ellipse's pin count.
Objects containing embedded pins by default allow connections to them, while pins having no pins inside them naturally do not. Embedded pins want connections when embedded, while objects containing pins but not embedded in other objects do not.
Make embedded pins available for connections or forbid connections to them.
If the object is embedded in another object, points to that other object. If not, points to this object.
The number of pins embedded in this object.
Fire a script on each embedded object.
What kinds of script? I tried this and got nothing. How do I define a script that multiple objects can follow?
Fire a script on each embedded pin.
What kinds of script? I tried this and got nothing. How do I define a script that multiple objects can follow?
If this object is embedded in some other object, allow or forbid using it as a connection point.
4.29 Category joystick
There are functions provided on the Joystick's Halo menu but not in scripting tiles, such as changing x and y range, or setting the Joystick to auto-center.
Range: 0-28.28, independent of joystick x and y axis ranges set in the Halo menu.
With the positive x-axis direction as 0, the angle of the line from the center of the joystick body to the handle. Mathematically,
What button? Is this activated by track real joystick on the Halo menu? Although the Joystick object in Etoys does not have buttons, the JoystickMorph in Squeak has methods for firing buttons, so it is possible to write a script to set this.
What button?
Joystick horizontal position (x-axis) on a scale from -5 to 5 by default. The range can be set using the Halo menu.
Joystick vertical position (y-axis) on a scale from -5 to 5 by default. The range can be set using the Halo menu.
4.30 Category kedama
There are two kedama categories, one for KedamaWorld, and one for KedamaPatch.
The color of the KedamaWorld object. Set with a color picker.
Set the mode for objects reaching any of the four edges of a KedamaWorld. A menu offers the selections
- wrap Continue from the opposite edge.
- stick Stop at the edge
- bouncing Change direction like a bouncing ball
Change the size of the KedamaWorld in proportion to this value.
Attempting to use this tile results in an error.
What is the display list? How do I access it?
What is the display list? How do I access it?
What is the display list? How do I access it?
What is the display list? How do I access it?
What is the display list? How do I access it?
4.31 Category kedama turtle
Part of the kedama Particles system. Kedama Turtle has only two categories in its viewer, namely kedama turtle and kedama turtle color.
The same as the forward by tile in the basic category of other objects.
Should be the same as the turn by tile in the basic category of other objects. However, nothing happens.
The same as the x tile in the geometry category of other objects.
The same as the y tile in the geometry category of other objects.
The same as the heading tile in the geometry category of other objects.
The same as the color tile in the color category of other objects.
What is this? What can I do with it? The user cannot set this variable.
Delete this turtle.
What is this? What can I do with it?
Has no effect.
What is this? What can I do with it?
What is this? What can I do with it?
One should be able to use the menu at the left to get tiles for internal variables of Kedama Turtle, but attempting to access any of them results in an error.
Angle to what?
Distance to what?
The turtle bounces if it reaches the boundary of the World. But I see no use for this tile.
No effect.
4.32 Category kedama turtle color
Cannot edit this color component, and cannot see any effect.
No visible effect.
No visible effect.
Cannot edit this color component, and cannot see any effect.
Cannot edit this color component, and cannot see any effect.
4.33 Category keyboard (PianoKeyboard)
When allowing chord is false, clicking a key on the PianoKeyboard creates a single note for as long as the mouse button is pressed. When it is set to true, clicking a key turns on a note and leaves it on. This allows the user to construct chords. To terminate a chord, set this value to false again.
The frequency of the last note played, whether alone or as a component of a chord.
4.34 Category magnifier (several magnifiers, but not RoundGlass)
The magnification of the image around the cursor in the magnifier display.
Whether to place a dot at the center of the magnifier
Whether to show a magnified image of what is around the cursor.
4.35 Category movie controls
Audio playback volume on a scale of 0.00-1.00.
Start playing the selected video.
Play from the current position in the video up to a specified position.
What is the scale used?
Stop playing, but remain at the same position in the file.
Go back to the beginning.
Whether or not Movie Player is playing a video.
Whether to start over at the end of the video, in an endless loop.
A number representing the current position in the video.
What is the scale used?
Length of current video in frames.
Length of current video in seconds.
A graphic image of the current frame.
The name of a file containing subtitles for the current video.
How is this set?
The name of the file containing the current video.
4.36 Category number line
The value at the beginning (left or bottom end) of a number line or the left or top of a slider.
The value at the end (right or top end) of the number line or the right or bottom of a slider.
The number of screen pixels in each unit.
The number of numeric units per tick mark.
The number of marks between numeric labels or legends.
Show an arrowhead at the beginning of the number line as well as the end.
Show or hide the zero. This can be used to display crossed horizontal and vertical number lines without the zeroes overlapping them.
4.37 Category paintbox (flaps)
Make a drawing in the specified object, which should be a playfield, according to the help text.
What playfield? What is this for? I tried it in the parts bin of a flap. Nothing. The tools palette appeared, but there was no place I could draw. I tried it in a Holder, and was able to draw, but when I clicked Keep, there was an error.
4.38 Pen Trails (graph paper, holder, playfield, x-y plane)
Should pen trails be laid down in all possible detail, or only showing movement from one tick to the next.
Can somebody give us an illustration of the difference?
Erase all pen trails currently visible in the playfield.
Are there currently any pen trails in this playfield?
Stop recording pen trails when objects move.
Start recording pen trails when objects move.
A representation of a complete pen trail. There is a menu item for putting it in hand.
A choice of lines, arrows, arrowheads, or dots.
4.39 Category phonepad
Dials a telephone number.
4.40 Category playfield (page, graph paper, holder, playfield, x-y plane)
What is this, and what can be done with it?
Horizon
Vertical position of the mouse, with the lower left corner of the playfield as 0@0.
Bring all parts that have moved outside the playfield back in.
Make any hidden objects visible. The hide tile is in the miscellaneous category.
4.41 Category polygon (arrows, curve, polygon, triangle)
The currently selected vertex for a number of purposes, as in other tiles below. It is highlighted in blue when handles are visible. There is no connection with the mouse cursor. For example, clicking a vertex handle does not set the cursor to that vertex.
The number of vertices and hence the number of sides of the polygon. Editing this value in the viewer or changing it in a script causes vertices to appear in front of the cursor, or to disappear starting at the cursor. The cursor is set to the next vertex after the ones deleted.
The x coordinate of the cursor.
The y coordinate of the cursor.
A new vertex is added at the same location as vertex number 1, with an edge of length 0.
A new vertex is added at the same location as the currently selected vertex, lying in front of it, with an edge of length 0.
A new vertex is added at the same location as the last vertex in sequence, with an edge of length 0.
In fact, two vertices remain, joined by a side of length 0. It is possible to remove one more vertex, leaving a polygon with 1 vertex and 0 sides.
The current vertex is removed, and the remaining vertices renumbered. The polygon is redrawn.
The vertices remain in the same places, but their order is randomized, and the polygon is redrawn using the new order.
If false, the polygon is a straight-sided polygon. If true, the polygon is actually a Bezier curve. In either case, dragging the middle of a side creates a new vertex and splits that side into two.
If false, the polygon is closed, with the last and first points joined by a side. If true, they are not joined.
If true, vertices are marked with yellow circles, except that the location of the cursor is marked with a blue circle. The midpoints of sides are marked with green triangles.
la (graph)
Play waveform as sound.
Remove all values from graph.
The x coordinate on the graph
What is this, and what can one do with it?
Load and graph data for the trigonometric sine function from 0 to , scaled with x from 0 to 4000, and y from -100 to 100.
Load and graph data for any sound on the menu.
Reverse the order of the values graphed, and the image of the graph.
The y value on the graph for the current x value. Editing this value graphs the value, and increments the cursor location by 0.01.
4.43 Category Scratch Command
What does this do?
What does this do?
What does this do?
What does this do?
What does these do?
What does this do?
What does this do?
4.44 Category Scratch Configuration
What does this do?
What does this do?
What does this do?
4.45 Category sector
Display or hide the single handle for setting the sector's angle.
The central angle of the sector, in degrees.
The radius of the circle from which the sector is cut.
4.46 Category slider
Width of the rectangular body of the slider.
Color of the background area in the slider.
The value of the slider at the lowest position.
The value of the slider at the highest position.
Reverse the slider so that it goes from max to min value.
Height of the rectangular body of the slider.
Color of the knob within the slider.
Value corresponding to the current position of the knob.
Whether to return integer values (true) or decimal fractions (false).
4.47 Category sound recorder
Play back the most recent recording. There is no tile to save a recording, even though there is a button to do so. There is no way, either with tiles or in the UI, to load a saved recording.
If no recording has been made in this session, an error dialog appears saying, "please record a sound first".
Start recording. This assumes that the software has connected to a microphone on the computer, which does not seem to take place.
Halts either recording or playback.
4.48 Category star
The number of points plus the vertices between the points. So the default five-pointed star has ten vertices.
The ratio of length and width of points. The default value is 42. Setting it to 81 makes a fve-pointed star into a pentagon. Setting it to 0 makes it five lines emanating from a point.
4.49 Category text (various text objects, but not Scrolling Text)
The text data held in this object without its first character.
Add the specified text to the end of the value of the object.
The character at the location specified by the cursor value.
The entire text value of this object.
The number of characters in the text value.
What happens if we put in Unicode text? Does this count Unicode characters correctly, or is it still a byte count? Well, it turns out that I cannot paste Unicode characters outside Latin-1 into a Text object and get a useful result.
An index into Text.
If the text is not empty, this is the initial character from its value. If it is empty, the value is '.'. Treatment of this value is inconsistent.
Insert the given characters at the cursor location. The text in this tile can be edited manually, or replaced by any other text value
Insert text from a specified object at the cursor location.
If the text is not empty, this is the final character from its value. If it is empty, the value is apparently '.'.
If a segment of Text can be interpreted as a number, a value for the first such segment. If a representation of a decimal number is embedded in a text, only the integer part is taken as the value.
4.50 Category time (Digital Clock)
A watcher for the hours portion of the current time.
A watcher for the minutes portion of the current time.
A watcher for the seconds portion of the current time.
4.51 Category trash
Delete permanently any objects deleted from the World and placed in the Trash Can.
The number of pages in the Trash Can holding deleted objects, with a help text on page 1, and a deleted object on each page after that.
Something missing here. Perhaps it can be restored from a previous version of this chapter.
Play the last video, if any.
There is no way with these tiles to record or load a video. What can it play?
Stop playing.
Whether the movie is being played
Determines whether the video window can be resized.
Set Video brightness on a scale of 0-1.
I can't play a video, so I can't see what this does.
Set extent (width and height), test pattern, and whether to display time.
Set Video contrast on a scale of 0-1.
I can't play a video, so I can't see what this does.
The last recorded frame.
I think. I see no way to view it, and in any case there is no way to play a video.
This is misnamed. It is color depth, not resolution.
The options are
- original, from the video itself
- 256 colors (8 bits per pixel)
Probably actually 8 bits per color (RGB) and 8 bits of Alpha (transparency) for a total of 32 bits per pixel.
- 256 grays (8 bits per pixel)
- 4 grays (2 bits per pixel)
- black and white (1 bit per pixel)