x>> ( object -- value )


Vocabulary
accessors

Inputs and outputs
objectan object
valuean object


Definition

GENERIC: x>> ( object -- value )


Methods

M: CGPoint x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class float }
{ initial 0.0 }
{ type CGFloat }
} read-struct-slot ; inline



M: GdkEventButton x>>
T{ struct-slot-spec
{ name "x" }
{ offset 24 }
{ class float }
{ initial 0.0 }
{ type gdouble }
} read-struct-slot ; inline



M: GdkEventConfigure x>>
T{ struct-slot-spec
{ name "x" }
{ offset 20 }
{ class fixnum }
{ initial 0 }
{ type gint }
} read-struct-slot ; inline



M: GdkEventMotion x>>
T{ struct-slot-spec
{ name "x" }
{ offset 24 }
{ class float }
{ initial 0.0 }
{ type gdouble }
} read-struct-slot ; inline



M: GdkEventScroll x>>
T{ struct-slot-spec
{ name "x" }
{ offset 24 }
{ class float }
{ initial 0.0 }
{ type gdouble }
} read-struct-slot ; inline



M: MEVENT x>>
T{ struct-slot-spec
{ name "x" }
{ offset 4 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline



M: PangoRectangle x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type gint }
} read-struct-slot ; inline



M: Rectangle x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class float }
{ initial 0.0 }
{ type float }
} read-struct-slot ; inline



M: Vector2 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class float }
{ initial 0.0 }
{ type float }
} read-struct-slot ; inline



M: Vector3 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class float }
{ initial 0.0 }
{ type float }
} read-struct-slot ; inline



M: Vector4 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class float }
{ initial 0.0 }
{ type float }
} read-struct-slot ; inline



M: XButtonEvent x>>
T{ struct-slot-spec
{ name "x" }
{ offset 64 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline



M: XConfigureEvent x>>
T{ struct-slot-spec
{ name "x" }
{ offset 48 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline



M: XConfigureRequestEvent x>>
T{ struct-slot-spec
{ name "x" }
{ offset 48 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline



M: XCreateWindowEvent x>>
T{ struct-slot-spec
{ name "x" }
{ offset 48 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline



M: XCrossingEvent x>>
T{ struct-slot-spec
{ name "x" }
{ offset 64 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline



M: XExposeEvent x>>
T{ struct-slot-spec
{ name "x" }
{ offset 40 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline



M: XGraphicsExposeEvent x>>
T{ struct-slot-spec
{ name "x" }
{ offset 40 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline



M: XGravityEvent x>>
T{ struct-slot-spec
{ name "x" }
{ offset 48 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline



M: XKeyEvent x>>
T{ struct-slot-spec
{ name "x" }
{ offset 64 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline



M: XMotionEvent x>>
T{ struct-slot-spec
{ name "x" }
{ offset 64 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline



M: XReparentEvent x>>
T{ struct-slot-spec
{ name "x" }
{ offset 56 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline



M: XSizeHints x>>
T{ struct-slot-spec
{ name "x" }
{ offset 8 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline



M: XWindowAttributes x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline



M: XWindowChanges x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline












M: cairo_glyph_t x>>
T{ struct-slot-spec
{ name "x" }
{ offset 8 }
{ class float }
{ initial 0.0 }
{ type double }
} read-struct-slot ; inline



M: cairo_path_data_t-point x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class float }
{ initial 0.0 }
{ type double }
} read-struct-slot ; inline



M: cairo_rectangle_int_t x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline



M: cairo_rectangle_t x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class float }
{ initial 0.0 }
{ type double }
} read-struct-slot ; inline






M: char1 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type char }
} read-struct-slot ; inline



M: char2 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type char }
} read-struct-slot ; inline



M: char3 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type char }
} read-struct-slot ; inline



M: char4 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type char }
} read-struct-slot ; inline






M: cpVect x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class float }
{ initial 0.0 }
{ type cpFloat }
} read-struct-slot ; inline









M: double1 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class float }
{ initial 0.0 }
{ type double }
} read-struct-slot ; inline



M: double2 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class float }
{ initial 0.0 }
{ type double }
} read-struct-slot ; inline



M: double3 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class float }
{ initial 0.0 }
{ type double }
} read-struct-slot ; inline



M: double4 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class float }
{ initial 0.0 }
{ type double }
} read-struct-slot ; inline



M: float1 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class float }
{ initial 0.0 }
{ type float }
} read-struct-slot ; inline



