Smalltalk/X Webserver

Documentation of class 'ProjectDefinition':

Class: ProjectDefinition

Inheritance
Description
Class protocol

Inheritance:

   Object
   |
   +--ProjectDefinition
      |
      +--ApplicationDefinition
      |
      +--LibraryDefinition

Package:: stx:libbasic

Category:: System-Support-Projects

Version:: rev: 1.312 date: 2010/04/07 17:51:24; user: cg; file: ProjectDefinition.st directory: libbasic; module: stx stc-classLibrary: libbasic

Description:

As ST/X is (still) very tightly bound with stc, we keep the package and project information
in a class-object (instead of some Project-object). This has the advantage, that it can be
compiled and included in a compiled class library just like any other class.
Every package includes an subclass of me (an instance of my meta), which provides useful
information about the versioning and packaging. Me myself, I know how to generate dependency
information and can generate makefiles and other build-support files for compilation.

Some special notes about extension methods:
if a package is loaded (Smalltalk loadPackage:'foo:bar/baz'), any already loaded package of which
methods are overwritten by an extension of this package, the other package is asked to safe those
methods in its safe(ForOverwrittenMethods). Thus, if the other package or any of its classes is asked
to file itself out, it can do so using the safe (otherwise, you'D not be able to checkin a class while
it has an overriding extension loaded).
Also, the information about which other package was in charge when a method is overwritten is recorded in
extensionOverwriteInfo. This is used to correctly reinstall an overwritten method, whenever a package is
unloaded.

Class protocol:

accessing

allPreRequisites: answer all (recursive) prerequisite project ids of myself - in random order.
If we exclude a project, but one of our prerequisite projects depends on it,
allPreRequisitesSorted: answer all the prerequisites of this projects sorted in
the order they are needed.
Use this to e.g. compile packages in the dependency order
directory: for packageId compatibility
initialClassNameForDefinitionOf: aPackageId: given a package-ID, return an appropriate class name for this package
libraryName
libraryNameFor: aProjectID
module
moduleDirectory
moduleDirectoryFor: aProjectID
moduleDirectory_win32
moduleDirectory_win32For: projectID
moduleFor: aProjectID
moduleOfClass: aClass
monticelloPackageName: hook for packages which have been loaded from monticello
msdosPathToPackage: toPackageID from: fromPackageID: Returns the path to the package defined by aPackageID relative to my path
msdosPathToTopFor: aProjectID: Returns the path to stx counting the number of $/ and $: in the package name and adding for each one '../' to get the ST/X top directory
packageDirectory
packageName: the last component
packageNameFor: aProjectID
parentProject
parentProjectFor: aProjectID
pathSeparator: platformName
pathSeparator_unix
pathSeparator_win32
pathTo: aBaseFilename inPackage: aPackageID architecture: arch: Returns the path to stx counting the number of $/ and $: in the package name and adding for each one '../' to get the ST/X top directory
pathToPackage_unix: aPackageID: Returns the path to stx counting the number of $/ and $: in the package name and adding for each one '../' to get the ST/X top directory
pathToPackage_win32: aPackageID: Returns the path to the package defined by aPackageID relative to my path
pathToTop_unix: Returns the path to stx counting the number of $/ and $: in the package name and adding for each one '../' to get the ST/X top directory
pathToTop_win32: Returns the path to stx counting the number of $/ and $: in the package name and adding for each one '../' to get the ST/X top directory
projectIsLoaded: answer true, if this project is completely loaded into the image
projectIsLoaded: something
requiredProjects
topRelativePathTo: aBaseFilename inPackage: aPackageID architecture: arch: Returns the path to stx counting the number of $/ and $: in the package name
and adding for each one '../' to get the ST/X top directory
topRelativePathToPackage_unix: aPackageID: Returns the path to the package as specified by aPackageID relative to the top directory
topRelativePathToPackage_win32: aPackageID: Returns the path to the package as specified by aPackageID relative to the top directory
unixPathToPackage: toPackageID from: fromPackageID: Returns the path to the package defined by aPackageID relative to my path
unixPathToTopFor: aProjectID: Returns the path to stx counting the number of $/ and $: in the package name and adding for each one '../' to get the ST/X top directory

accessing - packaging

