Sets padding for this shape, defined by a Rect object. Define the padding
in the Rect object as: left, top, right, bottom.
491873
public void setPadding(Rect padding) {
        if (padding == null) {
            mState.mPadding = null;
        } else {
            if (mState.mPadding == null) {
                mState.mPadding = new Rect();
            }
            mState.mPadding.set(padding);
        }
        invalidateSelf();
    }
1321543
public AT_Row setPaddingTop(int paddingTop) {
		if(this.hasCells()){
			for(AT_Cell cell : this.getCells()){
				cell.getContext().setPaddingTop(paddingTop);
			}
		}
		return this;
	}
768411
public void setMargin(Rectangle2D bounds, Direction... dirs)
    {
        for (Direction dir : dirs)
        {
            switch (dir)
            {
                case BOTTOM:
                    combinedTransform.transform(userBounds.getCenterX(), userBounds.getMinY(), (x,y)->
                    {
                        inverse.transform(x, y+bounds.getHeight(), this::updatePoint);
                    });
                    break;
                case LEFT:
                    combinedTransform.transform(userBounds.getMinX(), userBounds.getCenterY(), (x,y)->
                    {
                        inverse.transform(x-bounds.getWidth(), y, this::updatePoint);
                    });
                    break;
                case RIGHT:
                    combinedTransform.transform(userBounds.getMaxX(), userBounds.getCenterY(), (x,y)->
                    {
                        inverse.transform(x+bounds.getWidth(), y, this::updatePoint);
                    });
                    break;
                case TOP:
                    combinedTransform.transform(userBounds.getCenterX(), userBounds.getMaxY(), (x,y)->
                    {
                        inverse.transform(x, y-bounds.getHeight(), this::updatePoint);
                    });
                    break;
            }
        }
    }
739278
function setPoints(points) {
         var x = Infinity,
             y = Infinity,
             right = -Infinity,
             bottom = -Infinity;
         points.forEach(function (point) {
           x = Math.min(x, point.x);
           y = Math.min(y, point.y);
           right = Math.max(right, point.x);
           bottom = Math.max(bottom, point.y);
         });
         this.setShape(x, y, right - x, bottom - y);
         return this;
       }
156599
def set_layout(self):
        
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(self.canvas, 1, wx.EXPAND)
        hbox = wx.BoxSizer(wx.HORIZONTAL)
        if self.toolbar is not None:
            self.toobar = MyToolbar(self.canvas)
            self.toobar.Realize()
            hbox.Add(self.toobar, 0, wx.EXPAND | wx.RIGHT, 10)
        self.pos_st = wx.StaticText(self, label='')
        hbox.Add(self.pos_st, 0, wx.ALIGN_CENTER_VERTICAL)
        sizer.Add(hbox, 0, wx.EXPAND | wx.BOTTOM, 0)
        self.SetSizerAndFit(sizer)
1259279
public function setRegion(int $left, int $top, int $width, int $height) : void
    {
        if ($top < 0 || $left < 0) {
            throw new InvalidArgumentException('Left and top must be non-negative');
        }

        if ($height < 1 || $width < 1) {
            throw new InvalidArgumentException('Width and height must be at least 1');
        }

        $right = $left + $width;
        $bottom = $top + $height;

        if ($bottom > $this->height || $right > $this->width) {
            throw new InvalidArgumentException('The region must fit inside the matrix');
        }

        for ($y = $top; $y < $bottom; ++$y) {
            $offset = $y * $this->rowSize;

            for ($x = $left; $x < $right; ++$x) {
                $index = $offset + ($x >> 5);
                $this->bits[$index] = $this->bits[$index] | (1 << ($x & 0x1f));
            }
        }
    }
1163999
public void setBoardPadding(int l, int t, int r, int b) {
        mContentView.setPadding(l, t, r, b);
    }
432001
private void updatePaddingBounds(@NonNull Rect viewBounds) {
        if (mIconPadding >= 0
                && mIconPadding * 2 <= viewBounds.width()
                && mIconPadding * 2 <= viewBounds.height()) {
            mPaddingBounds.set(
                    viewBounds.left + mIconPadding,
                    viewBounds.top + mIconPadding,
                    viewBounds.right - mIconPadding,
                    viewBounds.bottom - mIconPadding);
        }
    }
631983
def set_shape(self, shape):
    """"""
    channels = shape[-1]
    acceptable_channels = ACCEPTABLE_CHANNELS[self._encoding_format]
    if channels not in acceptable_channels:
      raise ValueError('Acceptable `channels` for %s: %s (was %s)' % (
          self._encoding_format, acceptable_channels, channels))
    self._shape = tuple(shape)
1241340
def setPadding(self, pad):
		""""""
		_baseDes.setPadding(self, pad)
		for key in (self.__key1, self.__key2, self.__key3):
			key.setPadding(pad)
1359598
def setRect(self, rect):
		
		self.x, self.y, self.w, self.h = rect
462244
function setPosition(boundingBox, top, left, height, width) {
        var style = boundingBox.style;
        if (height <= 0 || width <= 0) {
            style.display = 'none';
            return false;
        }
        style.display = ''
        style.top = top + 'px';
        style.left = left + 'px';
        style.height = height + 'px';
        style.width = width + 'px';
        style.position = 'absolute';
    }
596454
def set_margins(self, left,top,right=-1):
        ""
        self.l_margin=left
        self.t_margin=top
        if(right==-1):
            right=left
        self.r_margin=right
709510
function() {
		var me = this;
		if (me.margins) {
			me.paddingLeft = Math.max(me.paddingLeft - me.margins.left, 0);
			me.paddingTop = Math.max(me.paddingTop - me.margins.top, 0);
			me.paddingRight = Math.max(me.paddingRight - me.margins.right, 0);
			me.paddingBottom = Math.max(me.paddingBottom - me.margins.bottom, 0);
		}
	}
1327726
public void setPadding(float padding) {
		if (Float.isNaN(padding_right)) {
			setPadding_right(padding);
		}
		if (Float.isNaN(padding_left)) {
			setPadding_left(padding);
		}
		if (Float.isNaN(padding_top)) {
			setPadding_top(padding);
		}
		if (Float.isNaN(padding_bottom)) {
			setPadding_bottom(padding);
		}
	}
1359972
function () {
        var self = this, style, rect;

        style = self.getEl().style;
        rect = self._layoutRect;

        style.left = rect.x + 'px';
        style.top = rect.y + 'px';
        style.zIndex = 0xFFFF + 0xFFFF;
      }
998827
def handle_padding(self, padding):
        ''''''
        left = padding[0]
        top = padding[1]
        right = padding[2]
        bottom = padding[3]

        offset_x = 0
        offset_y = 0
        new_width = self.engine.size[0]
        new_height = self.engine.size[1]

        if left > 0:
            offset_x = left
            new_width += left
        if top > 0:
            offset_y = top
            new_height += top
        if right > 0:
            new_width += right
        if bottom > 0:
            new_height += bottom
        new_engine = self.context.modules.engine.__class__(self.context)
        new_engine.image = new_engine.gen_image((new_width, new_height), '#fff')
        new_engine.enable_alpha()
        new_engine.paste(self.engine, (offset_x, offset_y))
        self.engine.image = new_engine.image