Class Part

The initial value is an empty string, which is the default category. Any new value must be a string. This should not be set in templates.

When building Parts for node data or link data in a model, the Diagram will call Model.getCategoryForNodeData or GraphLinksModel.getCategoryForLinkData to get the category string for the data object. The diagram uses this value to look up a template in Diagram.nodeTemplateMap, Diagram.linkTemplateMap or Diagram.groupTemplateMap. That template is copied to create the actual Part that is added to the diagram. The diagram will set this property to remember the category it used.

Note that the class of the new Part must be the same as the class of the original Part. For example, a Node cannot be replaced by a simple Part or vice-versa. Nor can a Link be replaced by a subclass of Link or vice-versa.

To change the category for a Part created for model data, call Model.setCategoryForNodeData or GraphLinksModel.setCategoryForLinkData.

This property is also used to distinguish Adornments on a Part. In this scenario you create the Adornment, often indirectly by specifying a template, and set this property explicitly. For example, ResizingTool.updateAdornments creates a resizing Adornment from the Part.resizeAdornmentTemplate and sets its category to be "Resizing". Changing the category of an existing Adornment will update any adorned part's association.

You cannot set this property on a Link; it is set for you automatically based on the group memberships of the connected nodes. You cannot set this property on an Adornment at all.

A template should not be a member of any group.

If the value is a function, that function must not modify the part's containing Group. The containing Group has already been changed -- trying to change it again may produce undefined behavior.

The initial value is null -- no function is called.

By default this function is null and the DraggingTool uses the snapped location, if one was determined and if DraggingTool.isGridSnapEnabled is true, or the proposed location (the second argument) if not snapping to a grid.

In either case the DraggingTool will limit the proposed new location by minLocation and maxLocation.

The function, if supplied, must not have any side-effects.

An example that limits moving a Node to the current viewport:

  function stayInViewport(part, pt, gridpt) {
    var diagram = part.diagram;
    if (diagram === null) return pt;
    // compute the area inside the viewport
    var v = diagram.viewportBounds.copy();
    v.subtractMargin(diagram.padding);
    // get the bounds of the part being dragged
    var bnd = part.actualBounds;
    var loc = part.location;
    // now limit the location appropriately
    var l = v.x + (loc.x - bnd.x);
    var r = v.right - (bnd.right - loc.x);
    var t = v.y + (loc.y - bnd.y);
    var b = v.bottom - (bnd.bottom - loc.y);
    if (l <= gridpt.x && gridpt.x <= r && t <= gridpt.y && gridpt.y <= b) return gridpt;
    var p = gridpt.copy();
    if (diagram.toolManager.draggingTool.isGridSnapEnabled) {
      // find a location that is inside V but also keeps the part's bounds within V
      var cw = diagram.grid.gridCellSize.width;
      if (cw > 0) {
        while (p.x > r) p.x -= cw;
        while (p.x < l) p.x += cw;
      }
      var ch = diagram.grid.gridCellSize.height;
      if (ch > 0) {
        while (p.y > b) p.y -= ch;
        while (p.y < t) p.y += ch;
      }
      return p;
    } else {
      p.x = Math.max(l, Math.min(p.x, r));
      p.y = Math.max(t, Math.min(p.y, b));
      return p;
    }
  }

Note that for this functionality you will also probably want to set Diagram.autoScrollRegion to be a zero margin.

  myDiagram.nodeTemplate =
    new go.Node(. . .,
      { dragComputation: stayInViewport },
      . . .
    )

The grouping command is implemented by CommandHandler.groupSelection and depends on CommandHandler.archetypeGroupData having been set to a node data object. A Group can be ungrouped by the user if you set Group.ungroupable to true.

If this property value is a function, it is called with one argument, this Part that whose isHighlighted value changed. By default this property is null.

Highlighted parts may be shown with a different appearance by changing the brush or visibility of one or more of the GraphObjects within the part. One way of doing that is by using binding. Consider part of the definition of a Node template:

new go.Shape({
    // ... shape properties
  })
  // Shape.fill is bound to Node.data.color
  .bind("fill", "color")
  // Shape.stroke is red when Node.isHighlighted is true, black otherwise
  .bind(new go.Binding("stroke", "isHighlighted",
                 function(h) { return h ? "red" : "black"; }).ofObject())

The initial value is true. A value of false causes Diagram.computeBounds to ignore this part. If the value is false, it is possible that user will not be able to scroll far enough to see this part, if the part's GraphObject.actualBounds are outside of the Diagram.documentBounds.

The initial value is true, meaning that this part is laid out by the layout responsible for this Part. If this part is a member of a Group, it is the Group.layout, otherwise it is the Diagram.layout.

A value of false means that this part is not affected by and does not affect any automatic layout, so the layoutConditions property is ignored. You will need to make sure that it has a real location or GraphObject.position value, or else the Part might not be visible anywhere in the diagram.

Another way of controlling when layouts are invalidated is by setting Part.layoutConditions or Layout.isInitial or Layout.isOngoing.

Selected parts typically are shown either with an Adornment or with a different appearance by changing the brush or visibility of one or more of the GraphObjects within the part.

Changing this value does not by itself raise any "ChangingSelection" and "ChangedSelection" DiagramEvents. Tools and the CommandHandler and methods such as Diagram.select do raise those DiagramEvents because they want to surround changes to this property with a single "ChangingSelection" DiagramEvent beforehand and a single "ChangedSelection" afterwards.

By default, setting this property to true will attempt to draw shadows only on the GraphObjects in this Part that appear to act as background objects, and not on GraphObjects that appear to be in front of other GraphObjects in the Part.