classNames: aCollectionOfClassNames: set the set of classes
classNamesAndAttributes: newSpec usingCompiler: compilerOrNil: set the set of classes. and attributes
Because this requires compilation of my classList-method, a compiler can be passed in,
which has to do the job.
(this is used by the systembrowser to pass in a CodeGeneratorTool with undo support)
excludeClasses: toExclude usingCompiler: compilerOrNil: exclude (remove from classList) a number of classes.
Because this requires compilation of my classList-method, a compiler can be passed in,
which has to do the job.
(this is used by the systembrowser to pass in a CodeGeneratorTool with undo support)
includeClasses: toInclude usingCompiler: compilerOrNil: include (add to classList) a number of classes.
Because this requires compilation of my classList-method, a compiler can be passed in,
which has to do the job.
(this is used by the systembrowser to pass in a CodeGeneratorTool with undo support)
makeClassesAutoloaded: toMakeAutoloaded usingCompiler: compilerOrNil: include as autoloaded (add to classList) a number of classes.
Because this requires compilation of my classList-method, a compiler can be passed in,
which has to do the job.
(this is used by the systembrowser to pass in a CodeGeneratorTool with undo support)

accessing - svn

svnRevision: Answers SVN revision of given package. The revision is computed
as follows:
1) Look at package directory if there is .svn administration
directory. If so, uses SVN to obtain SVN revision & return
2) If svnRevisionNr return non-nil, use that as SVN revision & return
3) If everything fails, compute maximum from all revision of all
classes & extensions

class initialization

initialize
initializeAllProjectDefinitions: needs everything else (especially the compiler etc.) to be initialized.
Therefore, its not invoked by #initialize, but instead explicitely,
by Smalltalk
installAutoloadedClasses: install all of my autoloaded classes (if any)

code generation

applicationIconFileName_code
classNamesAndAttributes_codeFor: aSpecArray: generate method code returning all classes of the project from the given spec.
classNamesAndAttributes_code_ignoreOldEntries: ignoreOldEntries ignoreOldDefinition: ignoreOldDefinition: generate method code returning all classes of the project.
Platform attributes are kept from the old definition.
If ignoreOldEntries is true, the list is completely recreated;
if false, existing entries are preserved.
If ignoreOldDefinition is true, the autoload attribute is set/reset if
the class is installed as autoloaded in the image (i.e. the state in the image is taken).
If false, it is taken from an existing definition in #classNamesAndAttributes
companyName_code
companyName_codeFor: aString
compileDescriptionMethods
description_code
effectivePreRequisites: get the preRequisites, that are not excluded
effectiveSubProjects: get the subProjects, that are not excluded
excludedFromPreRequisites_code: generate the code of the #excludedFromPreRequisites method
extensionMethodNames_code
extensionMethodNames_code_ignoreOldEntries: ignoreOldEntries
forEachContentsMethodsCodeToCompileDo: aTwoArgBlock ignoreOldDefinition: ignoreOldDefinition
forEachMethodsCodeToCompileDo: aTwoArgBlock
forEachMethodsCodeToCompileDo: aTwoArgBlock ignoreOldDefinition: ignoreOldDefinition
legalCopyright_code
preRequisites_code: generate the code of the #preRequisites method
productName_code
productName_codeFor: aString
svnRevisionNr_code: revisionNrOrNil

defaults

applicationTypes
defaultCategory
defaultProjectType
defaultProjectTypeForGUIApplication
defaultProjectTypeForNonGUIApplication
guiApplicationType
libraryType
libraryTypes
nonGuiApplicationType
projectTypeSelectors: a list of possible project type selectors
projectTypes: a list of possible project types

description

excludedFromPreRequisites: list packages which are to be explicitely excluded from the automatic constructed
prerequisites list. If empty, everything that is found along the inheritance of any of
my classes is considered to be a prerequisite package.
excludedFromSubProjects: list packages which are to be explicitely excluded from the automatic constructed
subProjects list. If empty, every sub-package is included as a prerequisite.
preRequisites: list packages which are required as a prerequisite. This method is generated automatically,
by searching along the inheritance chain of all of my classes.
However, when generating automatically, packages are only added - never removed, unless listed
in excludedFromPreRequisites.
preRequisitesForBuilding: for now, there is only one list of prerequisites present;
will be changed in the (near?) future
preRequisitesForLoading: for now, there is only one list of prerequisites present;
will be changed in the (near?) future
siblingsAreSubProjects
splashFileName: answer the base-name of the splash bitmap.

Default is nil, for no splash. If non-nil, it must be a bmp file's name
subProjects

description - actions