M: float2 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class float }
{ initial 0.0 }
{ type float }
} read-struct-slot ; inline



M: float3 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class float }
{ initial 0.0 }
{ type float }
} read-struct-slot ; inline



M: float4 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class float }
{ initial 0.0 }
{ type float }
} read-struct-slot ; inline






M: int1 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline



M: int2 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline



M: int3 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline



M: int4 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type int }
} read-struct-slot ; inline















M: long1 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class integer }
{ initial 0 }
{ type long }
} read-struct-slot ; inline



M: long2 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class integer }
{ initial 0 }
{ type long }
} read-struct-slot ; inline



M: long3 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class integer }
{ initial 0 }
{ type long }
} read-struct-slot ; inline



M: long4 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class integer }
{ initial 0 }
{ type long }
} read-struct-slot ; inline



M: longlong1 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class integer }
{ initial 0 }
{ type longlong }
} read-struct-slot ; inline



M: longlong2 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class integer }
{ initial 0 }
{ type longlong }
} read-struct-slot ; inline



M: longlong3 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class integer }
{ initial 0 }
{ type longlong }
} read-struct-slot ; inline



M: longlong4 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class integer }
{ initial 0 }
{ type longlong }
} read-struct-slot ; inline


















M: point x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class float }
{ initial 0.0 }
{ type float }
} read-struct-slot ; inline






M: short1 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type short }
} read-struct-slot ; inline



M: short2 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type short }
} read-struct-slot ; inline



M: short3 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type short }
} read-struct-slot ; inline



M: short4 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type short }
} read-struct-slot ; inline






M: uchar1 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type uchar }
} read-struct-slot ; inline



M: uchar2 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type uchar }
} read-struct-slot ; inline



M: uchar3 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type uchar }
} read-struct-slot ; inline



M: uchar4 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type uchar }
} read-struct-slot ; inline



M: uint1 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type uint }
} read-struct-slot ; inline



M: uint2 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type uint }
} read-struct-slot ; inline



M: uint3 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type uint }
} read-struct-slot ; inline



M: uint4 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type uint }
} read-struct-slot ; inline



M: ulong1 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class integer }
{ initial 0 }
{ type ulong }
} read-struct-slot ; inline



M: ulong2 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class integer }
{ initial 0 }
{ type ulong }
} read-struct-slot ; inline



M: ulong3 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class integer }
{ initial 0 }
{ type ulong }
} read-struct-slot ; inline



M: ulong4 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class integer }
{ initial 0 }
{ type ulong }
} read-struct-slot ; inline



M: ulonglong1 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class integer }
{ initial 0 }
{ type ulonglong }
} read-struct-slot ; inline



M: ulonglong2 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class integer }
{ initial 0 }
{ type ulonglong }
} read-struct-slot ; inline



M: ulonglong3 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class integer }
{ initial 0 }
{ type ulonglong }
} read-struct-slot ; inline



M: ulonglong4 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class integer }
{ initial 0 }
{ type ulonglong }
} read-struct-slot ; inline



M: ushort1 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type ushort }
} read-struct-slot ; inline



M: ushort2 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type ushort }
} read-struct-slot ; inline



M: ushort3 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type ushort }
} read-struct-slot ; inline



M: ushort4 x>>
T{ struct-slot-spec
{ name "x" }
{ offset 0 }
{ class fixnum }
{ initial 0 }
{ type ushort }
} read-struct-slot ; inline