From VisualWorks®, 7.6 of February 8, 2008 on March 3, 2008 at 9:43:44 pm (Dialog confirm: 'You are filing-in a Parcel source file!\\While this is possible it will not have\the same effect as loading the parcel.\None of the Parcel''s prerequisites will\be loaded and none of its load actions\will be performed.\\Are you sure you want to file-in?' withCRs) ifFalse: [self error: 'Parcel file-in abandoned. Choose terminate or close.'] <class> <name>ParcelManagerTool</name> <environment>Tools</environment> <super>UI.ApplicationModel</super> <private>false</private> none manager <imports></imports> <category>Tools-Parcel Manager</category> <attributes> <package>Tools-Parcel Manager</package> </attributes> </class> <comment> Tools.ParcelManagerTool
This is an abstract superclass of subapplications of the Parcel Manager window. Instance Variables: manager <ParcelManager> The ParcelManager serviced by this tool.
</comment> <class> <name>ParcelDirectoriesTool</name> <environment>Tools</environment> <super>Tools.ParcelManagerTool</super> <private>false</private> none directoryListHolder <imports></imports> <category>Tools-Parcel Manager</category> <attributes> <package>Tools-Parcel Manager</package> </attributes> </class> <comment> Tools.ParcelDirectoriesTool
This is a model of the hierarchical view of parcel directories that appears when the 'Directories' tab is selected on the left-hand side notebook. When a selection is made, the tool notifies the manager by sending a message #selectedGroups:. Instance Variables: directoryListHolder <SelectionInList> The model of the tree view of directories.
</comment> <class> <name>ParcelSelectionTool</name> <environment>Tools</environment> <super>Tools.ParcelManagerTool</super> <private>false</private> none <imports></imports> <category>Tools-Parcel Manager</category> <attributes> <package>Tools-Parcel Manager</package> </attributes> </class> <comment> Tools.ParcelSelectionTool
This is the abstract superclass of the tools that display a list of parcels and allow the user select one or more parcel. When parcel selection changes, the tool notifies the manager with a message #selectedParcels:. Subclasses must implement the following messages: accessing selectAll selections selections:
</comment> <class> <name>ParcelListTool</name> <environment>Tools</environment> <super>Tools.ParcelSelectionTool</super> <private>false</private> none parcelListHolder <imports></imports> <category>Tools-Parcel Manager</category> <attributes> <package>Tools-Parcel Manager</package> </attributes> </class> <comment> Tools.ParcelListTool
This is the model of an alphabetical list of parcels which is visible when the 'Alphabetical' tab is selected in the top right corner of the parcel manager is selected. It expects to receive a list of parcels to display as an argument of the #parcels: message. Instance Variables: parcelListHolder <MultiSelectionInList> description of parcelListHolder
</comment> <class> <name>ParcelGroup</name> <environment>Tools</environment> <super>Core.Object</super> <private>false</private> none name description subgroups items <imports> XML.Element XML.Attribute XML.Document </imports> <category>Tools-Parcel Manager</category> <attributes> <package>Tools-Parcel Manager</package> </attributes> </class> <comment> Tools.ParcelGroup
I am a group of parcels. I hold onto a collection of parcels I contain, as well as onto a collection of subgroups (that is, groups form a tree-like structure). Instance Variables: description <String> A description of parcels I contain. items <Collection of: <ParcelFileItem|ParcelInImageItem>> The items I contain. name <String> My name, displayed in various lists. subgroups <Collection of: <ParcelGroup>> Parcel groups I contain.
</comment> <class> <name>TopLevelParcelGroup</name> <environment>Tools</environment> <super>Tools.ParcelGroup</super> <private>false</private> none visualWorksGroup goodiesGroup previewGroup <imports></imports> <category>Tools-Parcel Manager</category> <attributes> <package>Tools-Parcel Manager</package> </attributes> </class> <comment> Tools.TopLevelParcelGroup
TopLevelParcelGroup is used by the directory tree view of parcels as the top-level item. It is also responsible for retrieving the actual data from the disk. Its direct subgroups include two predefined ones: VisualWorks group includes all parcel directories listed in the parcel path of Settings which start with $(VISUALWORKS). They are assumed to be directories that contain VisualWorks components. However, directories that start with $(VISUALWORKS) and contain 'goodies' are excluded from this group. Parcels that belong to these directories are shown in the lists with a "wrapped package" icon to indicate that they are standard supported components of VisualWorks. Goodies group includes all the directories which start with $(VISUALWORKS)\goodies and are assumed to contain goodies--unsupported parcels both from ParcPlace and 3rd party. There may be other subgroups, for other directories in the parcel path, such as '.'. All parcels belonging to directories other than VisualWorks are shown in the list with a "shopping bag" icon to distinguish them from supported parcels. Instance Variables: goodiesGroup <ParcelDirectory> description of goodiesGroup visualWorksGroup <ParcelGroup> description of visualWorksGroup
</comment> <class> <name>ParcelPrereqReference</name> <environment>Tools</environment> <super>Core.Object</super> <private>false</private> none item <imports></imports> <category>Tools-Parcel Manager</category> <attributes> <package>Tools-Parcel Manager</package> </attributes> </class> <comment> Tools.ParcelPrereqReference
ParcelPrereqReferences are used to keep track of prerequisites of a parcel. A ParcelPrereqItem contains ParcelPrereqReference instances as it prerequisites. ParcelPrereqReferences refer to the actual parcels. Each parcel knows the references to it (a parcel is a factory of references to it), which allows traversal of the prerequisite graph in both directions. A ParcelPrereqReference is normally created by sending a message #newReference to the parcel. Instance Variables: item <ParcelPrereqItem> The parcel this is a reference to.
</comment> <class> <name>ParcelManager</name> <environment>Tools</environment> <super>UI.ApplicationModel</super> <private>false</private> none categoryHolder parcelHolder detailHolder statusTextHolder categorySubapplication parcelSubapplication detailSubapplication selectedGroups displayedParcels selectedParcels <imports> private Refactory.Browser.RefactoringBrowser private Refactory.Browser.NavigatorState </imports> <category>Tools-Parcel Manager</category> <attributes> <package>Tools-Parcel Manager</package> </attributes> </class> <comment> Tools.ParcelManager
This is the top-level application model of the parcel manager. Instance Variables: categoryHolder <SelectionInList> This is the aspect of the left hand side notebook. It selects the kind of categorization we want to use when looking at parcels. parcelHolder <SelectionInList> This is the aspect of the top right notebook. It selects how we want to arrange the current parcel list: alphabetically or hierarchicaly in prerequisite order. detailHolder <SelectionInList> This is the aspect of the bottom right notebook. It selects what kind of information we want to see about the selected parcel(s). statusTextHolder <ValueHolder on: String> The aspect of the status bar text. categorySubapplication <ParcelManagerTool> The current application installed in the categorization notebook. parcelSubapplication <ParcelListTool | ParcelPrereqTreeTool> The current application installed in the parcel list view notebook. detailSubapplication <ParcelCommentTool | ParcelPropertiesTool> The current application installed in the parcel detail view notebook. selectedGroups <Collection of: ParcelGroup> Groups currently selected. displayedParcels <Collection of: <ParcelFileItem|ParcelInImageItem>> Parcels currently displayed in the parcel list view. selectedParcels <Collection of: <ParcelFileItem|ParcelInImageItem>> Parcels currently selected.
</comment> <class> <name>ParcelPrereqItem</name> <environment>Tools</environment> <super>Core.Object</super> <private>false</private> none parcel prerequisiteNames prerequisiteReferences references <imports></imports> <category>Tools-Parcel Manager</category> <attributes> <package>Tools-Parcel Manager</package> </attributes> </class> <comment> Tools.ParcelPrereqItem
ParcelPrereqItem is a wrapper on a parcel item (i.e. ParcelFileItem or ParcelInImageItem) keeping track of prerequisites of parcel it represents. Instance Variables: parcel <ParcelFileItem | ParcelInImageItem> The actual parcel (or rather, an item on the actual parcel). prerequisiteNames <Collection of: String> Names of parcels which are prerequisites of this one. prerequisiteReferences <Collection of: ParcelPrereqReference> References to the prerequisite parcels. references <Collection of: ParcelPrereqReference> Existing references to this parcel.
</comment> <class> <name>ParcelFavoritesTool</name> <environment>Tools</environment> <super>Tools.ParcelManagerTool</super> <private>false</private> none folderTreeHolder <imports> XML.XMLParser </imports> <category>Tools-Parcel Manager</category> <attributes> <package>Tools-Parcel Manager</package> </attributes> </class> <comment> Tools.ParcelFavoritesTool
This is the model for the list of parcel categories that appears when the 'Suggestions' tab is selected. Methods on the class side define the categories that appear in the list (which is actually a tree widget) and their content. In this release, categories and parcels in them are hard-coded. In future releases, an information field will be added to parcel files, and the list will be compiled automatically. Instance Variables: folderTreeHolder <MultiSelectionInTree> The aspect of the list of categories.
</comment> <class> <name>ParcelLoadedTool</name> <environment>Tools</environment> <super>Tools.ParcelFavoritesTool</super> <private>false</private> none <imports></imports> <category>Tools-Parcel Manager</category> <attributes> <package>Tools-Parcel Manager</package> </attributes> </class> <comment> Tools.ParcelLoadedTool
This is the model of the list of categories of currently loaded parcels. It appears when 'Loaded' tab is selected on the left-hand side notebook. The class side methods compute the list current at the time when they are invoked.
</comment> <class> <name>ParcelInImageItem</name> <environment>Tools</environment> <super>Core.Object</super> <private>false</private> none parcel <imports></imports> <category>Tools-Parcel Manager</category> <attributes> <package>Tools-Parcel Manager</package> </attributes> </class> <comment> Tools.ParcelInImageItem
I represent a parcel that is currently loaded. Instance Variables: parcel <CodeComponent | Pundle> description of parcel
</comment> <class> <name>ParcelCommentTool</name> <environment>Tools</environment> <super>Tools.ParcelManagerTool</super> <private>false</private> none textHolder <imports></imports> <category>Tools-Parcel Manager</category> <attributes> <package>Tools-Parcel Manager</package> </attributes> </class> <comment> Tools.ParcelCommentTool
This is the application model that shows the selected parcel's comments when the Comment tab is selected in the lower right corner of the parcel manager window. Like other application models for that part of the manager, it responds to message #parcels: to accept the list of parcels to show. Instance Variables: textHolder <ValueHolder on: Text> The aspect of the text widget displaying the comment.
</comment> <class> <name>ParcelDirectory</name> <environment>Tools</environment> <super>Tools.ParcelGroup</super> <private>false</private> none path <imports></imports> <category>Tools-Parcel Manager</category> <attributes> <package>Tools-Parcel Manager</package> </attributes> </class> <comment> Tools.ParcelDirectory
ParcelDirectory is a special kind of ParcelGroup, which obtains its items and subgroups from a directory. Parcel files in the directory become items, and subdirectories become subgroups, if requested. Instance Variables: path <Filename> The path to the directory.
</comment> <class> <name>ParcelPrereqTreeTool</name> <environment>Tools</environment> <super>Tools.ParcelSelectionTool</super> <private>false</private> none itemTree <imports></imports> <category>Tools-Parcel Manager</category> <attributes> <package>Tools-Parcel Manager</package> </attributes> </class> <comment> Tools.ParcelPrereqTreeTool
This is the model of the parcel selection tool that arranges the parcels into a tree to show their prerequisite relationship. Instance Variables: itemTree <MultiSelectionInTree> The aspect of the tree view.
</comment> <class> <name>ParcelPropertiesTool</name> <environment>Tools</environment> <super>Tools.ParcelManagerTool</super> <private>false</private> none textHolder <imports></imports> <category>Tools-Parcel Manager</category> <attributes> <package>Tools-Parcel Manager</package> </attributes> </class> <comment> Tools.ParcelPropertiesTool
This is the application model that shows the selected parcel's properties when the Properties tab is selected in the lower right corner of the parcel manager window. Like other application models for that part of the manager, it responds to message #parcels: to accept the list of parcels to show. Instance Variables: textHolder <ValueModel> description of textHolder
</comment> <class> <name>ParcelFileItem</name> <environment>Tools</environment> <super>Core.Object</super> <private>false</private> none filename properties <imports> XML.Element </imports> <category>Tools-Parcel Manager</category> <attributes> <package>Tools-Parcel Manager</package> </attributes> </class> <comment> Tools.ParcelFileItem
I represent a parcel file on the disk. I am used by various lists in the Parcel Manager to show that parcel. Instance Variables: filename <Filename> The filename of the parcel path. properties <Dictionary | nil> If not nil, a dictionary of parcel properties loaded from the file. If nil, either the properties have not been read yet, or the file is inaccessible.
</comment> <class> <name>ParcelPrereqCollector</name> <environment>Tools</environment> <super>Core.Object</super> <private>false</private> none knownItems topItems <imports></imports> <category>Tools-Parcel Manager</category> <attributes> <package>Tools-Parcel Manager</package> </attributes> </class> <comment> Tools.ParcelPrereqCollector
ParcelPrereqCollector reveals the prerequisite relationship between parcels. Parcels supplied to it using #addParcel: and #addAllParcels: are wrapped into ParcelPrereqItems. Parcels which are not prerequisites of other parcels end up in the 'topItems' collection. Other parcels are contained somewhere in prerequisite trees of those parcels. Instance Variables: knownItems <(Collection of: ParcelPrereqItem)> A collection of items created on all parcels added so far. topItems <(Collection of: (ParcelFileItem | ParcelInImageItem | ParcelPrereqItem))> Items of parcels added so far, that are not prerequisites of any other known parcels.
</comment> <methods> Tools.ParcelManagerTool <category>utilities</category>
orderedSelectionsOf: aMultiSelectionInList "Since multi selection in list reports #selections as a Set, they come out unordered. It really is more useful to be able to get them in the order they appear in the list. This is what this method is doing." | list | list := aMultiSelectionInList list. ^aMultiSelectionInList selectionIndexes asSortedCollection collect: [:each | list at: each]
</methods> <methods> Tools.ParcelManagerTool <category>initialize-release</category>
manager: aParcelManager manager := aParcelManager
</methods> <methods> Tools.ParcelManagerTool <category>actions</category>
refresh
</methods> <methods> Tools.ParcelManagerTool <category>private</category>
adjustReadOnlyWidgetBackground: aSymbol with: aBuilder "The default policy of giving distinguished backgrounds colors to read-only widgets looks bad in some cases. Change the specified widget to use regular text colors." | preferences | (aBuilder componentAt: aSymbol) ifNotNil: [:wrapper | preferences := LookPreferences new backgroundColor: SymbolicPaint textDataBackground asColorValue. preferences := preferences foregroundColor: SymbolicPaint textDataForeground asColorValue. wrapper widgetState colors: preferences]
</methods> <methods> Tools.ParcelManagerTool class <category>accessing</category>
tabLabel self subclassResponsibility
</methods> <methods> Tools.ParcelDirectoriesTool <category>notifications</category>
directorySelected manager selectedGroups: (self orderedSelectionsOf: self directoryListHolder)
</methods> <methods> Tools.ParcelDirectoriesTool <category>initialize-release</category>
initialize self directoryListHolder list: (TreeModel on: TopLevelParcelGroup current displayRoot: false childrenWith: [:item | item sortedSubgroups]). self directoryListHolder selectionIndexHolder onChangeSend: #directorySelected to: self
postBuildWith: aBuilder | treeView | treeView := (aBuilder componentAt: #directoryTree) widget. treeView controller expandFullyRoot
</methods> <methods> Tools.ParcelDirectoriesTool <category>aspects</category>
directoryListHolder "This method was generated by UIDefiner. Any edits made here may be lost whenever methods are automatically defined. The initialization provided below may have been preempted by an initialize method." ^directoryListHolder isNil ifTrue: [directoryListHolder := MultiSelectionInTree new] ifFalse: [directoryListHolder]
</methods> <methods> Tools.ParcelDirectoriesTool class <category>accessing</category>
description ^(#AllDirectoriesSystemSearchesParcel << #dialogs >> 'All directories the system searches to load parcels') asString
tabLabel ^(#Directories << #labels >> 'Directories') asString
</methods> <methods> Tools.ParcelSelectionTool <category>accessing</category>
selectAll "Subclasses should redefine this to select all displayed parcels." self subclassResponsibility
selections "Subclasses should redefine this to return a collection of currently selected parcels." self subclassResponsibility
selections: parcelCollection "Try to select the parcels in the argument collection. Not all of them are necessarily displayed now." self subclassResponsibility
</methods> <methods> Tools.ParcelSelectionTool <category>notifications</category>
parcelDoubleClicked: aSequenceController | selectedParcels | selectedParcels := self selections. ((selectedParcels allSatisfy: [:each | each isLoaded]) and: [self confirmUnloadOf: selectedParcels]) ifTrue: [^manager unloadParcels: selectedParcels]. ((selectedParcels allSatisfy: [:each | each isLoaded not]) and: [self confirmLoadOf: selectedParcels]) ifTrue: [^manager loadParcels: selectedParcels]
parcelSelected manager selectedParcels: self selections
</methods> <methods> Tools.ParcelSelectionTool <category>actions</category>
browseParcels manager browseParcels
loadParcels manager loadParcels: self selections
openChanges manager openChanges
openConflicts manager openConflicts
unloadParcels manager unloadParcels: self selections
</methods> <methods> Tools.ParcelSelectionTool <category>testing</category>
canBrowse ^self canUnload "since that means all selections are loaded"
canLoad | selections | selections := self selections. ^selections isEmpty not and: [selections allSatisfy: [:each | each isLoaded not and: [each isAccessible]]]
canUnload | selections | selections := self selections. ^selections isEmpty not and: [selections allSatisfy: [:each | each isLoaded]]
selectionsHaveSource | selections | selections := self selections. ^selections notEmpty and: [selections allSatisfy: [:each | each sourceExists]]
</methods> <methods> Tools.ParcelSelectionTool <category>private</category>
confirmLoadOf: parcelCollection | message | message := parcelCollection size = 1 ifTrue: [(#Load1sQ << #dialogs >> 'Load "<1s>"?') expandMacrosWith: parcelCollection first displayString] ifFalse: [(#LoadSelectedParcelsQ << #dialogs >> 'Load selected parcels?')]. ^Dialog confirm: message
confirmUnloadOf: parcelCollection | message | message := parcelCollection size = 1 ifTrue: [(#Unload1sQ << #dialogs >> 'Unload "<1s>"?') expandMacrosWith: parcelCollection first displayString] ifFalse: [(#UnloadSelectedParcelsQ << #dialogs >> 'Unload selected parcels?')]. ^Dialog confirm: message
popupMenu | menu | menu := self class basicParcelMenu. (menu atNameKey: #load) enabled: [self canLoad]. (menu atNameKey: #unload) enabled: [self canUnload]. (menu atNameKey: #openChanges) enabled: [self selectionsHaveSource]. (menu atNameKey: #openConflicts) enabled: [self selectionsHaveSource]. (menu atNameKey: #browse) enabled: [self canBrowse]. ^menu
</methods> <methods> Tools.ParcelListTool <category>accessing</category>
parcels: parcelCollection self parcelListHolder list: (self sorted: parcelCollection) asList
selectAll self parcelListHolder selectAll
selections ^self orderedSelectionsOf: self parcelListHolder
selections: parcelCollection self parcelListHolder selections: parcelCollection
</methods> <methods> Tools.ParcelListTool <category>private</category>
createItemOf: aView at: index reversing: aBoolean | item label | item := aView sequence at: index. label := self createLabelAndIconOf: item for: aView. ^aBoolean ifTrue: [(ReversingWrapper on: label) reverse: true asValue] ifFalse: [label]
createLabelAndIconOf: item for: aView ^(ExtendedLabelAndIcon with: item displayString attributes: aView textStyle offset: 0 @ 0) icon: item iconForLists; yourself
selectedVisualBlock ^[:view :index | BoundedWrapper on: (self createItemOf: view at: index reversing: true)]
sorted: parcelCollection ^(parcelCollection asSortedCollection: [:a :b | a displayString <= b displayString]) asArray
unselectedVisualBlock ^[:view :index | BoundedWrapper on: (self createItemOf: view at: index reversing: false)]
</methods> <methods> Tools.ParcelListTool <category>initialize-release</category>
initialize self parcelListHolder selectionIndexHolder onChangeSend: #parcelSelected to: self
postBuildWith: aBuilder | listWidget | listWidget := (aBuilder componentAt: #parcelList) widget. listWidget visualBlock: self unselectedVisualBlock. listWidget selectedVisualBlock: self selectedVisualBlock
</methods> <methods> Tools.ParcelListTool <category>aspects</category>
parcelListHolder "This method was generated by UIDefiner. Any edits made here may be lost whenever methods are automatically defined. The initialization provided below may have been preempted by an initialize method." ^parcelListHolder isNil ifTrue: [parcelListHolder := MultiSelectionInList new] ifFalse: [parcelListHolder]
</methods> <methods> Tools.ParcelListTool class <category>accessing</category>
tabLabel ^(#Alphabetical << #labels >> 'Alphabetical') asString
</methods> <methods> Tools.ParcelGroup <category>accessing</category>
addItem: aParcelItem items add: aParcelItem
addItems: aCollection items addAll: aCollection
addSubgroup: aParcelGroup subgroups add: aParcelGroup
addSubgroups: aCollection subgroups addAll: aCollection
description ^description isNil ifTrue: [self name] ifFalse: [description]
findGroup: aBlock (aBlock value: self) ifTrue: [^self]. subgroups do: [:each | | found | found := each findGroup: aBlock. found notNil ifTrue: [^found]]. ^nil
items ^items
name ^name == nil ifTrue: [nil] ifFalse: [name asString]
sortedSubgroups ^subgroups asSortedCollection: [:a :b | a name <= b name]
subgroups ^subgroups
</methods> <methods> Tools.ParcelGroup <category>initialize-release</category>
description: aString description := aString
initialize items := OrderedCollection new. subgroups := OrderedCollection new
name: aString name := aString
retrieveParcelFiles
</methods> <methods> Tools.ParcelGroup <category>testing</category>
isDirectory ^false
</methods> <methods> Tools.ParcelGroup <category>enumeration</category>
allItemsDo: aBlock self itemsDo: aBlock. subgroups do: [:each | each allItemsDo: aBlock]
itemsDo: aBlock items do: aBlock
subgroupsDo: aBlock subgroups do: aBlock
withAllSubgroupsDo: aBlock aBlock value: self. subgroups do: [:each | each withAllSubgroupsDo: aBlock]
</methods> <methods> Tools.ParcelGroup <category>printing</category>
displayString ^name notNil ifTrue: [self name] ifFalse: [super displayString]
printOn: aStream super printOn: aStream. aStream nextPutAll: ' ('; print: self name; nextPutAll: ')'
</methods> <methods> Tools.ParcelGroup <category>xml representation</category>
asXmlDocument ^XML.Document new addNode: self asXmlElement; yourself
asXmlElement ^Element tag: 'group' attributes: (Array with: (Attribute name: 'name' value: name) with: (Attribute name: 'description' value: description)) elements: (Array with: (Element tag: 'subgroups' elements: self subgroupsAsXmlElements) with: (Element tag: 'items' elements: self itemsAsXmlElements))
itemsAsXmlElements ^items isEmpty ifTrue: [nil] ifFalse: [items collect: [:each | each asXmlElement]]
subgroupsAsXmlElements ^subgroups isEmpty ifTrue: [nil] ifFalse: [subgroups collect: [:each | each asXmlElement]]
</methods> <methods> Tools.ParcelGroup class <category>instance creation</category>
named: aString ^self new name: aString; yourself
named: aString description: anotherString ^self new name: aString; description: anotherString; yourself
new ^super new initialize
</methods> <methods> Tools.ParcelGroup class <category>xml reading</category>
fromXmlElement: anElement "Answer a group created from the element. Signal an error in case of any problems with the element contents." | groupName description subgroups items | anElement tag type = 'group' ifFalse: [self invalidXmlElement]. groupName := anElement valueOfAttribute: 'name' ifAbsent: [self invalidXmlElement]. description := anElement valueOfAttribute: 'description' ifAbsent: [self invalidXmlElement]. subgroups := anElement elementNamed: 'subgroups'. items := anElement elementNamed: 'items'. subgroups := subgroups realElements collect: [:each | self fromXmlElement: each]. items := items realElements collect: [:each | ParcelFileItem fromXmlElement: each]. ^(self named: groupName description: description) addSubgroups: subgroups; addItems: items; yourself
invalidXmlElement self error: #InvalidXmlInParcelGroup << #dialogs >> 'Invalid XML in parcel group definition'
</methods> <methods> Tools.TopLevelParcelGroup <category>accessing</category>
goodiesGroup ^goodiesGroup
sortedSubgroups | extraGroups home sorted | extraGroups := subgroups copy. extraGroups remove: visualWorksGroup; remove: goodiesGroup; remove: previewGroup. home := extraGroups detect: [:some | some name = '.'] ifNone: [nil]. sorted := OrderedCollection new. home notNil ifTrue: [extraGroups remove: home. sorted add: home]. sorted add: visualWorksGroup; add: goodiesGroup; add: previewGroup. sorted addAll: (extraGroups asSortedCollection: [:a :b | a name <= b name]). ^sorted asArray
visualWorksGroup ^visualWorksGroup
</methods> <methods> Tools.TopLevelParcelGroup <category>private</category>
findOrCreateGroupFor: aFilename | group | group := self findGroup: [:some | some isDirectory and: [some path = aFilename]]. group notNil ifTrue: [^group]. group := ParcelDirectory path: aFilename. aFilename isVisualWorksFile ifTrue: [visualWorksGroup addSubgroup: group] ifFalse: [self addSubgroup: group]. ^group
</methods> <methods> Tools.TopLevelParcelGroup <category>initialize-release</category>
addEntry: aFilename (aFilename asString includes: $*) ifTrue: [^self addWildcardEntry: aFilename]. (self subgroups anySatisfy: [:grp | grp isDirectory and: [grp path asString = aFilename asString]]) ifFalse: [aFilename exists ifFalse: [^self]. aFilename isVisualWorksFile ifTrue: [visualWorksGroup addSubgroup: (ParcelDirectory path: aFilename)] ifFalse: [self addSubgroup: (ParcelDirectory path: aFilename)]]
addWildcardEntry: aFilename | directory group groups subGroups | directory := aFilename directory. ^(directory asString includes: $*) ifTrue: [groups := self addWildcardEntry: directory. subGroups := OrderedCollection new. groups do: [:each | each retrieveSubdirectories. subGroups addAll: each subgroups]. subGroups] ifFalse: [group := self findOrCreateGroupFor: directory. group retrieveSubdirectories. group subgroups]
initialize super initialize. visualWorksGroup := ParcelGroup named: (#VisualWorks << #dialogs >> 'VisualWorks') description: (#ParcelsSuppliedWithVisualWorks << #labels >> 'Parcels supplied with VisualWorks.'). self addSubgroup: visualWorksGroup. goodiesGroup := ParcelDirectory path: (Filename fromComponents: #('$(VISUALWORKS)' 'contributed')) name: (#Contributed << #dialogs >> 'Contributed') description: (#ContributedGroupDescription << #labels >> 'Third party applications and components. Not supported by Cincom.'). self addSubgroup: goodiesGroup. previewGroup := ParcelDirectory path: (Filename fromComponents: #('$(VISUALWORKS)' 'preview')) name: (#Preview << #dialogs >> 'Preview') description: (#PreviewGroupDescription << #dialogs >> 'VisualWorks components still in active development and not yet released officially.'). self addSubgroup: previewGroup
</methods> <methods> Tools.TopLevelParcelGroup class <category>utilities</category>
current "Return the top group for the system as it is at the moment." "self current" | topLevel | topLevel := self new. (UISettings preferenceFor: #parcelPath) do: [:each | topLevel addEntry: each]. ^topLevel
reportUncommentedParcels "self reportUncommentedParcels" | top | Transcript cr; show: (#UncommentedParcels << #dialogs >> '*** Uncommented parcels ***'); cr. top := self current. top withAllSubgroupsDo: [:each | each isDirectory ifTrue: [each retrieveParcelFiles]]. top allItemsDo: [:each | each comment isNil ifTrue: [Transcript tab; show: each filename asString; cr]]. Transcript show: (#Done << #dialogs >> '*** done ***')
</methods> <methods> Tools.ParcelPrereqReference <category>accessing</category>
allSiblings ^item references copyWithout: self
item ^item
name ^self item name
refersTo: aPrereqItem ^item = aPrereqItem
withAllSiblings ^item references
</methods> <methods> Tools.ParcelPrereqReference <category>initialize-release</category>
item: anItem item := anItem
</methods> <methods> Tools.ParcelManager <category>aspects</category>
categoryHolder "This method was generated by UIDefiner. Any edits made here may be lost whenever methods are automatically defined. The initialization provided below may have been preempted by an initialize method." ^categoryHolder isNil ifTrue: [categoryHolder := SelectionInList new] ifFalse: [categoryHolder]
detailHolder "This method was generated by UIDefiner. Any edits made here may be lost whenever methods are automatically defined. The initialization provided below may have been preempted by an initialize method." ^detailHolder isNil ifTrue: [detailHolder := SelectionInList new] ifFalse: [detailHolder]
parcelHolder "This method was generated by UIDefiner. Any edits made here may be lost whenever methods are automatically defined. The initialization provided below may have been preempted by an initialize method." ^parcelHolder isNil ifTrue: [parcelHolder := SelectionInList new] ifFalse: [parcelHolder]
statusTextHolder "This method was generated by UIDefiner. Any edits made here may be lost whenever methods are automatically defined. The initialization provided below may have been preempted by an initialize method." ^statusTextHolder isNil ifTrue: [statusTextHolder := String new asValue] ifFalse: [statusTextHolder]
</methods> <methods> Tools.ParcelManager <category>private</category>
checkForDanglingReferences: aParcel aParcel hasDanglingReferencesIfUnloaded ifTrue: [^Dialog confirm: ((#ParcelHasDanglingRefs << #dialogs >> '<1s> has dangling references.<n>Do you really want to unload the parcel''s code?') expandMacrosWith: aParcel name)]. ^true
createCategoryClient: aClass categorySubapplication := aClass new. categorySubapplication manager: self. ^categorySubapplication
createDetailClient: aClass detailSubapplication := aClass new. detailSubapplication manager: self; parcels: selectedParcels. ^detailSubapplication
createParcelClient: aClass parcelSubapplication := aClass new. parcelSubapplication manager: self; parcels: displayedParcels. ^parcelSubapplication
descriptionOfGroups: groupCollection groupCollection isEmpty ifTrue: [^(#NoSelection << #dialogs >> 'No selection')]. groupCollection size = 1 ifTrue: [^groupCollection first description]. ^((#x1sGroupsSelected << #dialogs >> '<1s> groups selected') expandMacrosWith: groupCollection size printString)
descriptionOfParcel: aParcelFile ^aParcelFile description
descriptionOfParcels: parcelCollection parcelCollection size = 1 ifTrue: [^self descriptionOfParcel: parcelCollection first]. ^((#x1sParcelsSelected << #dialogs >> '<1s> parcels selected') expandMacrosWith: parcelCollection size printString)
displayLoadFailureSummary: filenameCollection | messageStream | messageStream := String new writeStream. messageStream nextPutAll: (#LoadFailureSummary << #dialogs >> 'The following parcels could not be loaded due to OS errors:') asString; cr. filenameCollection do: [:each | messageStream nextPutAll: each asString; cr]. ^Dialog warn: messageStream contents
parcelsSortedForUnload: parcelCollection | parcels | parcels := (parcelCollection collect: [:each | Parcel parcelNamed: each name]) reject: [:some | some isNil]. ^(SystemUtils sortForLoading: parcels) reverse
postUnloadParcel (Dialog confirm: (#removeCatagoriesAndPurge << #dialogs >> 'Remove empty categories and purge Undeclared?')) ifTrue: [Cursor execute showWhile: [Root allNameSpaces do: [:ns | ns organization removeEmptyCategories]. ClassOrganizer allInstancesDo: [:clo | clo removeEmptyCategories]. Undeclared purgeUnusedBindings]]
refreshAll self refreshToolbar; refreshStatusBar. builder window component invalidate "to force icon repaint"
refreshStatusBar self statusTextHolder value: self statusBarText
refreshToolbar | toolbar sourceExists | toolbar := builder componentAt: #toolbarMenu. toolbar isNil ifTrue: [^self]. (toolbar componentAt: #load) isEnabled: self canLoad. (toolbar componentAt: #unload) isEnabled: self canUnload. sourceExists := self selectionsHaveSource. (toolbar componentAt: #openChanges) isEnabled: sourceExists. (toolbar componentAt: #openConflicts) isEnabled: sourceExists. (toolbar componentAt: #browse) isEnabled: self canBrowse. (toolbar componentAt: #selectAll) isEnabled: self anyParcelsDisplayed
statusBarText ^selectedParcels isEmpty ifTrue: [self descriptionOfGroups: selectedGroups] ifFalse: [self descriptionOfParcels: selectedParcels]
</methods> <methods> Tools.ParcelManager <category>notifications</category>
categoryTabSelected | clientClass | clientClass := self categoryHolder selection. clientClass isNil ifTrue: [^self]. self selectedGroups: Array new. Cursor wait showWhile: [(builder componentAt: #categoryNotebook) widget client: (self createCategoryClient: clientClass) spec: #windowSpec builder: builder newSubBuilder]
detailTabSelected | clientClass | clientClass := self detailHolder selection. clientClass isNil ifTrue: [^self]. (builder componentAt: #detailNotebook) widget client: (self createDetailClient: clientClass) spec: #windowSpec builder: builder newSubBuilder
parcelTabSelected | clientClass oldSelections | clientClass := self parcelHolder selection. clientClass isNil ifTrue: [^self]. oldSelections := selectedParcels. (builder componentAt: #parcelNotebook) widget client: (self createParcelClient: clientClass) spec: #windowSpec builder: builder newSubBuilder. parcelSubapplication selections: oldSelections
selectedGroups: aGroupCollection Cursor wait showWhile: [selectedGroups := aGroupCollection. displayedParcels := OrderedCollection new. aGroupCollection do: [:each | displayedParcels addAll: each items]. parcelSubapplication notNil ifTrue: [parcelSubapplication parcels: displayedParcels]. self refreshStatusBar]
selectedParcels: aCollection "Sent by the subapplication that manages parcel lists, whenever a new set of parcels selected." selectedParcels := aCollection. detailSubapplication notNil ifTrue: [detailSubapplication parcels: selectedParcels]. self refreshToolbar; refreshStatusBar
</methods> <methods> Tools.ParcelManager <category>initialize-release</category>
initialize selectedGroups := displayedParcels := selectedParcels := Array new. self initializeCategoryModel; initializeParcelModel; initializeDetailModel
initializeCategoryModel self categoryHolder list: (List with: ParcelFavoritesTool with: ParcelDirectoriesTool with: ParcelLoadedTool). self categoryHolder selectionIndexHolder onChangeSend: #categoryTabSelected to: self.
initializeDetailModel self detailHolder list: (List with: ParcelCommentTool with: ParcelPropertiesTool). self detailHolder selectionIndexHolder onChangeSend: #detailTabSelected to: self
initializeParcelModel self parcelHolder list: (List with: ParcelListTool with: ParcelPrereqTreeTool). self parcelHolder selectionIndexHolder onChangeSend: #parcelTabSelected to: self
postBuildWith: aBuilder #(categoryNotebook parcelNotebook detailNotebook) do: [:each | (aBuilder componentAt: each) widget tabBar component "ugh" displayStringSelector: #tabLabel]. self categoryHolder selectionIndex: 1. self parcelHolder selectionIndex: 1. self detailHolder selectionIndex: 1
postOpenWith: aBuilder self refreshToolbar; refreshStatusBar
</methods> <methods> Tools.ParcelManager <category>testing</category>
anyParcelsDisplayed ^displayedParcels isEmpty not
canBrowse ^selectedParcels size = 1 and: [self canUnload "that is, it is loaded"]
canLoad ^selectedParcels isEmpty not and: [selectedParcels allSatisfy: [:each | each isLoaded not and: [each isAccessible]]]
canUnload ^selectedParcels isEmpty not and: [selectedParcels allSatisfy: [:each | each isLoaded]]
selectionsHaveSource ^selectedParcels notEmpty and: [selectedParcels allSatisfy: [:each | each sourceExists]]
</methods> <methods> Tools.ParcelManager <category>actions</category>
aboutVisualWorks AboutVisualWorksDialog open
browseParcels | state | state := NavigatorState new. state parcels: selectedParcels. RefactoringBrowser openWithSelection: state
helpTopics SmalltalkWorkbench openHelpBook: 'VisualWorks Tools' topic: 'Parcel Manager'
loadParcelFromFile | filename parcel parcelHandle | filename := Dialog requestFileName: (#OpenParcel << #dialogs >> 'Open parcel') default: '*.pcl'. filename isEmpty ifTrue: [^self]. Notice show: (#LoadingParcelFromFileN1S << #dialogs >> 'Loading Parcel from file<n><1s>' expandMacrosWith: filename asString) while: [parcel := Parcel loadParcelFrom: filename]. parcel isNil ifTrue: [^self]. self categoryHolder selection: ParcelLoadedTool. parcelHandle := ParcelInImageItem new parcel: parcel. parcelHandle isVisualWorksParcel ifTrue: [categorySubapplication selectVisualWorksFolder] ifFalse: [parcelHandle isGoodie ifTrue: [categorySubapplication selectGoodiesFolder] ifFalse: [parcelHandle isPreview ifTrue: [categorySubapplication selectPreviewFolder] ifFalse: [categorySubapplication selectOtherFolder]]]. parcelSubapplication selections: (Array with: parcelHandle)
loadParcels self loadParcels: selectedParcels
loadParcels: parcelCollection Notice show: (#LoadingParcelOrParcels << #dialogs >> 'Loading <1?Parcels:Parcel>' expandMacrosWith: parcelCollection size > 1) while: [ | paths | paths := parcelCollection collect: [:each | each filename]. paths do: [:each | [Parcel loadParcelFrom: each] on: OsError do: [:ex | Dialog report: (#ErrorLoadingParcel1S << #dialogs >> 'Error loading parcel <1s>' expandMacrosWith: each asString) withTextSignalledBy: ex]]]. self refreshAll
openChanges selectedParcels do: [:each | ChangeList openOnFileNamed: each sourceFilename]
openConflicts selectedParcels do: [:each | | changeList | changeList := ChangeList new. changeList checkSystem: #exact; showConflicts: true; scanFilename: each sourceFilename. changeList open]
selectAll parcelSubapplication selectAll
unloadParcels self unloadParcels: selectedParcels
unloadParcels: parcelCollection Notice show: (#UnloadingParcelOrParcels << #dialogs >> 'Unloading <1?Parcels:Parcel>' expandMacrosWith: parcelCollection size > 1) while: [ | parcels | parcels := self parcelsSortedForUnload: parcelCollection. parcels do: [:parcel | (self checkForDanglingReferences: parcel) ifFalse: [^self]. (Parcel unloadParcelNamed: parcel name) ifTrue: [self postUnloadParcel]]]. categorySubapplication refresh. self refreshAll
</methods> <methods> Tools.ParcelManager class <category>generated resources</category>
browseIcon ^ToolbarIconLibrary default enablementVisualFor: #parcelBrowser
changeListConflictsIcon ^ToolbarIconLibrary default enablementVisualFor: #changeListConflicts
changeListIcon ^ToolbarIconLibrary default enablementVisualFor: #changeList
loadIcon ^ToolbarIconLibrary default enablementVisualFor: #loadParcel
selectAllIcon ^ToolbarIconLibrary default enablementVisualFor: #selectAll
unloadIcon ^ToolbarIconLibrary default enablementVisualFor: #unloadParcel
</methods> <methods> Tools.ParcelManager class <category>interface opening</category>
open "Override to use the currently-open manager, if one exists." ^self raiseSingleInstance ifNil: [super open]
</methods> <methods> Tools.ParcelPrereqItem <category>accessing</category>
addPrerequisiteReference: anItemReference prerequisiteReferences add: anItemReference
iconForLists ^parcel iconForLists
name ^parcel nameOr: [String new]
newReference | reference | reference := ParcelPrereqReference new item: self. references add: reference. ^reference
parcel ^parcel
prerequisiteCount ^prerequisiteReferences size
prerequisiteItems ^self prerequisiteReferences collect: [:each | each item]
prerequisiteReferences ^(prerequisiteReferences asSortedCollection: [:a :b | (prerequisiteNames indexOf: a name) <= (prerequisiteNames indexOf: b name)]) asArray
prerequisitesInclude: anItem ^prerequisiteReferences anySatisfy: [:any | any refersTo: anItem]
prerequisitesIncludeName: aString ^prerequisiteNames includes: aString
referenceCount ^references size
references ^references
</methods> <methods> Tools.ParcelPrereqItem <category>testing</category>
isGoodie ^parcel isGoodie
isLoaded ^parcel isLoaded
isOneOfMany ^self referenceCount > 1
isPreview ^parcel isPreview
isVisualWorksParcel ^parcel isVisualWorksParcel
</methods> <methods> Tools.ParcelPrereqItem <category>initialize-release</category>
parcel: aParcelFile parcel := aParcelFile. prerequisiteNames := parcel prerequisitesOr: [OrderedCollection new]. prerequisiteNames := prerequisiteNames collect: [:each | each first]. prerequisiteReferences := OrderedCollection new. references := OrderedCollection new
prerequisiteItems: aCollection prerequisiteReferences := aCollection collect: [:each | ParcelPrereqReference new item: each]. prerequisiteNames := aCollection collect: [:each | each name]
</methods> <methods> Tools.ParcelPrereqItem <category>printing</category>
displayString ^parcel displayString
printOn: aStream super printOn: aStream. aStream space; print: self name; space; print: self prerequisiteCount
</methods> <methods> Tools.ParcelPrereqItem <category>comparing</category>
= anotherItem ^parcel = anotherItem parcel
hash ^parcel hash
</methods> <methods> Tools.ParcelFavoritesTool <category>notifications</category>
folderSelected manager selectedGroups: (self orderedSelectionsOf: self folderTreeHolder)
</methods> <methods> Tools.ParcelFavoritesTool <category>aspects</category>
folderTreeHolder "This method was generated by UIDefiner. Any edits made here may be lost whenever methods are automatically defined. The initialization provided below may have been preempted by an initialize method." ^folderTreeHolder isNil ifTrue: [folderTreeHolder := MultiSelectionInTree new] ifFalse: [folderTreeHolder]
</methods> <methods> Tools.ParcelFavoritesTool <category>initialize-release</category>
initialize self folderTreeHolder list: (TreeModel on: self class topLevelGroup displayRoot: false childrenWith: [:item | item subgroups]). self folderTreeHolder selectionIndexHolder onChangeSend: #folderSelected to: self
</methods> <methods> Tools.ParcelFavoritesTool class <category>favorites list</category>
addAdvancedFolderTo: aGroup self addTo: aGroup subgroupNamed: (#AdvancedUtilities << #labels >> 'Advanced Utilities') description: (#AdvancedUtilitiesDesc << #labels >> 'Artifacts subtle and wizardly') withFilesNamed: #( '$(VISUALWORKS)\advanced\ATParserCompiler.pcl' '$(VISUALWORKS)\advanced\ATMetaNumerics.pcl' '$(VISUALWORKS)\goodies\other\T-Gen\T-Gen.pcl' '$(VISUALWORKS)\goodies\other\Regex11.pcl' '$(VISUALWORKS)\goodies\parc\vmplugin\HPSVMPrimitivePlugins.pcl' '$(VISUALWORKS)\goodies\other\SmaCC\SmaCC Development UI.pcl' )
addApplicationDevelopmentFolderTo: aGroup self addTo: aGroup subgroupNamed: (#ApplicationDevelopment << #labels >> 'Application Development') description: (#ApplicationDevelopmentDesc << #labels >> 'Tools and frameworks useful in application development and deployment') withFilesNamed: #( '$(VISUALWORKS)\dllcc\DLLCC.pcl' '$(VISUALWORKS)\parcels\BOSS.pcl' '$(VISUALWORKS)\parcels\Headless.pcl' '$(VISUALWORKS)\parcels\Compression-ZLib.pcl' '$(VISUALWORKS)\goodies\parc\I18n.pcl' '$(VISUALWORKS)\packaging\RuntimePackager.pcl' )
addApplicationServerFolderTo: aGroup self addTo: aGroup subgroupNamed: (#ApplicationServer << #labels >> 'Application Server') description: (#ApplicationServerDesc << #labels >> 'VisualWorks Web Application Server') withFilesNamed: #( '$(VISUALWORKS)\goodies\other\seaside\SeasideForWebToolKit.pcl' '$(VISUALWORKS)\web\WebToolkit.pcl' '$(VISUALWORKS)\wavedev\VisualWave.pcl' '$(VISUALWORKS)\wavedev\VisualWaveDemos.pcl' '$(VISUALWORKS)\waveserver\WaveLoad-Client.pcl' '$(VISUALWORKS)\waveserver\WaveLoad-Server.pcl' )
addDatabaseFolderTo: aGroup self addTo: aGroup subgroupNamed: (#Database << #labels >> 'Database') description: (#DatabaseDesc << #labels >> 'Database interfaces') withFilesNamed: #( '$(VISUALWORKS)\database\ODBCThapiEXDI.pcl' '$(VISUALWORKS)\database\ODBCEXDI.pcl' '$(VISUALWORKS)\database\OracleAlphaUnixThapiEXDI.pcl' '$(VISUALWORKS)\database\OracleEXDI.pcl' '$(VISUALWORKS)\database\OracleThapiEXDI.pcl' '$(VISUALWORKS)\database\OracleLens-Dev.pcl' '$(VISUALWORKS)\database\OracleLens.pcl' '$(VISUALWORKS)\goodies\other\PostgreSQL\PostgreSQLEXDI.pcl' '$(VISUALWORKS)\goodies\other\DB2\DB2EXDI.pcl' '$(VISUALWORKS)\goodies\other\DB2\DB2ThapiEXDI.pcl' )
addDeveloperToolsFolderTo: aGroup self addTo: aGroup subgroupNamed: (#DeveloperTools << #labels >> 'Developer Tools') description: (#DeveloperToolsDesc << #labels >> 'System components to make a developer''s life easier') withFilesNamed: #( '$(VISUALWORKS)\advanced\ATBenchmarks.pcl' '$(VISUALWORKS)\advanced\ATProfilingCore.pcl' '$(VISUALWORKS)\advanced\ATProfilingUI.pcl' '$(VISUALWORKS)\advanced\ATSystemAnalysis.pcl' '$(VISUALWORKS)\parcels\UIPainter.pcl' '$(VISUALWORKS)\goodies\other\Heeg\GHTools.pcl' '$(VISUALWORKS)\store\StoreForOracle8.pcl' '$(VISUALWORKS)\store\StoreForSqlServer.pcl' '$(VISUALWORKS)\goodies\other\PostgreSQL\StoreForPostgreSQL.pcl' '$(VISUALWORKS)\goodies\other\DB2\StoreForDB2.pcl' '$(VISUALWORKS)\goodies\other\SUnit\SUnitUI.pcl' '$(VISUALWORKS)\goodies\parc\Method-History.pcl' )
addDistributedComputingFolderTo: aGroup self addTo: aGroup subgroupNamed: (#DistributedComputing << #labels >> 'Distributed Computing') description: (#DistributedComputingDescr << #labels >> 'Various frameworks, protocols and tools for distributed computing') withFilesNamed: #( '$(VISUALWORKS)\opentalk\Opentalk-STST.pcl' '$(VISUALWORKS)\opentalk\Opentalk-XML.pcl' '$(VISUALWORKS)\opentalk\Opentalk-HTTP.pcl' '$(VISUALWORKS)\opentalk\Opentalk-SOAP.pcl' '$(VISUALWORKS)\opentalk\Opentalk-CGI.pcl' '$(VISUALWORKS)\opentalk\Opentalk-Core-Services.pcl' '$(VISUALWORKS)\opentalk\Opentalk-Groups.pcl' '$(VISUALWORKS)\opentalk\Opentalk-Tools-Console.pcl' '$(VISUALWORKS)\opentalk\Opentalk-Tools-Monitor.pcl' '$(VISUALWORKS)\dst\DST_Core_Services.pcl' '$(VISUALWORKS)\dst\DST_COS_Services.pcl' '$(VISUALWORKS)\dst\DST_I3.pcl' '$(VISUALWORKS)\dst\DST_Tools_Development.pcl' '$(VISUALWORKS)\dst\DST_Sample.pcl' )
addEnvironmentEnhancementsFolderTo: aGroup self addTo: aGroup subgroupNamed: (#EnvironmentEnhancements << #labels >> 'Environment Enhancements') description: (#EnvironmentEnhancementsDesc << #labels >> 'Enhancements of the existing tools and widgets') withFilesNamed: #( '$(VISUALWORKS)\goodies\parc\ProgrammingExtensions.pcl' '$(VISUALWORKS)\goodies\other\AutoComplete.pcl' '$(VISUALWORKS)\goodies\other\Heeg\ComposedTextEditor.pcl' '$(VISUALWORKS)\goodies\parc\CodingFeel.pcl' '$(VISUALWORKS)\goodies\parc\ColorEditing.pcl' '$(VISUALWORKS)\goodies\other\MagicKeys\MagicKeys.pcl' '$(VISUALWORKS)\goodies\other\RB_Tabs.pcl' '$(VISUALWORKS)\goodies\other\LearningMenus.pcl' '$(VISUALWORKS)\goodies\other\ExtraEmphases.pcl' '$(VISUALWORKS)\goodies\other\ThreePaneSelectorsBrowser\ThreePaneSelectorsBrowser.pcl' '$(VISUALWORKS)\goodies\parc\RBClassDefinitionTool.pcl' '$(VISUALWORKS)\goodies\parc\RBBytecodeTool.pcl' '$(VISUALWORKS)\goodies\parc\PDPMenuShortcutEditor.pcl' '$(VISUALWORKS)\parcels\RBSUnitExtensions.pcl' '$(VISUALWORKS)\parcels\RBRegexExtensions.pcl' '$(VISUALWORKS)\goodies\parc\DefaultPackageNamespaces.pcl' )
addGraphicsFolderTo: aGroup self addTo: aGroup subgroupNamed: (#Graphics << #labels >> 'Graphics') description: (#GraphicsDesc << #labels >> 'Drawing and image processing tools and frameworks') withFilesNamed: #( '$(VISUALWORKS)\parcels\BGOK.pcl' '$(VISUALWORKS)\parcels\PNGImageReader.pcl' '$(VISUALWORKS)\parcels\ArborGIFReaderWriter.pcl' '$(VISUALWORKS)\goodies\other\Jun\Jun577.pcl' '$(VISUALWORKS)\goodies\other\HotDraw\HotDraw.pcl' )
addNetworkingFolderTo: aGroup self addTo: aGroup subgroupNamed: (#Networking << #labels >> 'Networking') description: (#NetworkingDesc << #labels >> 'Frameworks and tools for web serving and other network communication issues') withFilesNamed: #( '$(VISUALWORKS)\net\NetClients.pcl' '$(VISUALWORKS)\net\IMAP.pcl' '$(VISUALWORKS)\net\Mail.pcl' '$(VISUALWORKS)\net\MIME.pcl' '$(VISUALWORKS)\net\NetConfigTool.pcl' '$(VISUALWORKS)\net\HTTP.pcl' '$(VISUALWORKS)\net\HTTPS.pcl' '$(VISUALWORKS)\net\FTP.pcl' '$(VISUALWORKS)\net\POP3.pcl' '$(VISUALWORKS)\net\SMTP.pcl' '$(VISUALWORKS)\web\WebToolkit.pcl' '$(VISUALWORKS)\goodies\other\WikiWorks\WikiWorks.pcl' '$(VISUALWORKS)\goodies\other\pongo\pongo.pcl' '$(VISUALWORKS)\goodies\other\TypeLess\IRC-TypeLess.pcl' '$(VISUALWORKS)\goodies\other\TwoflowerBundle.pcl' )
addOSMacFolderTo: aGroup self addTo: aGroup subgroupNamed: 'OS-Mac' description: (#MacDesc << #labels >> 'Mac-specific utilities and add-ons') withFilesNamed: #( '$(VISUALWORKS)\dllcc\DLLCC.pcl' '$(VISUALWORKS)\parcels\GHChangeEnterKey.pcl' '$(VISUALWORKS)\parcels\GHMacChangeListPatch.pcl' '$(VISUALWORKS)\parcels\GHMacCompTextPatch.pcl' '$(VISUALWORKS)\parcels\MacPrintingSupport.pcl' )
addOSWindowsFolderTo: aGroup self addTo: aGroup subgroupNamed: 'OS-Windows' description: (#WindowsDesc << #labels >> 'Windows-specific utilities and add-ons') withFilesNamed: #( '$(VISUALWORKS)\dllcc\DLLCC.pcl' '$(VISUALWORKS)\goodies\parc\WindowsGoodies.pcl' '$(VISUALWORKS)\goodies\parc\Windows-Shortcuts.pcl' '$(VISUALWORKS)\goodies\other\WinProcess.pcl' )
addSecurityFolderTo: aGroup self addTo: aGroup subgroupNamed: (#Security << #labels >> 'Security') description: (#SecurityDesc << #labels >> 'Cryptographic algorithms and security technologies: encryption, signatures, hashes, certificates, etc') withFilesNamed: #( '$(VISUALWORKS)\security\MD5.pcl' '$(VISUALWORKS)\security\SHA.pcl' '$(VISUALWORKS)\security\ARC4.pcl' '$(VISUALWORKS)\security\Blowfish.pcl' '$(VISUALWORKS)\security\AES.pcl' '$(VISUALWORKS)\security\DES.pcl' '$(VISUALWORKS)\security\RSA.pcl' '$(VISUALWORKS)\security\DSA.pcl' '$(VISUALWORKS)\security\DH.pcl' '$(VISUALWORKS)\security\X509.pcl' '$(VISUALWORKS)\security\SSL.pcl' )
addStoreFolderTo: aGroup self addTo: aGroup subgroupNamed: (#StoreFolderLabel << #labels >> 'Store Tools') description: (#StoreFolderLabelDesc << #labels >> 'Store connects and useful utilities') withFilesNamed: #( '$(VISUALWORKS)\store\StoreForOracle8.pcl' '$(VISUALWORKS)\store\StoreForSqlServer.pcl' '$(VISUALWORKS)\goodies\other\PostgreSQL\StoreForPostgreSQL.pcl' '$(VISUALWORKS)\goodies\other\InterBase\StoreForInterBase.pcl' '$(VISUALWORKS)\goodies\other\DB2\StoreForDB2.pcl' '$(VISUALWORKS)\goodies\other\StoreReplication.pcl' '$(VISUALWORKS)\goodies\other\StoreForAccess.pcl' '$(VISUALWORKS)\goodies\parc\ExportDatabaseUI.pcl' '$(VISUALWORKS)\parcels\RBStoreExtensions.pcl' )
addTo: aGroup subgroupNamed: aString description: descriptionString withFilesNamed: stringCollection | folder | folder := ParcelGroup named: aString asString description: descriptionString asString. stringCollection do: [:each | folder addItem: (ParcelFileItem filename: (Filename fromComponents: (each tokensBasedOn: $\)))]. aGroup addSubgroup: folder
addTop10FolderTo: aGroup self addTo: aGroup subgroupNamed: (#Essentials << #dialogs >> 'Essentials') description: (#EssentialComponents << #dialogs >> 'These are the most essential components you may want to have in your image') withFilesNamed: #( '$(VISUALWORKS)\parcels\UIPainter.pcl' '$(VISUALWORKS)\parcels\VWHelp.pcl' '$(VISUALWORKS)\advanced\AllAdvancedTools.pcl' '$(VISUALWORKS)\dllcc\DLLCC.pcl' '$(VISUALWORKS)\packaging\RuntimePackager.pcl' '$(VISUALWORKS)\goodies\parc\ProgrammingExtensions.pcl' '$(VISUALWORKS)\pdp\PDPLoadAll.pcl' )
addToysFolderTo: aGroup self addTo: aGroup subgroupNamed: (#Toys << #labels >> 'Toys') description: (#ToysDesc << #labels >> 'Games and eye candy') withFilesNamed: #( '$(VISUALWORKS)\goodies\other\Gremlin.pcl' '$(VISUALWORKS)\goodies\other\Tetris.pcl' '$(VISUALWORKS)\goodies\other\GoldenMonkey.pcl' '$(VISUALWORKS)\goodies\other\Reversi.pcl' '$(VISUALWORKS)\goodies\other\WinMineGame.pcl' '$(VISUALWORKS)\goodies\other\CastleMicrosloth.pcl' '$(VISUALWORKS)\goodies\parc\Xonix\Xonix.pcl' '$(VISUALWORKS)\goodies\other\BugTraffic\BugTraffic.pcl' '$(VISUALWORKS)\goodies\parc\JavaAsteroids\JavaAsteroids.pcl' '$(VISUALWORKS)\goodies\other\pongo\pongo.pcl' '$(VISUALWORKS)\goodies\other\TypeLess\IRC-TypeLess.pcl' '$(VISUALWORKS)\goodies\other\TwoflowerBundle.pcl' )
addWebServicesFolderTo: aGroup self addTo: aGroup subgroupNamed: (#WebServices << #labels >> 'Web Services') description: (#WebServicesDescr << #labels >> 'Frameworks, protocols and tools for Web Services') withFilesNamed: #( '$(VISUALWORKS)\webservices\XMLObjectMarshalers.pcl' '$(VISUALWORKS)\webservices\SOAP.pcl' '$(VISUALWORKS)\webservices\WSDL.pcl' '$(VISUALWORKS)\webservices\WSDLTool.pcl' '$(VISUALWORKS)\webservices\WebServicesClient.pcl' '$(VISUALWORKS)\webservices\WebServicesServer.pcl' '$(VISUALWORKS)\webservices\WebServicesDemo.pcl' '$(VISUALWORKS)\webservices\UDDIPublish.pcl' '$(VISUALWORKS)\webservices\UDDIInquire.pcl' '$(VISUALWORKS)\webservices\UDDISearchTool.pcl' '$(VISUALWORKS)\opentalk\Opentalk-XML.pcl' '$(VISUALWORKS)\opentalk\Opentalk-SOAP.pcl' '$(VISUALWORKS)\opentalk\Opentalk-HTTP.pcl' '$(VISUALWORKS)\opentalk\Opentalk-CGI.pcl' )
</methods> <methods> Tools.ParcelFavoritesTool class <category>accessing</category>
defaultTopLevelGroup "A fallback resource in case the suggestions file is missing." | top | top := ParcelGroup named: 'Suggestions'. "name is not displayed in the UI and does not need translation" self addTop10FolderTo: top; addDeveloperToolsFolderTo: top; addEnvironmentEnhancementsFolderTo: top; addStoreFolderTo: top; addApplicationDevelopmentFolderTo: top; addApplicationServerFolderTo: top; addDatabaseFolderTo: top; addDistributedComputingFolderTo: top; addWebServicesFolderTo: top; addGraphicsFolderTo: top; addNetworkingFolderTo: top; addOSMacFolderTo: top; addOSWindowsFolderTo: top; addSecurityFolderTo: top; addAdvancedFolderTo: top; addToysFolderTo: top. ^top
description ^(#SuggestionsDesc << #dialogs >> 'A categorized collections of the parcels you might want to load or know about') asString
reportErrorReading: suggestionsFile Transcript cr; show: (#ErrorReadingSuggestions1s << #dialogs >> 'Error reading parcel suggestions file "<1s>"; using hardcoded suggestions instead.' expandMacrosWith: suggestionsFile asResolvedString)
tabLabel ^(#Suggestions << #labels >> 'Suggestions') asString
topLevelGroup | foundName stream topGroup trialName | (Array with: '' with: Locale current languageID with: Locale current languageAndTerritory) do: [:lang | trialName := lang isEmpty ifTrue: ['suggestions.xml'] ifFalse: ['suggestions-', lang, '.xml']. trialName := Filename fromComponents: (#('$(VISUALWORKS)' 'parcels') copyWith: trialName). trialName definitelyExists ifTrue: [foundName := trialName]]. foundName notNil ifTrue: [stream := (foundName withEncoding: #UTF8) readStream. [topGroup := [self groupFromXmlStream: stream] on: Error do: [:ex | self reportErrorReading: foundName. ex return: nil]] ensure: [stream close]] ifFalse: [self reportErrorReading: (Filename fromComponents: #('$(VISUALWORKS)' 'parcels' 'suggestions.xml'))]. ^topGroup ifNil: [self defaultTopLevelGroup]
</methods> <methods> Tools.ParcelFavoritesTool class <category>favorites list-xml</category>
groupFromXmlFile: aFilename "Answer the parcel suggestions group from the XML file. Fail by signalling an error if there are format errors or the file does not exist." "self groupFromXmlFile: 'suggestions.xml' asFilename" | stream | stream := (aFilename withEncoding: #UTF8) readStream. ^[self groupFromXmlStream: stream] ensure: [stream close]
groupFromXmlStream: aStream "Answer the parcel suggestions group from the XML stream. Fail by signalling an error if there are format errors." | parser document | parser := XMLParser new. parser validate: false. document := parser parse: aStream. ^ParcelGroup fromXmlElement: document root
saveDefaultSuggestionsAs: aFilename "Save the current default suggestions (as defined by 'favorites list' methods of this class) as a disk file. This is a utility method and is not directly used by any code. As such, the there is no need to internationalize the comment below." "self saveDefaultSuggestionsAs: 'suggestions.xml' asFilename " | stream | stream := aFilename writeStream. [stream nextPutAll: '<?xml version="1.0"?>'; cr. stream nextPutAll: '<!-- This file defines the parcels displayed by the Suggestions tab of the ParcelManager. Its usual location is $(VISUALWORKS)/parcels/suggestions.xml. It can be regenerated with the default set of parcels by the utility method ParcelFavoritesTool class>>saveDefaultSuggestionsAs:. -->'; cr. self defaultTopLevelGroup asXmlDocument printOn: stream] ensure: [stream close]
</methods> <methods> Tools.ParcelLoadedTool <category>actions</category>
refresh | selections | selections := self folderTreeHolder selectionIndexes. self folderTreeHolder list: (TreeModel on: self class topLevelGroup displayRoot: false childrenWith: [:item | item subgroups]). self folderTreeHolder selectionIndexes: selections
selectGoodiesFolder self folderTreeHolder selectionIndex: 2
selectOtherFolder self folderTreeHolder selectionIndex: 3
selectPreviewFolder self folderTreeHolder selectionIndex: 4
selectVisualWorksFolder self folderTreeHolder selectionIndex: 1
</methods> <methods> Tools.ParcelLoadedTool class <category>accessing</category>
tabLabel ^(#Loaded << #labels >> 'Loaded') asString
topLevelGroup | parcels visualworks goodies other previews | parcels := Parcel parcels collect: [:each | ParcelInImageItem new parcel: each]. visualworks := ParcelGroup named: (#VisualWorksParcels << #labels >> 'VisualWorks Parcels'). goodies := ParcelGroup named: (#Contributed << #labels >> 'Contributed'). previews := ParcelGroup named: (#Previews << #labels >> 'Previews'). other := ParcelGroup named: (#OtherParcels << #labels >> 'Other Parcels'). parcels do: [:each | each isGoodie ifTrue: [goodies addItem: each] ifFalse: [each isPreview ifTrue: [previews addItem: each] ifFalse: [each isVisualWorksParcel ifTrue: [visualworks addItem: each] ifFalse: [other addItem: each]]]]. ^ParcelGroup new addSubgroup: visualworks; addSubgroup: goodies; addSubgroup: other; addSubgroup: previews; yourself
</methods> <methods> Tools.ParcelInImageItem <category>private</category>
baseIconKey ^self isAccessible ifTrue: [self isLoaded ifTrue: [#loadedParcel] ifFalse: [#unloadedParcel]] ifFalse: [#missingParcel]
goodieIconKey ^self isAccessible ifTrue: [self isLoaded ifTrue: [#loadedGoodieParcel] ifFalse: [#unloadedGoodieParcel]] ifFalse: [#missingGoodieParcel]
iconKey ^self isVisualWorksParcel ifTrue: [self baseIconKey] ifFalse: [self goodieIconKey]
</methods> <methods> Tools.ParcelInImageItem <category>testing</category>
isAccessible ^true "tentatively"
isGoodie ^self filenameComponents includes: 'contributed'
isLoaded ^parcel isLoaded
isPreview ^self filenameComponents includes: 'preview'
isVisualWorksParcel | nameString | nameString := self filename asString. ^('*VISUALWORKS*' match: nameString) and: [self isGoodie not and: [self isPreview not]]
sourceExists ^self sourceFilename ifNil: [false] ifNotNil: [:filename | filename exists and: [filename isReadable]]
</methods> <methods> Tools.ParcelInImageItem <category>initialize-release</category>
parcel: aParcel parcel := aParcel
</methods> <methods> Tools.ParcelInImageItem <category>accessing</category>
commentOr: aBlock ^parcel comment
commentOrErrorText ^parcel comment
environment parcel isNil ifTrue: [^nil]. ^parcel environment.
filename | components | components := self filenameComponents. ^components isEmpty ifTrue: [String new] ifFalse: [LogicalFilename fromComponents: components]
filenameComponents ^parcel propertyAt: #parcel ifAbsent: [Array new]
iconForLists ^ListIconLibrary visualFor: self iconKey
name ^parcel name
nameOr: aBlock ^parcel name
prerequisitesOr: aBlock ^parcel propertyAt: #prerequisiteParcels ifAbsent: aBlock
propertiesDictionary ^parcel properties
sourceFilename | baseComponents | baseComponents := self filenameComponents. baseComponents isEmpty ifTrue: [^nil]. ^((LogicalFilename fromComponents: baseComponents) asResolvedString, Parcel sourceExtension) asFilename
</methods> <methods> Tools.ParcelInImageItem <category>comparing</category>
= anotherParcel ^self name = anotherParcel name
hash ^self name hash
</methods> <methods> Tools.ParcelInImageItem <category>printing</category>
description ^(#ParcelInImageItemDesc << #dialogs >> '<1?VisualWorks Parcel:Unsupported Goodie>: <2s>') expandMacrosWith: self isVisualWorksParcel with: self filename asString
displayString | name version | name := parcel name. version := parcel version. version isNil ifTrue: [version := '?']. ^name, ' [', version, ']'
</methods> <methods> Tools.ParcelCommentTool <category>aspects</category>
textHolder "This method was generated by UIDefiner. Any edits made here may be lost whenever methods are automatically defined. The initialization provided below may have been preempted by an initialize method." ^textHolder isNil ifTrue: [textHolder := String new asValue] ifFalse: [textHolder]
</methods> <methods> Tools.ParcelCommentTool <category>private</category>
multipleParcelInformation: parcelFileCollection | stream | stream := TextStream on: (String new: 100). parcelFileCollection do: [:each | stream nextPutAllText: each displayString asText allBold; nextPutAll: ': '; nextPutAllText: (self singleParcelInformation: each); cr; cr]. ^stream contents
parcelInformationFor: parcelFileCollection parcelFileCollection size = 0 ifTrue: [^String new]. parcelFileCollection size = 1 ifTrue: [^self singleParcelInformation: parcelFileCollection first]. ^self multipleParcelInformation: parcelFileCollection
singleParcelInformation: aParcelFile ^aParcelFile commentOrErrorText
</methods> <methods> Tools.ParcelCommentTool <category>accessing</category>
parcels: parcelFileCollection self textHolder value: (self parcelInformationFor: parcelFileCollection)
</methods> <methods> Tools.ParcelCommentTool <category>initialize-release</category>
postBuildWith: aBuilder super postBuildWith: aBuilder. self adjustReadOnlyWidgetBackground: #text with: aBuilder
</methods> <methods> Tools.ParcelCommentTool class <category>accessing</category>
tabLabel ^(#Comment << #labels >> 'Comment') asString
</methods> <methods> Tools.ParcelDirectory <category>initialize-release</category>
initialize super initialize. items := nil
path: aPathname path := aPathname. name := aPathname tail
retrieveParcelFiles | fileNames | fileNames := [path asFilename directoryContents] on: OsError do: [:ex | items := Array new. ^self]. items := (self selectParcelsAmong: fileNames)
retrieveSubdirectories | fileNames | subgroups isEmpty ifFalse: [^self]. fileNames := [path asFilename directoryContents] on: OsError do: [:ex | ^self]. subgroups addAll: (self selectDirectoriesAmong: fileNames)
</methods> <methods> Tools.ParcelDirectory <category>testing</category>
isDirectory ^true
</methods> <methods> Tools.ParcelDirectory <category>accessing</category>
description ^description isNil ifTrue: [(#Directory1s << #dialogs >> 'Directory "<1s>"') expandMacrosWith: path asFilename asString] ifFalse: [description]
items items isNil ifTrue: [self retrieveParcelFiles]. ^items
path ^path
</methods> <methods> Tools.ParcelDirectory <category>private</category>
selectDirectoriesAmong: aCollection | parcels | parcels := OrderedCollection new. aCollection do: [:each | | file | file := path construct: each. file isDirectory ifTrue: [parcels add: (ParcelDirectory path: file)]]. ^parcels
selectParcelsAmong: aCollection | pattern parcels | pattern := '*' , Parcel fileExtension. parcels := OrderedCollection new. aCollection do: [:each | (pattern match: each) ifTrue: [parcels add: (ParcelFileItem fromFileNamed: each in: path)]]. ^parcels
</methods> <methods> Tools.ParcelDirectory class <category>instance creation</category>
path: aFilename ^self new path: aFilename; yourself
path: aFilename name: aString ^self new path: aFilename; name: aString; yourself
path: aFilename name: aString description: anotherString ^self new path: aFilename; name: aString; description: anotherString; yourself
</methods> <methods> Tools.ParcelPrereqTreeTool <category>aspects</category>
itemTree "This method was generated by UIDefiner. Any edits made here may be lost whenever methods are automatically defined. The initialization provided below may have been preempted by an initialize method." ^itemTree isNil ifTrue: [itemTree := MultiSelectionInTree new] ifFalse: [itemTree]
</methods> <methods> Tools.ParcelPrereqTreeTool <category>initialize-release</category>
initialize self itemTree selectionIndexHolder onChangeSend: #parcelSelected to: self
parcels: aCollection | collector | collector := ParcelPrereqCollector new. collector addAllParcels: aCollection. self itemTree list: (TreeModel on: collector asTopLevelItem displayRoot: false childrenWith: [:item | item prerequisiteItems]). builder notNil ifTrue: [(builder componentAt: #itemTree) widget controller expandFullyRoot]
postBuildWith: aBuilder (aBuilder componentAt: #itemTree) widget controller expandFullyRoot
</methods> <methods> Tools.ParcelPrereqTreeTool <category>accessing</category>
selectAll self itemTree selectAll
selections ^(self orderedSelectionsOf: self itemTree) collect: [:each | each parcel]
selections: parcelCollection self itemTree selections: (parcelCollection collect: [:each | ParcelPrereqItem new parcel: each])
</methods> <methods> Tools.ParcelPrereqTreeTool class <category>accessing</category>
tabLabel ^(#PrerequisiteTree << #labels >> 'Prerequisite Tree') asString
</methods> <methods> Tools.ParcelPropertiesTool <category>private</category>
multipleParcelInformation: parcelFileCollection | stream | stream := TextStream on: (String new: 100). parcelFileCollection do: [:each | stream nextPutAllText: each name asText allBold; nextPutAll: ': '; cr; nextPutAllText: (self singleParcelInformation: each); cr; cr]. ^stream contents
parcelInformationFor: parcelFileCollection parcelFileCollection size = 0 ifTrue: [^String new]. parcelFileCollection size = 1 ifTrue: [^self singleParcelInformation: parcelFileCollection first]. ^self multipleParcelInformation: parcelFileCollection
singleParcelInformation: aParcelFile | stream info keys | stream := TextStream on: (String new: 100). info := aParcelFile propertiesDictionary. info isNil ifTrue: [^(#CannotReadParcelFile << #dialogs >> 'Cannot read the parcel file') asText emphasizeAllWith: #italic]. keys := info keys asSortedCollection copyWithout: #comment. keys do: [:each | | value | stream nextPutAllText: each asText allBold; nextPutAll: ': '. value := info at: each. value isString ifTrue: [stream nextPutAll: value] ifFalse: [stream print: value]] separatedBy: [stream cr]. ^stream contents
</methods> <methods> Tools.ParcelPropertiesTool <category>accessing</category>
parcels: parcelFileCollection self textHolder value: (self parcelInformationFor: parcelFileCollection)
</methods> <methods> Tools.ParcelPropertiesTool <category>aspects</category>
textHolder "This method was generated by UIDefiner. Any edits made here may be lost whenever methods are automatically defined. The initialization provided below may have been preempted by an initialize method." ^textHolder isNil ifTrue: [textHolder := String new asValue] ifFalse: [textHolder]
</methods> <methods> Tools.ParcelPropertiesTool <category>initialize-release</category>
postBuildWith: aBuilder super postBuildWith: aBuilder. self adjustReadOnlyWidgetBackground: #text with: aBuilder
</methods> <methods> Tools.ParcelPropertiesTool class <category>accessing</category>
tabLabel ^(#Properties << #labels >> 'Properties') asString
</methods> <methods> Tools.ParcelFileItem <category>parcel attributes</category>
comment ^(self property: #comment or: [^nil]) first
commentOr: aBlock ^(self property: #comment or: [^aBlock value]) first
commentOrErrorText | comment | ^self isAccessible ifFalse: [(#CannotReadParcelFile << #dialogs >> 'Cannot read the parcel file') asText emphasizeAllWith: #italic] ifTrue: [comment := self property: #comment or: [nil]. comment notNil ifTrue: [comment first] ifFalse: [(#ThisParcelHasNoComment << #dialogs >> 'This parcel has no comment') asText emphasizeAllWith: #italic]]
environment ^nil.
format ^self property: #format or: nil
name ^self property: #parcel or: nil
nameOr: aBlock ^self property: #parcel or: aBlock
prerequisites ^self property: #prerequisiteParcels or: nil
prerequisitesOr: aBlock ^self property: #prerequisiteParcels or: aBlock
propertiesDictionary ^properties
timestamp ^self property: #timestamp or: nil
version ^self property: #version or: nil
versionOr: aBlock ^self property: #version or: aBlock
</methods> <methods> Tools.ParcelFileItem <category>private</category>
baseIconKey ^self isAccessible ifTrue: [self isLoaded ifTrue: [#loadedParcel] ifFalse: [#unloadedParcel]] ifFalse: [#missingParcel]
goodieIconKey ^self isAccessible ifTrue: [self isLoaded ifTrue: [#loadedGoodieParcel] ifFalse: [#unloadedGoodieParcel]] ifFalse: [#missingGoodieParcel]
iconKey ^self isVisualWorksParcel ifTrue: [self baseIconKey] ifFalse: [self goodieIconKey]
property: aSymbol or: aBlock ^properties isNil ifTrue: [aBlock value] ifFalse: [properties at: aSymbol ifAbsent: aBlock]
retrieveParcelProperties properties := [CodeReader new readInfoFromFileNamed: filename] on: OsError, CodeReader fileFormatSignal do: [:ex | ex return: nil]
</methods> <methods> Tools.ParcelFileItem <category>testing</category>
isAccessible "True if info has been loaded from the parcel file; so we know the file is there." ^properties notNil
isGoodie ^'*contributed*' match: self filename asString
isLoaded "Answer true if there is a parcel loaded by that name." | name version loadedParcel | name := self name. version := self version. name isNil ifTrue: [^false]. loadedParcel := Parcel parcelNamed: name. ^loadedParcel notNil and: [version isNil or: [loadedParcel version = version]]
isPreview ^'*preview*' match: self filename asString
isVisualWorksParcel | nameString | nameString := self filename asString. ^('*VISUALWORKS*' match: nameString) and: [self isGoodie not and: [self isPreview not]]
sourceExists ^self sourceFilename ifNil: [false] ifNotNil: [:sourceFilename | sourceFilename exists and: [sourceFilename isReadable]]
</methods> <methods> Tools.ParcelFileItem <category>printing</category>
description "Description shows up in the status bar when the parcel is selected." ^(#ParcelStatusDesc << #dialogs >> '<1?VisualWorks Parcel:Unsupported Goodie> (<2s>): <3s>') expandMacrosWith: self isVisualWorksParcel with: self statusString with: filename asFilename asString
displayString "Display string shows up in various lists." | name version | name := self nameOr: [filename tail]. version := self versionOr: ['?']. ^name, ' [', version, ']'
printOn: aStream super printOn: aStream. aStream nextPutAll: ' ('; print: (filename ifNotNil: [filename asString]); nextPutAll: ')'
statusString ^self isAccessible ifTrue: [self isLoaded ifTrue: [(#loaded << #labels >> 'loaded')] ifFalse: [(#notLoaded << #labels >> 'not loaded')]] ifFalse: [(#parcelFileIsNotFound << #dialogs >> 'parcel file is not found')]
</methods> <methods> Tools.ParcelFileItem <category>accessing</category>
filename ^filename
iconForLists ^ListIconLibrary visualFor: self iconKey
sourceFilename | extension baseString | extension := self filename asFilename extension. baseString := self filename asResolvedString. baseString := baseString copyFrom: 1 to: baseString size - extension size. ^(baseString, Parcel sourceExtension) asFilename
</methods> <methods> Tools.ParcelFileItem <category>initialize-release</category>
filename: aFilename filename := aFilename. self retrieveParcelProperties
</methods> <methods> Tools.ParcelFileItem <category>comparing</category>
= anotherObject ^self name = anotherObject name
hash ^self name hash
</methods> <methods> Tools.ParcelFileItem <category>xml representation</category>
asXmlElement ^Element tag: 'parcel' elements: (Array with: (Element tag: 'filename' elements: self filenameAsXmlElements))
filenameAsXmlElements ^filename componentStrings collect: [:each | Element tag: 'filename-component' elements: (Array with: (XML.Text text: each))]
</methods> <methods> Tools.ParcelFileItem class <category>instance creation</category>
filename: aFilename ^self new filename: aFilename; yourself
fromFileNamed: aString in: directoryFilename ^self new filename: (directoryFilename construct: aString); yourself
name: aString ^self filename: aString asFilename
</methods> <methods> Tools.ParcelFileItem class <category>xml reading</category>
fromXmlElement: anElement | filenameElement components | filenameElement := anElement elementNamed: 'filename'. components := filenameElement realElements collect: [:each | each tag type = 'filename-component' ifTrue: [each children first text] ifFalse: [self invalidXmlElement]]. ^self filename: (PortableFilename fromComponents: components)
invalidXmlElement self error: #InvalidXmlInParcelItem << #dialogs >> 'Invalid XML in parcel item definition'
</methods> <methods> Tools.ParcelPrereqCollector <category>collecting</category>
addAllParcels: aParcelCollection aParcelCollection do: [:each | self addParcel: each]
addParcel: aParcelHandle | item | item := ParcelPrereqItem new parcel: aParcelHandle. self addKnownPrerequisitesToItem: item; addItemToKnownPrerequisites: item. knownItems add: item. item references isEmpty ifTrue: [topItems add: item]
</methods> <methods> Tools.ParcelPrereqCollector <category>private</category>
addItemToKnownPrerequisites: anItem | itemName | itemName := anItem name. knownItems do: [:each | (each prerequisitesIncludeName: itemName) ifTrue: [each addPrerequisiteReference: anItem newReference]]
addKnownPrerequisitesToItem: anItem knownItems do: [:each | (anItem prerequisitesIncludeName: each name) ifTrue: [anItem addPrerequisiteReference: each newReference]]. topItems := topItems reject: [:any | anItem prerequisitesInclude: any]
sorted: parcelCollection ^(parcelCollection asSortedCollection: [:a :b | a displayString <= b displayString]) asArray
topLevelOtherItems ^topItems reject: [:each | each isVisualWorksParcel]
topLevelVWItems ^topItems select: [:each | each isVisualWorksParcel]
</methods> <methods> Tools.ParcelPrereqCollector <category>initialize-release</category>
initialize knownItems := OrderedCollection new. topItems := OrderedCollection new
</methods> <methods> Tools.ParcelPrereqCollector <category>accessing</category>
asTopLevelItem ^ParcelPrereqItem new prerequisiteItems: (self sorted: self topLevelVWItems), (self sorted: self topLevelOtherItems)
</methods> <methods> Tools.ParcelPrereqCollector class <category>instance creation</category>
new ^super new initialize
on: parcelHandleCollection ^self new addAllParcels: parcelHandleCollection; yourself
</methods> <methods> OS.LogicalFilename <category>testing</category>
isVisualWorksFile ^components first isString not and: [components first name = 'VISUALWORKS']
</methods> <methods> OS.Filename <category>testing</category>
isVisualWorksFile "We always specify files that we want to later recognize as VW components as logical filenames, so this guy is not." ^false
</methods> <methods> Tools.VisualLauncher class <category>generated resources</category>
cardfile ^ToolbarIconLibrary visualFor: #cardfile
</methods> <methods> Tools.ParcelDirectoriesTool class <category>interface specs</category>
windowSpec "UIPainter new openOnClass: self andSelector: #windowSpec" <resource: #canvas> ^#(#{UI.FullSpec} #window: #(#{UI.WindowSpec} #label: '' #bounds: #(#{Graphics.Rectangle} 506 344 1024 768 ) ) #component: #(#{UI.SpecCollection} #collection: #( #(#{UI.TreeViewSpec} #layout: #(#{Graphics.LayoutFrame} 0 0 0 0 0 1 0 1 ) #name: #directoryTree #model: #directoryListHolder #multipleSelections: true #useModifierKeys: true #selectionType: #highlight #useIcons: #folder #rootExpander: false ) ) ) )
</methods> <methods> Tools.ParcelSelectionTool class <category>resources</category>
basicParcelMenu "MenuEditor new openOnClass: self andSelector: #basicParcelMenu" <resource: #menu> ^#(#{UI.Menu} #( #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #_Load #defaultString: '&Load' #catalogID: #menus) #nameKey: #load #value: #loadParcels #labelImage: #(#{UI.ResourceRetriever} #{Tools.ToolbarIconLibrary} #loadParcel ) ) #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #_Unload #defaultString: '&Unload' #catalogID: #menus) #nameKey: #unload #value: #unloadParcels #labelImage: #(#{UI.ResourceRetriever} #{Tools.ToolbarIconLibrary} #unloadParcel ) ) #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #_OpenInChangeList #defaultString: '&Open in Change List' #catalogID: #menus) #nameKey: #openChanges #value: #openChanges #labelImage: #(#{UI.ResourceRetriever} #{ParcelManager} #changeListIcon ) ) #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #_CompareWithSystem #defaultString: '&Compare with System' #catalogID: #menus) #nameKey: #openConflicts #value: #openConflicts #labelImage: #(#{UI.ResourceRetriever} #{ParcelManager} #changeListConflictsIcon ) ) #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #Browse #defaultString: 'Browse' #catalogID: #menus) #nameKey: #browse #value: #browseParcels #labelImage: #(#{UI.ResourceRetriever} #{Tools.ToolbarIconLibrary} #parcelBrowser ) ) ) #(2 2 1 ) nil ) decodeAsLiteralArray
</methods> <methods> Tools.ParcelListTool class <category>interface specs</category>
windowSpec "UIPainter new openOnClass: self andSelector: #windowSpec" <resource: #canvas> ^#(#{UI.FullSpec} #window: #(#{UI.WindowSpec} #label: #(#{Kernel.UserMessage} #key: #UnlabeledCanvas #defaultString: 'Unlabeled Canvas' #catalogID: #labels) #bounds: #(#{Graphics.Rectangle} 512 384 891 739 ) ) #component: #(#{UI.SpecCollection} #collection: #( #(#{UI.SequenceViewSpec} #layout: #(#{Graphics.LayoutFrame} 0 0 0 0 0 1 0 1 ) #name: #parcelList #model: #parcelListHolder #callbacksSpec: #(#{UI.UIEventCallbackSubSpec} #doubleClickSelector: #parcelDoubleClicked: ) #menu: #popupMenu #multipleSelections: true #useModifierKeys: true #selectionType: #highlight ) ) ) )
</methods> <methods> Tools.ParcelManager class <category>interface specs</category>
windowSpec "UIPainter new openOnClass: self andSelector: #windowSpec" <resource: #canvas> ^#(#{UI.FullSpec} #window: #(#{UI.WindowSpec} #label: #(#{Kernel.UserMessage} #key: #ParcelManager #defaultString: 'Parcel Manager' #catalogID: #labels) #min: #(#{Core.Point} 400 270 ) #max: #(#{Core.Point} 0 0 ) #bounds: #(#{Graphics.Rectangle} 324 268 1024 768 ) #flags: 4 #menu: #menuBar #toolBar: #toolbarMenu ) #component: #(#{UI.SpecCollection} #collection: #( #(#{UI.TabControlSpec} #layout: #(#{Graphics.LayoutFrame} 0 0 0 0 -2 0.32 -25 1 ) #name: #categoryNotebook #model: #categoryHolder #labels: #() ) #(#{UI.ResizingSplitterSpec} #layout: #(#{Graphics.LayoutFrame} -2 0.32 0 0 2 0.32 -25 1 ) #name: #splitter1 #horizontal: false #minAboveSize: 120 #minBelowSize: 120 #aboveWidgets: 'categoryNotebook' #belowWidgets: 'parcelNotebook splitter2 detailNotebook' ) #(#{UI.TabControlSpec} #layout: #(#{Graphics.LayoutFrame} 2 0.32 0 0 0 1 -3 0.4 ) #name: #parcelNotebook #model: #parcelHolder #labels: #() ) #(#{UI.ResizingSplitterSpec} #layout: #(#{Graphics.LayoutFrame} 2 0.32 -3 0.4 0 1 0 0.4 ) #name: #splitter2 #horizontal: true #minAboveSize: 30 #minBelowSize: 30 #aboveWidgets: 'parcelNotebook' #belowWidgets: 'detailNotebook' ) #(#{UI.TabControlSpec} #layout: #(#{Graphics.LayoutFrame} 0 0.32 0 0.4 0 1 -25 1 ) #name: #detailNotebook #model: #detailHolder #labels: #() ) #(#{UI.InputFieldSpec} #layout: #(#{Graphics.LayoutFrame} 0 0 -25 1 0 1 0 1 ) #name: #statusText #model: #statusTextHolder #isReadOnly: true ) ) ) )
</methods> <methods> Tools.ParcelManager class <category>resources</category>
menuBar "MenuEditor new openOnClass: self andSelector: #menuBar" <resource: #menu> ^#(#{UI.Menu} #( #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #_File #defaultString: '&File' #catalogID: #menus) #submenu: #(#{UI.Menu} #( #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #LoadParcelFileDot #defaultString: '&Load Parcel File...' #catalogID: #menus) #nameKey: #loadFromFile #value: #loadParcelFromFile ) #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #_Close #defaultString: '&Close' #catalogID: #menus) #nameKey: #close #value: #closeRequest ) ) #(1 1 ) nil ) ) #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #_Parcel #defaultString: '&Parcel' #catalogID: #menus) #submenu: #(#{UI.Menu} #( #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #_SelectAll #defaultString: '&Select All' #catalogID: #menus) #value: #selectAll #enablementSelector: #anyParcelsDisplayed #shortcutKeyCharacter: $A #shortcutModifiers: 2 #labelImage: #(#{UI.ResourceRetriever} #{ParcelManager} #selectAllIcon ) ) #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #_Load #defaultString: '&Load' #catalogID: #menus) #value: #loadParcels #enablementSelector: #canLoad #shortcutKeyCharacter: $L #shortcutModifiers: 2 #labelImage: #(#{UI.ResourceRetriever} #{ParcelManager} #loadIcon ) ) #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #_Unload #defaultString: '&Unload' #catalogID: #menus) #value: #unloadParcels #enablementSelector: #canUnload #shortcutKeyCharacter: $U #shortcutModifiers: 2 #labelImage: #(#{UI.ResourceRetriever} #{ParcelManager} #unloadIcon ) ) #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #_OpenInChangeList #defaultString: '&Open in Change List' #catalogID: #menus) #nameKey: #openChanges #value: #openChanges #enablementSelector: #selectionsHaveSource #labelImage: #(#{UI.ResourceRetriever} #{ParcelManager} #changeListIcon ) ) #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #_CompareWithSystem #defaultString: '&Compare with System' #catalogID: #menus) #nameKey: #openConflicts #value: #openConflicts #enablementSelector: #selectionsHaveSource #labelImage: #(#{UI.ResourceRetriever} #{ParcelManager} #changeListConflictsIcon ) ) #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #_Browse #defaultString: '&Browse' #catalogID: #menus) #value: #browseParcels #enablementSelector: #canBrowse #shortcutKeyCharacter: $B #shortcutModifiers: 2 #labelImage: #(#{UI.ResourceRetriever} #{ParcelManager} #browseIcon ) ) ) #(1 2 2 1 ) nil ) ) #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #_Help #defaultString: '&Help' #catalogID: #menus) #submenu: #(#{UI.Menu} #( #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #_ParcelManager #defaultString: '&Parcel Manager' #catalogID: #menus) #value: #helpTopics #shortcutKeyCharacter: #F1 #shortcutModifiers: 0 #labelImage: #(#{UI.ResourceRetriever} #{ToolbarIconLibrary} #help ) ) #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #_AboutVisualWorksDot #defaultString: '&About VisualWorks...' #catalogID: #menus) #value: #aboutVisualWorks ) ) #(1 1 ) nil ) ) ) #(3 ) nil ) decodeAsLiteralArray
toolbarMenu "MenuEditor new openOnClass: self andSelector: #toolbarMenu" <resource: #menu> ^#(#{UI.Menu} #( #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #Load #defaultString: 'Load' #catalogID: #menus) #nameKey: #load #value: #loadParcels #labelImage: #(#{UI.ResourceRetriever} #{ParcelManager} #loadIcon ) #helpText: #(#{Kernel.UserMessage} #key: #LoadParcels #defaultString: 'Load Parcels' #catalogID: #menus) ) #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #Unload #defaultString: 'Unload' #catalogID: #menus) #nameKey: #unload #value: #unloadParcels #labelImage: #(#{UI.ResourceRetriever} #{ParcelManager} #unloadIcon ) #helpText: #(#{Kernel.UserMessage} #key: #UnloadParcels #defaultString: 'Unload Parcels' #catalogID: #menus) ) #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #OpenInChangeList #defaultString: 'Open in Change List' #catalogID: #menus) #nameKey: #openChanges #value: #openChanges #labelImage: #(#{UI.ResourceRetriever} #{ParcelManager} #changeListIcon ) #helpText: #(#{Kernel.UserMessage} #key: #OpenInChangeList #defaultString: 'Open in Change List' #catalogID: #menus) ) #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #CompareWithSystem #defaultString: 'Compare with System' #catalogID: #menus) #nameKey: #openConflicts #value: #openConflicts #labelImage: #(#{UI.ResourceRetriever} #{ParcelManager} #changeListConflictsIcon ) #helpText: #(#{Kernel.UserMessage} #key: #CompareWithSystem #defaultString: 'Compare with System' #catalogID: #menus) ) #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #Browse #defaultString: 'Browse' #catalogID: #menus) #nameKey: #browse #value: #browseParcels #labelImage: #(#{UI.ResourceRetriever} #{ParcelManager} #browseIcon ) #helpText: #(#{Kernel.UserMessage} #key: #BrowseParcel #defaultString: 'Browse Parcel' #catalogID: #menus) ) #(#{UI.MenuItem} #rawLabel: #(#{Kernel.UserMessage} #key: #SelectAll #defaultString: 'Select All' #catalogID: #menus) #nameKey: #selectAll #value: #selectAll #enablementSelector: #anyParcelsDisplayed #shortcutKeyCharacter: $A #shortcutModifiers: 2 #labelImage: #(#{UI.ResourceRetriever} #{ParcelManager} #selectAllIcon ) #helpText: #(#{Kernel.UserMessage} #key: #SelectAll #defaultString: 'Select All' #catalogID: #menus) ) ) #(2 2 2 ) nil ) decodeAsLiteralArray
</methods> <methods> Tools.ParcelFavoritesTool class <category>interface specs</category>
windowSpec "UIPainter new openOnClass: self andSelector: #windowSpec" <resource: #canvas> ^#(#{UI.FullSpec} #window: #(#{UI.WindowSpec} #label: #(#{Kernel.UserMessage} #key: #UnlabeledCanvas #defaultString: 'Unlabeled Canvas' #catalogID: #labels) #bounds: #(#{Graphics.Rectangle} 512 384 981 765 ) ) #component: #(#{UI.SpecCollection} #collection: #( #(#{UI.TreeViewSpec} #layout: #(#{Graphics.LayoutFrame} 0 0 0 0 0 1 0 1 ) #name: #folderTree #model: #folderTreeHolder #multipleSelections: true #useModifierKeys: true #selectionType: #highlight #useIcons: #folder #useChildImages: false #useLines: false ) ) ) )
</methods> <methods> Tools.ParcelCommentTool class <category>interface specs</category>
windowSpec "UIPainter new openOnClass: self andSelector: #windowSpec" <resource: #canvas> ^#(#{UI.FullSpec} #window: #(#{UI.WindowSpec} #label: #(#{Kernel.UserMessage} #key: #UnlabeledCanvas #defaultString: 'Unlabeled Canvas' #catalogID: #labels) #bounds: #(#{Graphics.Rectangle} 512 384 712 584 ) ) #component: #(#{UI.SpecCollection} #collection: #( #(#{UI.TextEditorSpec} #layout: #(#{Graphics.LayoutFrame} 0 0 0 0 0 1 0 1 ) #name: #text #model: #textHolder #isReadOnly: true #tabRequiresControl: true ) ) ) )
</methods> <methods> Tools.ParcelPrereqTreeTool class <category>interface specs</category>
windowSpec "UIPainter new openOnClass: self andSelector: #windowSpec" <resource: #canvas> ^#(#{UI.FullSpec} #window: #(#{UI.WindowSpec} #label: #(#{Kernel.UserMessage} #key: #UnlabeledCanvas #defaultString: 'Unlabeled Canvas' #catalogID: #labels) #bounds: #(#{Graphics.Rectangle} 512 384 712 584 ) ) #component: #(#{UI.SpecCollection} #collection: #( #(#{UI.TreeViewSpec} #layout: #(#{Graphics.LayoutFrame} 0 0 0 0 0 1 0 1 ) #name: #itemTree #model: #itemTree #callbacksSpec: #(#{UI.UIEventCallbackSubSpec} #doubleClickSelector: #parcelDoubleClicked: ) #menu: #popupMenu #multipleSelections: true #useModifierKeys: true #selectionType: #highlight #useIcons: #other #iconSelectors: #(#iconForLists ) #rootExpander: false ) ) ) )
</methods> <methods> Tools.ParcelPropertiesTool class <category>interface specs</category>
windowSpec "UIPainter new openOnClass: self andSelector: #windowSpec" <resource: #canvas> ^#(#{UI.FullSpec} #window: #(#{UI.WindowSpec} #label: #(#{Kernel.UserMessage} #key: #UnlabeledCanvas #defaultString: 'Unlabeled Canvas' #catalogID: #labels) #bounds: #(#{Graphics.Rectangle} 512 384 712 584 ) ) #component: #(#{UI.SpecCollection} #collection: #( #(#{UI.TextEditorSpec} #layout: #(#{Graphics.LayoutFrame} 0 0 0 0 0 1 0 1 ) #name: #text #model: #textHolder #isReadOnly: true #tabRequiresControl: true ) ) ) )
</methods> <methods> Tools.VisualLauncher <category>actions</category>
openParcelManager "Open a new ParcelManager." <menuItem: #(#ParcelManager #menus 'Parcel Manager') icon: #cardfile nameKey: #openParcelManager menu: #(#launcherToolBar) position: 10.01 helpText: #(#OpenAParcelManager #menus 'Open a Parcel Manager')> <menuItem: #(#_ParcelManager #menus '&Parcel Manager') icon: #cardfile nameKey: nil shortcutKeyCharacter: #F3 shortcutModifiers: 0 menu: #(#menuBar system) position: 9.01> self openApplicationForClassNamed: #{ParcelManager}
</methods> "Imported Classes:" self error: 'Attempting to file-in parcel imports. Choose terminate or close' <class> <name>Object</name> <environment>Core</environment> <super></super> <private>false</private> none <imports></imports> <category>Kernel-Objects</category> <attributes> <package>Kernel-Objects</package> </attributes> </class> <class> <name>ApplicationModel</name> <environment>UI</environment> <super>UI.Model</super> <private>false</private> none builder uiSession eventHandlers savedWindowInformation <imports></imports> <category>UIBuilder-Framework</category> <attributes> <package>UIBuilder-Framework</package> </attributes> </class> <class> <name>LogicalFilename</name> <environment>OS</environment> <super>Core.Object</super> <private>false</private> none components <imports></imports> <category>OS-Support</category> <attributes> <package>OS-Support</package> </attributes> </class> <class> <name>VisualLauncher</name> <environment>Tools</environment> <super>UI.ApplicationModel</super> <private>false</private> none menuBar toolBar textCollector toolDock <imports></imports> <category>Tools-Misc</category> <attributes> <package>Tools-Misc</package> </attributes> </class> <class> <name>Filename</name> <environment>OS</environment> <super>Core.Object</super> <private>false</private> none osName publicName logicalName <imports></imports> <category>OS-Support</category> <attributes> <package>OS-Support</package> </attributes> </class>