enigma.eRect Class Reference

Inheritance diagram for enigma.eRect:

Public Member Functions
def	__init__ (self, *args)
def	empty (self)
def	valid (self)
def	normalize (self)
def	left (self)
def	top (self)
def	right (self)
def	bottom (self)
def	rLeft (self)
def	rTop (self)
def	rRight (self)
def	rBottom (self)
def	x (self)
def	y (self)
def	setLeft (self, pos)
def	setTop (self, pos)
def	setRight (self, pos)
def	setBottom (self, pos)
def	setX (self, x)
def	setY (self, y)
def	topLeft (self)
def	bottomRight (self)
def	topRight (self)
def	bottomLeft (self)
def	topLeft1 (self)
def	bottomRight1 (self)
def	topRight1 (self)
def	bottomLeft1 (self)
def	center (self)
def	rect (self, x, y, w, h)
def	coords (self, x1, y1, x2, y2)
def	moveTopLeft (self, p)
def	moveBottomRight (self, p)
def	moveTopRight (self, p)
def	moveBottomLeft (self, p)
def	moveCenter (self, p)
def	moveBy (self, *args)
def	setRect (self, x, y, w, h)
def	setCoords (self, x1, y1, x2, y2)
def	size (self)
def	width (self)
def	height (self)
def	setWidth (self, w)
def	setHeight (self, h)
def	setSize (self, s)
def	setEmpty (self)
def	__or__ (self, r)
def	__and__ (self, r)
def	__ior__ (self, r)
def	__iand__ (self, r)
def	contains (self, *args)
def	unite (self, r)
def	intersect (self, r)
def	intersects (self, r)
def	scaleToCenterOf (self, other)
def	scaleToWidthOf (self, other)
def	scaleToHeightOf (self, other)
def	scaleToFill (self, other)
def	centerIn (self, other)
def	emptyRect ()
def	invalidRect ()
def	scale (self, x_n, x_d, y_n, y_d)

Static Public Attributes
	thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
	emptyRect = staticmethod(emptyRect)
	invalidRect = staticmethod(invalidRect)
	empty
	valid
	normalize
	left
	top
	right
	bottom
	rLeft
	rTop
	rRight
	rBottom
	x
	y
	setLeft
	setTop
	setRight
	setBottom
	setX
	setY
	topLeft
	bottomRight
	topRight
	bottomLeft
	topLeft1
	bottomRight1
	topRight1
	bottomLeft1
	center
	rect
	coords
	moveTopLeft
	moveBottomRight
	moveTopRight
	moveBottomLeft
	moveCenter
	moveBy
	setRect
	setCoords
	size
	width
	height
	setWidth
	setHeight
	setSize
	setEmpty
	contains
	unite
	intersect
	intersects
	scaleToCenterOf
	scaleToWidthOf
	scaleToHeightOf
	scaleToFill
	centerIn
	scale

Constructor & Destructor Documentation

__init__()

def enigma.eRect.__init__	(		self,
		*	args
	)

__init__(eRect self) -> eRect
__init__(eRect self, ePoint topleft, ePoint bottomright) -> eRect
__init__(eRect self, ePoint topleft, eSize size) -> eRect
__init__(eRect self, eSize size) -> eRect
__init__(eRect self, int width, int height) -> eRect
__init__(eRect self, int left, int top, int width, int height) -> eRect

Member Function Documentation

__and__()

def enigma.eRect.__and__	(		self,
			r
	)

__and__(eRect self, eRect r) -> eRect

__iand__()

def enigma.eRect.__iand__	(		self,
			r
	)

__iand__(eRect self, eRect r) -> eRect

__ior__()

def enigma.eRect.__ior__	(		self,
			r
	)

__ior__(eRect self, eRect r) -> eRect

__or__()

def enigma.eRect.__or__	(		self,
			r
	)

__or__(eRect self, eRect r) -> eRect

bottom()

def enigma.eRect.bottom

(

self

)

bottom(eRect self) -> int

bottomLeft()

def enigma.eRect.bottomLeft

(

self

)

bottomLeft(eRect self) -> ePoint

bottomLeft1()

def enigma.eRect.bottomLeft1

(

self

)

bottomLeft1(eRect self) -> ePoint

bottomRight()

def enigma.eRect.bottomRight

(

self

)

bottomRight(eRect self) -> ePoint

bottomRight1()

def enigma.eRect.bottomRight1

(

self

)

bottomRight1(eRect self) -> ePoint

center()

def enigma.eRect.center

(

self

)

center(eRect self) -> ePoint