To finely control shadows, you may need to set GraphObject.shadowVisible on elements of this Part, so that they explicitly do or do not get shadowed accordingly.

The color of the shadow is determined by shadowColor. The opacity of the shadow color is multiplied by the opacity of the shadowed object's brush. So, for example, if you have a Panel with a GraphObject.background that is "transparent", the shadow that is drawn for the panel will also be transparent.

The direction of the shadow that is cast is controlled by shadowOffset, and is independent of the Diagram.scale. The sharpness of the shadow is controlled by shadowBlur.

If this property value is a function, it is called with three arguments, this Part, the old Layer (may be null), and the new Layer (may be null). By default this property is null -- no function is called.

If this part is not yet in a Diagram, this value is used by Diagram.add to determine which Layer this part should go in. If no layer can be found with this name, it uses the default layer.

Changing the value of this property while it is already in a layer causes it to change layers if needed.

Individual layout conditions include: Part.LayoutAdded, Part.LayoutRemoved, Part.LayoutShown, Part.LayoutHidden, and Part.LayoutNodeSized.

This property is ignored when isLayoutPositioned is false -- no operation on this Part will by itself cause the responsible Layout to be invalidated.

You can also control when layouts are invalidated is by setting Layout.isInitial or Layout.isOngoing.

Value must be of type Point. The initial value is Point(NaN, NaN). It is commonplace to data bind this property to some property on your model node data.

The value is related to the GraphObject.position. For Parts, both are in document coordinates; setting one property will set the other property. By default both will have the same value. However, by setting either or both of locationSpot and locationObjectName, the location will be determined by a spot in the locationObject, a GraphObject that is in the visual tree of this Part. The GraphObject.position will always refer to the point at the top-left corner of the whole part.

The minLocation and maxLocation limit the location of a part, not its position. Grid snapping will normally locate the location to be on grid points.

The initial value is an empty string, meaning the whole Part itself determines the location. If you want to use a particular GraphObject in the visual tree of this Part, set this property to be the GraphObject.name of the element that you want to be the locationObject.

Value must be of the type Spot. The initial value is Spot.TopLeft. The value must be a specific spot -- i.e. one for which Spot.isSpot is true.

It is commonplace to set this property to Spot.Center, so that the location has a value corresponding to the point at the center of this Part's locationObject element. But the GraphObject.position of a Part is always at the top-left corner point of the GraphObject.actualBounds.

Value must be of type Point. The initial value is (Infinity, Infinity), which imposes no position constraint. A X value of NaN causes Diagram.computeMove to use the part's current location's X value as the maximum, and similarly for NaN as the Y value.

Value must be of type Point. The initial value is (-Infinity, -Infinity), which imposes no position constraint. A X value of NaN causes Diagram.computeMove to use the part's current location's X value as the minimum, and similarly for NaN as the Y value.

If you set this to true you may also want to set resizeObjectName to the GraphObject.named element that you want the user to resize. It is also commonplace to add a TwoWay Binding of that named element's GraphObject.desiredSize in order to save to the model data the value that the user set via the ResizingTool.

If an Adornment is supplied, it is normally a Panel.Spot panel that contains a Placeholder with some number of resize handles at the four corners or at the four side midpoints.

If you set this to true you may also want to set rotateObjectName to the GraphObject.named element that you want the user to rotate. It is also commonplace to add a TwoWay Binding of that named element's GraphObject.angle in order to save to the model data the value that the user set via the RotatingTool.

This Adornment should not have a Placeholder in it, because the RotatingTool will position it away from the rotateObject at its GraphObject.angle.

Value must be of the type Spot. The value must be a specific spot -- i.e. one for which Spot.isSpot is true, or else Spot.Default.

If the value is Spot.Default, the RotatingTool uses the locationSpot if the rotateObject is equal to the locationObject, otherwise it uses Spot.Center.

The initial value is Spot.Default.

If you set this to true you may also want to set selectionObjectName to the GraphObject.named element that you want to be adorned when the Part is selected.

If this is null, depending on the class of this Part, the value of Diagram.nodeSelectionAdornmentTemplate, Diagram.groupSelectionAdornmentTemplate, or Diagram.linkSelectionAdornmentTemplate is used instead.

It is commonplace to make use of a Placeholder in an Adornment for a Node, Group, or simple Part. The Placeholder represents the Adornment.adornedObject of the adorned Part. For Links, the Adornment must be of Panel.type Panel.Link.

If this property value is a function, it is called with one argument, this Part that was selected or that became unselected. When it is called, the value of Diagram.skipsUndoManager is temporarily set to true. By default this property is null.

This function is called with Diagram.skipsUndoManager temporarily set to true, so that any changes to GraphObjects are not recorded in the UndoManager. You do not need to start and commit any transaction in this function.

If no GraphObject has a GraphObject.name that is this name, selectionObject returns the whole Part.

This value is not affected by scale. Default value is 4.

The opacity of the shadow color is multiplied by the opacity of the shadowed object's brush. So, for example, if you have a Panel with a GraphObject.background that is "transparent", the shadow that is drawn for the panel will also be transparent.

The initial value is an empty string. This value is often used for sorting.

Within the same layer, nodes with larger zOrder values are placed in front of nodes with smaller zOrder values. When the value is NaN the ordering is not specified. The default value is NaN.

When a Group has a zOrder value of NaN, it is automatically placed behind its member nodes and links that also have no zOrder. Such automatic ordering is not guaranteed if any nodes including the groups have a numeric zOrder. If you do want to specify the zOrder of nodes, you should also specify the zOrder of their containing groups unless those groups are in different layers.