Sets the starting list of anchors before running the alignment routine.

@param anchors list of points that are tied to the given indices in the target
166334
public void setAnchors(int[] anchors) {
		super.anchors = new ArrayList<Anchor>();
		if (anchors != null) {
			for (int i = 0; i < anchors.length; i++) {
				if (anchors[i] >= 0) {
					addAnchor(i, anchors[i]);
				}
			}
		}
	}
1079512
public void setActiveIndices(final int[] indices) {
		TabSetModel model = getOrCreateComponentModel();

		if (indices == null || indices.length == 0) {
			model.activeTabs = null;
			return;
		}

		if (model.activeTabs == null) {
			model.activeTabs = new ArrayList<>(1);
		}

		model.activeTabs.clear();

		for (int index : indices) {
			model.activeTabs.add(index);
		}
	}
1060079
@SuppressWarnings("unchecked")
    @Internal
    protected final void setLinks(Map<String, Object> links) {
        for (Map.Entry<String, Object> entry : links.entrySet()) {
            String name = entry.getKey();
            Object value = entry.getValue();
            if (value instanceof Map) {
                Map<String, Object> linkMap = (Map<String, Object>) value;
                link(name, linkMap);
            }
        }
    }
5355
public void setVerticalAlignment(int verticalAlignment) {
        if (table != null)
            table.setExtendLastRow(verticalAlignment == Element.ALIGN_TOP);
        this.verticalAlignment = verticalAlignment;
    }
1056858
void setNewNodes() {

        int indexcount = tTable.getIndexCount();

        nPrimaryNode = new NodeAVLDisk(this, 0);

        NodeAVL n = nPrimaryNode;

        for (int i = 1; i < indexcount; i++) {
            n.nNext = new NodeAVLDisk(this, i);
            n       = n.nNext;
        }
    }
921144
public void setTextAlignment(final TextAlignment ALIGNMENT) {
        if (null == textAlignment) {
            _textAlignment = ALIGNMENT;
            fireTileEvent(RESIZE_EVENT);
        } else {
            textAlignment.set(ALIGNMENT);
        }
    }
459950
public final void setLink(Attributes attributes) {
        lineValues[GpxMetadata.LINELINK_HREF] = attributes.getValue(GPXTags.HREF);
    }
552493
protected void startInitialAlignment(boolean resetTxOffset) {
        if (logger.isDebugEnabled()) {
            logger.debug(String.format("(%s) Starting initial alignment", name));
        }

        // Comment from Oleg: this is done initialy to setup correct spot in tx
        // buffer: dunno, I just believe, for now.
        if (resetTxOffset) {
            // txOffset = 3;
            this.txFrame.offset = 3; // I really dont get this shift.
        }

        this.reset();

        // switch state

        // this.state = MTP2_NOT_ALIGNED;
        this.setState(MTP2_NOT_ALIGNED);

        // starting T2 timer
        start_T2();
    }
574763
public void removeAnchor(String a) {
        if(anchors == null) {
            anchors = new HashMap<String, Node>();
        }
        anchors.put(a, null);
    }
654938
public void setPoints(List<GeoPoint> points) {
        mOutline.clearPath();
        mOriginalPoints = new ArrayList<>(points.size());
        for (GeoPoint p:points) {
            mOriginalPoints.add(p);
        }
        mOutline.setPoints(points);
        setDefaultInfoWindowLocation();
    }
949148
public void setSymbolicLinks(java.util.Collection<SymbolicLink> symbolicLinks) {
        if (symbolicLinks == null) {
            this.symbolicLinks = null;
            return;
        }

        this.symbolicLinks = new java.util.ArrayList<SymbolicLink>(symbolicLinks);
    }
820776
public void setMarkers(List<GenericMarker> m){
        this.markers = m;
        for (GenericMarker marker : m) {
            marker.setMap(this);
        }
        //setup any clustering options
        clusterMarkers();
    }
899756
function anchorFirst() {
    self.startRow = anchorRow;
    self.startNode = selection.anchorNode;
    self.startOffset = selection.anchorOffset;
    self.endRow = focusRow;
    self.endNode = selection.focusNode;
    self.endOffset = selection.focusOffset;
  }
78002
def _do_anchor(self, anchor):
        
        if anchor:
            for x in anchor.split("-"):
                A, P = None, None
                if x.startswith("A") and len(self.chunks) > 0: # anchor
                    A, P = x, x.replace("A","P")
                    self._anchors[A] = self.chunks[-1]
                if x.startswith("P") and len(self.pnp) > 0:    # attachment (PNP)
                    A, P = x.replace("P","A"), x
                    self._anchors[P] = self.pnp[-1]
                if A in self._anchors and P in self._anchors and not self._anchors[P].anchor:
                    pnp = self._anchors[P]
                    pnp.anchor = self._anchors[A]
                    pnp.anchor.attachments.append(pnp)
1231142
public void setAttributes(java.util.Collection<TypedLinkAttributeDefinition> attributes) {
        if (attributes == null) {
            this.attributes = null;
            return;
        }

        this.attributes = new java.util.ArrayList<TypedLinkAttributeDefinition>(attributes);
    }
1341797
@Api
	public void initializeList(Collection<SearchWidget> searchWidgets) {
		LinkedHashMap<String, String> values = new LinkedHashMap<String, String>();
		for (SearchWidget searchWidget : searchWidgets) {
			values.put(searchWidget.getSearchWidgetId(), searchWidget.getName());
		}
		selectSearch.setValueMap(values);
		this.searchWidgets.addAll(searchWidgets);
	}
614109
public void setAssignments(java.util.Collection<Assignment> assignments) {
        if (assignments == null) {
            this.assignments = null;
            return;
        }

        this.assignments = new java.util.ArrayList<Assignment>(assignments);
    }