postLoadAction: invoked after loading a project
preLoadAction: invoked before loading a project
preUnloadAction: invoked before unloading a project

description - classes

additionalClassNamesAndAttributes
classNamesAndAttributes: a correponding method with real names must be present in my concrete subclasses
extensionMethodNames: list class/selector pairs of extensions.
A correponding method with real names must be present in my concrete subclasses
ignoredClassNames: can be redefined to suppress some classes from being included in a
generated classNamesAndAttributes spec

description - compilation

additionalBaseAddressDefinition_bc_dot_mak: allows for a base-address definition to be added to the bc.mak file.
Subclasses may redefine this to something like
LIB_BASE=$(LIBWIDG_BASE)
This will be inserted BEFORE the 'include stdHeader'
additionalDefinitions: allows for additional definitions/rules to be added to the make.proto and bc.mak file.
additionalDefinitions_bc_dot_mak: allows for additional definitions/rules to be added to the bc.mak file.
Subclasses may redefine this.
additionalDefinitions_make_dot_proto: allows for additional definitions/rules to be added to the make.proto file.
additionalDefinitions_nt_dot_mak: obsolete - kept for compatibility with old project files
additionalLinkLibraries_bc_dot_mak: allows for additional static libraries to be added to the bc.mak file.
Subclasses may redefine this
additionalLinkLibraries_make_dot_proto: allows for additional static libraries to be added to the make.proto file.
additionalLinkLibraries_nt_dot_mak: obsolete - kept for compatibility with old project files
additionalRulesSvn_make_dot_proto
additionalRules_bc_dot_mak: obsolete - kept for compatibility with old project files
additionalRules_make_dot_proto: allows for additional rules to be added to the make.proto file.
additionalSharedLinkLibraries_make_dot_proto: allows for additional shared libraries to be added to the make.proto file.
additionalTargetsSvn_make_dot_proto
additionalTargets_bc_dot_mak: obsolete - kept for compatibility with old project files
additionalTargets_make_dot_proto: allows for additional targets to be added to the make.proto file.
globalDefines: allow for the specification of additional defines for stc compilation of prerequisite packages
an subprojects
globalDefines_unix: allow for the specification of additional defines for stc compilation of prerequisite packages
an subprojects
globalDefines_win32: allow for the specification of additional defines for stc compilation of prerequisite packages
an subprojects
localDefines: allow for the specification of additional defines for stc compilation
localDefines_unix: allow for the specification of additional defines for stc compilation
localDefines_win32: allow for the specification of additional defines for stc compilation
localIncludes: allow for the specification of additional include directories
localIncludes_unix: allow for the specification of additional include directories
localIncludes_win32: allow for the specification of additional include directories
primaryTarget: allows the primary make target to be defined in the Make.proto/bc.mak file.
primaryTarget_bc_dot_mak: allows the primary make target to be defined in the bc.mak file.
primaryTarget_make_dot_proto: allows the primary make target to be defined in the Make.proto file.
stcOptimizationOptions: see the stc reference / stc usage for options.
For now, the following variants are useful:
+optspace3 most compact code
- use for all gui, application code.

+optinline +optinline2 +inlineNew
fastest code
- use only for computation-intensive classes
stcWarningOptions: see the stc reference / stc usage for options.
For now, the following variants are useful:
-warn no warnings
-warnNonStandard no warnings about non-standard smalltalk features

description - project information

applicationAdditionalIconFileNames: Return the icon-filenames for additional icons of the application
(empty collection if there are none)
applicationIconFileName: Return the icon-filename for the application (nil if there is none)
companyName: Returns a company string which will appear in <lib>.rc.
Under win32, this is placed into the dlls file-info
description: Returns a description string which will appear in vc.def / bc.def
fileDescription: Returns a description string which will appear in libName.rc and the rc-file
fileMajorVersionNr: Returns a versionNumber which will appear in libName.rc
fileMinorVersionNr: Returns a versionNumber which will appear in libName.rc
fileReleaseNr: Returns a releaseNumber which will appear in libName.rc
fileRevisionNr: Returns a revisionNumber which will appear in libName.rc
fileVersion: Returns a fileVersion string which will appear in libName.rc
fileVersionCommaSeparated: Returns a fileVersion string which will appear in libName.rc
internalName: Returns a name string which will appear in libName.rc
legalCopyright: Returns a copyright string which will appear in <lib>.rc.
Under win32, this is placed into the dlls file-info
majorVersionNr: Returns a versionNumber which will appear in libName.rc
minorVersionNr: Returns a versionNumber which will appear in libName.rc
productDate: Returns a product-date string which will appear in libName.rc and the installer file
productFilename: Returns a filename which be used as linkname, product file name etc.
productInstallDir: Returns a product default installDir which will appear in <app>.nsi.
productName: Returns a product name which will appear in <lib>.rc.
Under win32, this is placed into the dlls file-info
productNameAsValidFilename: Returns a product name which will appear in <lib>.rc.
Under win32, this is placed into the dlls file-info
productPublisher: Returns a product publisher which will appear in <app>.nsi.
productVersion: Returns a product version which will appear in libName.rc and the installer file
productVersionCommaSeparated: Returns a product version which will appear in libName.rc
productWebSite: Returns a product webSite which will appear in <app>.nsi.
releaseNr: Returns a releaseNr which will appear in libName.rc
revisionNr: Returns a revisionNr which will appear in libName.rc
versionNumber: Returns a version string which will appear in bc.def / vc.def

