See :meth:`set_window_size`.
423531
def configure(self, width, height):
        """"""
        self._imgwin_set = True
        self.set_window_size(width, height)
522822
def size_changed(self, settings, key, user_data):
        
        RectCalculator.set_final_window_rect(self.settings, self.guake.window)
731074
def set_size(self, size):
        
        buffer_size = self._calculate_zoom_buffer_size(size, self._zoom_level)
        self._size = size
        self._initialize_buffers(buffer_size)
923829
public function setWindowSize($size)
    {
        if ($size < 0) {
            $size += $this->size;
        }
        if ($size < 0 || $size > $this->size) {
            throw new PelDataWindowWindowException(
                'Window [0, %d] ' . 'does not fit in window [0, %d]',
                $size,
                $this->size
            );
        }
        $this->size = $size;
    }
452117
def set_col_min_width(self, x: int, min_width: int):
        """"""
        if x < 0:
            raise IndexError('x < 0')
        self._min_widths[x] = min_width
65789
def resize(self, size=None):
        

        if not self.israw():
            return

        size = size or tty.size(self.stdout)

        if size is not None:
            rows, cols = size
            try:
                self.client.resize(self.container, height=rows, width=cols)
            except IOError: # Container already exited
                pass
378770
def set_window(self, windowC, windowW):
        
        if not (windowW and windowC):
            windowW = np.max(self.img) - np.min(self.img)
            windowC = (np.max(self.img) + np.min(self.img)) / 2.0

        self.imgmax = windowC + (windowW / 2)
        self.imgmin = windowC - (windowW / 2)
        self.windowC = windowC
        self.windowW = windowW
769037
private void saveWindowSize(Dimension size) {
		if (size != null) {
			if (getExtendedState() == Frame.NORMAL) {
				if (logger.isDebugEnabled()) logger.debug("Saving preference " + PREF_WINDOW_SIZE + "=" + size.width + "," + size.height);
				this.preferences.put(prefnzPrefix+PREF_WINDOW_SIZE, size.width + ","	+ size.height);
			} else {
				if (logger.isDebugEnabled()) logger.debug("Preference " + PREF_WINDOW_SIZE + " not saved, cause window state is not 'normal'.");
			}
		}
	}
433078
def set_layout(wlayout, callback):
    ''''''
    global display_size
    global window_list
    global loaded_layout
    global pending_load
    global vehiclename
    #if not wlayout.name in window_list:
    #    print("layout %s" % wlayout)
    if not wlayout.name in window_list and loaded_layout is not None and wlayout.name in loaded_layout:
        callback(loaded_layout[wlayout.name])
    window_list[wlayout.name] = ManagedWindow(wlayout, callback)
    display_size = wlayout.dsize
    if pending_load:
        pending_load = False
        load_layout(vehiclename)
729657
def window_size(self, value):
        """"""
        if (value > 4 and
            value < self.parameter_maxima["window_size"] and
            value % 2):
            self._window_size = value
        else:
            raise InvalidWindowSizeError("Window size must be an odd number "
                                      "between 0 and {}.".format(
                                      self.parameter_maxima["window_size"] + 1))
        self._replace_bm()
520535
public void adjustGlassSize() {
        if (isGlassEnabled()) {
            ResizeHandler handler = getGlassResizer();
            if (handler != null) handler.onResize(null);
        }
    }
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()
330930
def set_window_size_callback(window, cbfun):
    
    window_addr = ctypes.cast(ctypes.pointer(window),
                              ctypes.POINTER(ctypes.c_long)).contents.value
    if window_addr in _window_size_callback_repository:
        previous_callback = _window_size_callback_repository[window_addr]
    else:
        previous_callback = None
    if cbfun is None:
        cbfun = 0
    c_cbfun = _GLFWwindowsizefun(cbfun)
    _window_size_callback_repository[window_addr] = (cbfun, c_cbfun)
    cbfun = c_cbfun
    _glfw.glfwSetWindowSizeCallback(window, cbfun)
    if previous_callback is not None and previous_callback[0] != 0:
        return previous_callback[0]
978021
def SADWindowSize(self, value):
        """"""
        if value >= 1 and value <= 11 and value % 2:
            self._sad_window_size = value
        else:
            raise InvalidSADWindowSizeError("SADWindowSize must be odd and "
                                            "between 1 and 11.")
        self._replace_bm()
610486
def resize(self, width: int,  height: int):
        
        self.width = width // self.widget.devicePixelRatio()
        self.height = height // self.widget.devicePixelRatio()
        self.buffer_width = width
        self.buffer_height = height

        if self.ctx:
            self.set_default_viewport()

        # Make sure we notify the example about the resize
        super().resize(self.buffer_width, self.buffer_height)
616401
def set_terminal_size(fd, size):
    """"""
    sizebuf = array.array('h', reversed(size))
    fcntl.ioctl(fd, termios.TIOCSWINSZ, sizebuf)
975008
def _set_windows(self, ticks, bars):
        
        self.tick_window = ticks
        self.bar_window = bars