Flip the orientation of the page.
357238
def flip(self, n_windows):
        

        assert n_windows >= 0
        self.page_index += (self.step * n_windows)
        self.cursor_index = n_windows
        self.inverted = not self.inverted
        self.top_item_height = None
686459
def flip(self):
        
        self._load()
        groups = self.config.keys()
        tabular = {}
        for g in groups:
            config = self.config[g]
            for k in config:
                r = tabular.get(k, {})
                r[g] = config[k]
                tabular[k] = r
        return tabular
496648
public function flip()
    {
        $this->counter++;
        unset($this->isLucky);
        $this->currentSide = $this->isLucky()? $this->expectedSide : $this->getOppositeSide($this->expectedSide);
        return $this->currentSide;
    }
1257295
def OnCellTextRotation(self, event):
        """"""

        with undo.group(_("Rotation")):
            self.grid.actions.toggle_attr("angle")

        self.grid.ForceRefresh()

        self.grid.update_attribute_toolbar()

        if is_gtk():
            try:
                wx.Yield()
            except:
                pass

        event.Skip()
320682
def orientation(self, image, geometry, options):
        
        if options.get('orientation', settings.THUMBNAIL_ORIENTATION):
            return self._orientation(image)
        self.reoriented = True
        return image
208006
private void changePage(final int direction) {
		int currentPage = pages.indexOf(cardManager.getVisible());
		currentPage = Math.min(2, Math.max(0, currentPage + direction));

		cardManager.makeVisible(pages.get(currentPage));

		prevButton.setDisabled(currentPage == 0);
		nextButton.setDisabled(currentPage == 2);
		finishButton.setDisabled(currentPage != 2);

		cancelButton.setUnsavedChanges(currentPage > 0);
	}
498160
protected function autoOrient()
    {
        // apply EXIF orientation to pixel data
        switch ($this->originalImage->getImageOrientation()) {
            case \Imagick::ORIENTATION_BOTTOMRIGHT:
                $this->originalImage->rotateimage('#000', 180); // rotate 180 degrees
                break;
            case \Imagick::ORIENTATION_RIGHTTOP:
                $this->originalImage->rotateimage('#000', 90); // rotate 90 degrees CW
                break;
            case \Imagick::ORIENTATION_LEFTBOTTOM:
                $this->originalImage->rotateimage('#000', -90); // rotate 90 degrees CCW
                break;
        }

        // reset EXIF orientation
        $this->originalImage->setImageOrientation(\Imagick::ORIENTATION_TOPLEFT);
    }
771417
public static void flipVertical( GrayS32 input ) {
		int h2 = input.height/2;

		for( int y = 0; y < h2; y++ ) {
			int index1 = input.getStartIndex() + y * input.getStride();
			int index2 = input.getStartIndex() + (input.height - y - 1) * input.getStride();

			int end = index1 + input.width;

			while( index1 < end ) {
				int tmp = input.data[index1];
				input.data[index1++] = input.data[index2];
				input.data[index2++] = (int)tmp;
			}
		}
	}
968827
private function rotateLL()
	{
		$value_before		=& $this->value;
		$right_before		=& $this->right;
		$this->value		=& $this->left->value;
		$this->right		=& $this->left;
		$this->left			=& $this->left->left;
		$this->right->left	=& $this->right->right;
		$this->right->right	=& $right_before;
		$this->right->value	=& $value_before;
	}
163106
def flip(self):
        

        left = self.left._replace(red=not self.left.red)
        right = self.right._replace(red=not self.right.red)
        top = self._replace(left=left, right=right, red=not self.red)
        return top
603946
function definePaperOrientation (options) {
  var paper = {border: options.border || '0'}

  if (options.height && options.width) {
    paper.width = options.width
    paper.height = options.height
  } else {
    paper.format = options.format || 'A4'
    paper.orientation = options.orientation || 'portrait'
  }

  return paper
}
807017
def flip_h(self, redraw=True):
        

        pixel_list = self.get_pixels()
        flipped = []
        for i in range(8):
            offset = i * 8
            flipped.extend(reversed(pixel_list[offset:offset + 8]))
        if redraw:
            self.set_pixels(flipped)
        return flipped
792925
function flipShadow(value) {
  var elements = value.split(/\s+/);

  if (!elements) { return value; }

  var inset = (elements[0] == 'inset') ? elements.shift() + ' ' : '';
  var property = elements[0].match(/^([-+]?\d+)(\w*)$/);

  if (!property) { return value; }

  return inset + [(-1 * +property[1]) + property[2]]
      .concat(elements.splice(1)).join(' ');
}
285332
def move_red_left(self):
        

        self = self.flip()
        if self.right is not NULL and self.right.left.red:
            self = self._replace(right=self.right.rotate_right())
            self = self.rotate_left().flip()

        return self
1351317
function (state) {
            scrollDirection = util.sign(state.page - layoutState.page);
            layoutState = state;
        }
928193
function() {
    this.deltaX =  window.pageXOffset
                || document.documentElement.scrollLeft
                || document.body.scrollLeft
                || 0;
    this.deltaY =  window.pageYOffset
                || document.documentElement.scrollTop
                || document.body.scrollTop
                || 0;
  }
886967
def flip(f):
    """"""
    ensure_callable(f)

    result = lambda *args, **kwargs: f(*reversed(args), **kwargs)
    functools.update_wrapper(result, f, ('__name__', '__module__'))
    return result