file generation

basicFileNamesToGenerate: answer a dictionary (filename -> generator method) with all the files,
that have to be generated for this package
fileNamesToGenerate: answer the files that have to be generated as a dictionary of names and generator method
forEachFileNameAndGeneratedContentsDo: aTwoArgBlock
forEachFileNameAndGeneratorMethodDo: aTwoArgBlock
generateFile: filename
generateRemoveShellScriptOn: aStream: generate a shell script to a cvs remove of broken class filenames.
To be called after the output of #generateRenameShellScript: has been performed
generateRenameShellScriptOn: aStream: generate a shell script to rename broken class filenames
generate_abbrev_dot_stc
generate_bc_dot_mak
generate_bmake_dot_mak
generate_lcmake_dot_mak
generate_loadAll
generate_make_dot_proto
generate_make_dot_spec
generate_makefile
generate_packageName_dot_rc
generate_vc_dot_def
generate_vcmake_dot_mak
protectedFileNames: names of files which should NOT be generated
- redefine this to protect a hand-written Make.proto or other handwritten support files
rcFilename

file mappings

bc_dot_mak_mappings
bmake_dot_mak_mappings
classLine_mappings: aClassName
make_dot_proto_mappings
make_dot_spec_mappings
makefile_mappings
packageName_dot_rc_mappings
replaceMappings: mappings in: fileTemplate: Replaces the defined variable mappings found in a file template with the corresponding information
st2c: aString

file mappings support

classNamesByCategory: answer a dictionary
category -> classNames topological sorted
commonSymbolsFlag: only for libraries
filenameForClass: classNameOrClass: answer the base filename of the class without suffix
generateClassLines: classLineTemplate: for the init-file: generate class-init-lines for all classes
generateClassLines: classLineTemplate forClasses: classNames: for the init-file: generate class-init-lines for a collection of classes
generateClassLines: classLineTemplate forClasses: classNames includeAdditionalClasses: includeAdditionalClasses: for the init-file: generate class-init-lines for a collection of classes
generateClassLines_libInit_dot_cc
generateClasses_make_dot_spec
generateDependencies: whichArchitecture
generateDependencies_unix
generateDependencies_win32
generateLocalIncludes_unix
generateLocalIncludes_win32
generateObjects_make_dot_spec
generateRequiredMakePrerequisites_bc_dot_mak
generateRequiredMakePrerequisites_make_dot_proto
generateSubDirectories
generate_definitionClassLine_libInit_dot_cc: for the init-file: generate a single class-init-line for the definition class itself
headerFileOutputArg: "all stx stuff goes to the common include directory.
objectLine_make_dot_spec_mappings: aClassName
subProjectBmakeCalls: generate submake-calls for borland bcc
subProjectLCmakeCalls: generate submake-calls for lc
subProjectMakeCallsUsing: callString
subProjectVCmakeCalls: generate submake-calls for visual-C

file templates

bc_dot_mak: answer a template for the bc.mak makefile.
Any variable definition %(Variable) will be later replaced by the mapping.
$% characters have to be duplicated.
Only needed for WIN

** This method raises an error - it must be redefined in concrete classes **
bmake_dot_mak: the template code for the bmake.bat file
classLine_libInit_dot_cc
lcmake_dot_mak: the template code for the lcmake.bat file
make_dot_proto: the template code for the make.proto file

