Apply a maximum extent. This will extend the map extend to be used by the percentage to increase.
347328
private void updateMaxExtent() {
		if (targetMap.getMapModel().isInitialized() && getGraphics().isReady()) {
			// map view size may not have been set yet !
			getMapModel().getMapView().setSize(getWidth(), getHeight());
			Bbox targetMaxBounds = getOverviewMaxBounds();

			MapView mapView = getMapModel().getMapView();

			// Set the maxBounds on this map as well:
			mapView.setMaxBounds(targetMaxBounds.buffer(targetMaxBounds.getWidth()));

			// apply buffer
			if (maxExtentIncreasePercentage > 0) {
				targetMaxBounds = targetMaxBounds
						.buffer(targetMaxBounds.getWidth() * maxExtentIncreasePercentage / 100);
			}

			// Then apply the map extent:
			mapView.applyBounds(targetMaxBounds, MapView.ZoomOption.LEVEL_FIT);

			// Immediately draw or remove the max extent rectangle:
			setDrawTargetMaxExtent(drawTargetMaxExtent);
		}
	}
1361623
def extend(self, **attributes):
        
        for key, value in attributes.iteritems():
            if not hasattr(self, key):
                setattr(self, key, value)
888030
def add_basemap(ax, zoom=12):
    
    url = ctx.sources.ST_TONER_LITE
    xmin, xmax, ymin, ymax = ax.axis()
    basemap, extent = ctx.bounds2img(xmin, ymin, xmax, ymax,
                                            zoom=zoom, url=url)
    ax.imshow(basemap, extent=extent, interpolation='bilinear')
    # restore original x/y limits
    ax.axis((xmin, xmax, ymin, ymax))
1091747
public R setLimit(int limit) {
        mQueryMap.put(LIMIT, String.valueOf(limit));
        return (R) this;
    }
217355
function extend(fn, m) {
  if(!isFunction(fn)) {
    throw new TypeError('extend: Function required for first argument')
  }
  if(!isExtend(m)) {
    throw new TypeError('extend: Extend required for second argument')
  }

  return (m[fl.extend] || m.extend).call(m, fn)
}
604383
def Expand(self):
        
        ret = libxml2mod.xmlTextReaderExpand(self._o)
        if ret is None:raise treeError('xmlTextReaderExpand() failed')
        __tmp = xmlNode(_obj=ret)
        return __tmp
367688
private void applyVerticalLimit()
    {
        if (mover.getY() < limitBottom && limitBottom != Integer.MIN_VALUE)
        {
            mover.teleportY(limitBottom);
        }
        else if (mover.getY() > limitTop && limitTop != Integer.MAX_VALUE)
        {
            mover.teleportY(limitTop);
        }
    }
596801
public function extend_fieldmap($map)
    {
        if (is_array($map)) {
            self::$fieldmap = array_merge($map, self::$fieldmap);
        }
    }
413130
@Override public void addMaxCardinalityRestriction(Class<? extends D> domain, int max)
	{
		if (multipleCardinality)
		{
			this.maxCardinalities.put(domain, max);
		} else
		{
			if (max == 1)
			{
				if (log.isInfoEnabled())
				{
					log.info("unnecessary use of cardinality restriction. " +
					         "Maybe you want to use functional instead?");
				}
			} else if (max == 0)
			{
				this.maxCardinalities.put(domain, max);
			} else
			{
				assert false;
			}
		}
	}
874695
public void extendBound(double[] lowerBound, double[] upperBound) {
        base.extendBound(lowerBound, upperBound);
        baseGrid.setBase(base);
        repaint();
    }
811126
def apply_limit(self):
    ''''''
    self._ensure_modification_is_safe()

    if self.query.limit is not None:
      self._iterable = limit_gen(self.query.limit, self._iterable)
469213
public void expand() {
    join(p, r.first());
    join(r.last(), n);
    // Necessary so that garbage collector
    // can delete rule and guard.
    r.theGuard.r = null;
    r.theGuard = null;
  }
176377
def setExpanded(self, state):
        
        if (state and self.testFlag(self.ItemIsExpandable)) or \
           (not state and self.testFlag(self.ItemIsCollapsible)):
            super(XTreeWidgetItem, self).setExpanded(state)
855396
public void setMax(int max)
    {
        this.max = max;
        if (this.max < Alterable.MIN)
        {
            this.max = Alterable.MIN;
        }
        set(cur);
    }
860193
protected void extendArray(int k) {
    // size + 1 could overflow
    if (this.size + k > this.keys.length) {
      int newCapacity;
      if (this.keys.length < 1024) {
        newCapacity = 2 * (this.size + k);
      } else {
        newCapacity = 5 * (this.size + k) / 4;
      }
      this.keys = Arrays.copyOf(this.keys, newCapacity);
      this.values = Arrays.copyOf(this.values, newCapacity);
    }
  }
440533
public int increase(double extrp, int increase)
    {
        final int current = getCurrent();
        final double increased = current + increase * extrp;
        set(increased);
        if (increased > max)
        {
            return max - current;
        }
        return increase;
    }
694794
protected final void expand (int needed)
    {
        int ocapacity = _buffer.capacity();
        int ncapacity = _buffer.position() + needed;
        if (ncapacity > ocapacity) {
            // increase the buffer size in large increments
            ncapacity = Math.max(ocapacity << 1, ncapacity);
            ByteBuffer newbuf = ByteBuffer.allocate(ncapacity);
            newbuf.put((ByteBuffer)_buffer.flip());
            _buffer = newbuf;
        }
    }