centerIn()

def enigma.eRect.centerIn	(		self,
			other
	)

centerIn(eRect self, eRect other)

contains()

def enigma.eRect.contains	(		self,
		*	args
	)

contains(eRect self, ePoint p) -> bool
contains(eRect self, int x, int y) -> bool
contains(eRect self, eRect r) -> bool

coords()

def enigma.eRect.coords	(		self,
			x1,
			y1,
			x2,
			y2
	)

coords(eRect self, int * x1, int * y1, int * x2, int * y2)

empty()

def enigma.eRect.empty

(

self

)

empty(eRect self) -> bool

emptyRect()

def enigma.eRect.emptyRect

(

)

emptyRect() -> eRect

height()

def enigma.eRect.height

(

self

)

height(eRect self) -> int

intersect()

def enigma.eRect.intersect	(		self,
			r
	)

intersect(eRect self, eRect r) -> eRect

intersects()

def enigma.eRect.intersects	(		self,
			r
	)

intersects(eRect self, eRect r) -> bool

invalidRect()

def enigma.eRect.invalidRect

(

)

invalidRect() -> eRect

left()

def enigma.eRect.left

(

self

)

left(eRect self) -> int

moveBottomLeft()

def enigma.eRect.moveBottomLeft	(		self,
			p
	)

moveBottomLeft(eRect self, ePoint p)

moveBottomRight()

def enigma.eRect.moveBottomRight	(		self,
			p
	)

moveBottomRight(eRect self, ePoint p)

moveBy()

def enigma.eRect.moveBy	(		self,
		*	args
	)

moveBy(eRect self, int dx, int dy)
moveBy(eRect self, ePoint r)

moveCenter()

def enigma.eRect.moveCenter	(		self,
			p
	)

moveCenter(eRect self, ePoint p)

moveTopLeft()

def enigma.eRect.moveTopLeft	(		self,
			p
	)

moveTopLeft(eRect self, ePoint p)

moveTopRight()

def enigma.eRect.moveTopRight	(		self,
			p
	)

moveTopRight(eRect self, ePoint p)

normalize()

def enigma.eRect.normalize

(

self

)

normalize(eRect self) -> eRect

rBottom()

def enigma.eRect.rBottom

(

self

)

rBottom(eRect self) -> int &

rect()

def enigma.eRect.rect	(		self,
			x,
			y,
			w,
			h
	)

rect(eRect self, int * x, int * y, int * w, int * h)

right()

def enigma.eRect.right

(

self

)

right(eRect self) -> int

rLeft()

def enigma.eRect.rLeft

(

self

)

rLeft(eRect self) -> int &

rRight()

def enigma.eRect.rRight

(

self

)

rRight(eRect self) -> int &

rTop()

def enigma.eRect.rTop

(

self

)

rTop(eRect self) -> int &

scale()

def enigma.eRect.scale	(		self,
			x_n,
			x_d,
			y_n,
			y_d
	)

scale(eRect self, int x_n, int x_d, int y_n, int y_d)

scaleToCenterOf()

def enigma.eRect.scaleToCenterOf	(		self,
			other
	)

scaleToCenterOf(eRect self, eRect other)

scaleToFill()

def enigma.eRect.scaleToFill	(		self,
			other
	)

scaleToFill(eRect self, eRect other)

scaleToHeightOf()

def enigma.eRect.scaleToHeightOf	(		self,
			other
	)

scaleToHeightOf(eRect self, eRect other)

scaleToWidthOf()

def enigma.eRect.scaleToWidthOf	(		self,
			other
	)

scaleToWidthOf(eRect self, eRect other)

setBottom()

def enigma.eRect.setBottom	(		self,
			pos
	)

setBottom(eRect self, int pos)

setCoords()

def enigma.eRect.setCoords	(		self,
			x1,
			y1,
			x2,
			y2
	)

setCoords(eRect self, int x1, int y1, int x2, int y2)

setEmpty()

def enigma.eRect.setEmpty

(

self

)

setEmpty(eRect self)

setHeight()

def enigma.eRect.setHeight	(		self,
			h
	)

setHeight(eRect self, int h)

setLeft()

def enigma.eRect.setLeft	(		self,
			pos
	)

setLeft(eRect self, int pos)

setRect()

def enigma.eRect.setRect	(		self,
			x,
			y,
			w,
			h
	)

setRect(eRect self, int x, int y, int w, int h)

setRight()

def enigma.eRect.setRight	(		self,
			pos
	)

setRight(eRect self, int pos)

setSize()

def enigma.eRect.setSize	(		self,
			s
	)

