The ACS vocabulary defines several independant domains:
- how to name the ACSFactoryUtilityImpl.L_ACS_TREE_GENERIC_UPPER_NODES constants for this ACS,
as names of the ACS nodes in the proper ACS internal frame,
- what are the gBase classes to use, since some generic classes may be
subclassed in an AcsAddon gBase package (see ACSFactoryUtilityImpl.L_CLASSIC_CLASS_KEYS),
- if the ACS is an AcsAddon, what are the specific new classes in
the AcsAddon gBase package (see ACSFactoryUtilityImpl.ACSADDON_EXTENSION_CLASSES).
The ACS vocabulary defines several independant domains:
- How to name the L_ACS_TREE_GENERIC_UPPER_NODES constants for this ACS,
as names of the ACS tree nodes in the proper ACS internal frame.
Optional node property for the Alternate relation:
mandatory key: node_name for a ground ACS or subACS;
the values are the names of the alternates for the key.
A constrained (opened or closed) child ACS has one or several of
the following relations to this object:
<ForChildAcsOpeningAndClosing>, <ForChildAcsOpeningNoClosing>
or <ForChildAcsIntegrity>.
ImmutableName/String map of visible spaces for a node, which extends the parent children
(if ImmutableNameTree.isHubNode is true) and the ImmutableNameTree areas of the node, if any.
These are the default values for the classes in the generic gBase package
that may be subclassed in an AcsAddon package, and are then accessible for all
the Access Road program through ARoad0.gBaseInterface.ACSRun.getM_AcsVocabulary().
map of the GraphicNode absolute cordinates in this panel Graphics2D,
the associated BaseObject name is the key,
Rectangle2D is the value type; get through GraphicNode.getShape().
current GraphicViewPropertyEditors associated to views when one of the two
'All views' JTabbedPane is used; the view name.toString() is the key
does not include the beamer property editors used for views.
map of DisplayableLinkImpls; the compound name constructed with
the two base objects names (eligible party first) is the key;
the value is a List of DisplayableLinkImpls for getting all the
visible or hiden links between two view base objects.
ImmutableName/String[] map of optional links which are managed by the user of this class
It is an optional node property with an ImmutableName/String[] map:
the optional key is the node or area name, or the sum of two node names,
the value is an optional String array, where all the properties are also optional
and without constraints on the format.
ImmutableName/ImmutableName[] map of the optional mandatory paths
It is an optional node property:
optional key: node_name is the beginning of the first path;
value: the optional array of node names is the mandatory paths to go accross
(if rights allow it),
where the structure is a one-item List, or a List
(first_node, second_node, beginning_node, third_node, fourth_node, beginning_node),
which indicates that there are two paths: from beginning_node to second_node,
and from beginning_node to third_node and fourth_node,
and where all the nodes are in the visible space of the beginning node
The map of the ACSObject roots which have with an opened or closed child ACS,
a relation among those set by ACSFactoryUtilityImpl.getKeysForConstrainedChildACSMap().
If the argument has the same ends and the same path, adds all the comments
in the _dLink AccessControlLinks to the relevant AccessControlLinks
of this instance, whatever the link type values in each AccessControlLink.
Puts the ending DisplayableLinkImpl after the starting DisplayableLinkImpl
to build up a new DisplayableLink where the AccessControlLinkImpls are cloned.
If the argument has the same ends and the same path, and for the activated
AccessControlLink types, adds all the rights and the comments of the argument
to the relevant AccessControlLinks of this instance.
The MVC pattern ensures that the GUI has a clear
structure, with:
(1) a model: a database-oriented class,
(2) 1a view: a class which displays the objects on the desktop,
(3) a controller: a class which offers service utilities to the two other classes,
and manages the more complex events
The MVC pattern ensures that the GUI has a clear
structure, with:
(1) a model: a database-oriented class,
(2) 1a view: a class which displays the objects on the desktop,
(3) a controller: a class which offers service utilities to the two other classes,
and manages the more complex events
The MVC pattern ensures that the GUI has a clear
structure, with:
(1) a model: a database-oriented class,
(2) 1a view: a class which displays the objects on the desktop,
(3) a controller: a class which offers service utilities to the two other classes,
and manages the more complex events