** This method raises an error - it must be redefined in concrete classes **
make_dot_spec
makefile
objectLine_make_dot_spec
packageName_dot_rc: the template code for the <libName>.rc file.
Only used for WIN
vcmake_dot_mak: the template code for the vcmake.bat file

instance creation

definitionClassForMonticelloPackage: aMonicelloPackagename
definitionClassForMonticelloPackage: aMonicelloPackagename createIfAbsent: createIfAbsent
definitionClassForPackage: aPackageID
definitionClassForPackage: aPackageID createIfAbsent: doCreateIfAbsent
definitionClassForPackage: aPackageID createIfAbsent: doCreateIfAbsent projectType: typeOrNil
definitionClassForPackage: newProjectID projectType: typeOrNil createIfAbsent: createIfAbsent
definitionClassForType: type: answer the class that describes a give project type
newForPackage: packageID
newNamed: newName package: packageID

loading

ensureFullyLoaded: ensure that all classes and extensions are loaded properly.
This is normally no problem for compiled classLibs - however, if a package
has only be installedAsAutoloaded, some classes might want to ensure that
when being loaded themself.
load: load the project
Answer true, if new classes have been installed for this package,
false if the package's classes have been already present.
loadAsAutoloaded: asAutoloaded: load the project.
If asAutoloaded == true, install all new classes as autoloaded.
Answer true, if new classes have been installed for this package,
false if the package's classes have been already present.
unloadPackage: unload the project.
Fails if there are still instances of any of my classes in the system

misc ui support

iconInBrowserSymbol

private

additionalClassAttributesFor: aClass: Answers additional set of class attributes for given class
Individual project definitions may override this method, but
overriding method should always merge its attributes with result
of 'super additionalClassAttributesFor: aClass'.

Here, we add #autoload attributes to all test cases and
test resources, as they are not neccessary for the package
and should not be compiled (because of unwanted dependency
on stx:goodies/sunit package)
checkIfClassesArePresent: check if all classes defined by this project are present and
offer a dialog to abort the current operation if not
classNamesAndAttributesAsSpecArray: given a classNamesAndAttributes array, make this a spec array (array of arrays).
This decompresses class-name entries into a one-element array for easier processing
classNamesAndAttributesDo: aBlock
classNamesAndAttributesFromSpecArray: aSpecArray: given a spec array (array of arrays), make this a classNamesAndAttributes array
as stored literally in the method.
This compresses single element array-elements into plain names
(to save code in the compiled binaries)
compile: someCode categorized: category
compiled_classes
compiled_classesDo: aBlock
compiled_classesForArchitecture: arch
compiled_classes_common
cvsRevision
inconsistency: message
makeOSIncludesWith: fileSeparator from: aString
makeUnixIncludes: aString
makeWin32Includes: aString
namesAndAttributesIn: aCollection do: aBlock
searchForClasses: answer all non-private classes that belong to this project.
They are sorted in load order
searchForClassesWithProject: aProjectID
searchForExtensions
searchForExtensionsWithProject: aProjectID: search for any class which has extensions from aProjectID.
Return the extension-methods sorted by classname-selector
searchForProjectsWhichProvideHeaderFiles
searchForSiblingProjects: answer all the packages (package names) having the my parent package
searchForSubProjects: answer all packages (package names), that are my subProjects
setupForType: typeOrNil

private-extension handling

hasSavedOverwrittenMethods: true, if any of my methods was overwritten by another loaded package.
These methods are now in my safe
methodOverwrittenBy: aMethod: return the (hidden) original method, which was located in another package
and which got overwritten by one of my extension methods. Nil if there is none.
rememberOverwrittenExtensionMethods: before loading, tell other packages to keep a safe reference to any method
which gets overloaded by me, and also remember here, whome I have overloaded.
This allows for two things:
a) correct fileout of the other base-package (for example, when checking in any of its class)
b) correct unloading of myself
rememberOverwrittenMethod: oldMethod inClass: aClass: invoked from another projectDefinition, when that package is about to be loaded
and about to overwrite one of my methods.
I will save the method locally, to allow for correct fileout of this class/project or
to correctly reestablish my methods when the other package is unloaded later.
restoreOverwrittenExtensionMethods: after unloading, tell other packages to restore any safed reference to any method
which got overloaded by me.
savedOverwrittenMethodForClass: aClass selector: aSelector: return one of my saved original methods

private-loading

