Contents

Component IDECore

comment:
Core no GUI Elements.

IDE::Component structure Xotcl Classes and Objects in sets.
It is container for Xotcl Classes and Objects
Classes Classes Hierarchy Objects Procsgroups

Class IDE

Procs:
initSystem {}

Class IDE::CommentHandler

subclasses:
IDE::ProcsGroup IDE::TclProcsDescription IDE::Component
comment:
Designed to use as mixin.
It has no requirements
It add functionality for hanlding comments.

Instprocs:

getComment {}
hasComment {}
setComment {text}

Class IDE::Component

parameter: name
superclasses:
IDE::CommentHandler
comment:
IDE::Component is base class for handling components.
Components are currently sets or Xotcl classes and objects
that can be loaded and saved as tcl packages

Instprocs:

addClass {class}
addObject {object}
addProcsGroup {aProcsGroup}
addRequiredCompList {comps}
asScript {nometa norequire}
basicAddObject {object}
basicCreateTclProcsGroup {name withNamespace}
basicCreate prevent to import group in VC (no function addProcGroup)
basicRemoveObject {object}
basicRemoveProcsGroup {group}
computeRequirements {}
copyClassOrObject {object newname}
createTclProcsGroup {name withNamespace}
destroy {}
getClasses {}
getClassesHierarchy {}
getCommentBody {}
getHierarchyFrom {classes}
getName {}
getObjectDefineList {}
Return the oderded list of classes and objects that respect the definition order. It means the base (parent classes) are before child classes.
getObjects {}
getProcsGroupWithName {name}
getProcsGroups {}
getProcsGroupsObjects {}
getRequiredFor {}
getRequiredFrom {}
getRequiredFromDeep {}
getVersionNumber {}
getVisibleClasses {}
init {args}
isPersistent {}
rekBuildDefList {object objectList}
removeClass {class}
removeObject {object}
removeProcsGroup {group}
rename {newname}
saveAsScript {file nometa}
setVersionNumber {number}
standardFileName {}
standardFileNameBase {}
unload {}
Procs:
getAllComponents {}
getCompObjectForName {component}
getCompObjectForNameIfExist {component}
getComponentNames {}
getObjectBody {object nometa}
importCompsFromFile {file}
initFromInterpreter {}
initPackageTracking {}
loadCompFromFile {file}
loadPackage {package}
loadPackageIfNone {package}
orderComponents {comps}
This predure orded the component list that the required componets are before the dependent components
registerInstproc {object}
registerObject {object}
registerProc {proc}
saveAllToPath {}
saveComplex {comps nometa onefile target}

Class IDE::Component::Tracker

comment:
Helper class for tracking new classes
by package loading

The tracker can recognize the new created classes and tcl-procs.
No all informations are computed yet. The tracker do not know
witch instproc and procs are defined in each package (this information are
sended to componet and ignored in it).
So all methods belong to package where the object were defined.

Instprocs:

create {cls args}
instproc {instproc args}
proc {proc args}
Procs:
importProc {args}
setOff {}
setOn {}
trackClass {class}
trackProc {args}

Class IDE::ObjectCommentsContainer

parameter: objectName
comment:
Helper class for hanlde methods comments.
It will be used for not persistent classes

Instprocs:

getMethodComment {type method}
hasMethodComment {type method}
setMethodComment {type method text}

Class IDE::ProcsGroup

parameter: name {withNamespace 0}
superclasses:
IDE::CommentHandler
comment:
This Class wrap the interface to normal tcl procedures.
It enable to use / reuse old tcl code in xotclIDE programming

defbody is used for namespace init method

name is the name of namespace or procs group (no namespace)

namespace eval myNameSpace {
   namespace export ... ... ...
    
   varible myVariable 
}

Instprocs:

