[Pkg] The Trunk: EToys-dtl.62.mcz

David T. Lewis uploaded a new version of EToys to project The Trunk: http://source.squeak.org/trunk/EToys-dtl.62.mcz

==================== Summary ====================

Name: EToys-dtl.62 Author: dtl Time: 28 February 2010, 8:01:32.124 pm UUID: b61a3910-c1a5-4990-8fb1-d51c6715a618 Ancestors: EToys-ar.61

The correct spelling of Etoys is "Etoys". Therefore rename the EToys package to "Etoys" and recategorize all package overrides to "*Etoys".

=============== Diff against EToys-ar.61 ===============

Item was changed: + ----- Method: ColorType>>updatingTileForTarget:partName:getter:setter: (in category '*Etoys-tiles') ----- - ----- Method: ColorType>>updatingTileForTarget:partName:getter:setter: (in category '*eToys-tiles') ----- updatingTileForTarget: aTarget partName: partName getter: getter setter: setter "Answer, for classic tiles, an updating readout tile for a part with the receiver's type, with the given getter and setter"

| readout | readout _ UpdatingRectangleMorph new. readout getSelector: getter; target: aTarget; borderWidth: 1; extent: 22@22. ((aTarget isKindOf: KedamaExamplerPlayer) and: [getter = #getColor]) ifTrue: [ readout getSelector: #getColorOpaque. ]. (setter isNil or: [#(unused none #nil) includes: setter]) ifFalse: [readout putSelector: setter]. ^ readout !

Item was changed: ObjectRepresentativeMorph subclass: #ClassRepresentativeMorph instanceVariableNames: 'classRepresented' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

Item was changed: + ----- Method: GeeMailMorph>>step (in category '*Etoys-customevents-stepping and presenter') ----- - ----- Method: GeeMailMorph>>step (in category '*eToys-customevents-stepping and presenter') ----- step "For each submorph of thePasteUp that has just been scrolled into view, fire the script named #scrolledIntoView, if any. For each submorph of thePasteUp that has just been scrolled out of view, fire the script named #scrolledOutOfView, if any." | lastVisible nowVisible newlyVisible newlyInvisible | super step. lastVisible := self visibleMorphs. nowVisible := (thePasteUp submorphs copyWithoutAll: (self allTextPlusMorphs)) select: [ :m | self bounds intersects: (m boundsIn: self world) ]. newlyInvisible := lastVisible difference: nowVisible. newlyInvisible do: [ :ea | ea triggerEvent: #scrolledOutOfView ]. newlyVisible := nowVisible difference: lastVisible. newlyVisible do: [ :ea | ea triggerEvent: #scrolledIntoView ]. self visibleMorphs: nowVisible. !

Item was changed: + ----- Method: StandardScriptingSystem>>readFormsFromFileNamed: (in category '*Etoys-form dictionary') ----- - ----- Method: StandardScriptingSystem>>readFormsFromFileNamed: (in category '*eToys-form dictionary') ----- readFormsFromFileNamed: aFileName "Read the entire FormDictionary in from a designated file on disk"

| aReferenceStream | aReferenceStream := ReferenceStream fileNamed: aFileName. FormDictionary := aReferenceStream next. aReferenceStream close

"ScriptingSystem readFormsFromFileNamed: 'EToyForms22Apr'"!

Item was changed: Object subclass: #ButtonProperties instanceVariableNames: 'target actionSelector arguments actWhen wantsRolloverIndicator mouseDownTime nextTimeToFire visibleMorph delayBetweenFirings mouseOverHaloWidth mouseOverHaloColor mouseDownHaloWidth mouseDownHaloColor stateCostumes currentLook' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Buttons'! - category: 'EToys-Buttons'!

!ButtonProperties commentStamp: '<historical>' prior: 0! ButtonProperties test1

ButtonProperties test2

ButtonProperties test3

!

Item was changed: + ----- Method: StandardScriptingSystem>>systemSlotNamesOfType: (in category '*Etoys-universal slots & scripts') ----- - ----- Method: StandardScriptingSystem>>systemSlotNamesOfType: (in category '*eToys-universal slots & scripts') ----- systemSlotNamesOfType: aType "Answer the type of the slot name, or nil if not found." | aList | self flag: #deferred. "Hard-coded etoyVocabulary needed here to make this work." aList := OrderedCollection new. Vocabulary eToyVocabulary methodInterfacesDo: [:anInterface | anInterface resultType = aType ifTrue: [aList add: anInterface selector]]. ^ aList!

Item was changed: AlignmentMorph subclass: #Viewer instanceVariableNames: 'scriptedPlayer' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

!Viewer commentStamp: 'sw 9/6/2002 13:14' prior: 0! 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.!

Item was changed: + ----- Method: CodeHolder>>showingTiles (in category '*Etoys-tiles') ----- - ----- Method: CodeHolder>>showingTiles (in category '*eToys-tiles') ----- showingTiles "Answer whether the receiver is currently showing tiles"

^ contentsSymbol == #tiles !

Item was changed: + ----- Method: StandardScriptingSystem>>colorForType: (in category '*Etoys-tile colors') ----- - ----- Method: StandardScriptingSystem>>colorForType: (in category '*eToys-tile colors') ----- colorForType: typeSymbol "Answer the color to use to represent the given type symbol"

true ifTrue: [^ self standardTileBorderColor].

typeSymbol capitalized = #Command ifTrue: [^ Color fromRgbTriplet: #(0.065 0.258 1.0)]. "Command is historical and idiosyncratic and should be regularized"

^ (Vocabulary vocabularyForType: typeSymbol) typeColor!

Item was changed: + ----- Method: BooleanType>>typeColor (in category '*Etoys-color') ----- - ----- Method: BooleanType>>typeColor (in category '*eToys-color') ----- typeColor "Answer the color for tiles to be associated with objects of this type"

^ self subduedColorFromTriplet: #(0.94 1.0 0.06)!

Item was changed: + ----- Method: TextMorph>>getNumericValue (in category '*Etoys-support') ----- - ----- Method: TextMorph>>getNumericValue (in category '*eToys-e-toy support') ----- getNumericValue "Obtain a numeric value from the receiver; if no digits, return zero"

| aString | ^ [(aString := text string) asNumber] ifError: [:a :b | ^ aString asInteger ifNil: [0]]!

Item was changed: + ----- Method: TempVariableNode>>explanation (in category '*Etoys-tiles') ----- - ----- Method: TempVariableNode>>explanation (in category '*eToys-tiles') ----- explanation

^(self isArg ifTrue: ['Method argument'] ifFalse: ['Temporary variable']),' <',self name,'>' !

Item was changed: + ----- Method: GeeMailMorph>>releaseCachedState (in category '*Etoys-customevents') ----- - ----- Method: GeeMailMorph>>releaseCachedState (in category '*eToys-customevents') ----- releaseCachedState super releaseCachedState. self removeProperty: #visibleMorphs!

Item was changed: Player subclass: #KedamaTurtlePlayer instanceVariableNames: 'world who x y headingRadians color visible' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

!KedamaTurtlePlayer commentStamp: '<historical>' prior: 0! A defunct class that represents the turtles in the KedamaWorld. In this version, each turtle was represented as a full-fledged player. Kept here to remember the alternative implementation.!

Item was changed: SymbolListTile subclass: #ScriptNameTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

!ScriptNameTile commentStamp: '<historical>' prior: 0! 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.!

Item was changed: + ----- Method: SymbolListType>>newReadoutTile (in category '*Etoys-tiles') ----- - ----- Method: SymbolListType>>newReadoutTile (in category '*eToys-tiles') ----- newReadoutTile "Answer a tile that can serve as a readout for data of this type"

^ SymbolListTile new choices: self choices dataType: self vocabularyName !

Item was changed: + ----- Method: TextFieldMorph>>couldHoldSeparateDataForEachInstance (in category '*Etoys-card in a stack') ----- - ----- Method: TextFieldMorph>>couldHoldSeparateDataForEachInstance (in category '*eToys-card in a stack') ----- couldHoldSeparateDataForEachInstance "Answer whether this type of morph is inherently capable of holding separate data for each instance ('card data')"

^ true!

Item was changed: + ----- Method: NumberType>>typeColor (in category '*Etoys-color') ----- - ----- Method: NumberType>>typeColor (in category '*eToys-color') ----- typeColor "Answer the color for tiles to be associated with objects of this type"

^ self subduedColorFromTriplet: #(0.8 0.4 0.2)!

Item was changed: + ----- Method: TextMorph>>configureForKids (in category '*Etoys-support') ----- - ----- Method: TextMorph>>configureForKids (in category '*eToys-e-toy support') ----- configureForKids super configureForKids. self lock!

Item was changed: + ----- Method: Point>>basicType (in category '*Etoys-tiles') ----- - ----- Method: Point>>basicType (in category '*eToys-tiles') ----- basicType "Answer a symbol representing the inherent type of the receiver"

^ #Point!

Item was changed: + ----- Method: DataType>>defaultArgumentTile (in category '*Etoys-tiles') ----- - ----- Method: DataType>>defaultArgumentTile (in category '*eToys-tiles') ----- defaultArgumentTile "Answer a tile to represent the type"

^ 'arg' newTileMorphRepresentative typeColor: self typeColor!

Item was changed: + ----- Method: AlignmentMorph>>addUpDownArrowsFor: (in category '*Etoys-initialization') ----- - ----- Method: AlignmentMorph>>addUpDownArrowsFor: (in category '*eToys-initialization') ----- addUpDownArrowsFor: aMorph "Add a column of up and down arrows that serve to send upArrowHit and downArrowHit to aMorph when they're pressed/held down"

| holder downArrow upArrow | holder := Morph new extent: 16 @ 16; beTransparent. downArrow := ImageMorph new image: (ScriptingSystem formAtKey: 'DownArrow'). upArrow := ImageMorph new image: (ScriptingSystem formAtKey: 'UpArrow'). upArrow position: holder bounds topLeft + (2@2). downArrow align: downArrow bottomLeft with: holder topLeft + (0 @ TileMorph defaultH) + (2@-2). holder addMorph: upArrow. holder addMorph: downArrow. self addMorphBack: holder. upArrow on: #mouseDown send: #upArrowHit to: aMorph. upArrow on: #mouseStillDown send: #upArrowHit to: aMorph. downArrow on: #mouseDown send: #downArrowHit to: aMorph. downArrow on: #mouseStillDown send: #downArrowHit to: aMorph.!

Item was changed: + ----- Method: Lexicon>>varTilesMenu (in category '*Etoys-tiles') ----- - ----- Method: Lexicon>>varTilesMenu (in category '*eToys-tiles') ----- varTilesMenu "Offer a menu of tiles for instance variables and a new temporary"

SyntaxMorph new offerVarsMenuFor: self targetObject in: self!

Item was changed: + ----- Method: Morph>>removeEventTrigger: (in category '*Etoys-customevents-scripting') ----- - ----- Method: Morph>>removeEventTrigger: (in category '*eToys-customevents-scripting') ----- removeEventTrigger: aSymbol "Remove all the event registrations for my Player that are triggered by aSymbol. User custom events are triggered at the World, while system custom events are triggered on individual Morphs."

| player | (player := self player) ifNil: [ ^self ]. self removeEventTrigger: aSymbol for: player. self currentWorld removeEventTrigger: aSymbol for: player.!

Item was changed: + ----- Method: DataType>>affordsCoercionToBoolean (in category '*Etoys-tiles') ----- - ----- Method: DataType>>affordsCoercionToBoolean (in category '*eToys-tiles') ----- affordsCoercionToBoolean "Answer true if a tile of this data type, when dropped into a pane that demands a boolean, could plausibly be expanded into a comparison (of the form frog < toad or frog = toad) to provide a boolean expression"

^ true!

Item was changed: + ----- Method: ServerDirectory>>eToyUserListUrl: (in category '*Etoys-school support') ----- - ----- Method: ServerDirectory>>eToyUserListUrl: (in category '*eToys-school support') ----- eToyUserListUrl: aString eToyUserListUrl := aString. eToyUserList := nil.!

Item was changed: + ----- Method: PasteUpMorph>>attemptCleanup (in category '*Etoys-world menu') ----- - ----- Method: PasteUpMorph>>attemptCleanup (in category '*eToys-world menu') ----- attemptCleanup "Try to fix up some bad things that are known to occur in some etoy projects we've seen. This is a bare beginning, but a useful place to tack on further cleanups, which then can be invoked whenever the attempt-cleanup item invoked from the debug menu"

self attemptCleanupReporting: true

" ActiveWorld attemptCleanup "!

Item was changed: TileLikeMorph subclass: #CompoundTileMorph instanceVariableNames: 'type testPart yesPart noPart' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

!CompoundTileMorph commentStamp: '<historical>' prior: 0! A statement with other whole statements inside it. If-Then. Test.!

Item was changed: AlignmentMorph subclass: #WatcherWrapper instanceVariableNames: 'player variableName' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Support'! - category: 'EToys-Scripting Support'!

!WatcherWrapper commentStamp: 'sw 1/6/2005 00:06' prior: 0! 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.!

Item was changed: + ----- Method: SimpleSliderMorph>>setNumericValue: (in category '*Etoys-support') ----- - ----- Method: SimpleSliderMorph>>setNumericValue: (in category '*eToys-e-toy support') ----- setNumericValue: aValue "Set the numeric value of the receiver to be as indicated"

^ self setScaledValue: aValue!

Item was changed: + ----- Method: Morph>>renameScriptActionsFor:from:to: (in category '*Etoys-customevents-scripting') ----- - ----- Method: Morph>>renameScriptActionsFor:from:to: (in category '*eToys-customevents-scripting') ----- renameScriptActionsFor: aPlayer from: oldSelector to: newSelector

self updateableActionMap keysAndValuesDo: [ :event :sequence | sequence asActionSequence do: [ :action | ((action receiver == aPlayer) and: [ (#(doScript: triggerScript:) includes: action selector) and: [ action arguments first == oldSelector ]]) ifTrue: [ action arguments at: 1 put: newSelector ]]] !

Item was changed: + ----- Method: AlignmentMorph>>configureForKids (in category '*Etoys-support') ----- - ----- Method: AlignmentMorph>>configureForKids (in category '*eToys-e-toy support') ----- configureForKids self disableDragNDrop. super configureForKids !

Item was changed: + ----- Method: Number>>vocabularyDemanded (in category '*Etoys-vocabulary') ----- - ----- Method: Number>>vocabularyDemanded (in category '*eToys-vocabulary') ----- vocabularyDemanded "Answer the vocabulary normally preferred by this object"

^ Vocabulary numberVocabulary!

Item was changed: + ----- Method: StandardScriptingSystem>>tilesForQuery:label: (in category '*Etoys-parts bin') ----- - ----- Method: StandardScriptingSystem>>tilesForQuery:label: (in category '*eToys-parts bin') ----- tilesForQuery: expressionString label: aLabel "Answer scripting tiles that represent the query,"

| aPhrase aTile | aPhrase := SystemQueryPhrase new. aTile := BooleanTile new. aTile setExpression: expressionString label: aLabel. aPhrase addMorph: aTile. ^ aPhrase !

Item was changed: + ----- Method: StringType>>setFormatForDisplayer: (in category '*Etoys-tiles') ----- - ----- Method: StringType>>setFormatForDisplayer: (in category '*eToys-tiles') ----- setFormatForDisplayer: aDisplayer "Set up the displayer to have the right format characteristics"

aDisplayer useStringFormat !

Item was changed: + ----- Method: StandardScriptingSystem>>globalCustomEventNames (in category '*Etoys-customevents-custom events') ----- - ----- Method: StandardScriptingSystem>>globalCustomEventNames (in category '*eToys-customevents-custom events') ----- globalCustomEventNames ^self customEventsRegistry keys asArray sort!

Item was changed: + ----- Method: NumberType>>addExtraItemsToMenu:forSlotSymbol: (in category '*Etoys-tiles') ----- - ----- Method: NumberType>>addExtraItemsToMenu:forSlotSymbol: (in category '*eToys-tiles') ----- addExtraItemsToMenu: aMenu forSlotSymbol: slotSym "If the receiver has extra menu items to add to the slot menu, here is its chance to do it. The defaultTarget of the menu is the player concerned."

aMenu add: 'decimal places...' translated selector: #setPrecisionFor: argument: slotSym. aMenu balloonTextForLastItem: 'Lets you choose how many decimal places should be shown in readouts for this variable' translated!

Item was changed: MethodWithInterface subclass: #UniclassScript instanceVariableNames: 'currentScriptEditor formerScriptingTiles isTextuallyCoded lastSourceString' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

!UniclassScript commentStamp: '<historical>' prior: 0! Represents a tile script of uniclass. Holds the ScriptEditorMorph structures for the current version of a user-defined tile script, as well as previous versions thereof.

In addition to the instance variables of my superclass, my instance variables are:

currentScriptEditor The current version of the ScriptEditorMorph for the script formerScriptingTiles A collection of pairs, (<timeStamp> (list of morphs)) each pair characterizing a prior tile version isTextuallyCoded A boolean. If true, then a hand-crafted user coding supersedes the tale of the tiles. This architecture is in transition, perhaps.!

Item was changed: + ----- Method: TheWorldMenu>>uniTilesClassicString (in category '*Etoys-action') ----- - ----- Method: TheWorldMenu>>uniTilesClassicString (in category '*eToys-action') ----- uniTilesClassicString ^ ((myProject parameterAt: #uniTilesClassic ifAbsent: [false]) ifTrue: ['<yes>'] ifFalse: ['<no>']), 'classic tiles' translated!

Item was changed: + ----- Method: StandardScriptingSystem>>fontForTiles (in category '*Etoys-font & color choices') ----- - ----- Method: StandardScriptingSystem>>fontForTiles (in category '*eToys-font & color choices') ----- fontForTiles ^ Preferences standardEToysFont!

Item was changed: + ----- Method: StandardScriptingSystem>>reportToUser: (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>reportToUser: (in category '*eToys-utilities') ----- reportToUser: aString "Make a message accessible to the user. For the moment, we simply defer to the Transcript mechanism"

Transcript cr; show: aString!

Item was changed: + ----- Method: StandardScriptingSystem>>customEventsRegistry (in category '*Etoys-customevents-custom events') ----- - ----- Method: StandardScriptingSystem>>customEventsRegistry (in category '*eToys-customevents-custom events') ----- customEventsRegistry ^Smalltalk at: #CustomEventsRegistry ifAbsentPut: [ IdentityDictionary new ].!

Item was changed: + ----- Method: StandardScriptingSystem>>addUserCustomEventNamed:help: (in category '*Etoys-customevents-custom events') ----- - ----- Method: StandardScriptingSystem>>addUserCustomEventNamed:help: (in category '*eToys-customevents-custom events') ----- addUserCustomEventNamed: aSymbol help: helpString self currentWorld addUserCustomEventNamed: aSymbol help: helpString. "Vocabulary addStandardVocabulary: UserCustomEventNameType new." Vocabulary customEventsVocabulary. SymbolListTile updateAllTilesForVocabularyNamed: #CustomEvents!

Item was changed: + ----- Method: StandardScriptingSystem>>restorePrivateGraphics (in category '*Etoys-form dictionary') ----- - ----- Method: StandardScriptingSystem>>restorePrivateGraphics (in category '*eToys-form dictionary') ----- restorePrivateGraphics "ScriptingSystem restorePrivateGraphics" | aReferenceStream | aReferenceStream := ReferenceStream fileNamed: 'disGraphics'. self mergeGraphicsFrom: aReferenceStream next. aReferenceStream close. !

Item was changed: + ----- Method: PasteUpMorph>>currentVocabularyFor: (in category '*Etoys-support') ----- - ----- Method: PasteUpMorph>>currentVocabularyFor: (in category '*eToys-support') ----- currentVocabularyFor: aScriptableObject "Answer the Vocabulary object to be applied when scripting an object in the world."

| vocabSymbol vocab aPointVocab | vocabSymbol := self valueOfProperty: #currentVocabularySymbol ifAbsent: [nil]. vocabSymbol ifNil: [vocab := self valueOfProperty: #currentVocabulary ifAbsent: [nil]. vocab ifNotNil: [vocabSymbol := vocab vocabularyName. self removeProperty: #currentVocabulary. self setProperty: #currentVocabularySymbol toValue: vocabSymbol]]. vocabSymbol ifNotNil: [^Vocabulary vocabularyNamed: vocabSymbol] ifNil: [(aScriptableObject isPlayerLike) ifTrue: [^Vocabulary eToyVocabulary]. (aScriptableObject isNumber) ifTrue: [^Vocabulary numberVocabulary]. (aScriptableObject isKindOf: Time) ifTrue: [^Vocabulary vocabularyForClass: Time]. (aScriptableObject isString) ifTrue: [^Vocabulary vocabularyForClass: String]. (aScriptableObject isPoint) ifTrue: [(aPointVocab := Vocabulary vocabularyForClass: Point) ifNotNil: [^aPointVocab]]. (aScriptableObject isKindOf: Date) ifTrue: [^Vocabulary vocabularyForClass: Date]. "OrderedCollection and Holder??" ^Vocabulary fullVocabulary]!

Item was changed: Morph subclass: #KedamaPatchMorph instanceVariableNames: 'form displayMax shiftAmount useLogDisplay displayForm diffusionRate scaledEvaporationRate sniffRange formChanged tmpForm autoChanged displayType' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

!KedamaPatchMorph commentStamp: 'yo 6/18/2004 18:31' prior: 0! I represent the patch variable. !

Item was changed: + ----- Method: MessageSend>>asTilesIn:globalNames: (in category '*Etoys-tiles') ----- - ----- Method: MessageSend>>asTilesIn:globalNames: (in category '*eToys-tiles') ----- asTilesIn: playerClass globalNames: makeSelfGlobal | code tree syn block phrase | "Construct SyntaxMorph tiles for me. If makeSelfGlobal is true, name the receiver and use that name, else use 'self'. (Note that this smashes 'self' into the receiver, regardless of what it was.)"

"This is really cheating!! Make a true parse tree later. -tk" code := String streamContents: [:strm | | keywords num | strm nextPutAll: 'doIt'; cr; tab. strm nextPutAll: (makeSelfGlobal ifTrue: [self stringFor: receiver] ifFalse: ['self']). keywords := selector keywords. strm space; nextPutAll: keywords first. (num := selector numArgs) > 0 ifTrue: [strm space. strm nextPutAll: (self stringFor: arguments first)]. 2 to: num do: [:kk | strm space; nextPutAll: (keywords at: kk). strm space; nextPutAll: (self stringFor: (arguments at: kk))]]. "decompile to tiles" tree := Compiler new parse: code in: playerClass notifying: nil. syn := tree asMorphicSyntaxUsing: SyntaxMorph. block := syn submorphs detect: [:mm | (mm respondsTo: #parseNode) ifTrue: [ mm parseNode class == BlockNode] ifFalse: [false]]. phrase := block submorphs detect: [:mm | (mm respondsTo: #parseNode) ifTrue: [ mm parseNode class == MessageNode] ifFalse: [false]]. ^ phrase

!

Item was changed: ThumbnailMorph subclass: #PlayerReferenceReadout instanceVariableNames: 'putSelector' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Support'! - category: 'EToys-Scripting Support'!

!PlayerReferenceReadout commentStamp: '<historical>' prior: 0! 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. !

Item was changed: StandardViewer subclass: #KedamaStandardViewer instanceVariableNames: 'stub restrictedIndex restrictedWho' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

Item was changed: TileMorph subclass: #ParameterTile instanceVariableNames: 'scriptEditor' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

!ParameterTile commentStamp: '<historical>' prior: 0! 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.!

Item was changed: + ----- Method: TheWorldMenu>>adaptedToWorld: (in category '*Etoys-scripting') ----- - ----- Method: TheWorldMenu>>adaptedToWorld: (in category '*eToys-scripting') ----- adaptedToWorld: aWorld "Can use me but need to adapt myself" self adaptToWorld: aWorld.!

Item was changed: + ----- Method: Text>>basicType (in category '*Etoys-tiles') ----- - ----- Method: Text>>basicType (in category '*eToys-tiles') ----- basicType "Answer a symbol representing the inherent type I hold"

"Number String Boolean player collection sound color etc" ^ #Text!

Item was changed: + ----- Method: ReturnNode>>explanation (in category '*Etoys-tiles') ----- - ----- Method: ReturnNode>>explanation (in category '*eToys-tiles') ----- explanation

^'Exit this method returning the value of ',expr explanation !

Item was changed: + ----- Method: StandardScriptingSystem>>userCustomEventNames (in category '*Etoys-customevents-custom events') ----- - ----- Method: StandardScriptingSystem>>userCustomEventNames (in category '*eToys-customevents-custom events') ----- userCustomEventNames ^ self currentWorld userCustomEventNames!

Item was changed: + ----- Method: SymbolListType>>defaultArgumentTile (in category '*Etoys-tiles') ----- - ----- Method: SymbolListType>>defaultArgumentTile (in category '*eToys-tiles') ----- defaultArgumentTile "Answer a tile to represent the type"

| aTile choices | aTile := SymbolListTile new choices: (choices := self choices) dataType: self vocabularyName. aTile addArrows. aTile setLiteral: choices first. ^ aTile!

Item was changed: + ----- Method: MatrixTransformMorph>>heading: (in category '*Etoys-geometry') ----- - ----- Method: MatrixTransformMorph>>heading: (in category '*eToys-geometry eToy') ----- heading: newHeading "Set the receiver's heading (in eToy terms)" self rotateBy: ((newHeading - self forwardDirection) - self innerAngle).!

Item was changed: Object subclass: #ScriptInstantiation instanceVariableNames: 'player selector status frequency anonymous tickingRate lastTick' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

!ScriptInstantiation commentStamp: '<historical>' prior: 0! One of these is associated with each user-defined script for each Player. Holds the state that defines when the script should be run automatically by the system.

player The player whose script this is. selector The message to send my player to activate this script status #ticking, #paused, #normal, #mouseDown, #mouseStillDown, #mouseUp, #mouseEnter, #mouseLeave, #keyStroke frequency For ticking scripts, their frequency. Place-holder: not implemented yet anonymous If true, the script has is unnamed -- in this case, the selector is private to the implementation!

Item was changed: Object subclass: #VariableDock instanceVariableNames: 'variableName type definingMorph morphGetSelector morphPutSelector playerGetSelector playerPutSelector defaultValue' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Stacks'! - category: 'EToys-Stacks'!

!VariableDock commentStamp: '<historical>' prior: 0! Represents a variable held in a Player on behalf of a Morph. When a new Player gets installed in the Morph, variables representing the old player need to be committed to the old player's storage, if not already done, and then new values for the variables need to be obtained from the new Player. The VariableDock does the actual data transfer.

variableName A Symbol. The name by which this variable known in the bearer, a Card type An object representing the variable's type. Initially, we, like the rest use a Symbol to represent this. Presently #string #number #boolean #object #reference #sound etc. definingMorph The morph that requested storage of this variable morphGetSelector The message to be sent to the morph to obtain the variable's value morphPutSelector The message to be sent to the morph to put a new var value into it owningClass The Uniclass of which this is an instance variable playerGetSelector The message to be sent to the Player to obtain its current stored value playerPutSelector The message to be sent to the Player to set a new stored value defaultValue The value to set for the variable by default floatPrecision e.g. 0, 0.1, 0.001. Only relevant for numeric-type variables !

Item was changed: + ----- Method: Morph>>instantiatedUserScriptsDo: (in category '*Etoys-customevents-scripting') ----- - ----- Method: Morph>>instantiatedUserScriptsDo: (in category '*eToys-customevents-scripting') ----- instantiatedUserScriptsDo: aBlock self actorStateOrNil ifNotNil: [ :aState | aState instantiatedUserScriptsDictionary do: aBlock]!

Item was changed: + ----- Method: NumberType>>addUserSlotItemsTo:slotSymbol: (in category '*Etoys-tiles') ----- - ----- Method: NumberType>>addUserSlotItemsTo:slotSymbol: (in category '*eToys-tiles') ----- addUserSlotItemsTo: aMenu slotSymbol: slotSym "Optionally add items to the menu that pertain to a user-defined slot of the given symbol"

"aMenu add: 'decimal places...' selector: #setPrecisionFor: argument: slotSym NB: This item is now generically added for system as well as user slots, so the addition is now done in NubmerType.addExtraItemsToMenu:forSlotSymbol:"!

Item was changed: AlignmentMorph subclass: #PlayerSurrogate instanceVariableNames: 'playerRepresented' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

!PlayerSurrogate commentStamp: '<historical>' prior: 0! An morph representing an E-Toy "Player" in an AllPlayersTool.!

Item was changed: + ----- Method: PluggableTextMorphWithModel>>couldHoldSeparateDataForEachInstance (in category '*Etoys-card in a stack') ----- - ----- Method: PluggableTextMorphWithModel>>couldHoldSeparateDataForEachInstance (in category '*eToys-card in a stack') ----- couldHoldSeparateDataForEachInstance "Answer whethre the receiver is structurally capable of holding uniqe data for each ard instance"

^ true!

Item was changed: + ----- Method: DataType>>addWatcherItemsToMenu:forGetter: (in category '*Etoys-tiles') ----- - ----- Method: DataType>>addWatcherItemsToMenu:forGetter: (in category '*eToys-tiles') ----- addWatcherItemsToMenu: aMenu forGetter: aGetter "Add watcher items to the menu if appropriate, provided the getter is not an odd-ball one for which a watcher makes no sense"

(Vocabulary gettersForbiddenFromWatchers includes: aGetter) ifFalse: [aMenu add: 'simple watcher' translated selector: #tearOffUnlabeledWatcherFor: argument: aGetter. aMenu add: 'detailed watcher' translated selector: #tearOffFancyWatcherFor: argument: aGetter. aMenu addLine]!

Item was changed: + ----- Method: ColorType>>defaultArgumentTile (in category '*Etoys-tiles') ----- - ----- Method: ColorType>>defaultArgumentTile (in category '*eToys-tiles') ----- defaultArgumentTile "Answer a tile to represent the type"

^ Color blue newTileMorphRepresentative!

Item was changed: SketchMorph subclass: #StickySketchMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Support'! - category: 'EToys-Scripting Support'!

Item was changed: + ----- Method: SymbolListType>>affordsCoercionToBoolean (in category '*Etoys-tiles') ----- - ----- Method: SymbolListType>>affordsCoercionToBoolean (in category '*eToys-tiles') ----- affordsCoercionToBoolean "Answer true if a tile of this data type, when dropped into a pane that demands a boolean, could plausibly be expanded into a comparison (of the form frog < toad or frog = toad) to provide a boolean expression"

"Formerly this had been disabled (9/27/01) but from today's perspective I don't see any reason to disable it..."

^ true!

Item was changed: PluggableTextMorph subclass: #MethodMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

Item was changed: Notification subclass: #GetTriggeringObjectNotification instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-CustomEvents'! - category: 'EToys-CustomEvents'!

!GetTriggeringObjectNotification commentStamp: '<historical>' prior: 0! This is used to report on the sender of #triggerScript:!

Item was changed: + ----- Method: BookMorph>>configureForKids (in category '*Etoys-support') ----- - ----- Method: BookMorph>>configureForKids (in category '*eToys-e-toy support') ----- configureForKids super configureForKids. pages do: [:aPage | aPage configureForKids].!

Item was changed: + ----- Method: TheWorldMenu>>scriptingDo (in category '*Etoys-popups') ----- - ----- Method: TheWorldMenu>>scriptingDo (in category '*eToys-popups') ----- scriptingDo

self doPopUp: self scriptingMenu!

Item was changed: StandardScriptingSystem subclass: #EToySystem instanceVariableNames: '' classVariableNames: 'EToyVersion EToyVersionDate' poolDictionaries: '' + category: 'Etoys-Experimental'! - category: 'EToys-Experimental'!

!EToySystem commentStamp: '<historical>' prior: 0! A global object holding onto properties and code of the overall E-toy system of the moment. Its code is entirely held on the class side; the class is never instantiated.!

Item was changed: + ----- Method: StandardScriptingSystem>>anyButtonPressedTiles (in category '*Etoys-parts bin') ----- - ----- Method: StandardScriptingSystem>>anyButtonPressedTiles (in category '*eToys-parts bin') ----- anyButtonPressedTiles "Answer tiles representing the query 'is any button pressed?'"

^ self tilesForQuery: '(ActiveHand anyButtonPressed)' label: 'button down?' translated!

Item was changed: + ----- Method: StandardScriptingSystem>>resetStaleScriptingReferences (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>resetStaleScriptingReferences (in category '*eToys-utilities') ----- resetStaleScriptingReferences "Remove all scripting references that are no longer needed"

References removeUnreferencedKeys

"ScriptingSystem resetStaleScriptingReferences" !

Item was changed: + ----- Method: CodeHolder>>showingTilesString (in category '*Etoys-tiles') ----- - ----- Method: CodeHolder>>showingTilesString (in category '*eToys-tiles') ----- showingTilesString "Answer a string characterizing whether tiles are currently showing or not"

^ (self showingTiles ifTrue: ['<yes>'] ifFalse: ['<no>']), 'tiles'!

Item was changed: KedamaExamplerPlayer subclass: #KedamaSequenceExecutionStub instanceVariableNames: 'who index arrays exampler' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

Item was changed: + ----- Method: Lexicon>>tilesMenu (in category '*Etoys-tiles') ----- - ----- Method: Lexicon>>tilesMenu (in category '*eToys-tiles') ----- tilesMenu "Offer a menu of tiles for assignment and constants"

SyntaxMorph new offerTilesMenuFor: self targetObject in: self!

Item was changed: + ----- Method: Number>>newTileMorphRepresentative (in category '*Etoys-tiles') ----- - ----- Method: Number>>newTileMorphRepresentative (in category '*eToys-tiles') ----- newTileMorphRepresentative ^ TileMorph new addArrows; setLiteral: self; addSuffixIfCan !

Item was changed: + ----- Method: StandardScriptingSystem>>stepButton (in category '*Etoys-script-control') ----- - ----- Method: StandardScriptingSystem>>stepButton (in category '*eToys-script-control') ----- stepButton | aButton | self flag: #deferred. "ambiguity about recipients" aButton := ThreePhaseButtonMorph new. aButton image: (ScriptingSystem formAtKey: 'StepPicOn'); offImage: (ScriptingSystem formAtKey: 'StepPic'); pressedImage: (ScriptingSystem formAtKey: 'StepPicOn'); arguments: (Array with: nil with: aButton); actionSelector: #stepStillDown:with:; target: self; setNameTo: 'Step Button'; actWhen: #whilePressed; on: #mouseDown send: #stepDown:with: to: self; on: #mouseStillDown send: #stepStillDown:with: to: self; on: #mouseUp send: #stepUp:with: to: self; setBalloonText: 'Run every paused script exactly once. Keep the mouse button down over "Step" and everything will keep running until you release it' translated. ^ aButton!

Item was changed: + ----- Method: StringHolder>>openSyntaxView (in category '*Etoys-tiles') ----- - ----- Method: StringHolder>>openSyntaxView (in category '*eToys-tiles') ----- openSyntaxView "Open a syntax view on the current method"

| class selector |

(selector := self selectedMessageName) ifNotNil: [ class := self selectedClassOrMetaClass. SyntaxMorph testClass: class andMethod: selector. ]!

Item was changed: + ----- Method: StandardScriptingSystem>>prepareForExternalReleaseNamed: (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>prepareForExternalReleaseNamed: (in category '*eToys-utilities') ----- prepareForExternalReleaseNamed: aReleaseName "ScriptingSystem prepareForExternalReleaseNamed: '2.2Beta'"

EToySystem stripMethodsForExternalRelease.

ScriptingSystem saveFormsToFileNamed: aReleaseName, '.Dis.Forms'. ScriptingSystem stripGraphicsForExternalRelease. ScriptingSystem cleanupsForRelease. Smalltalk at: #ScreenController ifPresent: [:sc | sc initialize] !

Item was changed: ScriptInstantiation subclass: #UserScript instanceVariableNames: 'currentScriptEditor formerScriptEditors' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

!UserScript commentStamp: '<historical>' prior: 0! Holds the ScriptEditorMorph structures for the current version of a user-defined tile script, as well as previous versions thereof. currentScriptEditor The current version of the ScriptEditorMorph for the script formerScriptEditors Earlier versions of the script, for recapturing via the Versions feature (a dictionary, <timeStamp> -> ScriptEditorMorph!

Item was changed: ObjectRepresentativeMorph subclass: #ListViewLine instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

Item was changed: + ----- Method: HandleMorph>>isCandidateForAutomaticViewing (in category '*Etoys-support') ----- - ----- Method: HandleMorph>>isCandidateForAutomaticViewing (in category '*eToys-e-toy support') ----- isCandidateForAutomaticViewing ^ false!

Item was changed: TileMorph subclass: #KedamaTurtleAtTile instanceVariableNames: 'turtleTile' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

Item was changed: + ----- Method: VariableNode>>explanation (in category '*Etoys-tiles') ----- - ----- Method: VariableNode>>explanation (in category '*eToys-tiles') ----- explanation

self isSelfPseudoVariable ifTrue: [^'the pseudo variable <self> (refers to the receiver)']. ^(#('instance' 'temporary' 'LIT3' 'global') at: self type ifAbsent: ['UNK',self type printString]),' variable <',self name,'>'

"LdInstType := 1. LdTempType := 2. LdLitType := 3. LdLitIndType := 4. "

!

Item was changed: + ----- Method: NumberType>>comparatorForSampleBoolean (in category '*Etoys-tiles') ----- - ----- Method: NumberType>>comparatorForSampleBoolean (in category '*eToys-tiles') ----- comparatorForSampleBoolean "Answer the comparator to use in tile coercions involving the receiver; normally, the equality comparator is used but NumberType overrides"

^ #<!

Item was changed: + ----- Method: StandardScriptingSystem>>nameForInstanceVariablesCategory (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>nameForInstanceVariablesCategory (in category '*eToys-utilities') ----- nameForInstanceVariablesCategory "Answer the name to use for the viewer category that contains instance variables"

^ #variables "^ #'instance variables'"

"ScriptingSystem nameForInstanceVariablesCategory"!

Item was changed: + ----- Method: StandardScriptingSystem>>arithmeticalOperatorsAndHelpStrings (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>arithmeticalOperatorsAndHelpStrings (in category '*eToys-utilities') ----- arithmeticalOperatorsAndHelpStrings "Answer an array consisting of lists of the standard arithmetical operator tiles and of the corresponding balloon help for them"

^ #((+ - * / // \ max: min:) ('add' 'subtract' 'multiply' 'divide' 'divide & truncate' 'remainder when divided by' 'larger value' 'smaller value' ))!

Item was changed: + ----- Method: UpdatingStringMorph>>couldHoldSeparateDataForEachInstance (in category '*Etoys-card in a stack') ----- - ----- Method: UpdatingStringMorph>>couldHoldSeparateDataForEachInstance (in category '*eToys-card in a stack') ----- couldHoldSeparateDataForEachInstance "Answer whether this type of morph is inherently capable of holding separate data for each instance ('card data')"

^ true!

Item was changed: + ----- Method: ColorPickerMorph>>isCandidateForAutomaticViewing (in category '*Etoys-support') ----- - ----- Method: ColorPickerMorph>>isCandidateForAutomaticViewing (in category '*eToys-e-toy support') ----- isCandidateForAutomaticViewing ^ false!

Item was changed: + ----- Method: StandardScriptingSystem>>stepDown:with: (in category '*Etoys-script-control') ----- - ----- Method: StandardScriptingSystem>>stepDown:with: (in category '*eToys-script-control') ----- stepDown: evt with: aMorph aMorph presenter stopRunningScripts!

Item was changed: + ----- Method: SimpleSliderMorph>>arrowDeltaFor: (in category '*Etoys-support') ----- - ----- Method: SimpleSliderMorph>>arrowDeltaFor: (in category '*eToys-e-toy support') ----- arrowDeltaFor: aGetter "Here just for testing the arrowDelta feature. To test, re-enable the code below by commenting out the first line, and you should see the minVal slot of the slider go up and down in increments of 5 as you work the arrows on its readout tile in a freshly-launched Viewer or detailed watcher" true ifTrue: [^ super arrowDeltaFor: aGetter]. ^ (aGetter == #getMinVal) ifTrue: [5] ifFalse: [1]!

Item was changed: + ----- Method: Quadrangle>>vocabularyDemanded (in category '*Etoys-vocabulary') ----- - ----- Method: Quadrangle>>vocabularyDemanded (in category '*eToys-vocabulary') ----- vocabularyDemanded "Answer the vocabulary that the receiver really would like to use in a Viewer"

^ Vocabulary quadVocabulary!

Item was changed: + ----- Method: StandardScriptingSystem>>doesOperatorWantArrows: (in category '*Etoys-universal slots & scripts') ----- - ----- Method: StandardScriptingSystem>>doesOperatorWantArrows: (in category '*eToys-universal slots & scripts') ----- doesOperatorWantArrows: aSymbol aSymbol = #, ifTrue:[^ false]. ^ aSymbol isInfix or: [#(isDivisibleBy:) includes: aSymbol]!

Item was changed: EToyVocabulary subclass: #EToyVectorVocabulary instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Protocols'! - category: 'EToys-Protocols'!

!EToyVectorVocabulary commentStamp: '<historical>' prior: 0! An extension of the etoy vocabulary in support of an experiment Alan Kay requested in summer 2001 for allowing any morph/player to be thought of as a vector. In effect, adds a category #vector to the viewer for such all morphs. Consult Ted Kaehler and Alan Kay for more information on this track.!

Item was changed: PlayerType subclass: #KedamaPatchType instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

!KedamaPatchType commentStamp: 'yo 6/18/2004 18:32' prior: 0! EToys Patch type. !

Item was changed: + ----- Method: PasteUpMorph>>modernizeBJProject (in category '*Etoys-support') ----- - ----- Method: PasteUpMorph>>modernizeBJProject (in category '*eToys-support') ----- modernizeBJProject "Prepare a kids' project from the BJ fork of September 2000 -- a once-off thing for converting such projects forward to a modern 3.1a image, in July 2001. Except for the #enableOnlyGlobalFlapsWithIDs: call, this could conceivably be called upon reloading *any* project, just for safety."

"ActiveWorld modernizeBJProject"

ScriptEditorMorph allInstancesDo: [:m | m userScriptObject]. Flaps enableOnlyGlobalFlapsWithIDs: {'Supplies' translated}. ActiveWorld abandonOldReferenceScheme. ActiveWorld relaunchAllViewers.!

Item was changed: + ----- Method: StandardScriptingSystem>>customEventNamesAndHelpStringsFor: (in category '*Etoys-customevents-custom events') ----- - ----- Method: StandardScriptingSystem>>customEventNamesAndHelpStringsFor: (in category '*eToys-customevents-custom events') ----- customEventNamesAndHelpStringsFor: aPlayer | retval morph | morph := aPlayer costume renderedMorph. retval := SortedCollection sortBlock: [ :a :b | a first < b first ]. self customEventsRegistry keysAndValuesDo: [ :k :v | | helpStrings | helpStrings := Array streamContents: [ :hsStream | v keysAndValuesDo: [ :registrant :array | (morph isKindOf: array second) ifTrue: [ | help | help := String streamContents: [ :stream | v size > 1 ifTrue: [ stream nextPut: $(; nextPutAll: array second name; nextPut: $); space ]. stream nextPutAll: array first ]. hsStream nextPut: help ]]]. helpStrings isEmpty ifFalse: [retval add: { k. helpStrings } ]]. ^ retval!

Item was changed: SimpleButtonMorph subclass: #ScriptActivationButton instanceVariableNames: 'uniclassScript' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

!ScriptActivationButton commentStamp: 'sw 3/11/2003 00:24' prior: 0! 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.!

Item was changed: + ----- Method: TextMorph>>setNumericValue: (in category '*Etoys-support') ----- - ----- Method: TextMorph>>setNumericValue: (in category '*eToys-e-toy support') ----- setNumericValue: aValue "Set the contents of the receiver to be a string obtained from aValue"

self newContents: aValue asString!

Item was changed: + ----- Method: StandardScriptingSystem>>readFormsFromFileNamed:andStoreIntoGlobal: (in category '*Etoys-form dictionary') ----- - ----- Method: StandardScriptingSystem>>readFormsFromFileNamed:andStoreIntoGlobal: (in category '*eToys-form dictionary') ----- readFormsFromFileNamed: aFileName andStoreIntoGlobal: globalName "Read the a FormDictionary in from a designated file on disk and save it in the designated global"

| aReferenceStream | aReferenceStream := ReferenceStream fileNamed: aFileName. Smalltalk at: globalName put: aReferenceStream next. aReferenceStream close

"ScriptingSystem readFormsFromFileNamed: 'SystemFormsFromFwdF.forms' andStoreIntoGlobal: #FormsTemp"

"ScriptingSystem saveForm: (FormsTemp at: #StackElementDesignationHelp) atKey: #StackElementDesignationHelp"!

Item was changed: + ----- Method: Morph>>removeAllEventTriggers (in category '*Etoys-customevents-scripting') ----- - ----- Method: Morph>>removeAllEventTriggers (in category '*eToys-customevents-scripting') ----- removeAllEventTriggers "Remove all the event registrations for my Player. User custom events are triggered at the World, while system custom events are triggered on individual Morphs."

| player | (player := self player) ifNil: [ ^self ]. self removeAllEventTriggersFor: player. self currentWorld removeAllEventTriggersFor: player.!

Item was changed: ColorTileMorph subclass: #ColorSeerTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

Item was changed: CategoryViewer subclass: #SearchingViewer instanceVariableNames: 'searchString' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

!SearchingViewer commentStamp: 'sw 8/16/2002 22:43' prior: 0! 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.!

Item was changed: + ----- Method: Number>>basicType (in category '*Etoys-tiles') ----- - ----- Method: Number>>basicType (in category '*eToys-tiles') ----- basicType "Answer a symbol representing the inherent type of the receiver"

^ #Number!

Item was changed: Morph subclass: #TilePadMorph instanceVariableNames: 'type' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

!TilePadMorph commentStamp: '<historical>' prior: 0! 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. !

Item was changed: TileMorph subclass: #SoundTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

!SoundTile commentStamp: 'sw 1/28/2005 01:42' prior: 0! A scripting tile representing a 'sound' constant. Sounds are represented by their names, which are strings; the actual sounds live in SampleSound's SoundLibrary.!

Item was changed: + ----- Method: StandardScriptingSystem>>smallBoldFont (in category '*Etoys-font & color choices') ----- - ----- Method: StandardScriptingSystem>>smallBoldFont (in category '*eToys-font & color choices') ----- smallBoldFont "Answer a small bold font for use in some standard scripting-support structures"

^ StrikeFont familyName: Preferences standardEToysFont familyName size: 12!

Item was changed: + ----- Method: UnknownType>>affordsCoercionToBoolean (in category '*Etoys-tiles') ----- - ----- Method: UnknownType>>affordsCoercionToBoolean (in category '*eToys-tiles') ----- affordsCoercionToBoolean "Answer true if a tile of this data type, when dropped into a pane that demands a boolean, could plausibly be expanded into a comparison (of the form frog < toad or frog = toad) to provide a boolean expression"

^ false!

Item was changed: + ----- Method: ParseNode>>addCommentToMorph: (in category '*Etoys-tiles') ----- - ----- Method: ParseNode>>addCommentToMorph: (in category '*eToys-tiles') ----- addCommentToMorph: aMorph | row | (self comment isNil or: [self comment isEmpty]) ifTrue: [^ self]. row := aMorph addTextRow: (String streamContents: [:strm | self printCommentOn: strm indent: 1]). row firstSubmorph color: (SyntaxMorph translateColor: #comment). row parseNode: (self as: CommentNode). !

Item was changed: TileMorph subclass: #ColorTileMorph instanceVariableNames: 'colorSwatch' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

Item was changed: + ----- Method: Form>>appearsToBeSameCostumeAs: (in category '*Etoys-testing') ----- - ----- Method: Form>>appearsToBeSameCostumeAs: (in category '*eToys-testing') ----- appearsToBeSameCostumeAs: anotherForm

(anotherForm isKindOf: self class) ifFalse: [^false]. anotherForm depth = self depth ifFalse: [^false]. ^anotherForm bits = bits !

Item was changed: + ----- Method: Class>>uniqueNameForReference (in category '*Etoys-class name') ----- - ----- Method: Class>>uniqueNameForReference (in category '*eToys-class name') ----- uniqueNameForReference "Answer a unique name by which the receiver can be referred to from user scripts, for example"

^ name!

Item was changed: + ----- Method: ServerDirectory>>eToyUserName: (in category '*Etoys-school support') ----- - ----- Method: ServerDirectory>>eToyUserName: (in category '*eToys-school support') ----- eToyUserName: aString "Ignored here"!

Item was changed: + ----- Method: PasteUpMorph>>userCustomEventsRegistry (in category '*Etoys-customevents-scripting') ----- - ----- Method: PasteUpMorph>>userCustomEventsRegistry (in category '*eToys-customevents-scripting') ----- userCustomEventsRegistry ^self valueOfProperty: #userCustomEventsRegistry ifAbsentPut: [ IdentityDictionary new ].!

Item was changed: + ----- Method: StandardScriptingSystem>>mergeGraphicsFrom: (in category '*Etoys-form dictionary') ----- - ----- Method: StandardScriptingSystem>>mergeGraphicsFrom: (in category '*eToys-form dictionary') ----- mergeGraphicsFrom: aDictionary "aDictionary is assumed to hold associations of the form <formName> -> <form>. Merge the graphics held by that dictionary into the internal FormDictionary, overlaying any existing entries with the ones found in aDictionary"

aDictionary associationsDo: [:assoc | self saveForm: assoc value atKey: assoc key]

"works ok even if keys in aDictionary are strings rather than symbols"!

Item was changed: AlignmentMorph subclass: #AllPlayersTool instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

!AllPlayersTool commentStamp: '<historical>' prior: 0! A tool that lets you see find, view, and obtain tiles for all the active players in the project.!

Item was changed: Object subclass: #ActorState instanceVariableNames: 'owningPlayer penDown penSize penColor fractionalPosition instantiatedUserScriptsDictionary penArrowheads trailStyle' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Support'! - category: 'EToys-Scripting Support'!

!ActorState commentStamp: '<historical>' prior: 0! Holds a record of data representing actor-like slots in the Morph, on behalf of an associated Player. Presently also holds onto the scriptInstantion objects that represent active scripts in an instance, but this will probably change soon.!

Item was changed: + ----- Method: WeakMessageSend>>asTilesIn:globalNames: (in category '*Etoys-tiles') ----- - ----- Method: WeakMessageSend>>asTilesIn:globalNames: (in category '*eToys-tiles') ----- asTilesIn: playerClass globalNames: makeSelfGlobal ^self asMessageSend asTilesIn: playerClass globalNames: makeSelfGlobal !

Item was changed: AlignmentMorph subclass: #ScriptEditorMorph instanceVariableNames: 'scriptName firstTileRow timeStamp playerScripted handWithTile showingMethodPane threadPolygon' classVariableNames: 'WritingUniversalTiles' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

!ScriptEditorMorph commentStamp: '<historical>' prior: 0! 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.!

Item was changed: + ----- Method: MessageSend>>asTilesIn: (in category '*Etoys-tiles') ----- - ----- Method: MessageSend>>asTilesIn: (in category '*eToys-tiles') ----- asTilesIn: playerClass | code tree syn block phrase | "Construct SyntaxMorph tiles for me."

"This is really cheating!! Make a true parse tree later. -tk" code := String streamContents: [:strm | | num keywords | strm nextPutAll: 'doIt'; cr; tab. strm nextPutAll: (self stringFor: receiver). keywords := selector keywords. strm space; nextPutAll: keywords first. (num := selector numArgs) > 0 ifTrue: [strm space. strm nextPutAll: (self stringFor: arguments first)]. 2 to: num do: [:kk | strm space; nextPutAll: (keywords at: kk). strm space; nextPutAll: (self stringFor: (arguments at: kk))]]. "decompile to tiles" tree := Compiler new parse: code in: playerClass notifying: nil. syn := tree asMorphicSyntaxUsing: SyntaxMorph. block := syn submorphs detect: [:mm | (mm respondsTo: #parseNode) ifTrue: [ mm parseNode class == BlockNode] ifFalse: [false]]. phrase := block submorphs detect: [:mm | (mm respondsTo: #parseNode) ifTrue: [ mm parseNode class == MessageNode] ifFalse: [false]]. ^ phrase

!

Item was changed: + ----- Method: StringType>>defaultArgumentTile (in category '*Etoys-tiles') ----- - ----- Method: StringType>>defaultArgumentTile (in category '*eToys-tiles') ----- defaultArgumentTile "Answer a tile to represent the type"

^ 'abc' translated newTileMorphRepresentative typeColor: self typeColor!

Item was changed: + ----- Method: PasteUpMorph>>getCharacters (in category '*Etoys-support') ----- - ----- Method: PasteUpMorph>>getCharacters (in category '*eToys-support') ----- getCharacters "obtain a string value from the receiver"

^ String streamContents: [:aStream | submorphs do: [:m | aStream nextPutAll: m getCharacters]]!

Item was changed: + ----- Method: SoundType>>typeColor (in category '*Etoys-color') ----- - ----- Method: SoundType>>typeColor (in category '*eToys-color') ----- typeColor "Answer the color for tiles to be associated with objects of this type"

^ self subduedColorFromTriplet: #(1.0 0.06 0.84) !

Item was changed: MessageNode subclass: #TileMessageNode instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Tile Scriptors'! - category: 'EToys-Tile Scriptors'!

Item was changed: + ----- Method: PasteUpMorph>>abandonOldReferenceScheme (in category '*Etoys-world menu') ----- - ----- Method: PasteUpMorph>>abandonOldReferenceScheme (in category '*eToys-world menu') ----- abandonOldReferenceScheme "Perform a one-time changeover" "ActiveWorld abandonOldReferenceScheme"

Preferences setPreference: #capitalizedReferences toValue: true. (self presenter allExtantPlayers collect: [:aPlayer | aPlayer class]) asSet do: [:aPlayerClass | aPlayerClass isUniClass ifTrue: [aPlayerClass abandonOldReferenceScheme]]!

Item was changed: + ----- Method: PasteUpMorph>>elementCount (in category '*Etoys-support') ----- - ----- Method: PasteUpMorph>>elementCount (in category '*eToys-support') ----- elementCount "Answer how many objects are contained within me"

^ submorphs size!

Item was changed: + ----- Method: EventHandler>>forgetDispatchesTo: (in category '*Etoys-initialization') ----- - ----- Method: EventHandler>>forgetDispatchesTo: (in category '*eToys-initialization') ----- forgetDispatchesTo: aSelector "aSelector is no longer implemented by my corresponding Player, so don't call it any more" mouseDownSelector == aSelector ifTrue: [mouseDownRecipient := mouseDownSelector := nil]. mouseMoveSelector == aSelector ifTrue: [mouseMoveRecipient := mouseMoveSelector := nil]. mouseStillDownSelector == aSelector ifTrue: [mouseStillDownRecipient := mouseStillDownSelector := nil]. mouseUpSelector == aSelector ifTrue: [mouseUpRecipient := mouseUpSelector := nil]. mouseEnterSelector == aSelector ifTrue: [mouseEnterRecipient := mouseEnterSelector := nil]. mouseLeaveSelector == aSelector ifTrue: [mouseLeaveRecipient := mouseLeaveSelector := nil]. mouseEnterDraggingSelector == aSelector ifTrue: [mouseEnterDraggingRecipient := mouseEnterDraggingSelector := nil]. mouseLeaveDraggingSelector == aSelector ifTrue: [mouseLeaveDraggingRecipient := mouseLeaveDraggingSelector := nil]. clickSelector == aSelector ifTrue: [clickRecipient := clickSelector := nil]. doubleClickSelector == aSelector ifTrue: [doubleClickRecipient := doubleClickSelector := nil]. doubleClickTimeoutSelector == aSelector ifTrue: [doubleClickTimeoutRecipient := doubleClickTimeoutSelector := nil]. keyStrokeSelector == aSelector ifTrue: [keyStrokeRecipient := keyStrokeSelector := nil].!

Item was changed: + ----- Method: MenuType>>defaultArgumentTile (in category '*Etoys-tiles') ----- - ----- Method: MenuType>>defaultArgumentTile (in category '*eToys-tiles') ----- defaultArgumentTile "Answer a tile to represent the type"

^ MenuTile new typeColor: self typeColor!

Item was changed: UpdatingSimpleButtonMorph subclass: #ScriptableButton instanceVariableNames: 'scriptSelector' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

!ScriptableButton commentStamp: '<historical>' prior: 0! A button intended for use with the card architecture and the user-scripting system.!

Item was changed: + ----- Method: HandMorph>>adaptedToWorld: (in category '*Etoys-scripting') ----- - ----- Method: HandMorph>>adaptedToWorld: (in category '*eToys-scripting') ----- adaptedToWorld: aWorld "If I refer to a world or a hand, return the corresponding items in the new world." ^aWorld primaryHand!

Item was changed: + ----- Method: StandardScriptingSystem>>statusHelpStringFor: (in category '*Etoys-customevents-help dictionary') ----- - ----- Method: StandardScriptingSystem>>statusHelpStringFor: (in category '*eToys-customevents-help dictionary') ----- statusHelpStringFor: aPlayer ^String streamContents: [ :stream | stream nextPutAll: 'normal -- run when called paused -- ready to run all the time ticking -- run all the time mouseDown -- run when mouse goes down on me mouseStillDown -- while mouse still down mouseUp -- when mouse comes back up mouseEnter -- when mouse enters my bounds, button up mouseLeave -- when mouse exits my bounds, button up mouseEnterDragging -- when mouse enters my bounds, button down mouseLeaveDragging -- when mouse exits my bounds, button down opening -- when I am being opened closing -- when I am being closed' translated.

"'keyStroke -- run when user hits a key' "

stream cr; cr; nextPutAll: 'More events:' translated; cr.

(self customEventNamesAndHelpStringsFor: aPlayer) do: [ :array | stream cr; nextPutAll: array first; nextPutAll: ' -- '. array second do: [ :help | stream nextPutAll: help translated ] separatedBy: [ stream nextPutAll: ' or ' translated ]].

(Preferences allowEtoyUserCustomEvents) ifTrue: [ self userCustomEventNames isEmpty ifFalse: [ stream cr; cr; nextPutAll: 'User custom events:' translated; cr. self currentWorld userCustomEventsRegistry keysAndValuesDo: [ :key :value | stream cr; nextPutAll: key; nextPutAll: ' -- '; nextPutAll: value ]]]]!

Item was changed: + ----- Method: TextMorph>>variableDocks (in category '*Etoys-player') ----- - ----- Method: TextMorph>>variableDocks (in category '*eToys-player') ----- variableDocks "Answer a list of VariableDock objects for docking up my data with an instance held in my containing playfield"

^ Array with: (VariableDock new variableName: self defaultVariableName type: #text definingMorph: self morphGetSelector: #contents morphPutSelector: #setNewContentsFrom:)!

Item was changed: + ----- Method: StandardScriptingSystem>>saveFormsToFileNamed: (in category '*Etoys-form dictionary') ----- - ----- Method: StandardScriptingSystem>>saveFormsToFileNamed: (in category '*eToys-form dictionary') ----- saveFormsToFileNamed: aFileName "Save the current state of form dictionary to disk for possible later retrieval" (ReferenceStream fileNamed: aFileName) nextPut: FormDictionary; close

"ScriptingSystem saveFormsToFileNamed: 'SystemForms06May98.forms'"!

Item was changed: SimpleHierarchicalListMorph subclass: #EToyHierarchicalTextMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Outliner'! - category: 'EToys-Outliner'!

Item was changed: + ----- Method: GeeMailMorph>>visibleMorphs: (in category '*Etoys-customevents-access') ----- - ----- Method: GeeMailMorph>>visibleMorphs: (in category '*eToys-customevents-access') ----- visibleMorphs: morphs "Answer a collection of morphs that were visible as of the last step" self setProperty: #visibleMorphs toValue: (WeakArray withAll: morphs)!

Item was changed: TileMorph subclass: #KedamaUpHillTile instanceVariableNames: 'patchTile' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

!KedamaUpHillTile commentStamp: 'yo 6/18/2004 18:34' prior: 0! I provide the special tile of 'upHill' setter. !

Item was changed: + ----- Method: ServerDirectory>>eToyUserList: (in category '*Etoys-school support') ----- - ----- Method: ServerDirectory>>eToyUserList: (in category '*eToys-school support') ----- eToyUserList: aCollectionOrNil "Set a list of all known users for eToy login support" eToyUserList := aCollectionOrNil.!

Item was changed: AlignmentMorphBob1 subclass: #EToyCommunicatorMorph instanceVariableNames: 'fields resultQueue' classVariableNames: 'LastFlashTime' poolDictionaries: '' + category: 'Etoys-Experimental'! - category: 'EToys-Experimental'!

!EToyCommunicatorMorph commentStamp: '<historical>' prior: 0! ====== 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] ]. !

Item was changed: Presenter subclass: #EtoysPresenter instanceVariableNames: 'associatedMorph standardPlayer standardPlayfield standardPalette playerList' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

!EtoysPresenter commentStamp: '<historical>' prior: 0! 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.

!

Item was changed: + ----- Method: NumberType>>newReadoutTile (in category '*Etoys-tiles') ----- - ----- Method: NumberType>>newReadoutTile (in category '*eToys-tiles') ----- newReadoutTile "Answer a tile that can serve as a readout for data of this type"

^ NumericReadoutTile new typeColor: Color lightGray lighter!

Item was changed: + ----- Method: ServerDirectory>>eToyUserList (in category '*Etoys-school support') ----- - ----- Method: ServerDirectory>>eToyUserList (in category '*eToys-school support') ----- eToyUserList "Return a list of all known users for eToy login support" | urlString | eToyUserList ifNotNil:[^eToyUserList]. urlString := self eToyUserListUrl. urlString ifNil:[^nil]. eToyUserList := self class parseEToyUserListFrom: urlString. ^eToyUserList!

Item was changed: CategoryViewer subclass: #KedamaCategoryViewer instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

Item was changed: + ----- Method: StandardScriptingSystem>>resetAllScriptingReferences (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>resetAllScriptingReferences (in category '*eToys-utilities') ----- resetAllScriptingReferences "Clear out all the elements in the References directory" Smalltalk at: #References put: IdentityDictionary new

"ScriptingSystem resetAllScriptingReferences"!

Item was changed: TileMorph subclass: #KedamaAngleToTile instanceVariableNames: 'turtleTile' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

!KedamaAngleToTile commentStamp: 'yo 6/18/2004 18:29' prior: 0! I provide the special tile of 'angle to'. !

Item was changed: + ----- Method: MenuMorph>>isCandidateForAutomaticViewing (in category '*Etoys-control') ----- - ----- Method: MenuMorph>>isCandidateForAutomaticViewing (in category '*eToys-control') ----- isCandidateForAutomaticViewing ^ false!

Item was changed: + ----- Method: ParseNode>>currentValueIn: (in category '*Etoys-tiles') ----- - ----- Method: ParseNode>>currentValueIn: (in category '*eToys-tiles') ----- currentValueIn: aContext

^nil!

Item was changed: + ----- Method: StandardScriptingSystem>>tryButtonFor: (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>tryButtonFor: (in category '*eToys-utilities') ----- tryButtonFor: aPhraseTileMorph | aButton | aButton := SimpleButtonMorph new. aButton target: aPhraseTileMorph; actionSelector: #try; label: '!!' font: Preferences standardEToysFont; color: Color yellow; borderWidth: 0. aButton actWhen: #whilePressed. aButton balloonTextSelector: #try. ^ aButton!

Item was changed: EToyProjectDetailsMorph subclass: #EToyProjectQueryMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Experimental'! - category: 'EToys-Experimental'!

Item was changed: TileMorph subclass: #StringReadoutTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

Item was changed: + ----- Method: Lexicon>>acceptTiles (in category '*Etoys-tiles') ----- - ----- Method: Lexicon>>acceptTiles (in category '*eToys-tiles') ----- acceptTiles | pp pq methodNode cls sel | "In complete violation of all the rules of pluggable panes, search dependents for my tiles, and tell them to accept."

pp := self dependents detect: [:pane | pane isKindOf: PluggableTileScriptorMorph] ifNone: [^ Beeper beep]. pq := pp findA: TransformMorph. methodNode := pq findA: SyntaxMorph. cls := methodNode parsedInClass. sel := cls compile: methodNode decompile classified: self selectedCategoryName notifying: nil. self noteAcceptanceOfCodeFor: sel. self reformulateListNoting: sel.!

Item was changed: ListItemWrapper subclass: #EToyTextNodeWrapper instanceVariableNames: 'parentWrapper' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Outliner'! - category: 'EToys-Outliner'!

Item was changed: + ----- Method: StandardScriptingSystem>>colorBehindTiles (in category '*Etoys-font & color choices') ----- - ----- Method: StandardScriptingSystem>>colorBehindTiles (in category '*eToys-font & color choices') ----- colorBehindTiles ^ Color r: 0.903 g: 1.0 b: 0.903!

Item was changed: AlignmentMorph subclass: #ViewerLine instanceVariableNames: 'elementSymbol' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

!ViewerLine commentStamp: 'sw 8/28/2004 20:32' prior: 0! Serves as a wrapper around a line in a Viewer, enforcing the desired layout properties.!

Item was changed: + ----- Method: Object>>basicType (in category '*Etoys-tiles') ----- - ----- Method: Object>>basicType (in category '*eToys-tiles') ----- basicType "Answer a symbol representing the inherent type of the receiver"

^ #Object!

Item was changed: SymbolListType subclass: #UserCustomEventNameType instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-CustomEvents'! - category: 'EToys-CustomEvents'!

!UserCustomEventNameType commentStamp: 'nk 6/12/2004 14:09' prior: 0! This is a data type that enumerates user-defined custom event names.

You can turn off the display of such events in the script status popups by turning off the

allowEtoyUserCustomEvents Preference.!

Item was changed: + ----- Method: ImageMorph>>variableDocks (in category '*Etoys-player') ----- - ----- Method: ImageMorph>>variableDocks (in category '*eToys-player') ----- variableDocks "Answer a list of VariableDock objects for docking up my data with an instance held in my containing playfield"

^ Array with: (VariableDock new variableName: self defaultVariableName type: #form definingMorph: self morphGetSelector: #image morphPutSelector: #setNewImageFrom:)!

Item was changed: + ----- Method: StandardScriptingSystem>>referenceAt:put: (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>referenceAt:put: (in category '*eToys-utilities') ----- referenceAt: aSymbol put: anObject "Store a reference to anObject at the given symbol in the References directory"

^ References at: aSymbol put: anObject!

Item was changed: + ----- Method: StandardScriptingSystem>>fontForNameEditingInScriptor (in category '*Etoys-font & color choices') ----- - ----- Method: StandardScriptingSystem>>fontForNameEditingInScriptor (in category '*eToys-font & color choices') ----- fontForNameEditingInScriptor ^ Preferences standardEToysFont!

Item was changed: AbstractHierarchicalList subclass: #EToyHierarchicalTextGizmo instanceVariableNames: 'topNode' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Outliner'! - category: 'EToys-Outliner'!

!EToyHierarchicalTextGizmo commentStamp: '<historical>' prior: 0! EToyHierarchicalTextGizmo example!

Item was changed: TileMorph subclass: #RandomNumberTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

Item was changed: + ----- Method: DataType>>wantsSuffixArrow (in category '*Etoys-tiles') ----- - ----- Method: DataType>>wantsSuffixArrow (in category '*eToys-tiles') ----- wantsSuffixArrow "Answer whether a tile showing data of this type would like to have a suffix arrow"

^ false!

Item was changed: SymbolListType subclass: #ScriptNameType instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Protocols-Type Vocabularies'! - category: 'EToys-Protocols-Type Vocabularies'!

!ScriptNameType commentStamp: '<historical>' prior: 0! ScriptNameType is a data type representing selectors of user-written scripts. The choices offered as values for data of this type are all the symbols that are implemented as names of user-written scripts in the current project.!

Item was changed: + ----- Method: SketchMorph>>variableDocks (in category '*Etoys-player') ----- - ----- Method: SketchMorph>>variableDocks (in category '*eToys-player') ----- variableDocks "Answer a list of VariableDock objects for docking up my data with an instance held in my containing playfield"

^ Array with: (VariableDock new variableName: self defaultVariableName type: #form definingMorph: self morphGetSelector: #form morphPutSelector: #setNewFormFrom:)!

Item was changed: + ----- Method: PasteUpMorph>>scriptorForTextualScript:ofPlayer: (in category '*Etoys-support') ----- - ----- Method: PasteUpMorph>>scriptorForTextualScript:ofPlayer: (in category '*eToys-support') ----- scriptorForTextualScript: aSelector ofPlayer: aPlayer | aScriptor | self world ifNil: [^ nil]. aScriptor := ScriptEditorMorph new setMorph: aPlayer costume scriptName: aSelector. aScriptor position: (self primaryHand position - (10 @ 10)). ^ aScriptor!

Item was changed: AssignmentTileMorph subclass: #KedamaSetColorComponentTile instanceVariableNames: 'patchTile' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

!KedamaSetColorComponentTile commentStamp: '<historical>' prior: 0! I provide the red, green or blue component setter tile. !

Item was changed: + ----- Method: TabbedPalette>>succeededInRevealing: (in category '*Etoys-support') ----- - ----- Method: TabbedPalette>>succeededInRevealing: (in category '*eToys-e-toy support') ----- succeededInRevealing: aPlayer | result | result := super succeededInRevealing: aPlayer. result ifTrue: ["BookMorph code will have called goToPageNumber:; here, we just need to get the tab selection right here" self selectTabOfBook: self currentPalette]. ^ result!

Item was changed: + ----- Method: SketchMorph>>acquirePlayerSimilarTo: (in category '*Etoys-e-toy support') ----- - ----- Method: SketchMorph>>acquirePlayerSimilarTo: (in category '*eToys-e-toy support') ----- acquirePlayerSimilarTo: aSketchMorphsPlayer "Retrofit into the receiver a player derived from the existing scripted player of a different morph. Works only between SketchMorphs. Maddeningly complicated by potential for transformations or native sketch-morph scaling in donor or receiver or both"

| myName myTop itsTop newTop newSketch | myTop := self topRendererOrSelf. aSketchMorphsPlayer belongsToUniClass ifFalse: [^ Beeper beep]. itsTop := aSketchMorphsPlayer costume. (itsTop renderedMorph isSketchMorph) ifFalse: [^ Beeper beep].

newTop := itsTop veryDeepCopy. "May be a sketch or a tranformation" myName := myTop externalName. "Snag before the replacement is added to the world, because otherwise that could affect this"

newSketch := newTop renderedMorph. newSketch form: self form. newSketch scalePoint: self scalePoint. newSketch bounds: self bounds. myTop owner addMorph: newTop after: myTop.

newTop heading ~= myTop heading ifTrue: "avoids annoying round-off error in what follows" [newTop player setHeading: myTop heading]. (newTop isFlexMorph and: [myTop == self]) ifTrue: [newTop removeFlexShell]. newTop := newSketch topRendererOrSelf. newTop bounds: self bounds. (newTop isFlexMorph and:[myTop isFlexMorph]) ifTrue:[ "Note: This completely dumps the above #bounds: information. We need to recompute the bounds based on the transform." newTop transform: myTop transform copy. newTop computeBounds]. newTop setNameTo: myName. newTop player class bringScriptsUpToDate. myTop delete!

Item was changed: FloatArray variableWordSubclass: #KedamaFloatArray instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

Item was changed: + ----- Method: PasteUpMorph>>fenceEnabled (in category '*Etoys-support') ----- - ----- Method: PasteUpMorph>>fenceEnabled (in category '*eToys-support') ----- fenceEnabled

^ self valueOfProperty: #fenceEnabled ifAbsent: [Preferences fenceEnabled]!

Item was changed: + ----- Method: DataType>>wantsAssignmentTileVariants (in category '*Etoys-tiles') ----- - ----- Method: DataType>>wantsAssignmentTileVariants (in category '*eToys-tiles') ----- wantsAssignmentTileVariants "Answer whether an assignment tile for a variable of this type should show variants to increase-by, decrease-by, multiply-by. NumberType says yes, the rest of us say no"

^ false!

Item was changed: + ----- Method: StandardScriptingSystem>>prototypicalHolder (in category '*Etoys-parts bin') ----- - ----- Method: StandardScriptingSystem>>prototypicalHolder (in category '*eToys-parts bin') ----- prototypicalHolder | aHolder | aHolder := PasteUpMorph authoringPrototype color: Color orange muchLighter; borderColor: Color orange lighter. aHolder setNameTo: 'holder'; extent: 160 @ 110. ^ aHolder behaveLikeHolder. !

Item was changed: GenericPropertiesMorph subclass: #ObjectPropertiesMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Experimental'! - category: 'EToys-Experimental'!

Item was changed: AlignmentMorph subclass: #AllScriptsTool instanceVariableNames: 'showingOnlyActiveScripts showingAllInstances showingOnlyTopControls' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

!AllScriptsTool commentStamp: '<historical>' prior: 0! 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.!

Item was changed: MessageNode subclass: #MessagePartNode instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Tile Scriptors'! - category: 'EToys-Tile Scriptors'!

Item was changed: + ----- Method: TextMorph>>currentDataValue (in category '*Etoys-player') ----- - ----- Method: TextMorph>>currentDataValue (in category '*eToys-player') ----- currentDataValue "Answer the current data value held by the receiver"

^ text!

Item was changed: + ----- Method: StandardScriptingSystem>>standardEventStati (in category '*Etoys-customevents-custom events') ----- - ----- Method: StandardScriptingSystem>>standardEventStati (in category '*eToys-customevents-custom events') ----- standardEventStati "Answer the events that can be directed to a particular morph by its event handler." ^ #(mouseDown "run when mouse goes down on me" mouseStillDown "while mouse still down" mouseUp "when mouse comes back up" mouseEnter "when mouse enters my bounds, button up" mouseLeave "when mouse exits my bounds, button up" mouseEnterDragging "when mouse enters my bounds, button down" mouseLeaveDragging "when mouse exits my bounds, button down" "keyStroke" "gesture" ) !

Item was changed: + ----- Method: TextMorph>>setNewContentsFrom: (in category '*Etoys-card in a stack') ----- - ----- Method: TextMorph>>setNewContentsFrom: (in category '*eToys-card & stack') ----- setNewContentsFrom: stringOrTextOrNil "Using stringOrTextOrNil as a guide, set the receiver's contents afresh. If the input parameter is nil, the a default value stored in a property of the receiver, if any, will supply the new initial content. This method is only called when a VariableDock is attempting to put a new value. This is still messy and ill-understood and not ready for prime time."

| defaultValue | stringOrTextOrNil ifNotNil: [^ self newContents: stringOrTextOrNil fromCard: (self valueOfProperty: #cardInstance)]. "Well, totally yuk -- emergency measure late on eve of demo" defaultValue := self valueOfProperty: #defaultValue ifAbsent: [ | atts tt | atts := text attributesAt: 1. "Preserve size, emphasis" tt := text copyReplaceFrom: 1 to: text size with: 'blankText'. atts do: [:anAtt | tt addAttribute: anAtt]. tt]. self contents: defaultValue deepCopy wrappedTo: self width. !

Item was changed: + ----- Method: HandMorph>>trailMorph (in category '*Etoys-pen') ----- - ----- Method: HandMorph>>trailMorph (in category '*eToys-pen') ----- trailMorph "You can't draw trails when picked up by the hand." ^ nil!

Item was changed: + ----- Method: BookMorph>>succeededInRevealing: (in category '*Etoys-support') ----- - ----- Method: BookMorph>>succeededInRevealing: (in category '*eToys-e-toy support') ----- succeededInRevealing: aPlayer currentPage ifNotNil: [currentPage player == aPlayer ifTrue: [^ true]]. pages do: [:aPage | (aPage succeededInRevealing: aPlayer) ifTrue: [self goToPageMorph: aPage. ^ true]]. ^ false!

Item was changed: + ----- Method: TextMorph>>newContents:fromCard: (in category '*Etoys-card in a stack') ----- - ----- Method: TextMorph>>newContents:fromCard: (in category '*eToys-card & stack') ----- newContents: stringOrText fromCard: aCard "Accept new text contents." | newText setter |

newText := stringOrText asText. text = newText ifTrue: [^ self]. "No substantive change"

text ifNotNil: [ text embeddedMorphs do: [ :m | m delete ] ].

text := newText.

"add all morphs off the visible region; they'll be moved into the right place when they become visible. (this can make the scrollable area too large, though)" stringOrText asText embeddedMorphs do: [ :m | self addMorph: m. m position: (-1000@0)].

self releaseParagraph. "update the paragraph cache" self paragraph. "re-instantiate to set bounds"

self holdsSeparateDataForEachInstance ifTrue: [setter := self valueOfProperty: #setterSelector. setter ifNotNil: [aCard perform: setter with: newText]].

self world ifNotNil: [self world startSteppingSubmorphsOf: self ]. !

Item was changed: + ----- Method: GraphicType>>typeColor (in category '*Etoys-color') ----- - ----- Method: GraphicType>>typeColor (in category '*eToys-color') ----- typeColor "Answer the color for tiles to be associated with objects of this type"

^ self subduedColorFromTriplet: #(0.806 1.0 0.806) !

Item was changed: + ----- Method: TextFieldMorph>>variableDocks (in category '*Etoys-player') ----- - ----- Method: TextFieldMorph>>variableDocks (in category '*eToys-player') ----- variableDocks "Answer a list of VariableDock objects for docking up my data with an instance held in my containing playfield"

^ Array with: (VariableDock new variableName: self defaultVariableName type: #text definingMorph: self morphGetSelector: #contents morphPutSelector: #setNewContentsFrom:)!

Item was changed: Player subclass: #CardPlayer instanceVariableNames: 'privateMorphs' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Stacks'! - category: 'EToys-Stacks'! CardPlayer class instanceVariableNames: 'variableDocks'!

!CardPlayer commentStamp: '<historical>' prior: 0! CardPlayer Instance variables of the Uniclass represent the data in the "fields" of each card in the stack. Each Instance variable is some kind of value holder.

The code for the *buttons* on the background resides in the CardPlayer uniclass.

privateMorphs -- OrderedCollection of objects specific to this card.

Individual CardPlayer classes need to store the search results of any instances that are templates. As a hack, we use a class variable TemplateMatches in each individual class (CardPlayer21). It is initialized in #matchIndex:. TemplateMatches an IndentityDictionary of (aCardPlayer -> (list of matching cards, index in that list)) ! CardPlayer class instanceVariableNames: 'variableDocks'!

Item was changed: + ----- Method: PasteUpMorph>>makeAllScriptEditorsReferToMasters (in category '*Etoys-world menu') ----- - ----- Method: PasteUpMorph>>makeAllScriptEditorsReferToMasters (in category '*eToys-world menu') ----- makeAllScriptEditorsReferToMasters "Ensure that all script editors refer to the first (by alphabetical externalName) Player among the list of siblings"

(self presenter allExtantPlayers groupBy: [ :p | p class ] having: [ :p | true ]) do: [ :group | group first allScriptEditors ]!

Item was changed: Model subclass: #ScriptingDomain instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

Item was changed: + ----- Method: TheWorldMenu>>scriptingMenu (in category '*Etoys') ----- - ----- Method: TheWorldMenu>>scriptingMenu (in category '*EToys') ----- scriptingMenu "Build the authoring-tools menu for the world."

^ self fillIn: (self menu: 'authoring tools...') from: { { 'objects (o)' . { #myWorld . #activateObjectsTool }. 'A searchable source of new objects.'}. nil. "----------" { 'view trash contents' . { #myWorld . #openScrapsBook:}. 'The place where all your trashed morphs go.'}. { 'empty trash can' . { Utilities . #emptyScrapsBook}. 'Empty out all the morphs that have accumulated in the trash can.'}. nil. "----------"

{ 'new scripting area' . { #myWorld . #detachableScriptingSpace}. 'A window set up for simple scripting.'}.

nil. "----------" { 'status of scripts' . {#myWorld . #showStatusOfAllScripts}. 'Lets you view the status of all the scripts belonging to all the scripted objects of the project.'}. { 'summary of scripts' . {#myWorld . #printScriptSummary}. 'Produces a summary of scripted objects in the project, and all of their scripts.'}. { 'browser for scripts' . {#myWorld . #browseAllScriptsTextually}. 'Allows you to view all the scripts in the project in a traditional programmers'' "browser" format'}.

nil.

{ 'gallery of players' . {#myWorld . #galleryOfPlayers}. 'A tool that lets you find out about all the players used in this project'}.

" { 'gallery of scripts' . {#myWorld . #galleryOfScripts}. 'Allows you to view all the scripts in the project'}."

{ 'etoy vocabulary summary' . {#myWorld . #printVocabularySummary }. 'Displays a summary of all the pre-defined commands and properties in the pre-defined EToy vocabulary.'}.

{ 'attempt misc repairs' . {#myWorld . #attemptCleanup}. 'Take measures that may help fix up some things about a faulty or problematical project.'}.

{ 'remove all viewers' . {#myWorld . #removeAllViewers}. 'Remove all the Viewers from this project.'}.

{ 'refer to masters' . {#myWorld . #makeAllScriptEditorsReferToMasters }. 'Ensure that all script editors are referring to the first (alphabetically by external name) Player of their type' }.

nil. "----------"

{ 'unlock locked objects' . { #myWorld . #unlockContents}. 'If any items on the world desktop are currently locked, unlock them.'}. { 'unhide hidden objects' . { #myWorld . #showHiders}. 'If any items on the world desktop are currently hidden, make them visible.'}. }!

Item was changed: + ----- Method: StandardScriptingSystem>>stopUp:with: (in category '*Etoys-script-control') ----- - ----- Method: StandardScriptingSystem>>stopUp:with: (in category '*eToys-script-control') ----- stopUp: dummy with: theButton | aPresenter | (aPresenter := theButton presenter) flushPlayerListCache. "catch guys not in cache but who're running" aPresenter stopRunningScriptsFrom: theButton!

Item was changed: AlignmentMorph subclass: #TileLikeMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

Item was changed: + ----- Method: BooleanType>>defaultArgumentTile (in category '*Etoys-tiles') ----- - ----- Method: BooleanType>>defaultArgumentTile (in category '*eToys-tiles') ----- defaultArgumentTile "Answer a tile to represent the type"

^ true newTileMorphRepresentative typeColor: self typeColor!

Item was changed: + ----- Method: Morph>>triggerEtoyEvent:from: (in category '*Etoys-customevents-scripting') ----- - ----- Method: Morph>>triggerEtoyEvent:from: (in category '*eToys-customevents-scripting') ----- triggerEtoyEvent: aSymbol from: aMorph "Trigger whatever scripts may be connected to the event named aSymbol. If anyone comes back to ask who sent it, return aMorph's player."

[ self triggerEvent: aSymbol ] on: GetTriggeringObjectNotification do: [ :ex | ex isNested ifTrue: [ ex pass ] ifFalse: [ ex resume: aMorph assuredPlayer ]] !

Item was changed: + ----- Method: StandardScriptingSystem>>uniqueNameForReference (in category '*Etoys-viewer') ----- - ----- Method: StandardScriptingSystem>>uniqueNameForReference (in category '*eToys-viewer') ----- uniqueNameForReference "Answer a more-or-less global name by which the receiver can be referred to in scripts"

^ #ScriptingSystem!

Item was changed: + ----- Method: WeakMessageSend>>asTilesIn: (in category '*Etoys-tiles') ----- - ----- Method: WeakMessageSend>>asTilesIn: (in category '*eToys-tiles') ----- asTilesIn: playerClass ^self asMessageSend asTilesIn: playerClass !

Item was changed: + ----- Method: NumberType>>defaultArgumentTile (in category '*Etoys-tiles') ----- - ----- Method: NumberType>>defaultArgumentTile (in category '*eToys-tiles') ----- defaultArgumentTile "Answer a tile to represent the type"

^ 5 newTileMorphRepresentative typeColor: self typeColor!

Item was changed: + ----- Method: Vocabulary>>subduedColorFrom: (in category '*Etoys-color') ----- - ----- Method: Vocabulary>>subduedColorFrom: (in category '*eToys-color') ----- subduedColorFrom: aColor "Answer a subdued color derived from the given color"

^ aColor mixed: ScriptingSystem colorFudge with: ScriptingSystem uniformTileInteriorColor!

Item was changed: + ----- Method: StandardScriptingSystem>>stepStillDown:with: (in category '*Etoys-script-control') ----- - ----- Method: StandardScriptingSystem>>stepStillDown:with: (in category '*eToys-script-control') ----- stepStillDown: dummy with: theButton theButton presenter stepStillDown: dummy with: theButton!

Item was changed: + ----- Method: ImageMorph>>wearCostume: (in category '*Etoys-other') ----- - ----- Method: ImageMorph>>wearCostume: (in category '*eToys-other') ----- wearCostume: anotherMorph

self image: anotherMorph form. !

Item was changed: + ----- Method: SketchMorph>>wearCostume: (in category '*Etoys-accessing') ----- - ----- Method: SketchMorph>>wearCostume: (in category '*eToys-accessing') ----- wearCostume: anotherMorph

self form: anotherMorph form. !

Item was changed: TileMorph subclass: #MenuTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

!MenuTile commentStamp: '<historical>' prior: 0! A tile representing a menu item!

Item was changed: + ----- Method: ImageMorph>>currentDataValue (in category '*Etoys-player') ----- - ----- Method: ImageMorph>>currentDataValue (in category '*eToys-player') ----- currentDataValue "Answer the current data value of the receiver, to be stored in each card instance if appropriate"

^ image!

Item was changed: + ----- Method: StandardScriptingSystem>>reclaimSpace (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>reclaimSpace (in category '*eToys-utilities') ----- reclaimSpace "Reclaim space from the scripting system, and report the result in an informer" "ScriptingSystem reclaimSpace"

| reclaimed | (reclaimed := self spaceReclaimed) > 0 ifTrue: [self inform: reclaimed printString, ' bytes reclaimed'] ifFalse: [self inform: 'Hmm... Nothing gained this time.']!

Item was changed: + ----- Method: Morph>>triggerCustomEvent: (in category '*Etoys-customevents-scripting') ----- - ----- Method: Morph>>triggerCustomEvent: (in category '*eToys-customevents-scripting') ----- triggerCustomEvent: aSymbol "Trigger whatever scripts may be connected to the custom event named aSymbol"

self currentWorld triggerEtoyEvent: aSymbol from: self!

Item was changed: 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' classVariableNames: 'RandomSeed' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

!KedamaMorph commentStamp: 'yo 6/18/2004 18:29' prior: 0! A tile-scriptable variant of StarSqueak. !

Item was changed: + ----- Method: StandardScriptingSystem>>resetStandardPartsBin (in category '*Etoys-parts bin') ----- - ----- Method: StandardScriptingSystem>>resetStandardPartsBin (in category '*eToys-parts bin') ----- resetStandardPartsBin "ScriptingSystem resetStandardPartsBin"

StandardPartsBin := nil!

Item was changed: + ----- Method: StandardScriptingSystem>>acceptableSlotNameFrom:forSlotCurrentlyNamed:asSlotNameIn:world: (in category '*Etoys-universal slots & scripts') ----- - ----- Method: StandardScriptingSystem>>acceptableSlotNameFrom:forSlotCurrentlyNamed:asSlotNameIn:world: (in category '*eToys-universal slots & scripts') ----- acceptableSlotNameFrom: originalString forSlotCurrentlyNamed: currentName asSlotNameIn: aPlayer world: aWorld "Produce an acceptable slot name, derived from the current name, for aPlayer. This method will always return a valid slot name that will be suitable for use in the given situation, though you might not like its beauty sometimes."

| aString stemAndSuffix proscribed stem suffix putative | aString := originalString asIdentifier: false. "get an identifier not lowercase" stemAndSuffix := aString stemAndNumericSuffix. proscribed := #(self super thisContext costume costumes dependents #true #false size), aPlayer class allInstVarNames.

stem := stemAndSuffix first. suffix := stemAndSuffix last. putative := aString asSymbol. [(putative ~~ currentName) and: [(proscribed includes: putative) or: [(aPlayer respondsTo: putative) or: [Smalltalk includesKey: putative]]]] whileTrue: [suffix := suffix + 1. putative := (stem, suffix printString) asSymbol]. ^ putative!

Item was changed: + ----- Method: SketchMorph>>currentDataValue (in category '*Etoys-player') ----- - ----- Method: SketchMorph>>currentDataValue (in category '*eToys-player') ----- currentDataValue "Answer the object which bears the current datum for the receiver"

^ originalForm!

Item was changed: + ----- Method: SketchMorph>>heading: (in category '*Etoys-geometry eToy') ----- - ----- Method: SketchMorph>>heading: (in category '*eToys-geometry eToy') ----- heading: newHeading "If not rotating normally, change forward direction rather than heading" rotationStyle == #normal ifTrue:[^super heading: newHeading]. self isFlexed ifTrue:[self forwardDirection: newHeading - owner rotationDegrees] ifFalse:[self forwardDirection: newHeading]. self layoutChanged!

Item was changed: + ----- Method: StandardScriptingSystem>>newScriptingSpace (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>newScriptingSpace (in category '*eToys-utilities') ----- newScriptingSpace "Answer a complete scripting space - raa 19 sept 2000 - experiment for Alan, a variant *not* in a window, now adopted as the only true scripting space"

^ self newScriptingSpace2!

Item was changed: RectangleMorph subclass: #UpdatingRectangleMorph instanceVariableNames: 'target lastValue getSelector putSelector contents' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Support'! - category: 'EToys-Scripting Support'!

!UpdatingRectangleMorph commentStamp: '<historical>' prior: 0! Intended for use as a color swatch coupled to a color obtained from the target, but made just slightly more general than that.!

Item was changed: + ----- Method: ServerDirectory>>eToyUserListUrl (in category '*Etoys-school support') ----- - ----- Method: ServerDirectory>>eToyUserListUrl (in category '*eToys-school support') ----- eToyUserListUrl ^eToyUserListUrl!

Item was changed: + ----- Method: ProjectViewMorph>>eToyStreamedRepresentationNotifying: (in category '*Etoys-user interface') ----- - ----- Method: ProjectViewMorph>>eToyStreamedRepresentationNotifying: (in category '*eToys-user interface') ----- eToyStreamedRepresentationNotifying: aWidget

| safeVariant outData |

self flag: #bob. "probably irrelevant" safeVariant := self copy. [ outData := SmartRefStream streamedRepresentationOf: safeVariant ] on: ProgressInitiationException do: [ :ex | ex sendNotificationsTo: [ :min :max :curr | aWidget ifNotNil: [aWidget flashIndicator: #working]. ]. ]. ^outData !

Item was changed: + ----- Method: Vocabulary>>typeColor (in category '*Etoys-queries') ----- - ----- Method: Vocabulary>>typeColor (in category '*eToys-queries') ----- typeColor "Answer the color for tiles to be associated with objects of this type"

^ self subduedColorFrom: Color green!

Item was changed: + ----- Method: SoundType>>setFormatForDisplayer: (in category '*Etoys-tiles') ----- - ----- Method: SoundType>>setFormatForDisplayer: (in category '*eToys-tiles') ----- setFormatForDisplayer: aDisplayer "Set up the displayer to have the right format characteristics"

aDisplayer useStringFormat !

Item was changed: + ----- Method: PasteUpMorph>>fenceEnabledString (in category '*Etoys-support') ----- - ----- Method: PasteUpMorph>>fenceEnabledString (in category '*eToys-support') ----- fenceEnabledString "Answer the string to be shown in a menu to represent the fence enabled status" ^ (self fenceEnabled ifTrue: ['<on>'] ifFalse: ['<off>']) , 'fence enabled' translated!

Item was changed: + ----- Method: SketchMorph>>basicType (in category '*Etoys-tiles') ----- - ----- Method: SketchMorph>>basicType (in category '*eToys-tiles') ----- basicType "Answer a symbol representing the inherent type I hold"

"Number String Boolean player collection sound color etc" ^ #Image!

Item was changed: + ----- Method: StandardScriptingSystem>>reinvigorateThumbnailsInViewerFlapTabs (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>reinvigorateThumbnailsInViewerFlapTabs (in category '*eToys-utilities') ----- reinvigorateThumbnailsInViewerFlapTabs "It has happened that the thumbnail in a viewer flap tab will go solid gray because it got associated with some passing and disused player temporarily created during the initial painting process. This method takes a sledge hammer to repair such thumbnails. At its genesis, this method is called only from the postscript of its defining fileout." ViewerFlapTab allInstancesDo: [:aTab | | vwr thumbnail | vwr := aTab referent findA: StandardViewer. thumbnail := aTab findA: ThumbnailMorph. (vwr notNil and: [thumbnail notNil]) ifTrue: [thumbnail objectToView: vwr scriptedPlayer]]

"ScriptingSystem reinvigorateThumbnailsInViewerFlapTabs"!

Item was changed: + ----- Method: Inspector>>tearOffTile (in category '*Etoys-menu commands') ----- - ----- Method: Inspector>>tearOffTile (in category '*eToys-menu commands') ----- tearOffTile "Tear off a tile that refers to the receiver's selection, and place it in the mophic hand"

| objectToRepresent | objectToRepresent := self selectionIndex == 0 ifTrue: [object] ifFalse: [self selection]. self currentHand attachMorph: (TileMorph new referTo: objectToRepresent) !

Item was changed: + ----- Method: PaintInvokingMorph>>isCandidateForAutomaticViewing (in category '*Etoys-support') ----- - ----- Method: PaintInvokingMorph>>isCandidateForAutomaticViewing (in category '*eToys-e-toy support') ----- isCandidateForAutomaticViewing ^ self isPartsDonor not!

Item was changed: + ----- Method: FullVocabulary>>typeColor (in category '*Etoys-initialization') ----- - ----- Method: FullVocabulary>>typeColor (in category '*eToys-initialization') ----- typeColor "Answer the color for tiles to be associated with objects of this type"

^ self subduedColorFromTriplet: #(1.0 0.26 0.98) !

Item was changed: UpdatingRectangleMorph subclass: #ColorSwatch instanceVariableNames: 'argument' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Support'! - category: 'EToys-Scripting Support'!

Item was changed: + ----- Method: StandardScriptingSystem>>goUp:with: (in category '*Etoys-script-control') ----- - ----- Method: StandardScriptingSystem>>goUp:with: (in category '*eToys-script-control') ----- goUp: evt with: aGoButton aGoButton presenter startRunningScriptsFrom: aGoButton!

Item was changed: + ----- Method: PasteUpMorph>>hideAllPlayers (in category '*Etoys-world menu') ----- - ----- Method: PasteUpMorph>>hideAllPlayers (in category '*eToys-world menu') ----- hideAllPlayers

| a | a := OrderedCollection new. self allMorphsDo: [ :x | (x isKindOf: ViewerFlapTab) ifTrue: [a add: x] ]. a do: [ :each | each delete]. !

Item was changed: + ----- Method: TextFieldMorph>>currentDataValue (in category '*Etoys-player') ----- - ----- Method: TextFieldMorph>>currentDataValue (in category '*eToys-player') ----- currentDataValue "Answer the current data value held by the receiver"

^ self contents!

Item was changed: + ----- Method: TextFieldMorph>>setNewContentsFrom: (in category '*Etoys-card in a stack') ----- - ----- Method: TextFieldMorph>>setNewContentsFrom: (in category '*eToys-card & stack') ----- setNewContentsFrom: textOrString "talk to my text" | tm |

(tm := self findA: TextMorph) ifNil: [^ nil]. tm valueOfProperty: #cardInstance ifAbsent: ["move it down" tm setProperty: #cardInstance toValue: (self valueOfProperty: #cardInstance)]. tm valueOfProperty: #holdsSeparateDataForEachInstance ifAbsent: ["move it down" tm setProperty: #holdsSeparateDataForEachInstance toValue: (self valueOfProperty: #holdsSeparateDataForEachInstance)]. ^ tm setNewContentsFrom: textOrString!

Item was changed: AssignmentTileMorph subclass: #KedamaSetPixelValueTile instanceVariableNames: 'patchTile' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

!KedamaSetPixelValueTile commentStamp: 'yo 6/18/2004 18:32' prior: 0! I provide the special tile of 'patchValueIn' setter. !

Item was changed: + ----- Method: FlapTab>>isCandidateForAutomaticViewing (in category '*Etoys-support') ----- - ----- Method: FlapTab>>isCandidateForAutomaticViewing (in category '*eToys-e-toy support') ----- isCandidateForAutomaticViewing ^ false!

Item was changed: TextContainer subclass: #SimplerTextContainer instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Outliner'! - category: 'EToys-Outliner'!

Item was changed: TileMorph subclass: #KedamaBounceOnTile instanceVariableNames: 'playerTile' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

Item was changed: AlignmentMorphBob1 subclass: #EtoyLoginMorph instanceVariableNames: 'theName theNameMorph actionBlock cancelBlock' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Experimental'! - category: 'EToys-Experimental'!

Item was changed: + ----- Method: CodeHolder>>showTiles: (in category '*Etoys-tiles') ----- - ----- Method: CodeHolder>>showTiles: (in category '*eToys-tiles') ----- showTiles: aBoolean "Set the showingTiles as indicated. The fact that there are initially no senders of this reflects that fact that initially this trait is only directly settable through the UI; later there may be senders, such as if one wanted to set a system up so that all newly-opened browsers showed tiles rather than text."

aBoolean ifTrue: [contentsSymbol := #tiles] ifFalse: [contentsSymbol == #tiles ifTrue: [contentsSymbol := #source]]. self setContentsToForceRefetch. self changed: #contents!

Item was changed: + ----- Method: StandardScriptingSystem>>patchInNewStandardPlayerForm (in category '*Etoys-form dictionary') ----- - ----- Method: StandardScriptingSystem>>patchInNewStandardPlayerForm (in category '*eToys-form dictionary') ----- patchInNewStandardPlayerForm "Patch in a darker and larger representation of a Dot. No senders -- called from the postscript of an update"

"ScriptingSystem patchInNewStandardPlayerForm"

FormDictionary at: #standardPlayer put: (Form extent: 13@13 depth: 16 fromArray: #( 0 0 0 65536 0 0 0 0 0 65537 65537 65536 0 0 0 65537 65537 65537 65537 65536 0 0 65537 65537 65537 65537 65536 0 1 65537 65537 65537 65537 65537 0 1 65537 65537 65537 65537 65537 0 65537 65537 65537 65537 65537 65537 65536 1 65537 65537 65537 65537 65537 0 1 65537 65537 65537 65537 65537 0 0 65537 65537 65537 65537 65536 0 0 65537 65537 65537 65537 65536 0 0 0 65537 65537 65536 0 0 0 0 0 65536 0 0 0) offset: 0@0)!

Item was changed: + ----- Method: StandardScriptingSystem>>uniformTileInteriorColor (in category '*Etoys-font & color choices') ----- - ----- Method: StandardScriptingSystem>>uniformTileInteriorColor (in category '*eToys-font & color choices') ----- uniformTileInteriorColor ^ Color r: 0.806 g: 1.0 b: 0.806!

Item was changed: + ----- Method: StandardScriptingSystem>>tileForArgType: (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>tileForArgType: (in category '*eToys-utilities') ----- tileForArgType: aType "Anwer a default tile to represent a datum of the given argument type, which may be either a symbol (e.g. #Color) or a class"

(aType isKindOf: Class) "Allowed in Ted's work" ifTrue: [^ aType name asString newTileMorphRepresentative typeColor: Color gray].

^ (Vocabulary vocabularyForType: aType) defaultArgumentTile!

Item was changed: IndentingListItemMorph subclass: #IndentingListParagraphMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Outliner'! - category: 'EToys-Outliner'!

Item was changed: AlignmentMorph subclass: #SyntaxMorph instanceVariableNames: 'parseNode markerMorph' classVariableNames: 'AllSpecs ContrastFactor DownRightArrow SelfTile SizeScaleFactor' poolDictionaries: '' + category: 'Etoys-Tile Scriptors'! - category: 'EToys-Tile Scriptors'!

!SyntaxMorph commentStamp: '<historical>' prior: 0! 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. !

Item was changed: + ----- Method: StandardScriptingSystem>>cleanupsForRelease (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>cleanupsForRelease (in category '*eToys-utilities') ----- cleanupsForRelease "Miscellaneous space cleanups to do before a release." "EToySystem cleanupsForRelease"

Socket deadServer: ''. "Don't reveal any specific server name" HandMorph initialize. "free cached ColorChart" PaintBoxMorph initialize. "forces Prototype to let go of extra things it might hold" Smalltalk removeKey: #AA ifAbsent: []. Smalltalk removeKey: #BB ifAbsent: []. Smalltalk removeKey: #CC ifAbsent: []. Smalltalk removeKey: #DD ifAbsent: []. Smalltalk removeKey: #Temp ifAbsent: [].

ScriptingSystem reclaimSpace. Smalltalk cleanOutUndeclared. Smalltalk reclaimDependents. Smalltalk forgetDoIts. Smalltalk removeEmptyMessageCategories. Symbol rehash!

Item was changed: + ----- Method: PolygonMorph>>heading: (in category '*Etoys-geometry') ----- - ----- Method: PolygonMorph>>heading: (in category '*eToys-geometry eToy') ----- heading: newHeading "Set the receiver's heading (in eToy terms). Note that polygons never use flex shells." self rotationDegrees: newHeading.!

Item was changed: + ----- Method: HaloMorph>>doMakeSiblingOrDup:with: (in category '*Etoys-handles') ----- - ----- Method: HaloMorph>>doMakeSiblingOrDup:with: (in category '*eToys-handles') ----- doMakeSiblingOrDup: evt with: dupHandle "Ask hand to duplicate my target, if shift key *is* pressed, or make a sibling if shift key *not* pressed"

^ (evt shiftPressed or: [target couldMakeSibling not]) ifFalse: [self doMakeSibling: evt with: dupHandle] ifTrue: [dupHandle color: Color green. self doDup: evt with: dupHandle]!

Item was changed: + ----- Method: PluggableTextMorphWithModel>>variableDocks (in category '*Etoys-player') ----- - ----- Method: PluggableTextMorphWithModel>>variableDocks (in category '*eToys-player') ----- variableDocks "Answer a list of VariableDocks that will handle the interface between me and instance data stored on my behalf on a card"

^ Array with: (VariableDock new variableName: self defaultVariableName type: #text definingMorph: self morphGetSelector: #getMyText morphPutSelector: #setMyText:)!

Item was changed: TileMorph subclass: #KedamaBounceOnColorTile instanceVariableNames: 'playerTile colorTile' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

Item was changed: + ----- Method: DataType>>addExtraItemsToMenu:forSlotSymbol: (in category '*Etoys-tiles') ----- - ----- Method: DataType>>addExtraItemsToMenu:forSlotSymbol: (in category '*eToys-tiles') ----- addExtraItemsToMenu: aMenu forSlotSymbol: slotSym "If the receiver has extra menu items to add to the slot menu, here is its chance to do it"!

Item was changed: + ----- Method: SystemDictionary>>vocabularyDemanded (in category '*Etoys-copying') ----- - ----- Method: SystemDictionary>>vocabularyDemanded (in category '*eToys-copying') ----- vocabularyDemanded "Answer the vocabulary that the receiver really would like to use in a Viewer"

^ Vocabulary vocabularyNamed: #System!

Item was changed: + ----- Method: SoundType>>newReadoutTile (in category '*Etoys-tiles') ----- - ----- Method: SoundType>>newReadoutTile (in category '*eToys-tiles') ----- newReadoutTile "Answer a tile that can serve as a readout for data of this type"

^ SoundReadoutTile new typeColor: Color lightGray lighter!

Item was changed: + ----- Method: WeakMessageSend>>stringFor: (in category '*Etoys-tiles') ----- - ----- Method: WeakMessageSend>>stringFor: (in category '*eToys-tiles') ----- stringFor: anObject ^self asMessageSend stringFor: anObject !

Item was changed: AlignmentMorphBob1 subclass: #StretchyImageMorph instanceVariableNames: 'form cache' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Experimental'! - category: 'EToys-Experimental'!

!StretchyImageMorph commentStamp: '<historical>' prior: 0! I draw a form to fill whatever bounds I have.!

Item was changed: + ----- Method: CollapsedMorph>>isMyUncollapsedMorph: (in category '*Etoys-queries') ----- - ----- Method: CollapsedMorph>>isMyUncollapsedMorph: (in category '*eToys-queries') ----- isMyUncollapsedMorph: aMorph "Answer whether my uncollapsed morph is aMorph"

^ uncollapsedMorph == aMorph!

Item was changed: + ----- Method: HaloMorph>>doDupOrMakeSibling:with: (in category '*Etoys-handles') ----- - ----- Method: HaloMorph>>doDupOrMakeSibling:with: (in category '*eToys-handles') ----- doDupOrMakeSibling: evt with: dupHandle "Ask hand to duplicate my target, if shift key *not* pressed, or make a sibling if shift key *is* pressed"

^ (evt shiftPressed and: [target couldMakeSibling]) ifTrue: [dupHandle color: Color green muchDarker. self doMakeSibling: evt with: dupHandle] ifFalse: [self doDup: evt with: dupHandle]!

Item was added: + SystemOrganization addCategory: #'Etoys-Buttons'! + SystemOrganization addCategory: #'Etoys-CustomEvents'! + SystemOrganization addCategory: #'Etoys-Experimental'! + SystemOrganization addCategory: #'Etoys-Outliner'! + SystemOrganization addCategory: #'Etoys-Protocols'! + SystemOrganization addCategory: #'Etoys-Protocols-Type Vocabularies'! + SystemOrganization addCategory: #'Etoys-Scripting'! + SystemOrganization addCategory: #'Etoys-Scripting Support'! + SystemOrganization addCategory: #'Etoys-Scripting Tiles'! + SystemOrganization addCategory: #'Etoys-Stacks'! + SystemOrganization addCategory: #'Etoys-StarSqueak'! + SystemOrganization addCategory: #'Etoys-Tile Scriptors'! + SystemOrganization addCategory: #'Etoys-Widgets'!

Item was changed: + ----- Method: StandardScriptingSystem>>stopButton (in category '*Etoys-script-control') ----- - ----- Method: StandardScriptingSystem>>stopButton (in category '*eToys-script-control') ----- stopButton "Answer a new button that can serve as a stop button" | aButton | aButton := ThreePhaseButtonMorph new. aButton image: (ScriptingSystem formAtKey: 'StopPic'); offImage: (ScriptingSystem formAtKey: 'StopPic'); pressedImage: (ScriptingSystem formAtKey: 'StopPicOn'). aButton actionSelector: #stopUp:with:; arguments: (Array with: nil with: aButton); actWhen: #buttonUp; target: self; setNameTo: 'Stop Button'; setBalloonText: 'Pause all ticking scripts.' translated. ^ aButton!

Item was changed: + ----- Method: UndefinedObject>>newTileMorphRepresentative (in category '*Etoys-tiles') ----- - ----- Method: UndefinedObject>>newTileMorphRepresentative (in category '*eToys-tiles') ----- newTileMorphRepresentative ^ UndescribedTile new!

Item was changed: + ----- Method: StandardScriptingSystem>>spaceReclaimed (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>spaceReclaimed (in category '*eToys-utilities') ----- spaceReclaimed "Reclaim space from the EToy system, and return the number of bytes reclaimed" "ScriptingSystem spaceReclaimed"

| oldFree | oldFree := Smalltalk garbageCollect. ThumbnailMorph recursionReset. Player removeUninstantiatedSubclassesSilently. Smalltalk cleanOutUndeclared. Smalltalk reclaimDependents. ^ Smalltalk garbageCollect - oldFree.!

Item was changed: + ----- Method: StandardScriptingSystem>>restoreClassicEToyLook (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>restoreClassicEToyLook (in category '*eToys-utilities') ----- restoreClassicEToyLook "Restore classic EToy look, as closely as possible. If ComicBold is present, restore it as the standard etoy and button font. Substitute ComicSansMS and Accuny as respective alternatives if the classic fonts are absent. If those also aren't available, do nothing."

| aTextStyle aFont | (aTextStyle := TextStyle named: #ComicBold) ifNotNil: [aFont := aTextStyle fontOfSize: 16. Preferences setEToysFontTo: aFont. Preferences setButtonFontTo: aFont] ifNil: [(aTextStyle := TextStyle named: #ComicSansMS) ifNotNil: [Preferences setEToysFontTo: (aTextStyle fontOfSize: 18)]. (aTextStyle := TextStyle named: #Accuny) ifNotNil: [Preferences setButtonFontTo: (aTextStyle fontOfSize: 12)]].

(aTextStyle := TextStyle named: #NewYork) ifNotNil: [Preferences setSystemFontTo: (aTextStyle fontOfSize: 12)]!

Item was changed: + ----- Method: PasteUpMorph>>removeUserCustomEventNamed: (in category '*Etoys-customevents-scripting') ----- - ----- Method: PasteUpMorph>>removeUserCustomEventNamed: (in category '*eToys-customevents-scripting') ----- removeUserCustomEventNamed: aSymbol ^self userCustomEventsRegistry removeKey: aSymbol ifAbsent: [].!

Item was changed: + ----- Method: DataType>>wantsArrowsOnTiles (in category '*Etoys-tiles') ----- - ----- Method: DataType>>wantsArrowsOnTiles (in category '*eToys-tiles') ----- wantsArrowsOnTiles "Answer whether this data type wants up/down arrows on tiles representing its values"

^ true!

Item was changed: + ----- Method: Boolean>>newTileMorphRepresentative (in category '*Etoys-tiles') ----- - ----- Method: Boolean>>newTileMorphRepresentative (in category '*eToys-tiles') ----- newTileMorphRepresentative ^ TileMorph new addArrows; setLiteral: self !

Item was changed: + ----- Method: SketchMorph>>asWearableCostume (in category '*Etoys-e-toy support') ----- - ----- Method: SketchMorph>>asWearableCostume (in category '*eToys-e-toy support') ----- asWearableCostume "Return a wearable costume for some player" ^(World drawingClass withForm: originalForm) copyCostumeStateFrom: self!

Item was changed: TileMorph subclass: #KedamaDistanceToTile instanceVariableNames: 'turtleTile' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

!KedamaDistanceToTile commentStamp: 'yo 6/18/2004 18:30' prior: 0! I provide the special tile of 'distance to'. !

Item was changed: + ----- Method: StandardScriptingSystem>>goButton (in category '*Etoys-script-control') ----- - ----- Method: StandardScriptingSystem>>goButton (in category '*eToys-script-control') ----- goButton | aButton | aButton := ThreePhaseButtonMorph new. aButton image: (ScriptingSystem formAtKey: 'GoPicOn'); offImage: (ScriptingSystem formAtKey: 'GoPic'); pressedImage: (ScriptingSystem formAtKey: 'GoPicOn'); actionSelector: #goUp:with:; arguments: (Array with: nil with: aButton); actWhen: #buttonUp; target: self; setNameTo: 'Go Button'; setBalloonText: 'Resume running all paused scripts' translated. ^ aButton!

Item was changed: + ----- Method: UpdatingStringMorph>>variableDocks (in category '*Etoys-player') ----- - ----- Method: UpdatingStringMorph>>variableDocks (in category '*eToys-player') ----- variableDocks "Answer a list of VariableDock objects for docking up my data with an instance held in my containing playfield. For a numeric-readout tile."

"Is CardPlayer class holding my variableDock, or should I be using the caching mechanism in Morph>>variableDocks?" ^ Array with: (VariableDock new variableName: (getSelector allButFirst: 3) withFirstCharacterDownshifted type: #number definingMorph: self morphGetSelector: #valueFromContents morphPutSelector: #acceptValue:)!

Item was changed: TextMorph subclass: #ShowEmptyTextMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Experimental'! - category: 'EToys-Experimental'!

!ShowEmptyTextMorph commentStamp: '<historical>' prior: 0! A slight modification on TextMorph to show empty fields just as one would fields with data: with a cursor and without the pink field!

Item was changed: + ----- Method: String>>newTileMorphRepresentative (in category '*Etoys-tiles') ----- - ----- Method: String>>newTileMorphRepresentative (in category '*eToys-tiles') ----- newTileMorphRepresentative ^ TileMorph new setLiteral: self;addSuffixIfCan!

Item was changed: RectangleMorph subclass: #TileMorph instanceVariableNames: 'type slotName literal operatorOrExpression actualObject downArrow upArrow suffixArrow typeColor lastArrowTick nArrowTicks operatorReadoutString possessive retractArrow vocabulary vocabularySymbol' classVariableNames: 'DownPicture RetractPicture SuffixArrowAllowance SuffixPicture UpArrowAllowance UpPicture UpdatingOperators' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

!TileMorph commentStamp: '<historical>' prior: 0! 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.!

Item was changed: + ----- Method: PluggableTextMorph>>eToyGetMainFont (in category '*Etoys-model access') ----- - ----- Method: PluggableTextMorph>>eToyGetMainFont (in category '*eToys-model access') ----- eToyGetMainFont

^ textMorph textStyle!

Item was changed: + ----- Method: Morph>>removeEventTrigger:for: (in category '*Etoys-customevents-scripting') ----- - ----- Method: Morph>>removeEventTrigger:for: (in category '*eToys-customevents-scripting') ----- removeEventTrigger: aSymbol for: aPlayer "Remove all the event registrations for aPlayer that are triggered by aSymbol. User custom events are triggered at the World, while system custom events are triggered on individual Morphs." self removeActionsSatisfying: [:action | action receiver == aPlayer and: [(#(#doScript: #triggerScript: ) includes: action selector) and: [action arguments first == aSymbol]]]!

Item was changed: + ----- Method: StandardScriptingSystem>>statusColorSymbolFor: (in category '*Etoys-font & color choices') ----- - ----- Method: StandardScriptingSystem>>statusColorSymbolFor: (in category '*eToys-font & color choices') ----- statusColorSymbolFor: statusSymbol #( (normal green) (ticking blue) (paused red) (mouseDown yellow) (mouseStillDown lightYellow) (mouseUp lightBlue) (mouseEnter lightBrown) (mouseLeave lightRed) (mouseEnterDragging lightGray) (mouseLeaveDragging darkGray) (keyStroke lightGreen)) do:

[:pair | statusSymbol == pair first ifTrue: [^ pair second]].

^ #blue!

Item was changed: DataType subclass: #PlayerType instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Protocols-Type Vocabularies'! - category: 'EToys-Protocols-Type Vocabularies'!

Item was changed: AlignmentMorph subclass: #ScriptStatusLine instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

Item was changed: + ----- Method: ColorType>>typeColor (in category '*Etoys-color') ----- - ----- Method: ColorType>>typeColor (in category '*eToys-color') ----- typeColor "Answer the color for tiles to be associated with objects of this type"

^ self subduedColorFromTriplet: #(1.0 0 0.065) !

Item was changed: MethodInterface subclass: #MethodWithInterface instanceVariableNames: 'playerClass' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

!MethodWithInterface commentStamp: '<historical>' prior: 0! A MethodInterface bound to an actual class.

selector A symbol - the selector being described argumentSpecifications A list of specifications for the formal arguments of the method resultSpecification A characterization of the return value of the method userLevel attributeKeywords A list of symbols, comprising keywords that the user wishes to associate with this method defaultStatus The status to apply to new instances of the class by default defaultFiresPerTick How many fires per tick, by default, should be allowed if ticking. playerClass The actual class with which this script is associated!

Item was changed: + ----- Method: StandardScriptingSystem>>referenceAt: (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>referenceAt: (in category '*eToys-utilities') ----- referenceAt: aSymbol "Answer the object referred to by aSymbol in the 'References' scheme of things, or nil if none"

^ References at: aSymbol ifAbsent: [nil]!

Item was changed: + ----- Method: DataType>>addUserSlotItemsTo:slotSymbol: (in category '*Etoys-tiles') ----- - ----- Method: DataType>>addUserSlotItemsTo:slotSymbol: (in category '*eToys-tiles') ----- addUserSlotItemsTo: aMenu slotSymbol: slotSym "Optionally add items to the menu that pertain to a user-defined slot of the given symbol" !

Item was changed: + ----- Method: SystemDictionary>>assureUniClass (in category '*Etoys-copying') ----- - ----- Method: SystemDictionary>>assureUniClass (in category '*eToys-copying') ----- assureUniClass "Assure that the receiver has a uniclass. Or rather, in this case, stop short of fulfilling such a request"

self error: 'We do not want uniclasses descending from here' !

Item was changed: Viewer subclass: #StandardViewer instanceVariableNames: 'firstPanel' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

!StandardViewer commentStamp: 'sw 8/17/2002 02:04' prior: 0! A structure that allows you to view state and behavior of an object; it consists of a header and then any number of CategoryViewers.!

Item was changed: Player subclass: #UnscriptedPlayer instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'! UnscriptedPlayer class instanceVariableNames: 'ephemeralPlayerRef'!

!UnscriptedPlayer commentStamp: '<historical>' prior: 0! My instances are Player objects that have not been scripted, and which hence do not require a unique scripts dictionary, etc. As soon as the needed, I am transformed automatically into a unique subclass of Player.! UnscriptedPlayer class instanceVariableNames: 'ephemeralPlayerRef'!

Item was changed: + ----- Method: StandardScriptingSystem>>buttonDownTile (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>buttonDownTile (in category '*eToys-utilities') ----- buttonDownTile "Answer a boolean-valued tile which reports whether the button is down"

^ self systemQueryPhraseWithActionString: '(ActiveHand anyButtonPressed)' labelled: 'button down?' translated!

Item was changed: + ----- Method: Morph>>removeAllEventTriggersFor: (in category '*Etoys-customevents-scripting') ----- - ----- Method: Morph>>removeAllEventTriggersFor: (in category '*eToys-customevents-scripting') ----- removeAllEventTriggersFor: aPlayer "Remove all the event registrations for aPlayer. User custom events are triggered at the World, while system custom events are triggered on individual Morphs."

self removeActionsSatisfying: [:action | action receiver == aPlayer and: [(#(#doScript: #triggerScript:) includes: action selector) ]].!

Item was changed: + ----- Method: GeeMailMorph>>visibleMorphs (in category '*Etoys-customevents-access') ----- - ----- Method: GeeMailMorph>>visibleMorphs (in category '*eToys-customevents-access') ----- visibleMorphs "Answer a collection of morphs that were visible as of the last step" ^Array withAll: (self valueOfProperty: #visibleMorphs ifAbsentPut: [ WeakArray new ]).!

Item was changed: TwoWayScrollPane subclass: #PluggableTileScriptorMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Tile Scriptors'! - category: 'EToys-Tile Scriptors'!

Item was changed: + ----- Method: StandardScriptingSystem>>stepUp:with: (in category '*Etoys-script-control') ----- - ----- Method: StandardScriptingSystem>>stepUp:with: (in category '*eToys-script-control') ----- stepUp: evt with: aMorph aMorph presenter stepUp: evt with: aMorph!

Item was changed: AlignmentMorph subclass: #ObjectRepresentativeMorph instanceVariableNames: 'objectRepresented' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

Item was changed: + ----- Method: Boolean>>basicType (in category '*Etoys-tiles') ----- - ----- Method: Boolean>>basicType (in category '*eToys-tiles') ----- basicType "Answer a symbol representing the inherent type of the receiver"

^ #Boolean!

Item was changed: + ----- Method: PluggableTextMorphWithModel>>currentDataValue (in category '*Etoys-player') ----- - ----- Method: PluggableTextMorphWithModel>>currentDataValue (in category '*eToys-player') ----- currentDataValue "Answer the current data value of the receiver"

^ myContents!

Item was changed: + ----- Method: StandardScriptingSystem>>customEventStati (in category '*Etoys-customevents-custom events') ----- - ----- Method: StandardScriptingSystem>>customEventStati (in category '*eToys-customevents-custom events') ----- customEventStati ^self globalCustomEventNames, self userCustomEventNames!

Item was changed: + ----- Method: String>>basicType (in category '*Etoys-tiles') ----- - ----- Method: String>>basicType (in category '*eToys-tiles') ----- basicType "Answer a symbol representing the inherent type of the receiver"

"Number String Boolean player collection sound color etc" ^ #String!

Item was changed: + ----- Method: ButtonPhaseType>>typeColor (in category '*Etoys-color') ----- - ----- Method: ButtonPhaseType>>typeColor (in category '*eToys-color') ----- typeColor "Answer the color for tiles to be associated with objects of this type"

^ self subduedColorFromTriplet: #(0.806 1.0 0.806) !

Item was changed: + ----- Method: PasteUpMorph>>showAllPlayers (in category '*Etoys-support') ----- - ----- Method: PasteUpMorph>>showAllPlayers (in category '*eToys-support') ----- showAllPlayers

| a | a := OrderedCollection new. self allMorphsDo: [ :x | (x player notNil and: [x player hasUserDefinedScripts]) ifTrue: [a add: x] ]. a do: [ :each | each openViewerForArgument]. !

Item was changed: EToyProjectRenamerMorph subclass: #EToyProjectDetailsMorph instanceVariableNames: 'projectDetails' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Experimental'! - category: 'EToys-Experimental'!

Item was changed: + ----- Method: PluggableTextMorph>>appendTextEtoy: (in category '*Etoys-transcript') ----- - ----- Method: PluggableTextMorph>>appendTextEtoy: (in category '*eToys-transcript') ----- appendTextEtoy: moreText "Append the text in the model's writeStream to the editable text. "

self handleEdit: [ self selectInvisiblyFrom: textMorph asText size + 1 to: textMorph asText size; replaceSelectionWith: moreText; selectFrom: textMorph asText size + 1 to: textMorph asText size; hasUnacceptedEdits: false; scrollSelectionIntoView; changed ]!

Item was changed: AlignmentMorphBob1 subclass: #GenericPropertiesMorph instanceVariableNames: 'myTarget thingsToRevert' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Experimental'! - category: 'EToys-Experimental'!

Item was changed: + ----- Method: GraphicType>>updatingTileForTarget:partName:getter:setter: (in category '*Etoys-tiles') ----- - ----- Method: GraphicType>>updatingTileForTarget:partName:getter:setter: (in category '*eToys-tiles') ----- updatingTileForTarget: aTarget partName: partName getter: getter setter: setter "Answer, for classic tiles, an updating readout tile for a part with the receiver's type, with the given getter and setter"

^ ThumbnailMorph new objectToView: aTarget viewSelector: getter; extent: 21@21; yourself!

Item was changed: + ----- Method: ParseNode>>explanation (in category '*Etoys-tiles') ----- - ----- Method: ParseNode>>explanation (in category '*eToys-tiles') ----- explanation

^self class printString!

Item was changed: + ----- Method: DataType>>comparatorForSampleBoolean (in category '*Etoys-tiles') ----- - ----- Method: DataType>>comparatorForSampleBoolean (in category '*eToys-tiles') ----- comparatorForSampleBoolean "Answer the comparator to use in tile coercions involving the receiver; normally, the equality comparator is used but NumberType overrides"

^ #=!

Item was changed: + ----- Method: StandardScriptingSystem>>nameForScriptsCategory (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>nameForScriptsCategory (in category '*eToys-utilities') ----- nameForScriptsCategory "Answer the name to use for the viewer category that contains scripts"

^ #scripts!

Item was changed: Object subclass: #KedamaVectorizer instanceVariableNames: 'attributes root' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

Item was changed: TileMorph subclass: #KedamaGetPixelValueTile instanceVariableNames: 'patchTile' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

!KedamaGetPixelValueTile commentStamp: '<historical>' prior: 0! I provide the patchValueIn getter tile. !

Item was changed: + ----- Method: SoundType>>defaultArgumentTile (in category '*Etoys-tiles') ----- - ----- Method: SoundType>>defaultArgumentTile (in category '*eToys-tiles') ----- defaultArgumentTile "Answer a tile to represent the type"

^ SoundTile new typeColor: self typeColor!

Item was changed: Model subclass: #Player instanceVariableNames: 'costume costumes' classVariableNames: 'BiggestSubclassNumber TimeOfError' poolDictionaries: 'References' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'! Player class instanceVariableNames: 'scripts slotInfo'!

!Player commentStamp: '<historical>' prior: 0! The fundamental user-scriptable entity. Always represented by a user-specific subclass of Player; instance vars and methods relate to user-defined structures.

costume is a Morph, the primary morph I am currently wearing for graphical display.

Scripts are defined in subclasses of Player. These are UniClasses.

Messages in scripts are sent to Players. A Player may delegate to its costume, or to an object the costume suggests. Or, a Player may designate some other object to receive the script messages it does not understand. (see doesNotUnderstand:) ! Player class instanceVariableNames: 'scripts slotInfo'!

Item was changed: TileMorph subclass: #AssignmentTileMorph instanceVariableNames: 'assignmentRoot assignmentSuffix dataType' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

Item was changed: + ----- Method: DataType>>subduedColorFromTriplet: (in category '*Etoys-color') ----- - ----- Method: DataType>>subduedColorFromTriplet: (in category '*eToys-color') ----- subduedColorFromTriplet: anRGBTriplet "Currently: as an expedient, simply return a standard system-wide constant; this is used only for the border-color of tiles... Formerly: Answer a subdued color derived from the rgb-triplet to use as a tile color."

^ ScriptingSystem standardTileBorderColor " ^ (Color fromRgbTriplet: anRGBTriplet) mixed: ScriptingSystem colorFudge with: ScriptingSystem uniformTileInteriorColor"!

Item was changed: + ----- Method: StandardScriptingSystem>>standardForms (in category '*Etoys-form dictionary') ----- - ----- Method: StandardScriptingSystem>>standardForms (in category '*eToys-form dictionary') ----- standardForms "ScriptingSystem standardForms" ^ FormDictionary collect: [:f | f]!

Item was changed: + ----- Method: PasteUpMorph>>addUserCustomEventNamed:help: (in category '*Etoys-customevents-scripting') ----- - ----- Method: PasteUpMorph>>addUserCustomEventNamed:help: (in category '*eToys-customevents-scripting') ----- addUserCustomEventNamed: aSymbol help: helpString self userCustomEventsRegistry at: aSymbol put: helpString. !

Item was changed: + ----- Method: StandardScriptingSystem>>installSolidMenuForm (in category '*Etoys-form dictionary') ----- - ----- Method: StandardScriptingSystem>>installSolidMenuForm (in category '*eToys-form dictionary') ----- installSolidMenuForm "ScriptingSystem installSolidMenuForm" self saveForm: (Form extent: 14@16 depth: 16 fromArray: #( 1 0 0 0 0 0 0 65537 65536 0 0 0 65537 0 65537 65537 65537 65537 65537 65537 65536 65537 65537 65537 65537 65537 1600061441 65536 65537 1600085855 1600085855 1600085855 1600085855 1600061441 65536 65537 1600085855 65537 65537 65537 65537 65536 65537 1600085855 65537 65537 65537 1600061441 65536 65537 1600085855 1600085855 1600085855 1600085855 1600085855 65537 65537 1600085855 65537 65537 65537 1600085855 65537 65537 1600085855 1600061441 65537 65537 89951 65537 65537 1600085855 1600085855 1600085855 1600085855 1600085855 65537 65537 1600085855 1600061441 65537 65537 65537 65537 65537 1600085855 65537 65537 65537 65536 65537 65537 65537 65537 65537 65537 65537 65537 1 65537 65537 65537 65537 65537 65536 0 65536 0 0 0 0 0) offset: 0@0) atKey: 'SolidMenu'!

Item was changed: + ----- Method: DataType>>setFormatForDisplayer: (in category '*Etoys-initialization') ----- - ----- Method: DataType>>setFormatForDisplayer: (in category '*eToys-initialization') ----- setFormatForDisplayer: aDisplayer "Set up the displayer to have the right format characteristics"

aDisplayer useDefaultFormat. aDisplayer growable: true !

Item was changed: + ----- Method: ColorType>>wantsArrowsOnTiles (in category '*Etoys-tiles') ----- - ----- Method: ColorType>>wantsArrowsOnTiles (in category '*eToys-tiles') ----- wantsArrowsOnTiles "Answer whether this data type wants up/down arrows on tiles representing its values"

^ false!

Item was changed: + ----- Method: FlapTab>>succeededInRevealing: (in category '*Etoys-support') ----- - ----- Method: FlapTab>>succeededInRevealing: (in category '*eToys-e-toy support') ----- succeededInRevealing: aPlayer "Try to reveal aPlayer, and answer whether we succeeded"

(super succeededInRevealing: aPlayer) ifTrue: [^ true]. self flapShowing ifTrue: [^ false]. (referent succeededInRevealing: aPlayer) ifTrue: [self showFlap. aPlayer costume goHome; addHalo. ^ true]. ^ false!

Item was changed: + ----- Method: UpdatingStringMorph>>currentDataValue (in category '*Etoys-player') ----- - ----- Method: UpdatingStringMorph>>currentDataValue (in category '*eToys-player') ----- currentDataValue "Answer the current data value held by the receiver"

^ self valueFromContents!

Item was changed: + ----- Method: Color>>newTileMorphRepresentative (in category '*Etoys-tiles') ----- - ----- Method: Color>>newTileMorphRepresentative (in category '*eToys-tiles') ----- newTileMorphRepresentative ^ ColorTileMorph new colorSwatchColor: self!

Item was changed: + ----- Method: PasteUpMorph>>tellAllContents: (in category '*Etoys-support') ----- - ----- Method: PasteUpMorph>>tellAllContents: (in category '*eToys-support') ----- tellAllContents: aMessageSelector "Send the given message selector to all the objects within the receiver"

self submorphs do: [:m | m player ifNotNil: [:p | p performScriptIfCan: aMessageSelector]]!

Item was changed: + ----- Method: UpdatingStringMorph>>setNewContentsFrom: (in category '*Etoys-card in a stack') ----- - ----- Method: UpdatingStringMorph>>setNewContentsFrom: (in category '*eToys-card & stack') ----- setNewContentsFrom: stringOrNumberOrNil

self acceptValue: stringOrNumberOrNil!

Item was changed: + ----- Method: StandardScriptingSystem>>removeCustomEventNamed:for: (in category '*Etoys-customevents-custom events') ----- - ----- Method: StandardScriptingSystem>>removeCustomEventNamed:for: (in category '*eToys-customevents-custom events') ----- removeCustomEventNamed: aSymbol for: registrant | registration helpString | registration := self customEventsRegistry at: aSymbol ifAbsent: [ ^nil ]. helpString := registration removeKey: registrant ifAbsent: []. registration isEmpty ifTrue: [ self customEventsRegistry removeKey: aSymbol ]. ^helpString!

Item was changed: + ----- Method: SimpleSliderMorph>>getNumericValue (in category '*Etoys-support') ----- - ----- Method: SimpleSliderMorph>>getNumericValue (in category '*eToys-e-toy support') ----- getNumericValue "Answer the numeric value of the receiver"

^ self getScaledValue!

Item was changed: + ----- Method: Vocabulary>>tileWordingForSelector: (in category '*Etoys-queries') ----- - ----- Method: Vocabulary>>tileWordingForSelector: (in category '*eToys-queries') ----- tileWordingForSelector: aSelector "Answer the wording to emblazon on tiles representing aSelector"

| anInterface | anInterface := self methodInterfaceAt: aSelector asSymbol ifAbsent: [ | inherent | inherent := Utilities inherentSelectorForGetter: aSelector. ^ inherent ifNil: [self translatedWordingFor: aSelector] ifNotNil: [inherent translated]]. ^ anInterface wording!

Item was changed: TileMorph subclass: #KedamaGetColorComponentTile instanceVariableNames: 'patchTile' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

!KedamaGetColorComponentTile commentStamp: '<historical>' prior: 0! I provide the red, green or blue component getter tile. !

Item was changed: + ----- Method: StandardScriptingSystem>>informScriptingUser: (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>informScriptingUser: (in category '*eToys-utilities') ----- informScriptingUser: aString "This provides a hook for logging messages that the user or the developer may wish to see; at present it simply logs the message to the Transcript, with a standard prefix to signal their provenance. Such messages will fall on the floor if there is no Transcript window open"

Transcript cr; show: 'SCRIPT NOTE: ', aString!

Item was changed: CategoryViewer subclass: #KedamaWhoSearchingViewer instanceVariableNames: 'searchString' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

Item was changed: EToyGenericDialogMorph subclass: #EToyProjectRenamerMorph instanceVariableNames: 'actionBlock theProject' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Experimental'! - category: 'EToys-Experimental'!

Item was changed: + ----- Method: StandardScriptingSystem>>newScriptingSpace2 (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>newScriptingSpace2 (in category '*eToys-utilities') ----- newScriptingSpace2 "Answer a complete scripting space"

| aTemplate aPlayfield aControl | (aTemplate := PasteUpMorph new) setNameTo: 'etoy'; extent: 638 @ 470; color: Color white; impartPrivatePresenter; setProperty: #automaticPhraseExpansion toValue: true; beSticky. aTemplate useRoundedCorners; borderWidth: 2. aControl := ScriptingSystem scriptControlButtons setToAdhereToEdge: #bottomLeft. aControl beSticky; borderWidth: 0; beTransparent. aTemplate addMorphBack: aControl. aTemplate presenter addTrashCan.

aTemplate addMorph: (aPlayfield := PasteUpMorph new). aPlayfield setNameTo: 'playfield'; useRoundedCorners; setToAdhereToEdge: #topLeft; extent: 340@300; position: aTemplate topRight - (400@0); beSticky; automaticViewing: true; wantsMouseOverHalos: true. aTemplate presenter standardPlayfield: aPlayfield. ^ aTemplate

!

Item was changed: + ----- Method: PasteUpMorph>>userCustomEventNames (in category '*Etoys-customevents-scripting') ----- - ----- Method: PasteUpMorph>>userCustomEventNames (in category '*eToys-customevents-scripting') ----- userCustomEventNames | reg | reg := self valueOfProperty: #userCustomEventsRegistry ifAbsent: [ ^#() ]. ^reg keys asArray sort!

Item was changed: + ----- Method: StringType>>typeColor (in category '*Etoys-color') ----- - ----- Method: StringType>>typeColor (in category '*eToys-color') ----- typeColor "Answer the color for tiles to be associated with objects of this type"

^ self subduedColorFromTriplet: #(0.0 0.0 1.0) !

Item was changed: + ----- Method: UpdatingStringMorph>>hasStructureOfComplexWatcher (in category '*Etoys-target access') ----- - ----- Method: UpdatingStringMorph>>hasStructureOfComplexWatcher (in category '*eToys-target access') ----- hasStructureOfComplexWatcher "Answer whether the receiver has precisely the structure of a so-called complex watcher, as used in the etoy system."

| top | top := (self owner ifNil: [^ false]) owner. ^ ((((top isMemberOf: AlignmentMorph) and: [top submorphs size = 4]) and: [top submorphs first isMemberOf: TileMorph]) and: [top submorphs third isMemberOf: AlignmentMorph])!

Item was changed: TileMorph subclass: #KedamaPatchTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

!KedamaPatchTile commentStamp: 'yo 6/18/2004 18:32' prior: 0! A special Tile that represents the Patch. !

Item was changed: TileMorph subclass: #KedamaTurtleOfTile instanceVariableNames: 'turtleTile' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

Item was changed: BookMorph subclass: #StackMorph instanceVariableNames: 'cards' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Stacks'! - category: 'EToys-Stacks'!

!StackMorph commentStamp: '<historical>' prior: 0! 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.!

Item was changed: + ----- Method: MenuType>>typeColor (in category '*Etoys-color') ----- - ----- Method: MenuType>>typeColor (in category '*eToys-color') ----- typeColor "Answer the color for tiles to be associated with objects of this type"

^ self subduedColorFromTriplet: #(0.4 0.4 0.4) !

Item was changed: UpdatingStringMorph subclass: #SyntaxUpdatingStringMorph instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Tile Scriptors'! - category: 'EToys-Tile Scriptors'!

Item was changed: AlignmentMorph subclass: #ScriptStatusControl instanceVariableNames: 'tickPauseWrapper tickPauseButtonsShowing scriptInstantiation' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

Item was changed: ThumbnailMorph subclass: #ThumbnailForAllPlayersTool instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

!ThumbnailForAllPlayersTool commentStamp: '<historical>' prior: 0! A thumbnail for use in an All-Players tool!

Item was changed: + ----- Method: LassoPatchMorph>>isCandidateForAutomaticViewing (in category '*Etoys-misc') ----- - ----- Method: LassoPatchMorph>>isCandidateForAutomaticViewing (in category '*eToys-misc') ----- isCandidateForAutomaticViewing "Answer whether the receiver is a candidate for automatic viewing. Only relevant if a now-seldom-used feature, automaticViewing, is in play"

^ self isPartsDonor not!

Item was changed: + ----- Method: StandardScriptingSystem>>addCustomEventFor:named:help:targetMorphClass: (in category '*Etoys-customevents-custom events') ----- - ----- Method: StandardScriptingSystem>>addCustomEventFor:named:help:targetMorphClass: (in category '*eToys-customevents-custom events') ----- addCustomEventFor: registrantClass named: aSymbol help: helpString targetMorphClass: targetClass | registration | registration := self customEventsRegistry at: aSymbol ifAbsentPut: [ IdentityDictionary new ]. registration at: registrantClass put: { helpString. targetClass }. !

Item was changed: + ----- Method: DataType>>updatingTileForTarget:partName:getter:setter: (in category '*Etoys-tiles') ----- - ----- Method: DataType>>updatingTileForTarget:partName:getter:setter: (in category '*eToys-tiles') ----- updatingTileForTarget: aTarget partName: partName getter: getter setter: setter "Answer, for classic tiles, an updating readout tile for a part with the receiver's type, with the given getter and setter"

| aTile displayer actualSetter | actualSetter := setter ifNotNil: [(#(none #nil unused) includes: setter) ifTrue: [nil] ifFalse: [setter]].

aTile := self newReadoutTile.

displayer := UpdatingStringMorph new getSelector: getter; target: aTarget; growable: true; minimumWidth: 24; putSelector: actualSetter. "Note that when typeSymbol = #number, the #target: call above will have dealt with floatPrecision details"

self setFormatForDisplayer: displayer. aTile addMorphBack: displayer. (actualSetter notNil and: [self wantsArrowsOnTiles]) ifTrue: [aTile addArrows]. getter numArgs == 0 ifTrue: [aTile setLiteralInitially: (aTarget perform: getter)]. ^ aTile !

Item was changed: PhraseTileMorph subclass: #SystemQueryPhrase instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

Item was changed: AlignmentMorphBob1 subclass: #EToyGenericDialogMorph instanceVariableNames: 'namedFields' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Experimental'! - category: 'EToys-Experimental'!

Item was changed: + ----- Method: NumberType>>wantsSuffixArrow (in category '*Etoys-tiles') ----- - ----- Method: NumberType>>wantsSuffixArrow (in category '*eToys-tiles') ----- wantsSuffixArrow "Answer whether a tile showing data of this type would like to have a suffix arrow"

^ true!

Item was changed: + ----- Method: StandardScriptingSystem>>buttonUpTile (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>buttonUpTile (in category '*eToys-utilities') ----- buttonUpTile "Answer a boolean-valued tile which reports whether the button is up"

^ self systemQueryPhraseWithActionString: '(ActiveHand noButtonPressed)' labelled: 'button up?' translated!

Item was changed: + ----- Method: StandardScriptingSystem>>setterSelectorForGetter: (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>setterSelectorForGetter: (in category '*eToys-utilities') ----- setterSelectorForGetter: aGetterSymbol "Answer the setter selector corresponding to a given getter"

^ (('s', (aGetterSymbol copyFrom: 2 to: aGetterSymbol size)), ':') asSymbol

"ScriptingSystem setterSelectorForGetter: #getCursor"!

Item was changed: ScriptEditorMorph subclass: #BooleanScriptEditor instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Support'! - category: 'EToys-Scripting Support'!

!BooleanScriptEditor commentStamp: '<historical>' prior: 0! A ScriptEditor required to hold a Boolean!

Item was changed: + ----- Method: Morph>>triggerEtoyEvent: (in category '*Etoys-customevents-scripting') ----- - ----- Method: Morph>>triggerEtoyEvent: (in category '*eToys-customevents-scripting') ----- triggerEtoyEvent: aSymbol "Trigger whatever scripts may be connected to the event named aSymbol. If anyone comes back to ask who sent it, return our player."

[ self triggerEvent: aSymbol ] on: GetTriggeringObjectNotification do: [ :ex | ex isNested ifTrue: [ ex pass ] ifFalse: [ ex resume: self assuredPlayer ]] !

Item was changed: + ----- Method: StandardScriptingSystem>>standardTileBorderColor (in category '*Etoys-tile colors') ----- - ----- Method: StandardScriptingSystem>>standardTileBorderColor (in category '*eToys-tile colors') ----- standardTileBorderColor "Answer the color to use for tile borders"

^ Color r: 0.804 g: 0.76 b: 0.564!

Item was changed: + ----- Method: TextMorph>>couldHoldSeparateDataForEachInstance (in category '*Etoys-card in a stack') ----- - ----- Method: TextMorph>>couldHoldSeparateDataForEachInstance (in category '*eToys-card in a stack') ----- couldHoldSeparateDataForEachInstance "Answer whether this type of morph is inherently capable of holding separate data for each instance ('card data')"

^ true!

Item was changed: TileMorph subclass: #UndescribedTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

Item was changed: + ----- Method: TheWorldMenu>>playfieldMenu (in category '*Etoys-construction') ----- - ----- Method: TheWorldMenu>>playfieldMenu (in category '*eToys-construction') ----- playfieldMenu

^ myWorld playfieldOptionsMenu!

Item was changed: + ----- Method: Color>>basicType (in category '*Etoys-tiles') ----- - ----- Method: Color>>basicType (in category '*eToys-tiles') ----- basicType "Answer a symbol representing the inherent type of the receiver"

^ #Color!

Item was changed: UpdatingThreePhaseButtonMorph subclass: #EtoyUpdatingThreePhaseButtonMorph instanceVariableNames: '' classVariableNames: 'CheckedForm MouseDownForm UncheckedForm' poolDictionaries: '' + category: 'Etoys-Widgets'! - category: 'EToys-Widgets'!

!EtoyUpdatingThreePhaseButtonMorph commentStamp: '<historical>' prior: 0! A slight variation wherein the actionSelector and getSelector both take argument(s).!

Item was changed: + ----- Method: PaintBoxMorph>>isCandidateForAutomaticViewing (in category '*Etoys-support') ----- - ----- Method: PaintBoxMorph>>isCandidateForAutomaticViewing (in category '*eToys-e-toy support') ----- isCandidateForAutomaticViewing ^ false!

Item was changed: + ----- Method: DataType>>newReadoutTile (in category '*Etoys-tiles') ----- - ----- Method: DataType>>newReadoutTile (in category '*eToys-tiles') ----- newReadoutTile "Answer a tile that can serve as a readout for data of this type"

^ StringReadoutTile new typeColor: Color lightGray lighter!

Item was changed: + ----- Method: NumberType>>wantsAssignmentTileVariants (in category '*Etoys-tiles') ----- - ----- Method: NumberType>>wantsAssignmentTileVariants (in category '*eToys-tiles') ----- wantsAssignmentTileVariants "Answer whether an assignment tile for a variable of this type should show variants to increase-by, decrease-by, multiply-by."

^ true!

Item was changed: + ----- Method: StandardScriptingSystem>>colorFudge (in category '*Etoys-tile colors') ----- - ----- Method: StandardScriptingSystem>>colorFudge (in category '*eToys-tile colors') ----- colorFudge ^ 0.4!

Item was changed: + ----- Method: StandardScriptingSystem>>scriptControlButtons (in category '*Etoys-script-control') ----- - ----- Method: StandardScriptingSystem>>scriptControlButtons (in category '*eToys-script-control') ----- scriptControlButtons "Answer a composite object that serves to control the stop/stop/go status of a Presenter"

| wrapper | wrapper := AlignmentMorph newRow setNameTo: 'script controls'. wrapper vResizing: #shrinkWrap. wrapper hResizing: #shrinkWrap. wrapper addMorph: self stopButton. wrapper addMorphBack: self stepButton. wrapper addMorphBack: self goButton. wrapper beTransparent. ^ wrapper!

Item was changed: + ----- Method: UnknownType>>wantsArrowsOnTiles (in category '*Etoys-tiles') ----- - ----- Method: UnknownType>>wantsArrowsOnTiles (in category '*eToys-tiles') ----- wantsArrowsOnTiles "Answer whether this data type wants up/down arrows on tiles representing its values"

^ false!

Item was changed: Object subclass: #SlotInformation instanceVariableNames: 'type documentation floatPrecision variableDock variableDefinition' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

!SlotInformation commentStamp: '<historical>' prior: 0! Holds information about user-defined instance variables in Players.!

Item was changed: EToyCommunicatorMorph subclass: #EToyProjectHistoryMorph instanceVariableNames: 'changeCounter' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Experimental'! - category: 'EToys-Experimental'!

!EToyProjectHistoryMorph commentStamp: '<historical>' prior: 0! EToyProjectHistoryMorph new openInWorld

EToyProjectHistoryMorph provides a quick reference of the most recent projects. Click on one to go there.!

Item was changed: Object subclass: #KedamaAttributeDictionary instanceVariableNames: 'dictionaries' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

Item was changed: KedamaExamplerPlayer subclass: #KedamaTurtleVectorPlayer instanceVariableNames: 'exampler info types arrays deletingIndex whoTable whoTableBase whoTableValid turtlesMap turtleMapValid lastWho lastWhoStub' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

Item was changed: + ----- Method: UndefinedObject>>initialize (in category '*Etoys-*Morphic-customevents-class initialization') ----- - ----- Method: UndefinedObject>>initialize (in category '*eToys-*Morphic-customevents-class initialization') ----- initialize "AlansTextPlusMorph initialize" ScriptingSystem addCustomEventFor: self named: #scrolledIntoView help: 'when I am scrolled into view in a GeeMailMorph' targetMorphClass: Morph. ScriptingSystem addCustomEventFor: self named: #scrolledOutOfView help: 'when I am scrolled out of view in a GeeMailMorph' targetMorphClass: Morph. !

Item was changed: + ----- Method: ClassDescription>>namedTileScriptSelectors (in category '*Etoys-accessing method dictionary') ----- - ----- Method: ClassDescription>>namedTileScriptSelectors (in category '*eToys-accessing method dictionary') ----- namedTileScriptSelectors "Answer a list of all the selectors of named tile scripts. Initially, only Player reimplements, but if we switch to a scheme in which every class can have uniclass subclasses, this would kick in elsewhere"

^ OrderedCollection new!

Item was changed: + ----- Method: SmallInteger>>uniqueNameForReference (in category '*Etoys-printing') ----- - ----- Method: SmallInteger>>uniqueNameForReference (in category '*eToys-printing') ----- uniqueNameForReference "Answer a nice name by which the receiver can be referred to by other objects. For SmallIntegers, we can actually just use the receiver's own printString, though this is pretty strange in some ways."

^ self asString!

Item was changed: SymbolListTile subclass: #TypeListTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

!TypeListTile commentStamp: '<historical>' prior: 0! A tile that offers a list of supported data types.!

Item was changed: StringReadoutTile subclass: #SoundReadoutTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

!SoundReadoutTile commentStamp: 'sw 11/24/2003 15:25' prior: 0! 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.!

Item was changed: + ----- Method: UpdatingStringMorph>>putOnBackground (in category '*Etoys-menus') ----- - ----- Method: UpdatingStringMorph>>putOnBackground (in category '*eToys-menus') ----- putOnBackground "Place the receiver, formerly private to its card, onto the shared background. If the receiver needs data carried on its behalf by the card, such data will be represented on every card."

"If I seem to have per-card data, then set that up." target class superclass == CardPlayer ifTrue: [ (self hasOwner: target costume) ifTrue: [ self setProperty: #holdsSeparateDataForEachInstance toValue: true]]. super putOnBackground.!

Item was changed: + ----- Method: PasteUpMorph>>recreateScripts (in category '*Etoys-support') ----- - ----- Method: PasteUpMorph>>recreateScripts (in category '*eToys-support') ----- recreateScripts "self currentWorld recreateScripts."

Preferences enable: #universalTiles. Preferences enable: #capitalizedReferences. "Rebuild viewers" self flapTabs do: [:ff | (ff isMemberOf: ViewerFlapTab) ifTrue: [ff referent submorphsDo: [:m | (m isStandardViewer) ifTrue: [m recreateCategories]]]]. "Rebuild scriptors" ((self flapTabs collect: [:t | t referent]) copyWith: self) do: [:w | w allScriptEditors do: [:scrEd | scrEd unhibernate]]!

Item was changed: Morph subclass: #KedamaTurtleMorph instanceVariableNames: 'kedamaWorld turtleCount isGroup' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

!KedamaTurtleMorph commentStamp: 'yo 6/18/2004 18:33' prior: 0! The exampler of turtles. !

Item was changed: TileLikeMorph subclass: #PhraseTileMorph instanceVariableNames: 'resultType brightenedOnEnter userScriptSelector justGrabbedFromViewer vocabulary vocabularySymbol' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

!PhraseTileMorph commentStamp: '<historical>' prior: 0! 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.

!

Item was changed: Viewer subclass: #CategoryViewer instanceVariableNames: 'namePane chosenCategorySymbol' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

!CategoryViewer commentStamp: '<historical>' prior: 0! 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.!

Item was changed: UnscriptedPlayer subclass: #UnscriptedCardPlayer instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting'! - category: 'EToys-Scripting'!

Item was changed: + ----- Method: ServerDirectory>>hasEToyUserList (in category '*Etoys-school support') ----- - ----- Method: ServerDirectory>>hasEToyUserList (in category '*eToys-school support') ----- hasEToyUserList ^eToyUserListUrl notNil!

Item was changed: + ----- Method: StandardScriptingSystem>>wordingForOperator: (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>wordingForOperator: (in category '*eToys-utilities') ----- wordingForOperator: aString "Answer the wording to be seen by the user for the given operator symbol/string"

| toTest | toTest := aString asString. #( (append: 'include at end') (arrowheadsOnAllPens 'arrowheads on all pens') (beep: 'make sound') (bounce: 'bounce') (clearTurtleTrails 'clear pen trails') (clearOwnersPenTrails 'clear all pen trails') (colorSees 'color sees') (color:sees: 'color sees') (doMenuItem: 'do menu item') (doScript: 'do') (forward: 'forward by') (goToRightOf: 'align after') (includeAtCursor: 'include at cursor') (isDivisibleBy: 'is divisible by') (liftAllPens 'lift all pens') (lowerAllPens 'lower all pens') (makeNewDrawingIn: 'start painting in') (max: 'max') (min: 'min') (moveToward: 'move toward') (noArrowheadsOnAllPens 'no arrowheads on pens') (overlapsAny 'overlaps any') (pauseAll: 'pause all') (pauseScript: 'pause script') (prepend: 'include at beginning') (seesColor: 'is over color') (startAll: 'start all') (startScript: 'start script') (stopProgramatically 'stop') (stopAll: 'stop all') (stopScript: 'stop script') (tellAllSiblings: 'tell all siblings') (tellSelfAndAllSiblings: 'send to all') (turn: 'turn by') (turnToward: 'turn toward') (wearCostumeOf: 'look like'))

do: [:pair | toTest = pair first ifTrue: [^ pair second]].

^ toTest

"StandardScriptingSystem initialize"

!

Item was changed: + ----- Method: GraphicType>>defaultArgumentTile (in category '*Etoys-tiles') ----- - ----- Method: GraphicType>>defaultArgumentTile (in category '*eToys-tiles') ----- defaultArgumentTile "Answer a tile to represent the type"

^ GraphicTile new typeColor: self typeColor!

Item was changed: GenericPropertiesMorph subclass: #TextPropertiesMorph instanceVariableNames: 'activeTextMorph applyToWholeText lastGlobalColor' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Experimental'! - category: 'EToys-Experimental'!

Item was changed: + ----- Method: LiteralNode>>explanation (in category '*Etoys-tiles') ----- - ----- Method: LiteralNode>>explanation (in category '*eToys-tiles') ----- explanation

(key isVariableBinding) ifFalse: [ ^'Literal ', key storeString ]. key key isNil ifTrue: [ ^'Literal ', ('###',key value soleInstance name) ] ifFalse: [ ^'Literal ', ('##', key key) ]. !

Item was changed: + ----- Method: StandardScriptingSystem>>helpStringOrNilForOperator: (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>helpStringOrNilForOperator: (in category '*eToys-utilities') ----- helpStringOrNilForOperator: anOperator "Answer the help string associated with the given operator, nil if none found."

| anIndex opsAndHelp | (anIndex := (opsAndHelp := self arithmeticalOperatorsAndHelpStrings) first indexOf: anOperator) > 0 ifTrue: [^ (opsAndHelp second at: anIndex) translated].

(anIndex := (opsAndHelp := self numericComparitorsAndHelpStrings) first indexOf: anOperator) > 0 ifTrue: [^ (opsAndHelp second at: anIndex) translated].

anOperator = #, ifTrue: [^ 'Concatenate two Strings' translated].

^ nil!

Item was changed: + ----- Method: ThumbnailMorph>>tearOffTile (in category '*Etoys-scripting') ----- - ----- Method: ThumbnailMorph>>tearOffTile (in category '*eToys-scripting') ----- tearOffTile (objectToView isPlayerLike) ifTrue: [^ objectToView tearOffTileForSelf].

objectToView ifNil: [^ nil]. ^ objectToView isMorph ifTrue: [objectToView] ifFalse: [objectToView costume] !

Item was changed: + ----- Method: ImageMorph>>couldHoldSeparateDataForEachInstance (in category '*Etoys-card in a stack') ----- - ----- Method: ImageMorph>>couldHoldSeparateDataForEachInstance (in category '*eToys-card in a stack') ----- couldHoldSeparateDataForEachInstance "Answer whether the receiver can potentially hold separate data for each instance"

^ true!

Item was changed: + ----- Method: TheWorldMenu>>playfieldDo (in category '*Etoys-popups') ----- - ----- Method: TheWorldMenu>>playfieldDo (in category '*eToys-popups') ----- playfieldDo "Build the playfield menu for the world."

self doPopUp: myWorld playfieldOptionsMenu!

Item was changed: + ----- Method: StringType>>wantsArrowsOnTiles (in category '*Etoys-tiles') ----- - ----- Method: StringType>>wantsArrowsOnTiles (in category '*eToys-tiles') ----- wantsArrowsOnTiles "Answer whether this data type wants up/down arrows on tiles representing its values"

^ false!

Item was changed: + ----- Method: StandardScriptingSystem>>globalCustomEventNamesFor: (in category '*Etoys-customevents-custom events') ----- - ----- Method: StandardScriptingSystem>>globalCustomEventNamesFor: (in category '*eToys-customevents-custom events') ----- globalCustomEventNamesFor: aPlayer | morph names | morph := aPlayer costume renderedMorph. names := SortedCollection new. self customEventsRegistry keysAndValuesDo: [ :k :v | (v anySatisfy: [ :array | morph isKindOf: array second ]) ifTrue: [ names add: k ]]. ^names asArray!

Item was changed: + ----- Method: GrabPatchMorph>>isCandidateForAutomaticViewing (in category '*Etoys-misc') ----- - ----- Method: GrabPatchMorph>>isCandidateForAutomaticViewing (in category '*eToys-misc') ----- isCandidateForAutomaticViewing "Answer whether the receiver is a candidate for automatic viewing. Only relevant if a now-seldom-used feature, automaticViewing, is in play"

^ self isPartsDonor not!

Item was changed: TileMorph subclass: #BooleanTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

!BooleanTile commentStamp: '<historical>' prior: 0! A tile whose result type is boolean.!

Item was changed: + ----- Method: StandardScriptingSystem>>helpStringForOperator: (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>helpStringForOperator: (in category '*eToys-utilities') ----- helpStringForOperator: anOperator "Answer the help string associated with the given operator. If none found, return a standard no-help-available reply"

^ (self helpStringOrNilForOperator: anOperator) ifNil: ['Sorry, no help available here' translated] "This should never be seen, but is provided as a backstop"!

Item was changed: + ----- Method: SketchMorph>>couldHoldSeparateDataForEachInstance (in category '*Etoys-card in a stack') ----- - ----- Method: SketchMorph>>couldHoldSeparateDataForEachInstance (in category '*eToys-card in a stack') ----- couldHoldSeparateDataForEachInstance "Answer whether this type of morph is inherently capable of holding separate data for each instance ('card data') SketchMorphs answer true, because they can serve as 'picture-holding' fields"

^ true!

Item was changed: + ----- Method: AssignmentNode>>explanation (in category '*Etoys-tiles') ----- - ----- Method: AssignmentNode>>explanation (in category '*eToys-tiles') ----- explanation

^'The value of ',value explanation,' is being stored in ',variable explanation !

Item was changed: Vocabulary subclass: #EToyVocabulary instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Protocols'! - category: 'EToys-Protocols'!

!EToyVocabulary commentStamp: '<historical>' prior: 0! EToyVocabulary - a vocabulary mirroring the capabilities available to end users in Squeak's old 1997-2000 etoy prototype.!

Item was changed: + ----- Method: PasteUpMorph>>attemptCleanupReporting: (in category '*Etoys-world menu') ----- - ----- Method: PasteUpMorph>>attemptCleanupReporting: (in category '*eToys-world menu') ----- attemptCleanupReporting: whetherToReport "Try to fix up some bad things that are known to occur in some etoy projects we've seen. If the whetherToReport parameter is true, an informer is presented after the cleanups"

| fixes | fixes := 0. ActiveWorld ifNotNil: [(ActiveWorld submorphs select: [:m | (m isKindOf: ScriptEditorMorph) and: [m submorphs isEmpty]]) do: [:m | m delete. fixes := fixes + 1]].

TransformationMorph allSubInstancesDo: [:m | (m player notNil and: [m renderedMorph ~~ m]) ifTrue: [m renderedMorph visible ifFalse: [m renderedMorph visible: true. fixes := fixes + 1]]].

(Player class allSubInstances select: [:cl | cl isUniClass]) do: [:aUniclass | fixes := fixes + aUniclass cleanseScripts].

self presenter flushPlayerListCache; allExtantPlayers. whetherToReport ifTrue: [self inform: ('{1} [or more] repair(s) made' translated format: {fixes printString})]

" ActiveWorld attemptCleanupReporting: true. ActiveWorld attemptCleanupReporting: false. "!

Item was changed: + ----- Method: StandardScriptingSystem>>holderWithAlphabet (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>holderWithAlphabet (in category '*eToys-utilities') ----- holderWithAlphabet "Answer a fully instantiated Holder that has submorphs that represent the letters of the uppercase alphabet, with each one having an 'index' slot which bears the letter's index in the alphabet -- 1 for A, 2 for B, etc. A few special characters are provided as per ack request 10/00; for these the index provided is rather arbitrarily assigned"

| aMorph aPlayer oneCharString aContainer aWrapper |

"ScriptingSystem holderWithAlphabet openInHand"

aContainer := self prototypicalHolder useRoundedCorners. aContainer borderColor: Color blue lighter.

aWrapper := AlignmentMorph new hResizing: #shrinkWrap; vResizing: #shrinkWrap; layoutInset: 0. aWrapper addMorphBack: (aMorph := TextMorph new contents: 'A'). aMorph beAllFont: ((TextStyle named: Preferences standardEToysFont familyName) fontOfSize: 24). aMorph width: 14; lock. aWrapper beTransparent; setNameTo: 'A'. aPlayer := aWrapper assuredPlayer. aPlayer addInstanceVariableNamed: #index type: #Number value: 1. aContainer addMorphBack: aWrapper. 2 to: 26 do: [:anIndex | | newMorph | newMorph := aWrapper usableSiblingInstance. newMorph player perform: #setIndex: with: anIndex. newMorph firstSubmorph contents: (oneCharString := ($A asciiValue + anIndex - 1) asCharacter asString). newMorph setNameTo: oneCharString.

aContainer addMorphBack: newMorph].

#(' ' '.' '#') with: #(27 28 29) do: [:aString :anIndex | | newMorph | newMorph := aWrapper usableSiblingInstance. newMorph player perform: #setIndex: with: anIndex. newMorph firstSubmorph contents: aString. aString = ' ' ifTrue: [newMorph setNameTo: 'space'. newMorph color: (Color gray alpha: 0.2)] ifFalse: [newMorph setNameTo: aString]. aContainer addMorphBack: newMorph].

aContainer setNameTo: 'alphabet'. aContainer isPartsBin: true. aContainer enableDrop: false. aContainer indicateCursor: false; width: 162. aContainer color: (Color r: 0.839 g: 1.0 b: 1.0). "Color fromUser" ^ aContainer!

Item was changed: + ----- Method: StandardScriptingSystem>>numericComparitorsAndHelpStrings (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>numericComparitorsAndHelpStrings (in category '*eToys-utilities') ----- numericComparitorsAndHelpStrings "Answer an array whose first element is the list of comparitors, and whose second element is a list of the corresponding help strings"

^ #((< <= = ~= > >= isDivisibleBy:) ('less than' 'less than or equal' 'equal' 'not equal' 'greater than' 'greater than or equal' 'divisible by' ))!

Item was changed: TileMorph subclass: #SymbolListTile instanceVariableNames: 'choices dataType' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

!SymbolListTile commentStamp: '<historical>' prior: 0! Instances of SymbolListTile are literal tiles whose literals are choosable from a finite list.!

Item was changed: TextMorph subclass: #EToyTextNode instanceVariableNames: 'children firstDisplay' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Outliner'! - category: 'EToys-Outliner'!

Item was changed: + ----- Method: StandardScriptingSystem>>allKnownClassVariableNames (in category '*Etoys-utilities') ----- - ----- Method: StandardScriptingSystem>>allKnownClassVariableNames (in category '*eToys-utilities') ----- allKnownClassVariableNames "Answer a set of all the knwon class variable names in the system. This normally retrieves them from a cache, and at present there is no organized mechanism for invalidating the cache. The idea is to avoid, in the References scheme, names that may create a conflict"

^ ClassVarNamesInUse ifNil: [ClassVarNamesInUse := self allClassVarNamesInSystem]

"ClassVarNamesInUse := nil. Time millisecondsToRun: [ScriptingSystem allKnownClassVariableNames]" !

Item was changed: TileMorph subclass: #GraphicTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

!GraphicTile commentStamp: '<historical>' prior: 0! A tile representing a graphic image.!

Item was changed: + ----- Method: PasteUpMorph>>relaunchAllViewers (in category '*Etoys-support') ----- - ----- Method: PasteUpMorph>>relaunchAllViewers (in category '*eToys-support') ----- relaunchAllViewers "Relaunch all the viewers in the project"

(self submorphs select: [:m | m isKindOf: ViewerFlapTab]) do: [:aTab | | aViewer | aViewer := aTab referent submorphs detect: [:sm | sm isStandardViewer] ifNone: [nil]. aViewer ifNotNil: [aViewer relaunchViewer] "ActiveWorld relaunchAllViewers"]!

Item was changed: + ----- Method: TabbedPalette>>viewMorph: (in category '*Etoys-viewer tab') ----- - ----- Method: TabbedPalette>>viewMorph: (in category '*eToys-viewer tab') ----- viewMorph: aMorph "The receiver is expected to have a viewer tab; select it, and target it to aMorph" | aPlayer aViewer oldOwner | ((currentPage isKindOf: Viewer) and: [currentPage scriptedPlayer == aMorph player]) ifTrue: [^ self]. oldOwner := owner. self delete. self visible: false. aPlayer := aMorph assuredPlayer. self showNoPalette. aViewer := StandardViewer new initializeFor: aPlayer barHeight: 0. aViewer enforceTileColorPolicy. self showNoPalette. currentPage ifNotNil: [currentPage delete]. self addMorphBack: (currentPage := aViewer beSticky). self snapToEdgeIfAppropriate. tabsMorph highlightTab: nil. self visible: true. oldOwner addMorphFront: self. self world startSteppingSubmorphsOf: aViewer. self layoutChanged!

Item was changed: TileMorph subclass: #NumericReadoutTile instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-Scripting Tiles'! - category: 'EToys-Scripting Tiles'!

Item was changed: + ----- Method: StandardScriptingSystem>>noButtonPressedTiles (in category '*Etoys-parts bin') ----- - ----- Method: StandardScriptingSystem>>noButtonPressedTiles (in category '*eToys-parts bin') ----- noButtonPressedTiles "Answer tiles representing the query 'is no button pressed?'"

^ self tilesForQuery: '(ActiveHand noButtonPressed)' label: 'button up?' translated!

Item was changed: + ----- Method: SketchMorph>>appearsToBeSameCostumeAs: (in category '*Etoys-e-toy support') ----- - ----- Method: SketchMorph>>appearsToBeSameCostumeAs: (in category '*eToys-e-toy support') ----- appearsToBeSameCostumeAs: aMorph

(aMorph isKindOf: self class) ifFalse: [^false]. ^originalForm == aMorph form or: [ originalForm appearsToBeSameCostumeAs: aMorph form ]!

Item was changed: Player subclass: #KedamaExamplerPlayer instanceVariableNames: 'kedamaWorld turtles sequentialStub' classVariableNames: '' poolDictionaries: '' + category: 'Etoys-StarSqueak'! - category: 'EToys-StarSqueak'!

Item was changed: + ----- Method: StandardScriptingSystem>>removeUserCustomEventNamed: (in category '*Etoys-customevents-custom events') ----- - ----- Method: StandardScriptingSystem>>removeUserCustomEventNamed: (in category '*eToys-customevents-custom events') ----- removeUserCustomEventNamed: eventName | retval | retval := self currentWorld removeUserCustomEventNamed: eventName. "Vocabulary addStandardVocabulary: UserCustomEventNameType new." Vocabulary customEventsVocabulary. SymbolListTile updateAllTilesForVocabularyNamed: #CustomEvents. ^retval!

Item was removed: - SystemOrganization addCategory: #'EToys-Buttons'! - SystemOrganization addCategory: #'EToys-CustomEvents'! - SystemOrganization addCategory: #'EToys-Experimental'! - SystemOrganization addCategory: #'EToys-Outliner'! - SystemOrganization addCategory: #'EToys-Protocols'! - SystemOrganization addCategory: #'EToys-Protocols-Type Vocabularies'! - SystemOrganization addCategory: #'EToys-Scripting'! - SystemOrganization addCategory: #'EToys-Scripting Support'! - SystemOrganization addCategory: #'EToys-Scripting Tiles'! - SystemOrganization addCategory: #'EToys-Stacks'! - SystemOrganization addCategory: #'EToys-StarSqueak'! - SystemOrganization addCategory: #'EToys-Tile Scriptors'! - SystemOrganization addCategory: #'EToys-Widgets'!