checkPrerequisitesForLoading
extensionOverwriteInfo
fetchSlotsFrom: myFirstIncarnation: this is invoked in a just loaded instance of myself,
to fetch the safe and extensionInfo from my first incarnation
loadAllClassesAsAutoloaded: asAutoloaded: load (fileIn) classes that should be present -
install as autoloaded classes marked to be autoloaded.
If asAutoloaded == true, all classes will be installed as autoloaded, even if not marked.

Answer true, if classes have been loaded
loadClassLibrary: try to load a binary class library
Return true if ok, false if not.
loadExtensions: load extension methods - do not load if they are already present
loadPackages: aListOfPackages asAutoloaded: asAutoloaded: load some packages (at least the projectDefinitions and their extensions).
If asAutoloaded == true, classes will be only installed as autoloaded.
loadPreRequisitesAsAutoloaded: asAutoloaded: load other packages (at least the projectDefinitions and their extensions)
loadSubProjects: load other packages (at least the projectDefinitions and their extensions)
loadSubProjectsAsAutoloaded: asAutoloaded: load other packages (at least the projectDefinitions and their extensions)
safeForOverwrittenMethods
unloadAllClasses
unloadClassLibrary
unloadSubProjects: unload other packages
update: anAspectSymbol with: argument from: changedObject: when any of my class methods is changed, we mark the project as unloaded.
May be some mor classes have to be loaded

private-prerequisites

addReferencesToClassesFromGlobalsIn: aSetOfClasses to: usedClassReasons: helper for searchForPreRequisites
addReferencesToClassesFromGlobalsInMethods: someMethods to: usedClassReasons: helper for searchForPreRequisites
searchForPreRequisites: answer a Dictionary where the keys are the prerequisite package for this package
and the values are a Set of reasons, why each package is required

queries

allClassNames
autoloaded_classNames
classNames: answer an array containing all the class names of the project's classes
classNamesForWhich: aBlock: a correponding method with real names is generated in my subclasses
classes: list my classes.
Project must be loaded - otherwise an error is reported here.
Use #classNames if you are only interested in the names
compiled_classNames
compiled_classNamesForPlatform: answer the classes to be compiled only for the current platformName
compiled_classNamesForPlatform: platformName: answer the classes to be compiled only for platformName
platformName is one of #unix, #win32 (OperatingSystem platformName)
compiled_classNames_common: classes to be compiled for any platform
compiled_classNames_unix: class, only to be compiled under unix
compiled_classNames_windows: class, only to be compiled under windows
extensionMethods: list my extension methods.
Project must be loaded - otherwise an error is reported here.
Use #extensionMethodsNames if you are only interested in the names
hasAllClassesFullyLoaded: return true, if all classes are present and loaded
hasAllClassesLoaded: return true, if all classes are present (although, some might be autoloaded)
hasAllClassesLoaded: checkIfFullyLoaded: check if all classes for this platform are present.
If checkIfFullyLoaded is true, they must be fully loaded; that means: not autoloaded
hasAllCompiledClassesFullyLoaded: return true, if all compiled classes are present and loaded
hasAllCompiledClassesLoaded: checkIfFullyLoaded: check if all compiled classes for this platform are present.
If checkIfFullyLoaded is true, they must be fully loaded, that is not autoloaded
hasAllExtensionsLoaded: answer true, if all extensions of this package have been loaded.
This is a query - so no side effects please
hasClasses: classNames loaded: checkIfFullyLoaded: answer true, if all classes referenced by classNames have been loaded
into the image. If checkIfFullyLoaded, classes installed as autoloaded
are not considered
hasExtensionMethods
hasPostLoadAction: true if postLoadAction has been redefined
hasPostUnloadAction: true if postUnloadAction has been redefined
hasPreLoadAction: true if preLoadAction has been redefined
hasPreUnloadAction: true if preUnloadAction has been redefined
isFullyLoaded
projectType: ** This method raises an error - it must be redefined in concrete classes **

queries-privacy

showClassDocumentationOf: aClass: used by the HTMLDoc-generator to ask if a classes' protocol is to be documented
or hidden.
(used for expecco, to suppress documentation of workflow- and expecco classes
in the expecco-class browser)

sanity checks

validateDescription

testing

isAbstract
isApplicationDefinition
isConsoleApplication
isGUIApplication
isLibraryDefinition
isProjectDefinition: concrete i.e. not abstract

ST/X 6.1.1; WebServer 1.620 at exept:8081; Wed, 23 May 2012 20:44:44 GMT