createProcForName {name}
deleteMethod {method}
getBody {nometa}
getComponent {}
getComponentName {}
getDefBody {}
getDescription {}
getMethodComment {type method}
getObjectName {}
getProcObjForName {name}
getProcObjForNameIfExist {name}
getProcsNames {}
getProcsObjects {}
handleDefinitionScript {skript}
handleScript {skript}
hasMethodComment {type method}
init {}
isPersistent {}
moveToComponent {component}
removeMethodObj {pobj}
rename {name}
setDefBody {skript}
setMethodComment {type method comment}
unload {}
Procs:
buildStuctFromArray {arr_ref}
unknown {args}

Class IDE::TclProcsDescription

parameter: name
superclasses:
IDE::CommentHandler
comment:
Using for handle (structure) normal tcl procs in component context of XOTclIDE.
This instaces has similar interface as xotcl class/objects.
That is comments, getting body

Instprocs:

getBody {}
getGroupObj {}
getMetaBody {}
getName {}
handleScript {script}
init {}
isPersistent {}
unload {}
Procs:
getAllRegisteredMethods {}
getMethodFor {method}
registerMethod {method wrapper}
unknown {args}
unregisterMethod {method}

Object IDE::CommentsContainer

comment:
Hanlde objects comments and is parent object for methods comments
(class IDE::ObjectsCommentsContainer)

all @ meta are delegating to method importMeta

the method "parseAndCleanMeta" try to initilize loaded Objects with
comment after loading

Procs:

cleanTclProcComments {}
destroyObject {object}
extractComment {meta}
getGroupForMethod {method}
getObjectContainer {object}
getObjectContainerWithCreate {object}
importComponentMeta {meta}
importMeta {meta}
importObjectMeta {meta}
importObjectMethodMeta {type meta}
importProcGroupMeta {meta}
importProcMeta {meta}
makeTclGroupsFromMeta {}
objectGetComment {object}
objectHasComment {object}
objectMethodGetComment {object type method}
objectMethodHasComment {object type method}
objectMethodSetComment {object type method comment}
objectSetComment {object comment}
parseAndCleanMeta {}
searchCommentForGroup {gobj}
searchCommentForMethod {method}

Object IDE::IntroProxy

comment:
Fasade for xotcl introspection.

Procs:

asDescriptionList {comment}
getBaseObjDef {name}
getBodyClassMethod {obj p}
getBodyClassMethodIfExist {obj p}
getBodyInstanceMethod {class p}
getBodyInstanceMethodIfExist {obj p}
getBodyInstanceSearchMethod {object ip}
getBodyMetadata {class m}
getBodyTclMethod {method}
getCategoriesForClass {class}
getCategoriesForObject {object}
getClassMethods {class categories}
getClasses {}
getClassesForComponent {component}
getComponents {}
getComponentsNoIDE {}
getInstanceMethods {class categories}
getObjDef {name}
getObjectCommentBody {object}
getObjectMethodCommentBody {object type method}
getObjects {}
getObjectsForComponent {component}
getProcBody {p}
getProcsGroupsForComponent {component}
getSubclassesDeep {cls}
getUnregisteredClasses {}
stripNamespace {name}

Object IDE::SystemConfigMap

Procs:
asScript {}
checkRequirements {compList}
getCleanedLoadList {components ignoreLoaded}
getComponentsList {ignoreLoaded}
getValueForType {type}
initFromSystem {}
loadComponentFromAny {component}
loadComponents {}
loadComponentsFromList {loadList}
loadFromFile {file}
makeDistribution {dir}
saveAsFile {file}
saveDistribution {dir}
setValueForType {type value}
startScriptInvocation {}
startScriptString {}
startScripts {}

Procsgroup ide

comment:
The are some extented list functions based
on Smalltalk container protocol

Methods:

ide::addToValueForKey {arr_ref key value}
ide::addToValueForKeyAt {arr_ref key value index}
ide::addToValueForKeyIfNone {arr_ref key value}
ide::lappendIfNone {list_ref elem}
ide::lcollect {var_ref list eval_action}
ide::lcontain {list elem}
ide::ldetect {var_ref list test}
ide::lremove {list_ref elem}
ide::lremoveAll {list_ref listr}
ide::lselect {var_ref list test}