setSize(eRect self, eSize s)

setTop()

def enigma.eRect.setTop	(		self,
			pos
	)

setTop(eRect self, int pos)

setWidth()

def enigma.eRect.setWidth	(		self,
			w
	)

setWidth(eRect self, int w)

setX()

def enigma.eRect.setX	(		self,
			x
	)

setX(eRect self, int x)

setY()

def enigma.eRect.setY	(		self,
			y
	)

setY(eRect self, int y)

size()

def enigma.eRect.size

(

self

)

size(eRect self) -> eSize

top()

def enigma.eRect.top

(

self

)

top(eRect self) -> int

topLeft()

def enigma.eRect.topLeft

(

self

)

topLeft(eRect self) -> ePoint

topLeft1()

def enigma.eRect.topLeft1

(

self

)

topLeft1(eRect self) -> ePoint

topRight()

def enigma.eRect.topRight

(

self

)

topRight(eRect self) -> ePoint

topRight1()

def enigma.eRect.topRight1

(

self

)

topRight1(eRect self) -> ePoint

unite()

def enigma.eRect.unite	(		self,
			r
	)

unite(eRect self, eRect r) -> eRect

valid()

def enigma.eRect.valid

(

self

)

valid(eRect self) -> bool

width()

def enigma.eRect.width

(

self

)

width(eRect self) -> int

x()

def enigma.eRect.x

(

self

)

x(eRect self) -> int

y()

def enigma.eRect.y

(

self

)

y(eRect self) -> int

Member Data Documentation

bottom

enigma.eRect.bottom

static

bottomLeft

enigma.eRect.bottomLeft

static

bottomLeft1

enigma.eRect.bottomLeft1

static

bottomRight

enigma.eRect.bottomRight

static

bottomRight1

enigma.eRect.bottomRight1

static

center

enigma.eRect.center

static

centerIn

enigma.eRect.centerIn

static

contains

enigma.eRect.contains

static

coords

enigma.eRect.coords

static

empty

enigma.eRect.empty

static

emptyRect

enigma.eRect.emptyRect = staticmethod(emptyRect)

static

height

enigma.eRect.height

static

intersect

enigma.eRect.intersect

static

intersects

enigma.eRect.intersects

static

invalidRect

enigma.eRect.invalidRect = staticmethod(invalidRect)

static

left

enigma.eRect.left

static

moveBottomLeft

enigma.eRect.moveBottomLeft

static

moveBottomRight

enigma.eRect.moveBottomRight

static

moveBy

enigma.eRect.moveBy

static

moveCenter

enigma.eRect.moveCenter

static

moveTopLeft

enigma.eRect.moveTopLeft

static

moveTopRight

enigma.eRect.moveTopRight

static

normalize

enigma.eRect.normalize

static

rBottom

enigma.eRect.rBottom

static

rect

enigma.eRect.rect

static

right

enigma.eRect.right

static

rLeft

enigma.eRect.rLeft

static

rRight

enigma.eRect.rRight

static

rTop

enigma.eRect.rTop

static

scale

enigma.eRect.scale

static

scaleToCenterOf

enigma.eRect.scaleToCenterOf

static

scaleToFill

enigma.eRect.scaleToFill

static

scaleToHeightOf

enigma.eRect.scaleToHeightOf

static

scaleToWidthOf

enigma.eRect.scaleToWidthOf

static

setBottom

enigma.eRect.setBottom

static

setCoords

enigma.eRect.setCoords

static

setEmpty

enigma.eRect.setEmpty

static

setHeight

enigma.eRect.setHeight

static

setLeft

enigma.eRect.setLeft

static

setRect

enigma.eRect.setRect

static

setRight

enigma.eRect.setRight

static

setSize

enigma.eRect.setSize

static

setTop

enigma.eRect.setTop

static

setWidth

enigma.eRect.setWidth

static

setX

enigma.eRect.setX

static

setY

enigma.eRect.setY

static

size

enigma.eRect.size

static

thisown

enigma.eRect.thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

static

top

enigma.eRect.top

static

topLeft

enigma.eRect.topLeft

static

topLeft1

enigma.eRect.topLeft1

static

topRight

enigma.eRect.topRight

static

topRight1

enigma.eRect.topRight1

static

unite

enigma.eRect.unite

static

valid

enigma.eRect.valid

static

width

enigma.eRect.width

static

x

enigma.eRect.x

static

y

enigma.eRect.y

static

---

The documentation for this class was generated from the following file:

• usr/lib/enigma2/python/enigma.py