Set all coordinate dimensions at once.
424895
def set_coordinates(self, x, y, z=None):
        """"""
        self.x = x
        self.y = y
        self.z = z
925684
def SetSize(self, rect):
        

        grid = self.main_window.grid
        key = grid.actions.cursor

        drawn_rect = grid.grid_renderer._get_drawn_rect(grid, key, rect)

        self._tc.SetDimensions(drawn_rect.x, drawn_rect.y,
                               drawn_rect.width+2, drawn_rect.height+2,
                               wx.SIZE_ALLOW_MINUS_ONE)
        self._tc.Layout()
544424
def setxy(self):
        
        self._edge_inverter()
        self._detect_alignment_conflicts()
        inf = float('infinity')
        # initialize vertex coordinates attributes:
        for l in self.layers:
            for v in l:
                self.grx[v].root  = v
                self.grx[v].align = v
                self.grx[v].sink  = v
                self.grx[v].shift = inf
                self.grx[v].X     = None
                self.grx[v].x     = [0.0]*4
        curvh = self.dirvh # save current dirvh value
        for dirvh in xrange(4):
            self.dirvh = dirvh
            self._coord_vertical_alignment()
            self._coord_horizontal_compact()
        self.dirvh = curvh # restore it
        # vertical coordinate assigment of all nodes:
        Y = 0
        for l in self.layers:
            dY = max([v.view.h/2. for v in l])
            for v in l:
                vx = sorted(self.grx[v].x)
                # mean of the 2 medians out of the 4 x-coord computed above:
                avgm = (vx[1]+vx[2])/2.
                # final xy-coordinates :
                v.view.xy = (avgm,Y+dY)
            Y += 2*dY+self.yspace
        self._edge_inverter()
517749
public void setSize(org.kie.dmn.model.api.dmndi.Dimension value) {
        this.size = value;
    }
1270446
def resize(self, dims):
        
        width, height = dims[:2]
        self.gl_resize(width, height)
521192
def _raw_dimensions(self):
        """"""
        return tuple(
            _RawDimension(dimension_dict, self._dimension_dicts)
            for dimension_dict in self._dimension_dicts
        )
429117
def _add_dimensions(self, item, dims, constant_keys):
        
        if isinstance(item, Layout):
            item.fixed = False

        dim_vals = [(dim, val) for dim, val in dims[::-1]
                    if dim not in self.drop]
        if isinstance(item, self.merge_type):
            new_item = item.clone(cdims=constant_keys)
            for dim, val in dim_vals:
                dim = asdim(dim)
                if dim not in new_item.kdims:
                    new_item = new_item.add_dimension(dim, 0, val)
        elif isinstance(item, self._nest_order[self.merge_type]):
            if len(dim_vals):
                dimensions, key = zip(*dim_vals)
                new_item = self.merge_type({key: item}, kdims=list(dimensions),
                                           cdims=constant_keys)
            else:
                new_item = item
        else:
            new_item = item.clone(shared_data=False, cdims=constant_keys)
            for k, v in item.items():
                new_item[k] = self._add_dimensions(v, dims[::-1], constant_keys)
        if isinstance(new_item, Layout):
            new_item.fixed = True

        return new_item
98271
private void setEAxis() {
		Rotation e = rotations.get(0);
		Rotation h = rotations.get(principalAxisIndex);
		e.setAxisAngle(new AxisAngle4d(h.getAxisAngle()));
		e.getAxisAngle().angle = 0.0;
		e.setFold(h.getFold());
	}
920415
def initialize_axes(self, boundary=0.05):
        """"""
        bs = [(self.vals[:, i].max()-self.vals[:, i].min())*boundary for i in range(3)]
        self.x_lim = np.array([self.vals[:, 0].min()-bs[0], self.vals[:, 0].max()+bs[0]])
        self.y_lim = np.array([self.vals[:, 1].min()-bs[1], self.vals[:, 1].max()+bs[1]])
        self.z_lim = np.array([self.vals[:, 2].min()-bs[2], self.vals[:, 2].max()+bs[2]])
900798
def add(self,dimlist,dimvalues):
        '''
        
        '''
        for i,d in enumerate(dimlist):
            self[d] = dimvalues[i]
        
        self.set_ndims()
893226
def resizeColumnsToContents(self):
        """"""
        self._autosized_cols = set()
        self._resizeColumnsToContents(self.table_level,
                                      self.table_index, self._max_autosize_ms)
        self._update_layout()
937954
def _scale_coords(self, x, y, extent, xo, yo):
        """"""
        return xo + (x * self._size * 2 / extent), yo + ((extent - y) * self._size / extent)
1197819
def setdict(self, D=None):
        """"""

        Di = np.concatenate((D, sl.atleast_nd(D.ndim, self.imp)),
                            axis=D.ndim-1)
        self.cbpdn.setdict(Di)
49967
function(config, allDimensions, height) {
        var usedDimensions = {};
        var usedValues = {};
        var contexts = {};
        configLoop:
            for(var i=0; i<config.length; i++) {
                if (config[i].settings) {
                    var setting = config[i].settings;
                    if(setting.length === 0 ) {
                        continue;
                    }
                    if(setting[0] === 'master') {
                        if(this.masterDelta !== undefined) {
                            this.masterDelta = mergeDeep(this._buildDelta(config[i]), this.masterDelta, true);
                        } else {
                            this.masterDelta = this._buildDelta(config[i]);
                        }
                        continue;
                    }
                    var context = new Array(height);
                    for(var q=0; q<height; q++) {
                        context[q] = DEFAULT;
                    }
                    for(var j=0; j<setting.length; j++) {
                        var kv = setting[j].split(':');
                        var dim = kv[0];
                        var index = allDimensions[dim];
                        if(index === undefined) {
                            console.log('WARNING: invalid dimension "' + dim +
                                '" in settings ' + JSON.stringify(setting));
                            continue configLoop;
                        }
                        usedDimensions[dim] = 1;
                        usedValues[dim] = usedValues[dim] || {};

                        if(kv[1].indexOf(',') === -1) {
                            usedValues[dim][kv[1]] = 1;
                            context[index] = kv[1];
                        } else {
                            var vals = kv[1].split(',');
                            context[index] = vals;
                            for(var k=0; k<vals.length; k++) {
                                usedValues[dim][vals[k]] = 1;
                            }
                        }
                    }
                    contexts[i] = context;
                }
            }
        return [usedDimensions, usedValues, contexts];
    }
186298
def fillRectangle(self, x, y, width, height, color):
        """"""
        #fallback variant, use update recatngle
        #override with specialized function for better performance
        self.updateRectangle(x, y, width, height, color*width*height)
8235
def _set_init_vars_and_dims(self, data_vars, coords, compat):
        
        both_data_and_coords = [k for k in data_vars if k in coords]
        if both_data_and_coords:
            raise ValueError('variables %r are found in both data_vars and '
                             'coords' % both_data_and_coords)

        if isinstance(coords, Dataset):
            coords = coords.variables

        variables, coord_names, dims = merge_data_and_coords(
            data_vars, coords, compat=compat)

        self._variables = variables
        self._coord_names = coord_names
        self._dims = dims
1205286
public void setDimension(int width, int height) {
        setWidth(String.valueOf(width));
        setHeight(String.valueOf(height));
        reload();
    }