| java.lang.Object
 org.enhydra.jawe.components.graph.GraphManager
| GraphManager | | public class GraphManager implements Serializable(Code) | | Class intended to serve as a control center for creation, removal, resizing
and changing position of Participants as well as for doing the same things
with Activity objects and Transitions. Class manages this actions in such a
way that undoing of operations are possible. It incorporates multiple view
and model changes into one by doing them virtually, and after all changes are
done, in interaction with JaWEGraphModel class applies this changes so that
undo is possible. Instance of this class is joined to to all objects of
classes derived from Graph class.
This class also handles the relationships between visual and logical
representation of workflow graph.
When reading a package from an XML file, this class creates imported objects
and establishes relationship between graph objects (classes within jawe and
jawe.graph package) and 'graph logic' objects ( classes within jawe.xml
package).
author:
Sasa Bojanic
author:
Miroslav Popov |
| Field Summary | |
| protected boolean | pLoaded
|
| Constructor Summary | |
| public | GraphManager(Graph g)
Creates new workflow manager for given graph. |
| Method Summary | |
| public List | addOrRemoveBreakPoint(GraphTransitionInterface gtra, Point p, boolean toAdd)
| | public void | arrangeActivityPosition(Activity act)
| | public void | arrangeBubblePosition(ExtendedAttribute ea, GraphParticipantInterface newPar)
| | protected void | arrangeParticipantHorizontally(Object par, Map propertyMap, ParentMap parentMap)
| | protected void | arrangeParticipantRelationsOnly(Map propertyMap, ParentMap parentMap)
| | protected void | arrangeParticipantVertically(Object par, Map propertyMap, ParentMap parentMap)
Resizing participant par and it's parents to appropriate height, and
translating other participants accordingly to changes of participant par.
The size's and positions are calculated considering propertyMap and
parentMap - which means for future children state, and for bounds that are
constantly changed during other calculations. | | protected void | arrangeParticipants(Map propertyMap, ParentMap parentMap)
Arranges participants according to the given property and parent maps. | | protected void | arrangeParticipantsHorizontally(Object[] pars, Map propertyMap, ParentMap parentMap)
| | protected void | arrangeParticipantsVertically(Object[] pars, Map propertyMap, ParentMap parentMap)
Arranging heights and positions of given participants and positions of
participants that must be translated due to a change of given
participants. | | protected void | changeBounds(Object cell, Map propertyMap, Rectangle r)
Replaces bounding rectangle of given cell in propertyMap object with
rectangle r if cell is contained within the propertyMap object, otherwise
adds new entry to the propertyMap that consists of given cell and a map
containing given rectangle r. | | public GraphTransitionInterface | connectStartOrEndBubble(GraphBubbleActivityInterface startOrEnd, String actId)
| | protected static boolean | containsBubble(Set gacts, boolean start)
| | public void | createWorkflowGraph(XMLCollectionElement wpOrAs)
Creates graph representation of given workflow process. | | public boolean | doesRootParticipantExist()
| | public Object | findNearestCell(Object selectedCell, int direction)
Finds the nearest cell to the given cell in given direction. | | public GraphParticipantInterface | findParentActivityParticipantForLocation(Point loc, Map propertyMap, ParentMap parentMap)
Finds new participant for activity after it's position changes. | | public GraphParticipantInterface | findParentForLocation(Point loc)
| | public Rectangle | getBounds(Object cell, Map propertyMap)
Gets bounding rectangle of given cell. | | protected Rectangle | getBoundsOfParticipantFutureActivities(GraphParticipantInterface par, Map propertyMap, ParentMap parentMap)
Gets the bounding rectangle of future children activities of given
Participant par (that will be participants activities after parent map is
applied). | | public GraphBubbleActivityInterface | getBubble(ExtendedAttribute ea)
Returns start/end graph bubble object which represents start/end ext. | | protected static Point | getBubbleOffsetPoint(Point actOffs, boolean start, Dimension defActDim, boolean isGraphRotated)
| | public Point | getCenter(Object go)
Returns the central point of given graph object. | | public List | getDisplayedParticipants()
| | protected Set | getEnds()
Returns end bubbles. | | public Graph | getGraph()
Returns the graph which is managed. | | public GraphActivityInterface | getGraphActivity(String id)
Returns graph Activity object which represents XPDL activity with given Id
attribute. | | public GraphActivityInterface | getGraphActivity(Activity act)
| | public GraphController | getGraphController()
| | public GraphParticipantInterface | getGraphParticipant(String id)
Returns graph Participant object which represents XPDL participant with
given Id attribute. | | public GraphParticipantInterface | getGraphParticipant(Participant par)
| | public GraphTransitionInterface | getGraphTransition(String id)
Returns graph Transition object which represents XPDL transition with
given Id attribute. | | public GraphTransitionInterface | getGraphTransition(Transition tra)
| | public Dimension | getGraphsPreferredSize()
| | public int | getHorizontalOffset()
Returns horizontal offset for inserting participants. | | protected GraphParticipantInterface | getLeafParticipantForXPos(int xPos, Map propertyMap, ParentMap parentMap)
| | protected GraphParticipantInterface | getLeafParticipantForYPos(int yPos, Map propertyMap, ParentMap parentMap)
Returns leaf participant that bounds given y-coordinate. | | protected int | getNewRootParXPos(Map propertyMap, ParentMap parentMap)
| | protected int | getNewRootParYPos(Map propertyMap, ParentMap parentMap)
Gets the insertation point (y-coordinate) of new root participant. | | public Point | getOffset(GraphActivityInterface a, Map propertyMap)
Returns the point within the graph where the upper-left corner of given
graph activity is placed. | | public Point | getOffset(Point actPoint)
| | protected Set | getParticipantFutureActivities(GraphParticipantInterface par, ParentMap parentMap)
Gets future children activities of given participant par (that will be
par's activities after parent map is applied). | | protected int | getParticipantHeight(Object par, Map propertyMap)
Gets height of given participant (from it's current view or from
propertyMap). | | public String | getParticipantId(Point pos)
| | protected int | getParticipantWidth(Object par, Map propertyMap)
Gets width of given participant (from it's current view or from
propertyMap). | | protected GraphParticipantInterface[] | getParticipantsForXPos(int xPos, int direction, Map propertyMap, ParentMap parentMap)
| | protected GraphParticipantInterface[] | getParticipantsForYPos(int yPos, int direction, Map propertyMap, ParentMap parentMap)
Returns participants that are under or above given yPos, or contains that
y-position:
direction=0 -> under,
direction=1 -> above,
direction=2 -> contains. | | protected List | getPoints(GraphTransitionInterface cell, Map propertyMap)
| | public Point | getRealPosition(GraphActivityInterface a, GraphParticipantInterface gpar)
| | protected int | getRootParticipantHeight(Map propertyMap, ParentMap parentMap)
| | protected int | getRootParticipantWidth(Map propertyMap, ParentMap parentMap)
Gets the width of root participants. | | protected Set | getStarts()
Returns start bubbles. | | public Rectangle | getUnionBounds(Rectangle[] rects)
Gets union of given rectangles. | | public CellView | getView(Object cell)
Gets view of given object. | | public XMLCollectionElement | getXPDLOwner()
Returns the object (part of mapped XML logic) that is represented by the
graph managed by WorklowManager. | | public JaWEGraphModel | graphModel()
Returns the graph model - the model that represents the graph view. | | protected boolean | hasAnyActivity(GraphParticipantInterface par, ParentMap parentMap)
Checks if given participant par has activities. | | protected boolean | hasAnyParticipant(GraphParticipantInterface par, ParentMap parentMap)
Checks if given participant par has other participants. | | public static boolean | hasConnectedEndBubble(GraphActivityInterface act)
| | public static boolean | hasConnectedStartBubble(GraphActivityInterface act)
| | public void | init()
| | public GraphActivityInterface | insertActivity(Activity xpdla)
| | public GraphActivityInterface | insertEnd(ExtendedAttribute eea)
| | public List | insertMissingStartEndBubbles()
| | public GraphParticipantInterface | insertParticipantAndArrangeParticipants(Participant par)
Inserts new Participant cell into model. | | public GraphActivityInterface | insertStart(ExtendedAttribute sea)
| | public GraphTransitionInterface | insertTransition(Transition xpdltra)
| | public boolean | isFreeTextExpressionParticipantShown()
| | protected boolean | isGraphRotated()
| | public void | moveCellsAndArrangeParticipants(Map propertyMap)
| | public boolean | moveParticipants(List partsToMove, boolean direction, Map propertyMap, ParentMap parentMap)
| | public void | moveParticipants(Object[] cellsToMove, boolean direction)
| | protected int | optimalParticipantHeight(GraphParticipantInterface par, Map propertyMap, ParentMap parentMap)
Calculates minimal participant height, which depends of position of all of
its Activity cells. | | protected int | optimalParticipantWidth(GraphParticipantInterface par, Map propertyMap, ParentMap parentMap)
| | protected int | optimalRootParticipantHeight(List participants, Map propertyMap, ParentMap parentMap)
| | protected int | optimalRootParticipantWidth(List participants, Map propertyMap, ParentMap parentMap)
Calculates the minimal width of root participants. | | public void | removeActivity(Activity xpdla)
| | public void | removeBubble(ExtendedAttribute ea)
| | public void | removeCells(Object[] cellsToDelete)
| | public void | removeCellsAndArrangeParticipants(Object[] cellsToDelete)
Removes cells cellsToDelete from model. | | public void | removeStartEndBubbles()
| | public void | removeTransition(Transition xpdltra)
| | protected void | removeTransition(GraphTransitionInterface gtra)
| | protected void | resize(Object[] cells, Map propertyMap, int dw, int dh)
Resizes given participants. | | protected void | resizeAllParticipantsHorizontally(Map propertyMap, ParentMap parentMap)
Method that resizes all participants horizontally to get there minimal
needed sizes. | | protected void | resizeAllParticipantsVertically(Map propertyMap, ParentMap parentMap)
| | protected void | translateHorizontally(Map propertyMap, ParentMap parentMap, int xPos, int dv)
| | protected void | translateParticipant(GraphParticipantInterface par, Map propertyMap, ParentMap parentMap, int dx, int dy)
Translates single participant and its children.The method checks for
bounds of cells within propertyMap and uses parentMap to translate right
children (the children that will be it's after applying parentMap). | | protected void | translateParticipants(GraphParticipantInterface[] cells, Map propertyMap, ParentMap parentMap, int dx, int dy)
Translates given participants using propertyMap for bounds checking and
parentMap for future children checking. | | protected void | translateVertically(Map propertyMap, ParentMap parentMap, int yPos, int dv)
Translates participants under given position yPos vertically for a value
of dv. | | protected Set | updateActivityParent(GraphActivityInterface ac, Map propertyMap, ParentMap parentMap)
Determines old and new participant for activity, adjusts activities
position if needed and properly changes parent of activity (adds entry
into the parentMap). | | public void | updateBreakPoints(GraphTransitionInterface gtra, Map propertyMap)
| | public void | updateBubble(ExtendedAttribute ea)
| | protected void | updateModelAndArrangeParticipants(Object[] insert, Map propertyMap, ParentMap parentMap, Map viewMap, String actionName, ConnectionSet cs, boolean arrangeParticipants)
Inserts new activities into model, changes positions and sizes of
participants due to a insertion of new activities or due to a moving of
activities. | | public void | updateStyle(GraphTransitionInterface gtra)
| | protected void | updateStyle(GraphTransitionInterface gtra, Map propertyMap)
| | public void | updateTransition(Transition xpdltra)
| | protected List | updateXPDLActivitiesPosition(Map propertyMap)
|
| pLoaded | | protected boolean pLoaded(Code) | | |
| GraphManager | | public GraphManager(Graph g)(Code) | | Creates new workflow manager for given graph.
Parameters:
g - The graph that manager manages. |
| arrangeActivityPosition | | public void arrangeActivityPosition(Activity act)(Code) | | |
| arrangeParticipantHorizontally | | protected void arrangeParticipantHorizontally(Object par, Map propertyMap, ParentMap parentMap)(Code) | | |
| arrangeParticipantRelationsOnly | | protected void arrangeParticipantRelationsOnly(Map propertyMap, ParentMap parentMap)(Code) | | |
| arrangeParticipantVertically | | protected void arrangeParticipantVertically(Object par, Map propertyMap, ParentMap parentMap)(Code) | | Resizing participant par and it's parents to appropriate height, and
translating other participants accordingly to changes of participant par.
The size's and positions are calculated considering propertyMap and
parentMap - which means for future children state, and for bounds that are
constantly changed during other calculations. If propertyMap and parentMap
are null, size's and positions are calculated for current state. Also, if
par that is to be arranged has entry in parentMap as removed participant,
it will not be arranged.
|
| arrangeParticipants | | protected void arrangeParticipants(Map propertyMap, ParentMap parentMap)(Code) | | Arranges participants according to the given property and parent maps.
|
| arrangeParticipantsHorizontally | | protected void arrangeParticipantsHorizontally(Object[] pars, Map propertyMap, ParentMap parentMap)(Code) | | |
| arrangeParticipantsVertically | | protected void arrangeParticipantsVertically(Object[] pars, Map propertyMap, ParentMap parentMap)(Code) | | Arranging heights and positions of given participants and positions of
participants that must be translated due to a change of given
participants.
|
| changeBounds | | protected void changeBounds(Object cell, Map propertyMap, Rectangle r)(Code) | | Replaces bounding rectangle of given cell in propertyMap object with
rectangle r if cell is contained within the propertyMap object, otherwise
adds new entry to the propertyMap that consists of given cell and a map
containing given rectangle r.
|
| containsBubble | | protected static boolean containsBubble(Set gacts, boolean start)(Code) | | |
| createWorkflowGraph | | public void createWorkflowGraph(XMLCollectionElement wpOrAs)(Code) | | Creates graph representation of given workflow process. It creates a graph
entities (participants, activities, transitions) and associates the
workflow logic to it. The graph entities are inserted according to the
data that wp object holds (the data from XML file).
This is used when reading a workflow definition from an XML file.
Parameters:
wpOrAs - Object that mapps the logic of WorkflowProcess element of XML -defines a particular Workflow process. |
| doesRootParticipantExist | | public boolean doesRootParticipantExist()(Code) | | |
| findNearestCell | | public Object findNearestCell(Object selectedCell, int direction)(Code) | | Finds the nearest cell to the given cell in given direction.
Parameters:
selectedCell - first currently selected cell
Parameters:
direction - 0-Up, 1-Down, 2-Left, 3-Right (if given some other no, the Up isassumed) The nearest cell to the given one in given direction, or null ifno such cell. |
| findParentActivityParticipantForLocation | | public GraphParticipantInterface findParentActivityParticipantForLocation(Point loc, Map propertyMap, ParentMap parentMap)(Code) | | Finds new participant for activity after it's position changes. WARNING:
this method changes it's argument loc if not appropriate.
|
| getBounds | | public Rectangle getBounds(Object cell, Map propertyMap)(Code) | | Gets bounding rectangle of given cell. The rectangle is either current
rectangle of cellView either from propertyMap where are held bounding
rectangles of various cells during multiple resizing and/or translating of
cells.
|
| getBoundsOfParticipantFutureActivities | | protected Rectangle getBoundsOfParticipantFutureActivities(GraphParticipantInterface par, Map propertyMap, ParentMap parentMap)(Code) | | Gets the bounding rectangle of future children activities of given
Participant par (that will be participants activities after parent map is
applied). Bounding rectangle is union of previous mentioned activities.
|
| getBubbleOffsetPoint | | protected static Point getBubbleOffsetPoint(Point actOffs, boolean start, Dimension defActDim, boolean isGraphRotated)(Code) | | |
| getCenter | | public Point getCenter(Object go)(Code) | | Returns the central point of given graph object.
|
| getDisplayedParticipants | | public List getDisplayedParticipants()(Code) | | |
| getEnds | | protected Set getEnds()(Code) | | Returns end bubbles.
|
| getGraph | | public Graph getGraph()(Code) | | Returns the graph which is managed.
|
| getHorizontalOffset | | public int getHorizontalOffset()(Code) | | Returns horizontal offset for inserting participants.
|
| getLeafParticipantForYPos | | protected GraphParticipantInterface getLeafParticipantForYPos(int yPos, Map propertyMap, ParentMap parentMap)(Code) | | Returns leaf participant that bounds given y-coordinate. If y-coordinate
is at boundary of two participants, method returns one that is above. The
method checks for bounds of cells within propertyMap.
|
| getNewRootParXPos | | protected int getNewRootParXPos(Map propertyMap, ParentMap parentMap)(Code) | | |
| getNewRootParYPos | | protected int getNewRootParYPos(Map propertyMap, ParentMap parentMap)(Code) | | Gets the insertation point (y-coordinate) of new root participant.
|
| getOffset | | public Point getOffset(GraphActivityInterface a, Map propertyMap)(Code) | | Returns the point within the graph where the upper-left corner of given
graph activity is placed. The point origin is the upper-left corner of
participant graph object that holds given activity.
|
| getParticipantFutureActivities | | protected Set getParticipantFutureActivities(GraphParticipantInterface par, ParentMap parentMap)(Code) | | Gets future children activities of given participant par (that will be
par's activities after parent map is applied).
|
| getParticipantHeight | | protected int getParticipantHeight(Object par, Map propertyMap)(Code) | | Gets height of given participant (from it's current view or from
propertyMap).
|
| getParticipantWidth | | protected int getParticipantWidth(Object par, Map propertyMap)(Code) | | Gets width of given participant (from it's current view or from
propertyMap).
|
| getParticipantsForYPos | | protected GraphParticipantInterface[] getParticipantsForYPos(int yPos, int direction, Map propertyMap, ParentMap parentMap)(Code) | | Returns participants that are under or above given yPos, or contains that
y-position:
direction=0 -> under,
direction=1 -> above,
direction=2 -> contains. The method checks for bounds of cells within
propertyMap. If some of model's participants is entered in parentMap as
removed participant, this method doesn't consider that participant.
|
| getRootParticipantHeight | | protected int getRootParticipantHeight(Map propertyMap, ParentMap parentMap)(Code) | | |
| getRootParticipantWidth | | protected int getRootParticipantWidth(Map propertyMap, ParentMap parentMap)(Code) | | Gets the width of root participants. The method checks for bounds of cells
within propertyMap. If some of model's participants has entry within
propertyMap as removed, this participant doesn't count.
|
| getStarts | | protected Set getStarts()(Code) | | Returns start bubbles.
|
| getView | | public CellView getView(Object cell)(Code) | | Gets view of given object.
|
| getXPDLOwner | | public XMLCollectionElement getXPDLOwner()(Code) | | Returns the object (part of mapped XML logic) that is represented by the
graph managed by WorklowManager. That object can be instance of the
Package, WorkflowProcess or ...xml.elements.BlockActivity class, and is
held as a property of the manager's graph object.
The object (representing XML logic) that is represented by thismanager's graph. |
| graphModel | | public JaWEGraphModel graphModel()(Code) | | Returns the graph model - the model that represents the graph view. (See
JGraph documentation).
|
| hasAnyActivity | | protected boolean hasAnyActivity(GraphParticipantInterface par, ParentMap parentMap)(Code) | | Checks if given participant par has activities. If parentMap is null, or
there is no entry for this this participant within a parentMap, the
current state is checked, elsewhere parentMap is checked-in other words
future state of participant activities (state after aplying parentMap) is
returned.
|
| hasAnyParticipant | | protected boolean hasAnyParticipant(GraphParticipantInterface par, ParentMap parentMap)(Code) | | Checks if given participant par has other participants. If parentMap is
null, or there is no entry for this this participant within a parentMap,
the current state is checked, elsewhere parentMap is checked-in other
words future state of participant participants (state after aplying
parentMap) is returned.
This method has meaning in previous versions of JaWE, now it always
returns false.
|
| insertMissingStartEndBubbles | | public List insertMissingStartEndBubbles()(Code) | | |
| insertParticipantAndArrangeParticipants | | public GraphParticipantInterface insertParticipantAndArrangeParticipants(Participant par)(Code) | | Inserts new Participant cell into model. First, the
parent of new Participant is searched, and if found, put into ParentMap
(it is not inserted into model at ones). If parent participant isn't found ->
root participant will be inserted. After that model's view is arranged
(Participants are moved and translated along with it's children cells) to
suite to the new model state - this is done "virtually" which means that
changes are not directly applied to view until all changes are made. At
the end, all changes are applied to model and view. Such procedure enables
compound undo support.
This method is called when inserting new Participant into model.
|
| isFreeTextExpressionParticipantShown | | public boolean isFreeTextExpressionParticipantShown()(Code) | | |
| isGraphRotated | | protected boolean isGraphRotated()(Code) | | |
| moveCellsAndArrangeParticipants | | public void moveCellsAndArrangeParticipants(Map propertyMap)(Code) | | |
| moveParticipants | | public boolean moveParticipants(List partsToMove, boolean direction, Map propertyMap, ParentMap parentMap)(Code) | | |
| moveParticipants | | public void moveParticipants(Object[] cellsToMove, boolean direction)(Code) | | |
| optimalParticipantHeight | | protected int optimalParticipantHeight(GraphParticipantInterface par, Map propertyMap, ParentMap parentMap)(Code) | | Calculates minimal participant height, which depends of position of all of
its Activity cells. The height is calculated considering propertyMap and
parentMap - which means for future children state, and for bounds that are
constantly changed during other calculations. If propertyMap and parentMap
are null, size is calculated for current state.
|
| optimalRootParticipantHeight | | protected int optimalRootParticipantHeight(List participants, Map propertyMap, ParentMap parentMap)(Code) | | |
| optimalRootParticipantWidth | | protected int optimalRootParticipantWidth(List participants, Map propertyMap, ParentMap parentMap)(Code) | | Calculates the minimal width of root participants. It depends of minimal
allowed width of leaf participants, which depends on the position of
Activity cells in them. The width is calculated considering propertyMap
and parentMap - which means for future children state, and for bounds that
are constantly changed during other calculations. If propertyMap and
parentMap are null, size is calculated for current state.
|
| removeCells | | public void removeCells(Object[] cellsToDelete)(Code) | | |
| removeCellsAndArrangeParticipants | | public void removeCellsAndArrangeParticipants(Object[] cellsToDelete)(Code) | | Removes cells cellsToDelete from model. This means that given
cells and all of their descendants as well as all transitions that
connects given cells, will be removed from model. First, all remained
participants are moved and resized according to participants that are
beeing removed and ParentMap for all removed cells is created (all these
things are made "virtually" - not applied to model and view). After that
model's new view is arranged (Participants are moved and translated (along
with it's children cells) according to the remained children - this is
also done "virtually". At the end, all changes are applied to model and
view. Such procedure enables compound undo support.
This method is called when deleting or cutting cells from graph.
|
| removeStartEndBubbles | | public void removeStartEndBubbles()(Code) | | |
| resize | | protected void resize(Object[] cells, Map propertyMap, int dw, int dh)(Code) | | Resizes given participants. The resizing is done to propertyMap which will
later (after all needed operation) be applied.
|
| resizeAllParticipantsHorizontally | | protected void resizeAllParticipantsHorizontally(Map propertyMap, ParentMap parentMap)(Code) | | Method that resizes all participants horizontally to get there minimal
needed sizes. The size is calculated considering propertyMap and parentMap -
which means for future children state, and for bounds that are constantly
changed during other calculations. If propertyMap and parentMap are null,
size is calculated for current state.
|
| resizeAllParticipantsVertically | | protected void resizeAllParticipantsVertically(Map propertyMap, ParentMap parentMap)(Code) | | |
| translateHorizontally | | protected void translateHorizontally(Map propertyMap, ParentMap parentMap, int xPos, int dv)(Code) | | |
| translateParticipant | | protected void translateParticipant(GraphParticipantInterface par, Map propertyMap, ParentMap parentMap, int dx, int dy)(Code) | | Translates single participant and its children.The method checks for
bounds of cells within propertyMap and uses parentMap to translate right
children (the children that will be it's after applying parentMap). The
translating is done to propertyMap which will later (after all needed
operation) be applied.
|
| translateParticipants | | protected void translateParticipants(GraphParticipantInterface[] cells, Map propertyMap, ParentMap parentMap, int dx, int dy)(Code) | | Translates given participants using propertyMap for bounds checking and
parentMap for future children checking. The translating is done to
propertyMap which will later (after all needed operation) be applied.
See Also: GraphManager.translateParticipant |
| translateVertically | | protected void translateVertically(Map propertyMap, ParentMap parentMap, int yPos, int dv)(Code) | | Translates participants under given position yPos vertically for a value
of dv. The translating is done to propertyMap which will later (after all
needed operation) be applied.
See Also: GraphManager.translateParticipants |
| updateActivityParent | | protected Set updateActivityParent(GraphActivityInterface ac, Map propertyMap, ParentMap parentMap)(Code) | | Determines old and new participant for activity, adjusts activities
position if needed and properly changes parent of activity (adds entry
into the parentMap).
|
| updateModelAndArrangeParticipants | | protected void updateModelAndArrangeParticipants(Object[] insert, Map propertyMap, ParentMap parentMap, Map viewMap, String actionName, ConnectionSet cs, boolean arrangeParticipants)(Code) | | Inserts new activities into model, changes positions and sizes of
participants due to a insertion of new activities or due to a moving of
activities. Also, finds and changes parent's of inserted/changed-position
activities. This method is called when inserting new activities, when
pasting activities, and when moving activities. All changes to the model
and to the view are at first made virtually (to the parentMap and to the
propertyMap) and when all is done, method insertAndEdit of PEGraphModel
class is called to actually make changes. The updateCollection parameter
is used when some objects are inserted into model, to update collection of
XML elements.
Parameters:
arrangeParticipants - TODO |
| updateXPDLActivitiesPosition | | protected List updateXPDLActivitiesPosition(Map propertyMap)(Code) | | |
|
|