Set private ``_sad_window_size`` and reset ``_block_matcher``.
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()
401133
def setMinimumSize(self, *args):
        
        super(XView, self).setMinimumSize(*args)
        
        if ( not self.signalsBlocked() ):
            self.sizeConstraintChanged.emit()
166253
private void setSizeRatio(double size) {
        double width = widthHeightRatio * size;
        double height = size / widthHeightRatio;
        if (width <= size) {
            setSize(width, size);
        } else if (height <= size) {
            setSize(size, height);
        } else {
            setSize(size, size);
        }
    }
529164
private void updateErrorContainerSize(double w, double errorContainerHeight) {
        errorContainerClip.setWidth(w);
        errorContainerClip.setHeight(errorContainerHeight);
        resize(w, errorContainerHeight);
    }
1057983
def set_size(self, name: str, size: int):
        """"""
        if self._needs_to_be_in_name_map(name):
            if len(name) >= 128:
                raise ValueError("Name is too long")
            self.name_map[name] = size
        else:
            crc32 = binascii.crc32(name.encode())
            self.crc32_map[crc32] = size
1061143
def set_bin_window(self, bin_size=None, window_size=None):
        """"""
        bin_size = bin_size or self.bin_size
        window_size = window_size or self.window_size
        assert 1e-6 < bin_size < 1e3
        assert 1e-6 < window_size < 1e3
        assert bin_size < window_size
        self.bin_size = bin_size
        self.window_size = window_size
        # Set the status message.
        b, w = self.bin_size * 1000, self.window_size * 1000
        self.set_status('Bin: {:.1f} ms. Window: {:.1f} ms.'.format(b, w))
304000
def _adjust_width(self):
        """"""
        if self.bar_width > self.max_iter:
            self.bar_width = int(self.max_iter)
840654
def set_size(self, size):
        
        if size == 'small':
            self._set_size_small()
        elif size == 'large':
            self._set_size_large()
        else:
            raise ValueError('Size must be large or small')
1366661
def set_size(self, w, h):
        
        self.attributes['width'] = str(w)
        self.attributes['height'] = str(h)
1333274
private Dimension restoreWindowSize() {
		Dimension result = null;
		final String sizestr = preferences.get(prefnzPrefix+PREF_WINDOW_SIZE, null);
		if (sizestr != null) {
			int width = 0;
			int height = 0;
			final String[] sizes = sizestr.split("[,]");
			try {
				width = Integer.parseInt(sizes[0].trim());
				height = Integer.parseInt(sizes[1].trim());
			} catch (final Exception e) {
				// ignoring, cause is prevented by default values;
			}
			if (width > 0 && height > 0) {
				result = new Dimension(width, height);
				if (logger.isDebugEnabled()) logger.debug("Restoring preference " + PREF_WINDOW_SIZE + "=" + result.width + "," + result.height);
				this.setSize(result);
			}
		}
		return result;
	}
375160
def set_size(self, pt=None, px=None):
        

        assert (pt, px) != (None, None)

        if pt is not None:
            self.__init__(pt, self.font_name)
        else:
            self.__init__(self.px_to_pt(px), self.font_name)
422976
public void resizeTempBlockMeta(TempBlockMeta tempBlockMeta, long newSize)
      throws InvalidWorkerStateException {
    long oldSize = tempBlockMeta.getBlockSize();
    if (newSize > oldSize) {
      reserveSpace(newSize - oldSize, false);
      tempBlockMeta.setBlockSize(newSize);
    } else if (newSize < oldSize) {
      throw new InvalidWorkerStateException("Shrinking block, not supported!");
    }
  }
276936
def setFontPointSize(self, size):
        
        self.blockSignals(True)
        self.editor().setFontPointSize(size)
        self.blockSignals(False)
555836
def setPageSize( self, pageSize ):
        
        if self._pageSize == pageSize:
            return
        
        self._pageSize = pageSize
        
        # update the display size
        ssize = nativestring(pageSize)
        if ( ssize == '0' ):
            ssize = ''
        
        self._pageSizeCombo.blockSignals(True)
        index = self._pageSizeCombo.findText(ssize)
        self._pageSizeCombo.setCurrentIndex(index)
        self._pageSizeCombo.blockSignals(False)
274220
def setBatchSize(self, size):
        
        self._batchSize = size
        try:
            self._worker.setBatchSize(size)
        except AttributeError:
            pass
344617
public synchronized  void setLastBlockSize(long blockId, long blockSize) {
    assert blocks.size() > 0;
    LocatedBlock last = blocks.get(blocks.size() - 1);
    if (underConstruction && blockSize > last.getBlockSize()) {
      assert blockId == last.getBlock().getBlockId();
      this.setFileLength(this.getFileLength() + blockSize - last.getBlockSize());
      last.setBlockSize(blockSize);

      if (LOG.isDebugEnabled()) {
        LOG.debug("DFSClient setting last block " + last + " to length "
            + blockSize + " filesize is now " + getFileLength());
      }
    }
  }
113876
function restoreOriginalWidth(p_sType, p_aArgs, p_oObject) {

        var sOriginalWidth = p_oObject[0],
            sNewWidth = p_oObject[1],
            oConfig = this.cfg,
            sCurrentWidth = oConfig.getProperty("width");

        if (sCurrentWidth == sNewWidth) {
            oConfig.setProperty("width", sOriginalWidth);
        }

        this.unsubscribe("hide", restoreOriginalWidth, p_oObject);
    }