Index

API symbols

`$`:

`*=`:

`*`:

core: proc a(vec: TVec): auto

a=:

core: proc a=[T](vec: var TVec; value: T)

aa:

core: proc aa(vec: TVec): auto

aa=:

core: proc aa=[T](vec: var TVec; value: T)

aaa:

core: proc aaa(vec: TVec): auto

aaa=:

core: proc aaa=[T](vec: var TVec; value: T)

aaaa:

core: proc aaaa(vec: TVec): auto

aaaa=:

core: proc aaaa=[T](vec: var TVec; value: T)

aaab:

core: proc aaab(vec: TVec): auto

aaab=:

core: proc aaab=[T](vec: var TVec; value: T)

aaag:

core: proc aaag(vec: TVec): auto

aaag=:

core: proc aaag=[T](vec: var TVec; value: T)

aaar:

core: proc aaar(vec: TVec): auto

aaar=:

core: proc aaar=[T](vec: var TVec; value: T)

aab:

core: proc aab(vec: TVec): auto

aab=:

core: proc aab=[T](vec: var TVec; value: T)

aaba:

core: proc aaba(vec: TVec): auto

aaba=:

core: proc aaba=[T](vec: var TVec; value: T)

aabb:

core: proc aabb(vec: TVec): auto

aabb=:

core: proc aabb=[T](vec: var TVec; value: T)

aabg:

core: proc aabg(vec: TVec): auto

aabg=:

core: proc aabg=[T](vec: var TVec; value: T)

aabr:

core: proc aabr(vec: TVec): auto

aabr=:

core: proc aabr=[T](vec: var TVec; value: T)

aag:

core: proc aag(vec: TVec): auto

aag=:

core: proc aag=[T](vec: var TVec; value: T)

aaga:

core: proc aaga(vec: TVec): auto

aaga=:

core: proc aaga=[T](vec: var TVec; value: T)

aagb:

core: proc aagb(vec: TVec): auto

aagb=:

core: proc aagb=[T](vec: var TVec; value: T)

aagg:

core: proc aagg(vec: TVec): auto

aagg=:

core: proc aagg=[T](vec: var TVec; value: T)

aagr:

core: proc aagr(vec: TVec): auto

aagr=:

core: proc aagr=[T](vec: var TVec; value: T)

aar:

core: proc aar(vec: TVec): auto

aar=:

core: proc aar=[T](vec: var TVec; value: T)

aara:

core: proc aara(vec: TVec): auto

aara=:

core: proc aara=[T](vec: var TVec; value: T)

aarb:

core: proc aarb(vec: TVec): auto

aarb=:

core: proc aarb=[T](vec: var TVec; value: T)

aarg:

core: proc aarg(vec: TVec): auto

aarg=:

core: proc aarg=[T](vec: var TVec; value: T)

aarr:

core: proc aarr(vec: TVec): auto

aarr=:

core: proc aarr=[T](vec: var TVec; value: T)

ab:

core: proc ab(vec: TVec): auto

ab=:

core: proc ab=[T](vec: var TVec; value: T)

aba:

core: proc aba(vec: TVec): auto

aba=:

core: proc aba=[T](vec: var TVec; value: T)

abaa:

core: proc abaa(vec: TVec): auto

abaa=:

core: proc abaa=[T](vec: var TVec; value: T)

abab:

core: proc abab(vec: TVec): auto

abab=:

core: proc abab=[T](vec: var TVec; value: T)

abag:

core: proc abag(vec: TVec): auto

abag=:

core: proc abag=[T](vec: var TVec; value: T)

abar:

core: proc abar(vec: TVec): auto

abar=:

core: proc abar=[T](vec: var TVec; value: T)

abb:

core: proc abb(vec: TVec): auto

abb=:

core: proc abb=[T](vec: var TVec; value: T)

abba:

core: proc abba(vec: TVec): auto

abba=:

core: proc abba=[T](vec: var TVec; value: T)

abbb:

core: proc abbb(vec: TVec): auto

abbb=:

core: proc abbb=[T](vec: var TVec; value: T)

abbg:

core: proc abbg(vec: TVec): auto

abbg=:

core: proc abbg=[T](vec: var TVec; value: T)

abbr:

core: proc abbr(vec: TVec): auto

abbr=:

core: proc abbr=[T](vec: var TVec; value: T)

abg:

core: proc abg(vec: TVec): auto

abg=:

core: proc abg=[T](vec: var TVec; value: T)

abga:

core: proc abga(vec: TVec): auto

abga=:

core: proc abga=[T](vec: var TVec; value: T)

abgb:

core: proc abgb(vec: TVec): auto

abgb=:

core: proc abgb=[T](vec: var TVec; value: T)

abgg:

core: proc abgg(vec: TVec): auto

abgg=:

core: proc abgg=[T](vec: var TVec; value: T)

abgr:

core: proc abgr(vec: TVec): auto

abgr=:

core: proc abgr=[T](vec: var TVec; value: T)

Above:

x: const Above

abr:

core: proc abr(vec: TVec): auto

abr=:

core: proc abr=[T](vec: var TVec; value: T)

abra:

core: proc abra(vec: TVec): auto

abra=:

core: proc abra=[T](vec: var TVec; value: T)

abrb:

core: proc abrb(vec: TVec): auto

abrb=:

core: proc abrb=[T](vec: var TVec; value: T)

abrg:

core: proc abrg(vec: TVec): auto

abrg=:

core: proc abrg=[T](vec: var TVec; value: T)

abrr:

core: proc abrr(vec: TVec): auto

abrr=:

core: proc abrr=[T](vec: var TVec; value: T)

abs:

Absolute:

xi: const Absolute

AccessMode:

mixer_module: enum AccessMode

actionDown:

input: proc actionDown[T](action: T): bool

actionPressed:

input: proc actionPressed[T](action: T): bool

actionReleased:

input: proc actionReleased[T](action: T): bool

actionValue:

input: proc actionValue[T](action: T): float32

addImage:

image: proc addImage[T: PixelType](imageArray: var ImageArray[T]; image: sink Image[T])

addSound:

mixer_module: proc addSound(mixer: var Mixer; name: string; sound: SoundData)

AddToList:

xi: const AddToList

addTrack:

mixer_module: proc addTrack(mixer: var Mixer; name: string; level: Level = 1.0'f32)

ag:

core: proc ag(vec: TVec): auto

ag=:

core: proc ag=[T](vec: var TVec; value: T)

aga:

core: proc aga(vec: TVec): auto

aga=:

core: proc aga=[T](vec: var TVec; value: T)

agaa:

core: proc agaa(vec: TVec): auto

agaa=:

core: proc agaa=[T](vec: var TVec; value: T)

agab:

core: proc agab(vec: TVec): auto

agab=:

core: proc agab=[T](vec: var TVec; value: T)

agag:

core: proc agag(vec: TVec): auto

agag=:

core: proc agag=[T](vec: var TVec; value: T)

agar:

core: proc agar(vec: TVec): auto

agar=:

core: proc agar=[T](vec: var TVec; value: T)

agb:

core: proc agb(vec: TVec): auto

agb=:

core: proc agb=[T](vec: var TVec; value: T)

agba:

core: proc agba(vec: TVec): auto

agba=:

core: proc agba=[T](vec: var TVec; value: T)

agbb:

core: proc agbb(vec: TVec): auto

agbb=:

core: proc agbb=[T](vec: var TVec; value: T)

agbg:

core: proc agbg(vec: TVec): auto

agbg=:

core: proc agbg=[T](vec: var TVec; value: T)

agbr:

core: proc agbr(vec: TVec): auto

agbr=:

core: proc agbr=[T](vec: var TVec; value: T)

agg:

core: proc agg(vec: TVec): auto

agg=:

core: proc agg=[T](vec: var TVec; value: T)

agga:

core: proc agga(vec: TVec): auto

agga=:

core: proc agga=[T](vec: var TVec; value: T)

aggb:

core: proc aggb(vec: TVec): auto

aggb=:

core: proc aggb=[T](vec: var TVec; value: T)

aggg:

core: proc aggg(vec: TVec): auto

aggg=:

core: proc aggg=[T](vec: var TVec; value: T)

aggr:

core: proc aggr(vec: TVec): auto

aggr=:

core: proc aggr=[T](vec: var TVec; value: T)

aggregate_context:

sqlite3: proc aggregate_context(para1: Pcontext; nBytes: int32): pointer

aggregate_count:

sqlite3: proc aggregate_count(para1: Pcontext): int32

agr:

core: proc agr(vec: TVec): auto

agr=:

core: proc agr=[T](vec: var TVec; value: T)

agra:

core: proc agra(vec: TVec): auto

agra=:

core: proc agra=[T](vec: var TVec; value: T)

agrb:

core: proc agrb(vec: TVec): auto

agrb=:

core: proc agrb=[T](vec: var TVec; value: T)

agrg:

core: proc agrg(vec: TVec): auto

agrg=:

core: proc agrg=[T](vec: var TVec; value: T)

agrr:

core: proc agrr(vec: TVec): auto

agrr=:

core: proc agrr=[T](vec: var TVec; value: T)

AHardwareBuffer:

api: object AHardwareBuffer

AllHints:

xutil: const AllHints

AllocAll:

x: const AllocAll

AllocNone:

x: const AllocNone

AllowExposures:

x: const AllowExposures

AllPlanes:

xlib: const AllPlanes

AllTemporary:

x: const AllTemporary

AllValues:

xutil: const AllValues

AlreadyGrabbed:

x: const AlreadyGrabbed

Always:

x: const Always

ANativeWindow:

api: object ANativeWindow

angleBetween:

core: proc angleBetween(a, b: Vec3f): float32

AnyButton:

x: const AnyButton

AnyKey:

x: const AnyKey

AnyModifier:

x: const AnyModifier

AnyPropertyType:

x: const AnyPropertyType

AppName:

core: proc AppName(): string

ar:

core: proc ar(vec: TVec): auto

ar=:

core: proc ar=[T](vec: var TVec; value: T)

ara:

core: proc ara(vec: TVec): auto

ara=:

core: proc ara=[T](vec: var TVec; value: T)

araa:

core: proc araa(vec: TVec): auto

araa=:

core: proc araa=[T](vec: var TVec; value: T)

arab:

core: proc arab(vec: TVec): auto

arab=:

core: proc arab=[T](vec: var TVec; value: T)

arag:

core: proc arag(vec: TVec): auto

arag=:

core: proc arag=[T](vec: var TVec; value: T)

arar:

core: proc arar(vec: TVec): auto

arar=:

core: proc arar=[T](vec: var TVec; value: T)

arb:

core: proc arb(vec: TVec): auto

arb=:

core: proc arb=[T](vec: var TVec; value: T)

arba:

core: proc arba(vec: TVec): auto

arba=:

core: proc arba=[T](vec: var TVec; value: T)

arbb:

core: proc arbb(vec: TVec): auto

arbb=:

core: proc arbb=[T](vec: var TVec; value: T)

arbg:

core: proc arbg(vec: TVec): auto

arbg=:

core: proc arbg=[T](vec: var TVec; value: T)

arbr:

core: proc arbr(vec: TVec): auto

arbr=:

core: proc arbr=[T](vec: var TVec; value: T)

ArcChord:

x: const ArcChord

ArcPieSlice:

x: const ArcPieSlice

arg:

core: proc arg(vec: TVec): auto

arg=:

core: proc arg=[T](vec: var TVec; value: T)

arga:

core: proc arga(vec: TVec): auto

arga=:

core: proc arga=[T](vec: var TVec; value: T)

argb:

core: proc argb(vec: TVec): auto

argb=:

core: proc argb=[T](vec: var TVec; value: T)

argg:

core: proc argg(vec: TVec): auto

argg=:

core: proc argg=[T](vec: var TVec; value: T)

argr:

core: proc argr(vec: TVec): auto

argr=:

core: proc argr=[T](vec: var TVec; value: T)

arr:

core: proc arr(vec: TVec): auto

arr=:

core: proc arr=[T](vec: var TVec; value: T)

arra:

core: proc arra(vec: TVec): auto

arra=:

core: proc arra=[T](vec: var TVec; value: T)

arrb:

core: proc arrb(vec: TVec): auto

arrb=:

core: proc arrb=[T](vec: var TVec; value: T)

arrg:

core: proc arrg(vec: TVec): auto

arrg=:

core: proc arrg=[T](vec: var TVec; value: T)

arrr:

core: proc arrr(vec: TVec): auto

arrr=:

core: proc arrr=[T](vec: var TVec; value: T)

asDescriptorSetData:

rendering: proc asDescriptorSetData[T](data: sink T): auto

asGPUArray:

rendering: proc asGPUArray[T](data: sink openArray[T]; bufferType: static BufferType): auto

asGPUValue:

rendering: proc asGPUValue[T](data: sink T; bufferType: static BufferType): auto

assignBuffers:

AsyncAll:

xi: const AsyncAll

AsyncBoth:

x: const AsyncBoth

AsyncKeyboard:

x: const AsyncKeyboard

AsyncOtherDevices:

xi: const AsyncOtherDevices

AsyncPointer:

x: const AsyncPointer

AsyncThisDevice:

xi: const AsyncThisDevice

Atom:

x: type Atom

AUDIO_SAMPLE_RATE:

AutoRepeatModeDefault:

x: const AutoRepeatModeDefault

AutoRepeatModeOff:

x: const AutoRepeatModeOff

AutoRepeatModeOn:

x: const AutoRepeatModeOn

await:

rendering: proc await(fence: VkFence; timeout = high(uint64)): bool

B:

core: const B

b:

core: proc b(vec: TVec): auto

b=:

core: proc b=[T](vec: var TVec; value: T)

ba:

core: proc ba(vec: TVec): auto

ba=:

core: proc ba=[T](vec: var TVec; value: T)

baa:

core: proc baa(vec: TVec): auto

baa=:

core: proc baa=[T](vec: var TVec; value: T)

baaa:

core: proc baaa(vec: TVec): auto

baaa=:

core: proc baaa=[T](vec: var TVec; value: T)

baab:

core: proc baab(vec: TVec): auto

baab=:

core: proc baab=[T](vec: var TVec; value: T)

baag:

core: proc baag(vec: TVec): auto

baag=:

core: proc baag=[T](vec: var TVec; value: T)

baar:

core: proc baar(vec: TVec): auto

baar=:

core: proc baar=[T](vec: var TVec; value: T)

bab:

core: proc bab(vec: TVec): auto

bab=:

core: proc bab=[T](vec: var TVec; value: T)

baba:

core: proc baba(vec: TVec): auto

baba=:

core: proc baba=[T](vec: var TVec; value: T)

babb:

core: proc babb(vec: TVec): auto

babb=:

core: proc babb=[T](vec: var TVec; value: T)

babg:

core: proc babg(vec: TVec): auto

babg=:

core: proc babg=[T](vec: var TVec; value: T)

babr:

core: proc babr(vec: TVec): auto

babr=:

core: proc babr=[T](vec: var TVec; value: T)

backup_finish:

sqlite3: proc backup_finish(pBackup: PSqlite3_Backup): int32

backup_init:

sqlite3: proc backup_init(pDest: PSqlite3; zDestName: cstring; pSource: PSqlite3; zSourceName: cstring): PSqlite3_Backup

backup_pagecount:

sqlite3: proc backup_pagecount(pBackup: PSqlite3_Backup): int32

backup_remaining:

sqlite3: proc backup_remaining(pBackup: PSqlite3_Backup): int32

backup_step:

sqlite3: proc backup_step(pBackup: PSqlite3_Backup; nPage: int32): int32

BadAccess:

x: const BadAccess

BadAlloc:

x: const BadAlloc

BadAtom:

x: const BadAtom

BadColor:

x: const BadColor

BadCursor:

x: const BadCursor

BadDrawable:

x: const BadDrawable

BadFont:

x: const BadFont

BadGC:

x: const BadGC

BadIDChoice:

x: const BadIDChoice

BadImplementation:

x: const BadImplementation

BadLength:

x: const BadLength

BadMatch:

x: const BadMatch

BadName:

x: const BadName

BadPixmap:

x: const BadPixmap

BadRequest:

x: const BadRequest

BadValue:

x: const BadValue

BadWindow:

x: const BadWindow

bag:

core: proc bag(vec: TVec): auto

bag=:

core: proc bag=[T](vec: var TVec; value: T)

baga:

core: proc baga(vec: TVec): auto

baga=:

core: proc baga=[T](vec: var TVec; value: T)

bagb:

core: proc bagb(vec: TVec): auto

bagb=:

core: proc bagb=[T](vec: var TVec; value: T)

bagg:

core: proc bagg(vec: TVec): auto

bagg=:

core: proc bagg=[T](vec: var TVec; value: T)

bagr:

core: proc bagr(vec: TVec): auto

bagr=:

core: proc bagr=[T](vec: var TVec; value: T)

bar:

core: proc bar(vec: TVec): auto

bar=:

core: proc bar=[T](vec: var TVec; value: T)

bara:

core: proc bara(vec: TVec): auto

bara=:

core: proc bara=[T](vec: var TVec; value: T)

barb:

core: proc barb(vec: TVec): auto

barb=:

core: proc barb=[T](vec: var TVec; value: T)

barg:

core: proc barg(vec: TVec): auto

barg=:

core: proc barg=[T](vec: var TVec; value: T)

barr:

core: proc barr(vec: TVec): auto

barr=:

core: proc barr=[T](vec: var TVec; value: T)

bb:

core: proc bb(vec: TVec): auto

bb=:

core: proc bb=[T](vec: var TVec; value: T)

bba:

core: proc bba(vec: TVec): auto

bba=:

core: proc bba=[T](vec: var TVec; value: T)

bbaa:

core: proc bbaa(vec: TVec): auto

bbaa=:

core: proc bbaa=[T](vec: var TVec; value: T)

bbab:

core: proc bbab(vec: TVec): auto

bbab=:

core: proc bbab=[T](vec: var TVec; value: T)

bbag:

core: proc bbag(vec: TVec): auto

bbag=:

core: proc bbag=[T](vec: var TVec; value: T)

bbar:

core: proc bbar(vec: TVec): auto

bbar=:

core: proc bbar=[T](vec: var TVec; value: T)

bbb:

core: proc bbb(vec: TVec): auto

bbb=:

core: proc bbb=[T](vec: var TVec; value: T)

bbba:

core: proc bbba(vec: TVec): auto

bbba=:

core: proc bbba=[T](vec: var TVec; value: T)

bbbb:

core: proc bbbb(vec: TVec): auto

bbbb=:

core: proc bbbb=[T](vec: var TVec; value: T)

bbbg:

core: proc bbbg(vec: TVec): auto

bbbg=:

core: proc bbbg=[T](vec: var TVec; value: T)

bbbr:

core: proc bbbr(vec: TVec): auto

bbbr=:

core: proc bbbr=[T](vec: var TVec; value: T)

bbg:

core: proc bbg(vec: TVec): auto

bbg=:

core: proc bbg=[T](vec: var TVec; value: T)

bbga:

core: proc bbga(vec: TVec): auto

bbga=:

core: proc bbga=[T](vec: var TVec; value: T)

bbgb:

core: proc bbgb(vec: TVec): auto

bbgb=:

core: proc bbgb=[T](vec: var TVec; value: T)

bbgg:

core: proc bbgg(vec: TVec): auto

bbgg=:

core: proc bbgg=[T](vec: var TVec; value: T)

bbgr:

core: proc bbgr(vec: TVec): auto

bbgr=:

core: proc bbgr=[T](vec: var TVec; value: T)

bbr:

core: proc bbr(vec: TVec): auto

bbr=:

core: proc bbr=[T](vec: var TVec; value: T)

bbra:

core: proc bbra(vec: TVec): auto

bbra=:

core: proc bbra=[T](vec: var TVec; value: T)

bbrb:

core: proc bbrb(vec: TVec): auto

bbrb=:

core: proc bbrb=[T](vec: var TVec; value: T)

bbrg:

core: proc bbrg(vec: TVec): auto

bbrg=:

core: proc bbrg=[T](vec: var TVec; value: T)

bbrr:

core: proc bbrr(vec: TVec): auto

bbrr=:

core: proc bbrr=[T](vec: var TVec; value: T)

BellFeedbackClass:

xi: const BellFeedbackClass

Below:

x: const Below

bestMemory:

rendering: proc bestMemory(mappable: bool; filter: seq[uint32] = @[]): uint32

bg:

core: proc bg(vec: TVec): auto

bg=:

core: proc bg=[T](vec: var TVec; value: T)

bga:

core: proc bga(vec: TVec): auto

bga=:

core: proc bga=[T](vec: var TVec; value: T)

bgaa:

core: proc bgaa(vec: TVec): auto

bgaa=:

core: proc bgaa=[T](vec: var TVec; value: T)

bgab:

core: proc bgab(vec: TVec): auto

bgab=:

core: proc bgab=[T](vec: var TVec; value: T)

bgag:

core: proc bgag(vec: TVec): auto

bgag=:

core: proc bgag=[T](vec: var TVec; value: T)

bgar:

core: proc bgar(vec: TVec): auto

bgar=:

core: proc bgar=[T](vec: var TVec; value: T)

bgb:

core: proc bgb(vec: TVec): auto

bgb=:

core: proc bgb=[T](vec: var TVec; value: T)

bgba:

core: proc bgba(vec: TVec): auto

bgba=:

core: proc bgba=[T](vec: var TVec; value: T)

bgbb:

core: proc bgbb(vec: TVec): auto

bgbb=:

core: proc bgbb=[T](vec: var TVec; value: T)

bgbg:

core: proc bgbg(vec: TVec): auto

bgbg=:

core: proc bgbg=[T](vec: var TVec; value: T)

bgbr:

core: proc bgbr(vec: TVec): auto

bgbr=:

core: proc bgbr=[T](vec: var TVec; value: T)

bgg:

core: proc bgg(vec: TVec): auto

bgg=:

core: proc bgg=[T](vec: var TVec; value: T)

bgga:

core: proc bgga(vec: TVec): auto

bgga=:

core: proc bgga=[T](vec: var TVec; value: T)

bggb:

core: proc bggb(vec: TVec): auto

bggb=:

core: proc bggb=[T](vec: var TVec; value: T)

bggg:

core: proc bggg(vec: TVec): auto

bggg=:

core: proc bggg=[T](vec: var TVec; value: T)

bggr:

core: proc bggr(vec: TVec): auto

bggr=:

core: proc bggr=[T](vec: var TVec; value: T)

bgr:

core: proc bgr(vec: TVec): auto

bgr=:

core: proc bgr=[T](vec: var TVec; value: T)

bgra:

core: proc bgra(vec: TVec): auto

BGRA:

image: type BGRA

bgra=:

core: proc bgra=[T](vec: var TVec; value: T)

bgrb:

core: proc bgrb(vec: TVec): auto

bgrb=:

core: proc bgrb=[T](vec: var TVec; value: T)

bgrg:

core: proc bgrg(vec: TVec): auto

bgrg=:

core: proc bgrg=[T](vec: var TVec; value: T)

bgrr:

core: proc bgrr(vec: TVec): auto

bgrr=:

core: proc bgrr=[T](vec: var TVec; value: T)

bind_blob:

bindDescriptorSet:

bind_double:

sqlite3: proc bind_double(para1: PStmt; para2: int32; para3: float64): int32

bind_int:

sqlite3: proc bind_int(para1: PStmt; para2: int32; para3: int32): int32

bind_int64:

sqlite3: proc bind_int64(para1: PStmt; para2: int32; para3: int64): int32

bindNull:

db_sqlite: proc bindNull(ps: SqlPrepared; paramIdx: int)

bind_null:

sqlite3: proc bind_null(para1: PStmt; para2: int32): int32

bindParam:

bind_parameter_count:

sqlite3: proc bind_parameter_count(para1: PStmt): int32

bind_parameter_index:

sqlite3: proc bind_parameter_index(para1: PStmt; zName: cstring): int32

bind_parameter_name:

sqlite3: proc bind_parameter_name(para1: PStmt; para2: int32): cstring

bindParams:

db_sqlite: macro bindParams(ps: SqlPrepared; params: varargs[untyped]): untyped

bind_text:

bind_text16:

BitmapBitOrder:

xlib: proc BitmapBitOrder(dpy: PDisplay): cint

BitmapFileInvalid:

xutil: const BitmapFileInvalid

BitmapNoMemory:

xutil: const BitmapNoMemory

BitmapOpenFailed:

xutil: const BitmapOpenFailed

BitmapPad:

xlib: proc BitmapPad(dpy: PDisplay): cint

BitmapSuccess:

xutil: const BitmapSuccess

BitmapUnit:

xlib: proc BitmapUnit(dpy: PDisplay): cint

BlackPixel:

xlib: proc BlackPixel(dpy: PDisplay; scr: cint): culong

BlackPixelOfScreen:

xlib: proc BlackPixelOfScreen(s: PScreen): culong

Bottom:

core: VerticalAlignment.Bottom

BottomIf:

x: const BottomIf

Box:

collision: ColliderType.Box

br:

core: proc br(vec: TVec): auto

br=:

core: proc br=[T](vec: var TVec; value: T)

bra:

core: proc bra(vec: TVec): auto

bra=:

core: proc bra=[T](vec: var TVec; value: T)

braa:

core: proc braa(vec: TVec): auto

braa=:

core: proc braa=[T](vec: var TVec; value: T)

brab:

core: proc brab(vec: TVec): auto

brab=:

core: proc brab=[T](vec: var TVec; value: T)

brag:

core: proc brag(vec: TVec): auto

brag=:

core: proc brag=[T](vec: var TVec; value: T)

brar:

core: proc brar(vec: TVec): auto

brar=:

core: proc brar=[T](vec: var TVec; value: T)

brb:

core: proc brb(vec: TVec): auto

brb=:

core: proc brb=[T](vec: var TVec; value: T)

brba:

core: proc brba(vec: TVec): auto

brba=:

core: proc brba=[T](vec: var TVec; value: T)

brbb:

core: proc brbb(vec: TVec): auto

brbb=:

core: proc brbb=[T](vec: var TVec; value: T)

brbg:

core: proc brbg(vec: TVec): auto

brbg=:

core: proc brbg=[T](vec: var TVec; value: T)

brbr:

core: proc brbr(vec: TVec): auto

brbr=:

core: proc brbr=[T](vec: var TVec; value: T)

brg:

core: proc brg(vec: TVec): auto

brg=:

core: proc brg=[T](vec: var TVec; value: T)

brga:

core: proc brga(vec: TVec): auto

brga=:

core: proc brga=[T](vec: var TVec; value: T)

brgb:

core: proc brgb(vec: TVec): auto

brgb=:

core: proc brgb=[T](vec: var TVec; value: T)

brgg:

core: proc brgg(vec: TVec): auto

brgg=:

core: proc brgg=[T](vec: var TVec; value: T)

brgr:

core: proc brgr(vec: TVec): auto

brgr=:

core: proc brgr=[T](vec: var TVec; value: T)

brr:

core: proc brr(vec: TVec): auto

brr=:

core: proc brr=[T](vec: var TVec; value: T)

brra:

core: proc brra(vec: TVec): auto

brra=:

core: proc brra=[T](vec: var TVec; value: T)

brrb:

core: proc brrb(vec: TVec): auto

brrb=:

core: proc brrb=[T](vec: var TVec; value: T)

brrg:

core: proc brrg(vec: TVec): auto

brrg=:

core: proc brrg=[T](vec: var TVec; value: T)

brrr:

core: proc brrr(vec: TVec): auto

brrr=:

core: proc brrr=[T](vec: var TVec; value: T)

Buffer:

rendering: object Buffer

BufferType:

rendering: enum BufferType

BUILD_RESOURCEROOT:

resources: const BUILD_RESOURCEROOT

busy_handler:

sqlite3: proc busy_handler(para1: PSqlite3; para2: proc (para1: pointer; para2: int32): int32 {.cdecl.}; para3: pointer): int32

busy_timeout:

sqlite3: proc busy_timeout(para1: PSqlite3; ms: int32): int32

Button1:

x: const Button1

Button1Mask:

x: const Button1Mask

Button1MotionMask:

x: const Button1MotionMask

Button2:

x: const Button2

Button2Mask:

x: const Button2Mask

Button2MotionMask:

x: const Button2MotionMask

Button3:

x: const Button3

Button3Mask:

x: const Button3Mask

Button3MotionMask:

x: const Button3MotionMask

Button4:

x: const Button4

Button4Mask:

x: const Button4Mask

Button4MotionMask:

x: const Button4MotionMask

Button5:

x: const Button5

Button5Mask:

x: const Button5Mask

Button5MotionMask:

x: const Button5MotionMask

ButtonClass:

xi: const ButtonClass

ButtonMotionMask:

x: const ButtonMotionMask

ButtonPress:

x: const ButtonPress

ButtonPressMask:

x: const ButtonPressMask

ButtonRelease:

x: const ButtonRelease

ButtonReleaseMask:

x: const ButtonReleaseMask

calculateCollider:

collision: proc calculateCollider(points: openArray[Vec3f]; theType: ColliderType): Collider

Callback:

sqlite3: type Callback

CAMetalLayer:

api: object CAMetalLayer

CapButt:

x: const CapButt

CapNotLast:

x: const CapNotLast

CapProjecting:

x: const CapProjecting

CapRound:

x: const CapRound

ceil:

CellsOfScreen:

xlib: proc CellsOfScreen(s: PScreen): cint

Center:

CenterGravity:

x: const CenterGravity

changes:

sqlite3: proc changes(para1: PSqlite3): int32

chararr32:

xlib: type chararr32

checkVkResult:

api: template checkVkResult(call: untyped)

CirculateNotify:

x: const CirculateNotify

CirculateRequest:

x: const CirculateRequest

clamp:

CleanString:

core: proc CleanString(str: openArray[char]): string

clear_bindings:

sqlite3: proc clear_bindings(para1: PStmt): int32

clearSwapchain:

rendering: proc clearSwapchain()

ClientMessage:

x: const ClientMessage

ClipByChildren:

x: const ClipByChildren

close:

CloseSoundDevice:

mixer_module: proc CloseSoundDevice(soundDevice: NativeSoundDevice)

col:

collation_needed:

sqlite3: proc collation_needed(para1: PSqlite3; para2: pointer; para3: Collation_needed_func): int32

collation_needed16:

sqlite3: proc collation_needed16(para1: PSqlite3; para2: pointer; para3: Collation_needed_func): int32

Collation_needed_func:

sqlite3: type Collation_needed_func

Collider:

collision: object Collider

ColliderType:

collision: enum ColliderType

collision:

collision: proc collision(a, b: Collider; as2D = false): tuple[hasCollision: bool, normal: Vec3f, penetrationDepth: float32]

Colormap:

x: type Colormap

ColormapChangeMask:

x: const ColormapChangeMask

ColormapInstalled:

x: const ColormapInstalled

ColormapNotify:

x: const ColormapNotify

ColormapUninstalled:

x: const ColormapUninstalled

column_blob:

sqlite3: proc column_blob(para1: PStmt; iCol: int32): pointer

column_bytes:

sqlite3: proc column_bytes(para1: PStmt; iCol: int32): int32

column_bytes16:

sqlite3: proc column_bytes16(para1: PStmt; iCol: int32): int32

ColumnCount:

core: template ColumnCount(m: typedesc): int

column_count:

sqlite3: proc column_count(PStmt: PStmt): int32

column_decltype:

sqlite3: proc column_decltype(para1: PStmt; i: int32): cstring

column_decltype16:

sqlite3: proc column_decltype16(para1: PStmt; para2: int32): pointer

column_double:

sqlite3: proc column_double(para1: PStmt; iCol: int32): float64

column_int:

sqlite3: proc column_int(para1: PStmt; iCol: int32): int32

column_int64:

sqlite3: proc column_int64(para1: PStmt; iCol: int32): int64

column_name:

sqlite3: proc column_name(para1: PStmt; para2: int32): cstring

column_name16:

sqlite3: proc column_name16(para1: PStmt; para2: int32): pointer

column_table_name:

sqlite3: proc column_table_name(para1: PStmt; para2: int32): cstring

column_text:

sqlite3: proc column_text(para1: PStmt; iCol: int32): cstring

column_text16:

sqlite3: proc column_text16(para1: PStmt; iCol: int32): pointer

column_type:

sqlite3: proc column_type(para1: PStmt; iCol: int32): int32

commit_hook:

sqlite3: proc commit_hook(para1: PSqlite3; para2: proc (para1: pointer): int32 {.cdecl.}; para3: pointer): pointer

complete:

sqlite3: proc complete(sql: cstring): int32

complete16:

sqlite3: proc complete16(sql: pointer): int32

Complex:

x: const Complex

ConfigureNotify:

x: const ConfigureNotify

ConfigureRequest:

x: const ConfigureRequest

ConnectionNumber:

xlib: proc ConnectionNumber(dpy: PDisplay): cint

contains:

collision: proc contains(collider: Collider; x: Vec3f): bool

ControlMapIndex:

x: const ControlMapIndex

ControlMask:

x: const ControlMask

Convex:

x: const Convex

CoordModeOrigin:

x: const CoordModeOrigin

CoordModePrevious:

x: const CoordModePrevious

copy:

image: proc copy[S, T](img: ImageObject[S, T]): ImageObject[S, T]

CopyFromParent:

x: const CopyFromParent

COUNT:

xi: const COUNT

CPoint:

xutil: object CPoint

CREATE:

xi: const CREATE

create_collation:

sqlite3: proc create_collation(para1: PSqlite3; zName: cstring; eTextRep: int32; para4: pointer; xCompare: Create_collation_func): int32

create_collation16:

sqlite3: proc create_collation16(para1: PSqlite3; zName: cstring; eTextRep: int32; para4: pointer; xCompare: Create_collation_func): int32

Create_collation_func:

sqlite3: type Create_collation_func

createDirectPresentationRenderPass:

rendering: proc createDirectPresentationRenderPass(depthBuffer: bool; samples = VK_SAMPLE_COUNT_1_BIT): RenderPass

create_function:

sqlite3: proc create_function(para1: PSqlite3; zFunctionName: cstring; nArg: int32; eTextRep: int32; para5: pointer; xFunc: Create_function_func_func; xStep: Create_function_step_func; xFinal: Create_function_final_func): int32

create_function16:

sqlite3: proc create_function16(para1: PSqlite3; zFunctionName: pointer; nArg: int32; eTextRep: int32; para5: pointer; xFunc: Create_function_func_func; xStep: Create_function_step_func; xFinal: Create_function_final_func): int32

Create_function_final_func:

sqlite3: type Create_function_final_func

Create_function_func_func:

sqlite3: type Create_function_func_func

Create_function_step_func:

sqlite3: type Create_function_step_func

createIndirectPresentationRenderPass:

rendering: proc createIndirectPresentationRenderPass(depthBuffer: bool; samples = VK_SAMPLE_COUNT_1_BIT): ( RenderPass, RenderPass)

CreateNotify:

x: const CreateNotify

createPipeline:

rendering: proc createPipeline[TShader](renderPass: RenderPass; topology: VkPrimitiveTopology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; polygonMode: VkPolygonMode = VK_POLYGON_MODE_FILL; cullMode: openArray[VkCullModeFlagBits] = [VK_CULL_MODE_BACK_BIT]; frontFace: VkFrontFace = VK_FRONT_FACE_CLOCKWISE; lineWidth = 1.0'f32; depthClampEnable = false): Pipeline[ TShader]

createWindow:

rendering: proc createWindow(title: string): NativeWindow

cross:

core: proc cross(a, b: TVec3): auto

cunsigned:

xlib: type cunsigned

currentFiF:

rendering: proc currentFiF(): int

CurrentTime:

x: const CurrentTime

Cursor:

x: type Cursor

CursorShape:

x: const CursorShape

CWBackingPixel:

x: const CWBackingPixel

CWBackingPlanes:

x: const CWBackingPlanes

CWBackingStore:

x: const CWBackingStore

CWBackPixel:

x: const CWBackPixel

CWBackPixmap:

x: const CWBackPixmap

CWBitGravity:

x: const CWBitGravity

CWBorderPixel:

x: const CWBorderPixel

CWBorderPixmap:

x: const CWBorderPixmap

CWBorderWidth:

x: const CWBorderWidth

CWColormap:

x: const CWColormap

CWCursor:

x: const CWCursor

CWDontPropagate:

x: const CWDontPropagate

CWEventMask:

x: const CWEventMask

CWHeight:

x: const CWHeight

CWOverrideRedirect:

x: const CWOverrideRedirect

CWSaveUnder:

x: const CWSaveUnder

CWSibling:

x: const CWSibling

CWStackMode:

x: const CWStackMode

CWWidth:

x: const CWWidth

CWWinGravity:

x: const CWWinGravity

CWX:

x: const CWX

CWY:

x: const CWY

data_count:

sqlite3: proc data_count(PStmt: PStmt): int32

dbArray:

db_common: DbTypeKind.dbArray

dbBindParamError:

db_sqlite: template dbBindParamError(paramIdx: int; val: varargs[untyped])

dbBit:

db_common: DbTypeKind.dbBit

dbBlob:

db_common: DbTypeKind.dbBlob

dbBool:

db_common: DbTypeKind.dbBool

dbBox:

db_common: DbTypeKind.dbBox

dbCircle:

db_common: DbTypeKind.dbCircle

DbColumn:

db_common: object DbColumn

DbColumns:

db_common: type DbColumns

dbComposite:

db_common: DbTypeKind.dbComposite

DbConn:

db_sqlite: type DbConn

dbDate:

db_common: DbTypeKind.dbDate

dbDatetime:

db_common: DbTypeKind.dbDatetime

dbDecimal:

db_common: DbTypeKind.dbDecimal

DbEffect:

db_common: object DbEffect

dbEnum:

db_common: DbTypeKind.dbEnum

DbError:

db_common: object DbError

dbError:

dbFixedChar:

db_common: DbTypeKind.dbFixedChar

dbFloat:

db_common: DbTypeKind.dbFloat

dbFormatImpl:

dbutils: template dbFormatImpl(formatstr: SqlQuery; dbQuote: proc (s: string): string {.nimcall.}; args: varargs[string]): string

dbGeometry:

db_common: DbTypeKind.dbGeometry

dbInet:

db_common: DbTypeKind.dbInet

dbInt:

db_common: DbTypeKind.dbInt

dbJson:

db_common: DbTypeKind.dbJson

dbLine:

db_common: DbTypeKind.dbLine

dbLseg:

db_common: DbTypeKind.dbLseg

dbMacAddress:

db_common: DbTypeKind.dbMacAddress

dbNull:

db_common: DbTypeKind.dbNull

dbPath:

db_common: DbTypeKind.dbPath

dbPoint:

db_common: DbTypeKind.dbPoint

dbPolygon:

db_common: DbTypeKind.dbPolygon

dbQuote:

db_sqlite: proc dbQuote(s: string): string

dbSerial:

db_common: DbTypeKind.dbSerial

dbSet:

db_common: DbTypeKind.dbSet

dbTime:

db_common: DbTypeKind.dbTime

dbTimeInterval:

db_common: DbTypeKind.dbTimeInterval

dbTimestamp:

db_common: DbTypeKind.dbTimestamp

DbType:

db_common: object DbType

DbTypeKind:

db_common: enum DbTypeKind

dbUInt:

db_common: DbTypeKind.dbUInt

dbUnknown:

db_common: DbTypeKind.dbUnknown

dbUrl:

db_common: DbTypeKind.dbUrl

dbUser1:

db_common: DbTypeKind.dbUser1

dbUser2:

db_common: DbTypeKind.dbUser2

dbUser3:

db_common: DbTypeKind.dbUser3

dbUser4:

db_common: DbTypeKind.dbUser4

dbUser5:

db_common: DbTypeKind.dbUser5

dbUuid:

db_common: DbTypeKind.dbUuid

dbVarchar:

db_common: DbTypeKind.dbVarchar

dbXml:

db_common: DbTypeKind.dbXml

DefaultBlanking:

x: const DefaultBlanking

DefaultColormap:

xlib: proc DefaultColormap(dpy: PDisplay; scr: cint): Colormap

DefaultColormapOfScreen:

xlib: proc DefaultColormapOfScreen(s: PScreen): Colormap

DefaultDepth:

xlib: proc DefaultDepth(dpy: PDisplay; scr: cint): cint

DefaultDepthOfScreen:

xlib: proc DefaultDepthOfScreen(s: PScreen): cint

DefaultExposures:

x: const DefaultExposures

DefaultFontShader:

text: object DefaultFontShader

DefaultGC:

xlib: proc DefaultGC(dpy: PDisplay; scr: cint): GC

DefaultGCOfScreen:

xlib: proc DefaultGCOfScreen(s: PScreen): GC

DEFAULT_PACKAGE:

core: const DEFAULT_PACKAGE

DefaultRootWindow:

xlib: proc DefaultRootWindow(dpy: PDisplay): Window

DefaultScreen:

xlib: proc DefaultScreen(dpy: PDisplay): cint

DefaultScreenOfDisplay:

xlib: proc DefaultScreenOfDisplay(dpy: PDisplay): PScreen

DefaultVisual:

xlib: proc DefaultVisual(dpy: PDisplay; scr: cint): PVisual

DefaultVisualOfScreen:

xlib: proc DefaultVisualOfScreen(s: PScreen): PVisual

DeleteFromList:

xi: const DeleteFromList

deleteMessage:

rendering: var deleteMessage

Depth:

xlib: object Depth

DEPTH_FORMAT:

rendering: const DEPTH_FORMAT

DescriptorSet:

rendering: template DescriptorSet(index: DescriptorSetIndex)

DescriptorSetData:

rendering: object DescriptorSetData

destroy:

rendering: proc destroy(window: NativeWindow)

DestroyAll:

x: const DestroyAll

DestroyNotify:

x: const DestroyNotify

destroyPipeline:

rendering: proc destroyPipeline(pipeline: Pipeline)

destroyRenderData:

rendering: proc destroyRenderData(renderData: RenderData)

destroyRenderPass:

rendering: proc destroyRenderPass(renderPass: RenderPass)

destroySwapchain:

rendering: proc destroySwapchain(swapchain: Swapchain)

destroyVulkan:

rendering: proc destroyVulkan()

deviceButton1Motion:

xi: const deviceButton1Motion

deviceButton2Motion:

xi: const deviceButton2Motion

deviceButton3Motion:

xi: const deviceButton3Motion

deviceButton4Motion:

xi: const deviceButton4Motion

deviceButton5Motion:

xi: const deviceButton5Motion

deviceButtonGrab:

xi: const deviceButtonGrab

deviceButtonMotion:

xi: const deviceButtonMotion

DeviceMode:

xi: const DeviceMode

deviceOwnerGrabButton:

xi: const deviceOwnerGrabButton

devicePointerMotionHint:

xi: const devicePointerMotionHint

DEVICE_RESOLUTION:

xi: const DEVICE_RESOLUTION

DirectColor:

x: const DirectColor

DisableAccess:

x: const DisableAccess

DisableScreenInterval:

x: const DisableScreenInterval

DisableScreenSaver:

x: const DisableScreenSaver

Display:

xlib: type Display

DisplayCells:

xlib: proc DisplayCells(dpy: PDisplay; scr: cint): cint

DisplayHeight:

xlib: proc DisplayHeight(dpy: PDisplay; scr: cint): cint

DisplayHeightMM:

xlib: proc DisplayHeightMM(dpy: PDisplay; scr: cint): cint

DisplayOfScreen:

xlib: proc DisplayOfScreen(s: PScreen): PDisplay

DisplayPlanes:

xlib: proc DisplayPlanes(dpy: PDisplay; scr: cint): cint

DisplayString:

xlib: proc DisplayString(dpy: PDisplay): cstring

DisplayWidth:

xlib: proc DisplayWidth(dpy: PDisplay; scr: cint): cint

DisplayWidthMM:

xlib: proc DisplayWidthMM(dpy: PDisplay; scr: cint): cint

DoBlue:

x: const DoBlue

DoesBackingStore:

xlib: proc DoesBackingStore(s: PScreen): cint

DoesSaveUnders:

xlib: proc DoesSaveUnders(s: PScreen): XBool

DoGreen:

x: const DoGreen

DontAllowExposures:

x: const DontAllowExposures

DontCareState:

xutil: const DontCareState

Dont_Check:

xi: const Dont_Check

DontPreferBlanking:

x: const DontPreferBlanking

DontSendCoreEvents:

xi: const DontSendCoreEvents

DoRed:

x: const DoRed

dot:

Drawable:

x: type Drawable

DvAccelDenom:

xi: const DvAccelDenom

DvAccelNum:

xi: const DvAccelNum

DvAutoRepeatMode:

xi: const DvAutoRepeatMode

DvDuration:

xi: const DvDuration

DvInteger:

xi: const DvInteger

DvKey:

xi: const DvKey

DvKeyClickPercent:

xi: const DvKeyClickPercent

DvLed:

xi: const DvLed

DvLedMode:

xi: const DvLedMode

DvPercent:

xi: const DvPercent

DvPitch:

xi: const DvPitch

DvString:

xi: const DvString

DvThreshold:

xi: const DvThreshold

EastGravity:

x: const EastGravity

EnableAccess:

x: const EnableAccess

ENGINE_LOGLEVEL:

core: const ENGINE_LOGLEVEL

EnterNotify:

x: const EnterNotify

EnterWindowMask:

x: const EnterWindowMask

errcode:

sqlite3: proc errcode(db: PSqlite3): int32

errmsg:

sqlite3: proc errmsg(para1: PSqlite3): cstring

errmsg16:

sqlite3: proc errmsg16(para1: PSqlite3): pointer

EvenOddRule:

x: const EvenOddRule

Event:

events: object Event

EventMaskOfScreen:

xlib: proc EventMaskOfScreen(s: PScreen): clong

EventType:

events: enum EventType

exec:

execAffectedRows:

Expose:

x: const Expose

ExposureMask:

x: const ExposureMask

F:

xlib: object F

f32:

fadeTo:

mixer_module: proc fadeTo(mixer: var Mixer; track: string; level: Level; time: float)

FamilyChaos:

x: const FamilyChaos

FamilyDECnet:

x: const FamilyDECnet

FamilyInternet:

x: const FamilyInternet

FamilyInternet6:

x: const FamilyInternet6

FamilyServerInterpreted:

x: const FamilyServerInterpreted

fastRows:

FeedbackClass:

xi: const FeedbackClass

fetchAll:

background_loader: proc fetchAll(ld: var BackgroundLoader)

FillOpaqueStippled:

x: const FillOpaqueStippled

FillSolid:

x: const FillSolid

FillStippled:

x: const FillStippled

FillTiled:

x: const FillTiled

finalize:

FirstExtensionError:

x: const FirstExtensionError

rendering: proc flushAllMemory(renderData: RenderData)

flushBuffer:

rendering: proc flushBuffer(buffer: Buffer)

FocusChangeMask:

x: const FocusChangeMask

FocusClass:

xi: const FocusClass

FocusIn:

x: const FocusIn

FocusOut:

x: const FocusOut

FollowKeyboard:

xi: const FollowKeyboard

Font:

x: type Font

FontChange:

x: const FontChange

FontLeftToRight:

x: const FontLeftToRight

FontObj:

text: object FontObj

FontRightToLeft:

x: const FontRightToLeft

ForgetGravity:

x: const ForgetGravity

free:

sqlite3: proc free(z: cstring)

free_table:

sqlite3: proc free_table(result: cstringArray)

fullscreen:

rendering: proc fullscreen(): bool

funcdisp:

xlib: type funcdisp

funcifevent:

xlib: type funcifevent

G:

core: const G

g:

core: proc g(vec: TVec): auto

g=:

core: proc g=[T](vec: var TVec; value: T)

ga:

core: proc ga(vec: TVec): auto

ga=:

core: proc ga=[T](vec: var TVec; value: T)

gaa:

core: proc gaa(vec: TVec): auto

gaa=:

core: proc gaa=[T](vec: var TVec; value: T)

gaaa:

core: proc gaaa(vec: TVec): auto

gaaa=:

core: proc gaaa=[T](vec: var TVec; value: T)

gaab:

core: proc gaab(vec: TVec): auto

gaab=:

core: proc gaab=[T](vec: var TVec; value: T)

gaag:

core: proc gaag(vec: TVec): auto

gaag=:

core: proc gaag=[T](vec: var TVec; value: T)

gaar:

core: proc gaar(vec: TVec): auto

gaar=:

core: proc gaar=[T](vec: var TVec; value: T)

gab:

core: proc gab(vec: TVec): auto

gab=:

core: proc gab=[T](vec: var TVec; value: T)

gaba:

core: proc gaba(vec: TVec): auto

gaba=:

core: proc gaba=[T](vec: var TVec; value: T)

gabb:

core: proc gabb(vec: TVec): auto

gabb=:

core: proc gabb=[T](vec: var TVec; value: T)

gabg:

core: proc gabg(vec: TVec): auto

gabg=:

core: proc gabg=[T](vec: var TVec; value: T)

gabr:

core: proc gabr(vec: TVec): auto

gabr=:

core: proc gabr=[T](vec: var TVec; value: T)

gag:

core: proc gag(vec: TVec): auto

gag=:

core: proc gag=[T](vec: var TVec; value: T)

gaga:

core: proc gaga(vec: TVec): auto

gaga=:

core: proc gaga=[T](vec: var TVec; value: T)

gagb:

core: proc gagb(vec: TVec): auto

gagb=:

core: proc gagb=[T](vec: var TVec; value: T)

gagg:

core: proc gagg(vec: TVec): auto

gagg=:

core: proc gagg=[T](vec: var TVec; value: T)

gagr:

core: proc gagr(vec: TVec): auto

gagr=:

core: proc gagr=[T](vec: var TVec; value: T)

gar:

core: proc gar(vec: TVec): auto

gar=:

core: proc gar=[T](vec: var TVec; value: T)

gara:

core: proc gara(vec: TVec): auto

gara=:

core: proc gara=[T](vec: var TVec; value: T)

garb:

core: proc garb(vec: TVec): auto

garb=:

core: proc garb=[T](vec: var TVec; value: T)

garg:

core: proc garg(vec: TVec): auto

garg=:

core: proc garg=[T](vec: var TVec; value: T)

garr:

core: proc garr(vec: TVec): auto

garr=:

core: proc garr=[T](vec: var TVec; value: T)

gb:

core: proc gb(vec: TVec): auto

gb=:

core: proc gb=[T](vec: var TVec; value: T)

gba:

core: proc gba(vec: TVec): auto

gba=:

core: proc gba=[T](vec: var TVec; value: T)

gbaa:

core: proc gbaa(vec: TVec): auto

gbaa=:

core: proc gbaa=[T](vec: var TVec; value: T)

gbab:

core: proc gbab(vec: TVec): auto

gbab=:

core: proc gbab=[T](vec: var TVec; value: T)

gbag:

core: proc gbag(vec: TVec): auto

gbag=:

core: proc gbag=[T](vec: var TVec; value: T)

gbar:

core: proc gbar(vec: TVec): auto

gbar=:

core: proc gbar=[T](vec: var TVec; value: T)

gbb:

core: proc gbb(vec: TVec): auto

gbb=:

core: proc gbb=[T](vec: var TVec; value: T)

gbba:

core: proc gbba(vec: TVec): auto

gbba=:

core: proc gbba=[T](vec: var TVec; value: T)

gbbb:

core: proc gbbb(vec: TVec): auto

gbbb=:

core: proc gbbb=[T](vec: var TVec; value: T)

gbbg:

core: proc gbbg(vec: TVec): auto

gbbg=:

core: proc gbbg=[T](vec: var TVec; value: T)

gbbr:

core: proc gbbr(vec: TVec): auto

gbbr=:

core: proc gbbr=[T](vec: var TVec; value: T)

gbg:

core: proc gbg(vec: TVec): auto

gbg=:

core: proc gbg=[T](vec: var TVec; value: T)

gbga:

core: proc gbga(vec: TVec): auto

gbga=:

core: proc gbga=[T](vec: var TVec; value: T)

gbgb:

core: proc gbgb(vec: TVec): auto

gbgb=:

core: proc gbgb=[T](vec: var TVec; value: T)

gbgg:

core: proc gbgg(vec: TVec): auto

gbgg=:

core: proc gbgg=[T](vec: var TVec; value: T)

gbgr:

core: proc gbgr(vec: TVec): auto

gbgr=:

core: proc gbgr=[T](vec: var TVec; value: T)

gbr:

core: proc gbr(vec: TVec): auto

gbr=:

core: proc gbr=[T](vec: var TVec; value: T)

gbra:

core: proc gbra(vec: TVec): auto

gbra=:

core: proc gbra=[T](vec: var TVec; value: T)

gbrb:

core: proc gbrb(vec: TVec): auto

gbrb=:

core: proc gbrb=[T](vec: var TVec; value: T)

gbrg:

core: proc gbrg(vec: TVec): auto

gbrg=:

core: proc gbrg=[T](vec: var TVec; value: T)

gbrr:

core: proc gbrr(vec: TVec): auto

gbrr=:

core: proc gbrr=[T](vec: var TVec; value: T)

GC:

xlib: type GC

GCArcMode:

x: const GCArcMode

GCBackground:

x: const GCBackground

GCCapStyle:

x: const GCCapStyle

GCClipMask:

x: const GCClipMask

GCClipXOrigin:

x: const GCClipXOrigin

GCClipYOrigin:

x: const GCClipYOrigin

GCDashList:

x: const GCDashList

GCDashOffset:

x: const GCDashOffset

GCFillRule:

x: const GCFillRule

GCFillStyle:

x: const GCFillStyle

GCFont:

x: const GCFont

GCForeground:

x: const GCForeground

GCFunction:

x: const GCFunction

GCGraphicsExposures:

x: const GCGraphicsExposures

GCJoinStyle:

x: const GCJoinStyle

GCLastBit:

x: const GCLastBit

GCLineStyle:

x: const GCLineStyle

GCLineWidth:

x: const GCLineWidth

GContext:

x: type GContext

GCPlaneMask:

x: const GCPlaneMask

GCStipple:

x: const GCStipple

GCSubwindowMode:

x: const GCSubwindowMode

GCTile:

x: const GCTile

GCTileStipXOrigin:

x: const GCTileStipXOrigin

GCTileStipYOrigin:

x: const GCTileStipYOrigin

GenericEvent:

x: const GenericEvent

getAllRows:

getAspectRatio:

rendering: proc getAspectRatio(): float32

get_auxdata:

sqlite3: proc get_auxdata(para1: Pcontext; para2: int32): pointer

getLevel:

getLoaded:

loaders: proc getLoaded[T: ResourceType](path: string; package = DEFAULT_PACKAGE): T

getLoadedData:

background_loader: proc getLoadedData[T](ld: var BackgroundLoader[T]; path, package: string): T

getMousePosition:

rendering: proc getMousePosition(window: NativeWindow): Vec2i

getRow:

db_sqlite: proc getRow(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): Row

get_table:

sqlite3: proc get_table(para1: PSqlite3; sql: cstring; resultp: var cstringArray; nrow, ncolumn: var cint; errmsg: ptr cstring): int32

getValue:

gg:

core: proc gg(vec: TVec): auto

gg=:

core: proc gg=[T](vec: var TVec; value: T)

gga:

core: proc gga(vec: TVec): auto

gga=:

core: proc gga=[T](vec: var TVec; value: T)

ggaa:

core: proc ggaa(vec: TVec): auto

ggaa=:

core: proc ggaa=[T](vec: var TVec; value: T)

ggab:

core: proc ggab(vec: TVec): auto

ggab=:

core: proc ggab=[T](vec: var TVec; value: T)

ggag:

core: proc ggag(vec: TVec): auto

ggag=:

core: proc ggag=[T](vec: var TVec; value: T)

ggar:

core: proc ggar(vec: TVec): auto

ggar=:

core: proc ggar=[T](vec: var TVec; value: T)

ggb:

core: proc ggb(vec: TVec): auto

ggb=:

core: proc ggb=[T](vec: var TVec; value: T)

ggba:

core: proc ggba(vec: TVec): auto

ggba=:

core: proc ggba=[T](vec: var TVec; value: T)

ggbb:

core: proc ggbb(vec: TVec): auto

ggbb=:

core: proc ggbb=[T](vec: var TVec; value: T)

ggbg:

core: proc ggbg(vec: TVec): auto

ggbg=:

core: proc ggbg=[T](vec: var TVec; value: T)

ggbr:

core: proc ggbr(vec: TVec): auto

ggbr=:

core: proc ggbr=[T](vec: var TVec; value: T)

ggg:

core: proc ggg(vec: TVec): auto

ggg=:

core: proc ggg=[T](vec: var TVec; value: T)

ggga:

core: proc ggga(vec: TVec): auto

ggga=:

core: proc ggga=[T](vec: var TVec; value: T)

gggb:

core: proc gggb(vec: TVec): auto

gggb=:

core: proc gggb=[T](vec: var TVec; value: T)

gggg:

core: proc gggg(vec: TVec): auto

gggg=:

core: proc gggg=[T](vec: var TVec; value: T)

gggr:

core: proc gggr(vec: TVec): auto

gggr=:

core: proc gggr=[T](vec: var TVec; value: T)

ggr:

core: proc ggr(vec: TVec): auto

ggr=:

core: proc ggr=[T](vec: var TVec; value: T)

ggra:

core: proc ggra(vec: TVec): auto

ggra=:

core: proc ggra=[T](vec: var TVec; value: T)

ggrb:

core: proc ggrb(vec: TVec): auto

ggrb=:

core: proc ggrb=[T](vec: var TVec; value: T)

ggrg:

core: proc ggrg(vec: TVec): auto

ggrg=:

core: proc ggrg=[T](vec: var TVec; value: T)

ggrr:

core: proc ggrr(vec: TVec): auto

ggrr=:

core: proc ggrr=[T](vec: var TVec; value: T)

GltfData:

gltf: object GltfData

GltfNode:

gltf: object GltfNode

GlyphInfo:

text: object GlyphInfo

GotFocus:

events: EventType.GotFocus

GPUArray:

rendering: object GPUArray

GPUData:

rendering: type GPUData

GPUValue:

rendering: object GPUValue

gr:

core: proc gr(vec: TVec): auto

gr=:

core: proc gr=[T](vec: var TVec; value: T)

gra:

core: proc gra(vec: TVec): auto

gra=:

core: proc gra=[T](vec: var TVec; value: T)

graa:

core: proc graa(vec: TVec): auto

graa=:

core: proc graa=[T](vec: var TVec; value: T)

grab:

core: proc grab(vec: TVec): auto

grab=:

core: proc grab=[T](vec: var TVec; value: T)

GrabFrozen:

x: const GrabFrozen

GrabInvalidTime:

x: const GrabInvalidTime

GrabModeAsync:

x: const GrabModeAsync

GrabModeSync:

x: const GrabModeSync

GrabNotViewable:

x: const GrabNotViewable

GrabSuccess:

x: const GrabSuccess

grag:

core: proc grag(vec: TVec): auto

grag=:

core: proc grag=[T](vec: var TVec; value: T)

GraphicsExpose:

x: const GraphicsExpose

grar:

core: proc grar(vec: TVec): auto

grar=:

core: proc grar=[T](vec: var TVec; value: T)

GravityNotify:

x: const GravityNotify

Gray:

image: type Gray

GrayScale:

x: const GrayScale

grb:

core: proc grb(vec: TVec): auto

grb=:

core: proc grb=[T](vec: var TVec; value: T)

grba:

core: proc grba(vec: TVec): auto

grba=:

core: proc grba=[T](vec: var TVec; value: T)

grbb:

core: proc grbb(vec: TVec): auto

grbb=:

core: proc grbb=[T](vec: var TVec; value: T)

grbg:

core: proc grbg(vec: TVec): auto

grbg=:

core: proc grbg=[T](vec: var TVec; value: T)

grbr:

core: proc grbr(vec: TVec): auto

grbr=:

core: proc grbr=[T](vec: var TVec; value: T)

grg:

core: proc grg(vec: TVec): auto

grg=:

core: proc grg=[T](vec: var TVec; value: T)

grga:

core: proc grga(vec: TVec): auto

grga=:

core: proc grga=[T](vec: var TVec; value: T)

grgb:

core: proc grgb(vec: TVec): auto

grgb=:

core: proc grgb=[T](vec: var TVec; value: T)

grgg:

core: proc grgg(vec: TVec): auto

grgg=:

core: proc grgg=[T](vec: var TVec; value: T)

grgr:

core: proc grgr(vec: TVec): auto

grgr=:

core: proc grgr=[T](vec: var TVec; value: T)

grr:

core: proc grr(vec: TVec): auto

grr=:

core: proc grr=[T](vec: var TVec; value: T)

grra:

core: proc grra(vec: TVec): auto

grra=:

core: proc grra=[T](vec: var TVec; value: T)

grrb:

core: proc grrb(vec: TVec): auto

grrb=:

core: proc grrb=[T](vec: var TVec; value: T)

grrg:

core: proc grrg(vec: TVec): auto

grrg=:

core: proc grrg=[T](vec: var TVec; value: T)

grrr:

core: proc grrr(vec: TVec): auto

grrr=:

core: proc grrr=[T](vec: var TVec; value: T)

GXand:

x: const GXand

GXandInverted:

x: const GXandInverted

GXandReverse:

x: const GXandReverse

GXclear:

x: const GXclear

GXcopy:

x: const GXcopy

GXcopyInverted:

x: const GXcopyInverted

GXequiv:

x: const GXequiv

GXinvert:

x: const GXinvert

GXnand:

x: const GXnand

GXnoop:

x: const GXnoop

GXnor:

x: const GXnor

GXor:

x: const GXor

GXorInverted:

x: const GXorInverted

GXorReverse:

x: const GXorReverse

GXset:

x: const GXset

GXxor:

x: const GXxor

HadConfigUpdate:

settings: proc HadConfigUpdate(): bool

hasFocus:

input: proc hasFocus(): bool

hasValidationLayer:

rendering: proc hasValidationLayer(): bool

HeightMMOfScreen:

xlib: proc HeightMMOfScreen(s: PScreen): cint

HeightOfScreen:

xlib: proc HeightOfScreen(s: PScreen): cint

HeightValue:

xutil: const HeightValue

HorizontalAlignment:

core: enum HorizontalAlignment

horizontalAlignment:

text: proc horizontalAlignment(textbox: Textbox): HorizontalAlignment

horizontalAlignment=:

text: proc horizontalAlignment=(textbox: var Textbox; value: HorizontalAlignment)

HostDelete:

x: const HostDelete

HostInsert:

x: const HostInsert

i32:

i8:

IconicState:

xutil: const IconicState

IconMaskHint:

xutil: const IconMaskHint

IconPixmapHint:

xutil: const IconPixmapHint

IconPositionHint:

xutil: const IconPositionHint

IconWindowHint:

xutil: const IconWindowHint

Image:

image: type Image

ImageArray:

image: type ImageArray

ImageByteOrder:

xlib: proc ImageByteOrder(dpy: PDisplay): cint

ImageObject:

image: object ImageObject

InactiveState:

xutil: const InactiveState

INAME:

xi: const INAME

IncludeInferiors:

x: const IncludeInferiors

IndexBuffer:

rendering: BufferType.IndexBuffer

IndexBufferMapped:

rendering: BufferType.IndexBufferMapped

INFLIGHTFRAMES:

rendering: const INFLIGHTFRAMES

initBackgroundLoader:

background_loader: proc initBackgroundLoader[T](loadFn: proc (path, package: string): T {.gcsafe.}): ptr BackgroundLoader[ T]

initDescriptorSet:

rendering: proc initDescriptorSet(renderData: RenderData; layout: VkDescriptorSetLayout; descriptorSet: DescriptorSetData)

initRenderData:

rendering: proc initRenderData(descriptorPoolLimit = 1024'u32): RenderData

initTextbox:

text: proc initTextbox[T: string | seq[Rune]](renderdata: var RenderData; descriptorSetLayout: VkDescriptorSetLayout; font: Font; baseScale: float32; text: T = default(T); maxLen: int = text.len; verticalAlignment: VerticalAlignment = Center; horizontalAlignment: HorizontalAlignment = Center; maxWidth = 0.0'f32): Textbox

initVulkan:

rendering: proc initVulkan(appName: string = "semicongine app")

InProximity:

xi: const InProximity

InputFocus:

x: const InputFocus

InputHint:

xutil: const InputHint

InputOnly:

x: const InputOnly

InputOutput:

x: const InputOutput

insert:

db_sqlite: proc insert(db: DbConn; query: SqlQuery; pkName: string; args: varargs[string, `$`]): int64

insertID:

db_sqlite: proc insertID(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64

InstanceAttribute:

rendering: template InstanceAttribute()

InstantRow:

db_sqlite: type InstantRow

instantRows:

IntegerFeedbackClass:

xi: const IntegerFeedbackClass

interrupt:

sqlite3: proc interrupt(para1: PSqlite3)

intersects:

collision: proc intersects(a, b: Collider; as2D = false): bool

inversed:

core: proc inversed(a: Mat4): Mat4

IOSurfaceRef:

api: object IOSurfaceRef

IsCursorKey:

xutil: proc IsCursorKey(keysym: KeySym): bool

IsFunctionKey:

xutil: proc IsFunctionKey(keysym: KeySym): bool

IsKeypadKey:

xutil: proc IsKeypadKey(keysym: KeySym): bool

isLoaded:

IsMiscFunctionKey:

xutil: proc IsMiscFunctionKey(keysym: KeySym): bool

IsModifierKey:

xutil: proc IsModifierKey(keysym: KeySym): bool

IsPFKey:

xutil: proc IsPFKey(keysym: KeySym): bool

isPlaying:

IsPrivateKeypadKey:

xutil: proc IsPrivateKeypadKey(keysym: KeySym): bool

IsUnmapped:

x: const IsUnmapped

IsUnviewable:

x: const IsUnviewable

IsViewable:

x: const IsViewable

IsXExtensionDevice:

xi: const IsXExtensionDevice

IsXKeyboard:

xi: const IsXKeyboard

IsXPointer:

xi: const IsXPointer

items:

api: iterator items[T: HoleyEnum](E: typedesc[T]): T

JoinBevel:

x: const JoinBevel

JoinMiter:

x: const JoinMiter

JoinRound:

x: const JoinRound

KBAutoRepeatMode:

x: const KBAutoRepeatMode

KBBellDuration:

x: const KBBellDuration

KBBellPercent:

x: const KBBellPercent

KBBellPitch:

x: const KBBellPitch

KbdFeedbackClass:

xi: const KbdFeedbackClass

KBKey:

x: const KBKey

KBKeyClickPercent:

x: const KBKeyClickPercent

KBLed:

x: const KBLed

KBLedMode:

x: const KBLedMode

Key:

events: enum Key

KeyClass:

xi: const KeyClass

KeyCode:

x: type KeyCode

keyIsDown:

input: proc keyIsDown(key: Key): bool

KeymapNotify:

x: const KeymapNotify

KeymapStateMask:

x: const KeymapStateMask

KeyPress:

x: const KeyPress

KeyPressed:

events: EventType.KeyPressed

KeyPressMask:

x: const KeyPressMask

KeyRelease:

x: const KeyRelease

KeyReleased:

events: EventType.KeyReleased

KeyReleaseMask:

x: const KeyReleaseMask

KeySym:

x: type KeySym

keyWasPressed:

keyWasReleased:

input: proc keyWasReleased(key: Key): bool

LASTEvent:

x: const LASTEvent

LastExtensionError:

x: const LastExtensionError

last_insert_rowid:

sqlite3: proc last_insert_rowid(para1: PSqlite3): int64

LastKnownRequestProcessed:

xlib: proc LastKnownRequestProcessed(dpy: PDisplay): culong

layout:

rendering: proc layout(pipeline: Pipeline; level: int): VkDescriptorSetLayout

LeaveNotify:

x: const LeaveNotify

LeaveWindowMask:

x: const LeaveWindowMask

LedFeedbackClass:

xi: const LedFeedbackClass

LedModeOff:

x: const LedModeOff

LedModeOn:

x: const LedModeOn

Left:

core: HorizontalAlignment.Left

len:

db_sqlite: proc len(row: InstantRow): int32

length:

Level:

mixer_module: type Level

libversion:

sqlite3: proc libversion(): cstring

libversion_number:

sqlite3: proc libversion_number(): int32

libX11:

libXi:

xi: const libXi

LineDoubleDash:

x: const LineDoubleDash

LineOnOffDash:

x: const LineOnOffDash

LineSolid:

x: const LineSolid

list:

litems:

core: iterator litems[IX, T](a: array[IX, T]): lent T

load:

storage: proc load[T](storageType: StorageType; key: string; default: T; table = DEFAULT_KEY_VALUE_TABLE_NAME): T

loadActionMapping:

input: proc loadActionMapping[T]()

loadAsync:

loaders: proc loadAsync[T: ResourceType](path: string; package = DEFAULT_PACKAGE)

loadAudio:

loaders: proc loadAudio(path: string; package = DEFAULT_PACKAGE): SoundData

loadBytes:

loaders: proc loadBytes(path, package: string): seq[byte]

loadConfig:

loaders: proc loadConfig(path: string; package = DEFAULT_PACKAGE): Config

loadExtension:

api: proc loadExtension(instance: VkInstance; extension: string)

loadFont:

text: proc loadFont(path: string; lineHeightPixels = 80.0'f32; additional_codepoints: openArray[Rune] = []; charset = ASCII_CHARSET; package = DEFAULT_PACKAGE): Font

loadImage:

loaders: proc loadImage[T: PixelType](path: string; package = DEFAULT_PACKAGE): Image[T]

loadImageArray:

loadImageData:

image: proc loadImageData[T: PixelType](pngData: string | seq[uint8]): tuple[width: uint32, height: uint32, data: seq[T]]

loadJson:

loaders: proc loadJson(path: string; package = DEFAULT_PACKAGE): JsonNode

loadMeshes:

loaders: proc loadMeshes[TMesh, TMaterial](path: string; meshAttributesMapping: static MeshAttributeNames; materialAttributesMapping: static MaterialAttributeNames; package = DEFAULT_PACKAGE): GltfData[TMesh, TMaterial]

loadResource:

resources: proc loadResource(path: string; package = DEFAULT_PACKAGE): Stream

loadResource_intern:

loadVK_AMD_buffer_marker:

api: proc loadVK_AMD_buffer_marker(instance: VkInstance)

loadVK_AMD_device_coherent_memory:

api: proc loadVK_AMD_device_coherent_memory(instance: VkInstance)

loadVK_AMD_display_native_hdr:

api: proc loadVK_AMD_display_native_hdr(instance: VkInstance)

loadVK_AMD_gcn_shader:

api: proc loadVK_AMD_gcn_shader(instance: VkInstance)

loadVK_AMD_gpu_shader_half_float:

api: proc loadVK_AMD_gpu_shader_half_float(instance: VkInstance)

loadVK_AMD_gpu_shader_int16:

api: proc loadVK_AMD_gpu_shader_int16(instance: VkInstance)

loadVK_AMD_memory_overallocation_behavior:

api: proc loadVK_AMD_memory_overallocation_behavior(instance: VkInstance)

loadVK_AMD_mixed_attachment_samples:

api: proc loadVK_AMD_mixed_attachment_samples(instance: VkInstance)

loadVK_AMD_negative_viewport_height:

api: proc loadVK_AMD_negative_viewport_height(instance: VkInstance)

loadVK_AMD_pipeline_compiler_control:

api: proc loadVK_AMD_pipeline_compiler_control(instance: VkInstance)

loadVK_AMD_rasterization_order:

api: proc loadVK_AMD_rasterization_order(instance: VkInstance)

loadVK_AMD_shader_ballot:

api: proc loadVK_AMD_shader_ballot(instance: VkInstance)

loadVK_AMD_shader_core_properties:

api: proc loadVK_AMD_shader_core_properties(instance: VkInstance)

loadVK_AMD_shader_core_properties2:

api: proc loadVK_AMD_shader_core_properties2(instance: VkInstance)

loadVK_AMD_shader_early_and_late_fragment_tests:

api: proc loadVK_AMD_shader_early_and_late_fragment_tests(instance: VkInstance)

loadVK_AMD_shader_explicit_vertex_parameter:

api: proc loadVK_AMD_shader_explicit_vertex_parameter(instance: VkInstance)

loadVK_AMD_shader_fragment_mask:

api: proc loadVK_AMD_shader_fragment_mask(instance: VkInstance)

loadVK_AMD_shader_image_load_store_lod:

api: proc loadVK_AMD_shader_image_load_store_lod(instance: VkInstance)

loadVK_AMD_shader_info:

api: proc loadVK_AMD_shader_info(instance: VkInstance)

loadVK_AMD_shader_trinary_minmax:

api: proc loadVK_AMD_shader_trinary_minmax(instance: VkInstance)

loadVK_AMD_texture_gather_bias_lod:

api: proc loadVK_AMD_texture_gather_bias_lod(instance: VkInstance)

loadVK_ARM_shader_core_builtins:

api: proc loadVK_ARM_shader_core_builtins(instance: VkInstance)

loadVK_ARM_shader_core_properties:

api: proc loadVK_ARM_shader_core_properties(instance: VkInstance)

loadVK_EXT_acquire_drm_display:

api: proc loadVK_EXT_acquire_drm_display(instance: VkInstance)

loadVK_EXT_astc_decode_mode:

api: proc loadVK_EXT_astc_decode_mode(instance: VkInstance)

loadVK_EXT_attachment_feedback_loop_layout:

api: proc loadVK_EXT_attachment_feedback_loop_layout(instance: VkInstance)

loadVK_EXT_blend_operation_advanced:

api: proc loadVK_EXT_blend_operation_advanced(instance: VkInstance)

loadVK_EXT_border_color_swizzle:

api: proc loadVK_EXT_border_color_swizzle(instance: VkInstance)

loadVK_EXT_buffer_device_address:

api: proc loadVK_EXT_buffer_device_address(instance: VkInstance)

loadVK_EXT_calibrated_timestamps:

api: proc loadVK_EXT_calibrated_timestamps(instance: VkInstance)

loadVK_EXT_color_write_enable:

api: proc loadVK_EXT_color_write_enable(instance: VkInstance)

loadVK_EXT_conditional_rendering:

api: proc loadVK_EXT_conditional_rendering(instance: VkInstance)

loadVK_EXT_conservative_rasterization:

api: proc loadVK_EXT_conservative_rasterization(instance: VkInstance)

loadVK_EXT_custom_border_color:

api: proc loadVK_EXT_custom_border_color(instance: VkInstance)

loadVK_EXT_debug_report:

api: proc loadVK_EXT_debug_report(instance: VkInstance)

loadVK_EXT_debug_utils:

api: proc loadVK_EXT_debug_utils(instance: VkInstance)

loadVK_EXT_depth_clamp_zero_one:

api: proc loadVK_EXT_depth_clamp_zero_one(instance: VkInstance)

loadVK_EXT_depth_clip_control:

api: proc loadVK_EXT_depth_clip_control(instance: VkInstance)

loadVK_EXT_depth_clip_enable:

api: proc loadVK_EXT_depth_clip_enable(instance: VkInstance)

loadVK_EXT_depth_range_unrestricted:

api: proc loadVK_EXT_depth_range_unrestricted(instance: VkInstance)

loadVK_EXT_descriptor_buffer:

api: proc loadVK_EXT_descriptor_buffer(instance: VkInstance)

loadVK_EXT_device_address_binding_report:

api: proc loadVK_EXT_device_address_binding_report(instance: VkInstance)

loadVK_EXT_device_fault:

api: proc loadVK_EXT_device_fault(instance: VkInstance)

loadVK_EXT_device_memory_report:

api: proc loadVK_EXT_device_memory_report(instance: VkInstance)

loadVK_EXT_direct_mode_display:

api: proc loadVK_EXT_direct_mode_display(instance: VkInstance)

loadVK_EXT_discard_rectangles:

api: proc loadVK_EXT_discard_rectangles(instance: VkInstance)

loadVK_EXT_display_control:

api: proc loadVK_EXT_display_control(instance: VkInstance)

loadVK_EXT_display_surface_counter:

api: proc loadVK_EXT_display_surface_counter(instance: VkInstance)

loadVK_EXT_extended_dynamic_state3:

api: proc loadVK_EXT_extended_dynamic_state3(instance: VkInstance)

loadVK_EXT_external_memory_dma_buf:

api: proc loadVK_EXT_external_memory_dma_buf(instance: VkInstance)

loadVK_EXT_external_memory_host:

api: proc loadVK_EXT_external_memory_host(instance: VkInstance)

loadVK_EXT_filter_cubic:

api: proc loadVK_EXT_filter_cubic(instance: VkInstance)

loadVK_EXT_fragment_density_map:

api: proc loadVK_EXT_fragment_density_map(instance: VkInstance)

loadVK_EXT_fragment_density_map2:

api: proc loadVK_EXT_fragment_density_map2(instance: VkInstance)

loadVK_EXT_fragment_shader_interlock:

api: proc loadVK_EXT_fragment_shader_interlock(instance: VkInstance)

loadVK_EXT_graphics_pipeline_library:

api: proc loadVK_EXT_graphics_pipeline_library(instance: VkInstance)

loadVK_EXT_hdr_metadata:

api: proc loadVK_EXT_hdr_metadata(instance: VkInstance)

loadVK_EXT_headless_surface:

api: proc loadVK_EXT_headless_surface(instance: VkInstance)

loadVK_EXT_image_2d_view_of_3d:

api: proc loadVK_EXT_image_2d_view_of_3d(instance: VkInstance)

loadVK_EXT_image_compression_control:

api: proc loadVK_EXT_image_compression_control(instance: VkInstance)

loadVK_EXT_image_compression_control_swapchain:

api: proc loadVK_EXT_image_compression_control_swapchain(instance: VkInstance)

loadVK_EXT_image_drm_format_modifier:

api: proc loadVK_EXT_image_drm_format_modifier(instance: VkInstance)

loadVK_EXT_image_sliced_view_of_3d:

api: proc loadVK_EXT_image_sliced_view_of_3d(instance: VkInstance)

loadVK_EXT_image_view_min_lod:

api: proc loadVK_EXT_image_view_min_lod(instance: VkInstance)

loadVK_EXT_index_type_uint8:

api: proc loadVK_EXT_index_type_uint8(instance: VkInstance)

loadVK_EXT_legacy_dithering:

api: proc loadVK_EXT_legacy_dithering(instance: VkInstance)

loadVK_EXT_line_rasterization:

api: proc loadVK_EXT_line_rasterization(instance: VkInstance)

loadVK_EXT_load_store_op_none:

api: proc loadVK_EXT_load_store_op_none(instance: VkInstance)

loadVK_EXT_memory_budget:

api: proc loadVK_EXT_memory_budget(instance: VkInstance)

loadVK_EXT_memory_priority:

api: proc loadVK_EXT_memory_priority(instance: VkInstance)

loadVK_EXT_mesh_shader:

api: proc loadVK_EXT_mesh_shader(instance: VkInstance)

loadVK_EXT_multi_draw:

api: proc loadVK_EXT_multi_draw(instance: VkInstance)

loadVK_EXT_multisampled_render_to_single_sampled:

api: proc loadVK_EXT_multisampled_render_to_single_sampled(instance: VkInstance)

loadVK_EXT_mutable_descriptor_type:

api: proc loadVK_EXT_mutable_descriptor_type(instance: VkInstance)

loadVK_EXT_non_seamless_cube_map:

api: proc loadVK_EXT_non_seamless_cube_map(instance: VkInstance)

loadVK_EXT_opacity_micromap:

api: proc loadVK_EXT_opacity_micromap(instance: VkInstance)

loadVK_EXT_pageable_device_local_memory:

api: proc loadVK_EXT_pageable_device_local_memory(instance: VkInstance)

loadVK_EXT_pci_bus_info:

api: proc loadVK_EXT_pci_bus_info(instance: VkInstance)

loadVK_EXT_physical_device_drm:

api: proc loadVK_EXT_physical_device_drm(instance: VkInstance)

loadVK_EXT_pipeline_library_group_handles:

api: proc loadVK_EXT_pipeline_library_group_handles(instance: VkInstance)

loadVK_EXT_pipeline_properties:

api: proc loadVK_EXT_pipeline_properties(instance: VkInstance)

loadVK_EXT_pipeline_protected_access:

api: proc loadVK_EXT_pipeline_protected_access(instance: VkInstance)

loadVK_EXT_pipeline_robustness:

api: proc loadVK_EXT_pipeline_robustness(instance: VkInstance)

loadVK_EXT_post_depth_coverage:

api: proc loadVK_EXT_post_depth_coverage(instance: VkInstance)

loadVK_EXT_primitives_generated_query:

api: proc loadVK_EXT_primitives_generated_query(instance: VkInstance)

loadVK_EXT_primitive_topology_list_restart:

api: proc loadVK_EXT_primitive_topology_list_restart(instance: VkInstance)

loadVK_EXT_provoking_vertex:

api: proc loadVK_EXT_provoking_vertex(instance: VkInstance)

loadVK_EXT_queue_family_foreign:

api: proc loadVK_EXT_queue_family_foreign(instance: VkInstance)

loadVK_EXT_rasterization_order_attachment_access:

api: proc loadVK_EXT_rasterization_order_attachment_access(instance: VkInstance)

loadVK_EXT_rgba10x6_formats:

api: proc loadVK_EXT_rgba10x6_formats(instance: VkInstance)

loadVK_EXT_robustness2:

api: proc loadVK_EXT_robustness2(instance: VkInstance)

loadVK_EXT_sample_locations:

api: proc loadVK_EXT_sample_locations(instance: VkInstance)

loadVK_EXT_shader_atomic_float:

api: proc loadVK_EXT_shader_atomic_float(instance: VkInstance)

loadVK_EXT_shader_atomic_float2:

api: proc loadVK_EXT_shader_atomic_float2(instance: VkInstance)

loadVK_EXT_shader_image_atomic_int64:

api: proc loadVK_EXT_shader_image_atomic_int64(instance: VkInstance)

loadVK_EXT_shader_module_identifier:

api: proc loadVK_EXT_shader_module_identifier(instance: VkInstance)

loadVK_EXT_shader_stencil_export:

api: proc loadVK_EXT_shader_stencil_export(instance: VkInstance)

loadVK_EXT_shader_subgroup_ballot:

api: proc loadVK_EXT_shader_subgroup_ballot(instance: VkInstance)

loadVK_EXT_shader_subgroup_vote:

api: proc loadVK_EXT_shader_subgroup_vote(instance: VkInstance)

loadVK_EXT_subpass_merge_feedback:

api: proc loadVK_EXT_subpass_merge_feedback(instance: VkInstance)

loadVK_EXT_surface_maintenance1:

api: proc loadVK_EXT_surface_maintenance1(instance: VkInstance)

loadVK_EXT_swapchain_colorspace:

api: proc loadVK_EXT_swapchain_colorspace(instance: VkInstance)

loadVK_EXT_swapchain_maintenance1:

api: proc loadVK_EXT_swapchain_maintenance1(instance: VkInstance)

loadVK_EXT_transform_feedback:

api: proc loadVK_EXT_transform_feedback(instance: VkInstance)

loadVK_EXT_validation_cache:

api: proc loadVK_EXT_validation_cache(instance: VkInstance)

loadVK_EXT_validation_features:

api: proc loadVK_EXT_validation_features(instance: VkInstance)

loadVK_EXT_validation_flags:

api: proc loadVK_EXT_validation_flags(instance: VkInstance)

loadVK_EXT_vertex_attribute_divisor:

api: proc loadVK_EXT_vertex_attribute_divisor(instance: VkInstance)

loadVK_EXT_vertex_input_dynamic_state:

api: proc loadVK_EXT_vertex_input_dynamic_state(instance: VkInstance)

loadVK_EXT_ycbcr_image_arrays:

api: proc loadVK_EXT_ycbcr_image_arrays(instance: VkInstance)

loadVK_GOOGLE_decorate_string:

api: proc loadVK_GOOGLE_decorate_string(instance: VkInstance)

loadVK_GOOGLE_display_timing:

api: proc loadVK_GOOGLE_display_timing(instance: VkInstance)

loadVK_GOOGLE_hlsl_functionality1:

api: proc loadVK_GOOGLE_hlsl_functionality1(instance: VkInstance)

loadVK_GOOGLE_surfaceless_query:

api: proc loadVK_GOOGLE_surfaceless_query(instance: VkInstance)

loadVK_GOOGLE_user_type:

api: proc loadVK_GOOGLE_user_type(instance: VkInstance)

loadVK_HUAWEI_cluster_culling_shader:

api: proc loadVK_HUAWEI_cluster_culling_shader(instance: VkInstance)

loadVK_HUAWEI_invocation_mask:

api: proc loadVK_HUAWEI_invocation_mask(instance: VkInstance)

loadVK_HUAWEI_subpass_shading:

api: proc loadVK_HUAWEI_subpass_shading(instance: VkInstance)

loadVK_IMG_filter_cubic:

api: proc loadVK_IMG_filter_cubic(instance: VkInstance)

loadVK_IMG_format_pvrtc:

api: proc loadVK_IMG_format_pvrtc(instance: VkInstance)

loadVK_INTEL_performance_query:

api: proc loadVK_INTEL_performance_query(instance: VkInstance)

loadVK_INTEL_shader_integer_functions2:

api: proc loadVK_INTEL_shader_integer_functions2(instance: VkInstance)

loadVK_KHR_acceleration_structure:

api: proc loadVK_KHR_acceleration_structure(instance: VkInstance)

loadVK_KHR_deferred_host_operations:

api: proc loadVK_KHR_deferred_host_operations(instance: VkInstance)

loadVK_KHR_display:

api: proc loadVK_KHR_display(instance: VkInstance)

loadVK_KHR_display_swapchain:

api: proc loadVK_KHR_display_swapchain(instance: VkInstance)

loadVK_KHR_external_fence_fd:

api: proc loadVK_KHR_external_fence_fd(instance: VkInstance)

loadVK_KHR_external_memory_fd:

api: proc loadVK_KHR_external_memory_fd(instance: VkInstance)

loadVK_KHR_external_semaphore_fd:

api: proc loadVK_KHR_external_semaphore_fd(instance: VkInstance)

loadVK_KHR_fragment_shader_barycentric:

api: proc loadVK_KHR_fragment_shader_barycentric(instance: VkInstance)

loadVK_KHR_fragment_shading_rate:

api: proc loadVK_KHR_fragment_shading_rate(instance: VkInstance)

loadVK_KHR_get_display_properties2:

api: proc loadVK_KHR_get_display_properties2(instance: VkInstance)

loadVK_KHR_get_surface_capabilities2:

api: proc loadVK_KHR_get_surface_capabilities2(instance: VkInstance)

loadVK_KHR_global_priority:

api: proc loadVK_KHR_global_priority(instance: VkInstance)

loadVK_KHR_incremental_present:

api: proc loadVK_KHR_incremental_present(instance: VkInstance)

loadVK_KHR_performance_query:

api: proc loadVK_KHR_performance_query(instance: VkInstance)

loadVK_KHR_pipeline_executable_properties:

api: proc loadVK_KHR_pipeline_executable_properties(instance: VkInstance)

loadVK_KHR_pipeline_library:

api: proc loadVK_KHR_pipeline_library(instance: VkInstance)

loadVK_KHR_portability_enumeration:

api: proc loadVK_KHR_portability_enumeration(instance: VkInstance)

loadVK_KHR_present_id:

api: proc loadVK_KHR_present_id(instance: VkInstance)

loadVK_KHR_present_wait:

api: proc loadVK_KHR_present_wait(instance: VkInstance)

loadVK_KHR_push_descriptor:

api: proc loadVK_KHR_push_descriptor(instance: VkInstance)

loadVK_KHR_ray_query:

api: proc loadVK_KHR_ray_query(instance: VkInstance)

loadVK_KHR_ray_tracing_maintenance1:

api: proc loadVK_KHR_ray_tracing_maintenance1(instance: VkInstance)

loadVK_KHR_ray_tracing_pipeline:

api: proc loadVK_KHR_ray_tracing_pipeline(instance: VkInstance)

loadVK_KHR_shader_clock:

api: proc loadVK_KHR_shader_clock(instance: VkInstance)

loadVK_KHR_shader_subgroup_uniform_control_flow:

api: proc loadVK_KHR_shader_subgroup_uniform_control_flow(instance: VkInstance)

loadVK_KHR_shared_presentable_image:

api: proc loadVK_KHR_shared_presentable_image(instance: VkInstance)

loadVK_KHR_surface:

api: proc loadVK_KHR_surface(instance: VkInstance)

loadVK_KHR_surface_protected_capabilities:

api: proc loadVK_KHR_surface_protected_capabilities(instance: VkInstance)

loadVK_KHR_swapchain:

api: proc loadVK_KHR_swapchain(instance: VkInstance)

loadVK_KHR_swapchain_mutable_format:

api: proc loadVK_KHR_swapchain_mutable_format(instance: VkInstance)

loadVK_KHR_workgroup_memory_explicit_layout:

api: proc loadVK_KHR_workgroup_memory_explicit_layout(instance: VkInstance)

loadVK_LUNARG_direct_driver_loading:

api: proc loadVK_LUNARG_direct_driver_loading(instance: VkInstance)

loadVK_NV_clip_space_w_scaling:

api: proc loadVK_NV_clip_space_w_scaling(instance: VkInstance)

loadVK_NV_compute_shader_derivatives:

api: proc loadVK_NV_compute_shader_derivatives(instance: VkInstance)

loadVK_NV_cooperative_matrix:

api: proc loadVK_NV_cooperative_matrix(instance: VkInstance)

loadVK_NV_copy_memory_indirect:

api: proc loadVK_NV_copy_memory_indirect(instance: VkInstance)

loadVK_NV_corner_sampled_image:

api: proc loadVK_NV_corner_sampled_image(instance: VkInstance)

loadVK_NV_coverage_reduction_mode:

api: proc loadVK_NV_coverage_reduction_mode(instance: VkInstance)

loadVK_NV_dedicated_allocation:

api: proc loadVK_NV_dedicated_allocation(instance: VkInstance)

loadVK_NV_dedicated_allocation_image_aliasing:

api: proc loadVK_NV_dedicated_allocation_image_aliasing(instance: VkInstance)

loadVK_NV_device_diagnostic_checkpoints:

api: proc loadVK_NV_device_diagnostic_checkpoints(instance: VkInstance)

loadVK_NV_device_diagnostics_config:

api: proc loadVK_NV_device_diagnostics_config(instance: VkInstance)

loadVK_NV_device_generated_commands:

api: proc loadVK_NV_device_generated_commands(instance: VkInstance)

loadVK_NV_external_memory:

api: proc loadVK_NV_external_memory(instance: VkInstance)

loadVK_NV_external_memory_capabilities:

api: proc loadVK_NV_external_memory_capabilities(instance: VkInstance)

loadVK_NV_external_memory_rdma:

api: proc loadVK_NV_external_memory_rdma(instance: VkInstance)

loadVK_NV_fill_rectangle:

api: proc loadVK_NV_fill_rectangle(instance: VkInstance)

loadVK_NV_fragment_coverage_to_color:

api: proc loadVK_NV_fragment_coverage_to_color(instance: VkInstance)

loadVK_NV_fragment_shading_rate_enums:

api: proc loadVK_NV_fragment_shading_rate_enums(instance: VkInstance)

loadVK_NV_framebuffer_mixed_samples:

api: proc loadVK_NV_framebuffer_mixed_samples(instance: VkInstance)

loadVK_NV_geometry_shader_passthrough:

api: proc loadVK_NV_geometry_shader_passthrough(instance: VkInstance)

loadVK_NV_glsl_shader:

api: proc loadVK_NV_glsl_shader(instance: VkInstance)

loadVK_NV_inherited_viewport_scissor:

api: proc loadVK_NV_inherited_viewport_scissor(instance: VkInstance)

loadVK_NV_linear_color_attachment:

api: proc loadVK_NV_linear_color_attachment(instance: VkInstance)

loadVK_NV_memory_decompression:

api: proc loadVK_NV_memory_decompression(instance: VkInstance)

loadVK_NV_mesh_shader:

api: proc loadVK_NV_mesh_shader(instance: VkInstance)

loadVK_NV_optical_flow:

api: proc loadVK_NV_optical_flow(instance: VkInstance)

loadVK_NV_present_barrier:

api: proc loadVK_NV_present_barrier(instance: VkInstance)

loadVK_NV_ray_tracing:

api: proc loadVK_NV_ray_tracing(instance: VkInstance)

loadVK_NV_ray_tracing_invocation_reorder:

api: proc loadVK_NV_ray_tracing_invocation_reorder(instance: VkInstance)

loadVK_NV_ray_tracing_motion_blur:

api: proc loadVK_NV_ray_tracing_motion_blur(instance: VkInstance)

loadVK_NV_representative_fragment_test:

api: proc loadVK_NV_representative_fragment_test(instance: VkInstance)

loadVK_NV_sample_mask_override_coverage:

api: proc loadVK_NV_sample_mask_override_coverage(instance: VkInstance)

loadVK_NV_scissor_exclusive:

api: proc loadVK_NV_scissor_exclusive(instance: VkInstance)

loadVK_NV_shader_image_footprint:

api: proc loadVK_NV_shader_image_footprint(instance: VkInstance)

loadVK_NV_shader_sm_builtins:

api: proc loadVK_NV_shader_sm_builtins(instance: VkInstance)

loadVK_NV_shader_subgroup_partitioned:

api: proc loadVK_NV_shader_subgroup_partitioned(instance: VkInstance)

loadVK_NV_shading_rate_image:

api: proc loadVK_NV_shading_rate_image(instance: VkInstance)

loadVK_NV_viewport_array2:

api: proc loadVK_NV_viewport_array2(instance: VkInstance)

loadVK_NV_viewport_swizzle:

api: proc loadVK_NV_viewport_swizzle(instance: VkInstance)

loadVK_NVX_binary_import:

api: proc loadVK_NVX_binary_import(instance: VkInstance)

loadVK_NVX_image_view_handle:

api: proc loadVK_NVX_image_view_handle(instance: VkInstance)

loadVK_NVX_multiview_per_view_attributes:

api: proc loadVK_NVX_multiview_per_view_attributes(instance: VkInstance)

loadVK_QCOM_fragment_density_map_offset:

api: proc loadVK_QCOM_fragment_density_map_offset(instance: VkInstance)

loadVK_QCOM_image_processing:

api: proc loadVK_QCOM_image_processing(instance: VkInstance)

loadVK_QCOM_multiview_per_view_render_areas:

api: proc loadVK_QCOM_multiview_per_view_render_areas(instance: VkInstance)

loadVK_QCOM_multiview_per_view_viewports:

api: proc loadVK_QCOM_multiview_per_view_viewports(instance: VkInstance)

loadVK_QCOM_render_pass_shader_resolve:

api: proc loadVK_QCOM_render_pass_shader_resolve(instance: VkInstance)

loadVK_QCOM_render_pass_store_ops:

api: proc loadVK_QCOM_render_pass_store_ops(instance: VkInstance)

loadVK_QCOM_render_pass_transform:

api: proc loadVK_QCOM_render_pass_transform(instance: VkInstance)

loadVK_QCOM_rotated_copy_commands:

api: proc loadVK_QCOM_rotated_copy_commands(instance: VkInstance)

loadVK_QCOM_tile_properties:

api: proc loadVK_QCOM_tile_properties(instance: VkInstance)

loadVK_SEC_amigo_profiling:

api: proc loadVK_SEC_amigo_profiling(instance: VkInstance)

loadVK_VALVE_descriptor_set_host_mapping:

api: proc loadVK_VALVE_descriptor_set_host_mapping(instance: VkInstance)

loadVK_VERSION_1_0:

api: proc loadVK_VERSION_1_0(instance: VkInstance)

loadVK_VERSION_1_1:

api: proc loadVK_VERSION_1_1(instance: VkInstance)

loadVK_VERSION_1_2:

api: proc loadVK_VERSION_1_2(instance: VkInstance)

loadVK_VERSION_1_3:

api: proc loadVK_VERSION_1_3(instance: VkInstance)

loadVulkan:

api: proc loadVulkan(instance: VkInstance)

LockMapIndex:

x: const LockMapIndex

LockMask:

x: const LockMask

lockMouse:

input: proc lockMouse(value: bool)

LostFocus:

events: EventType.LostFocus

LowerHighest:

x: const LowerHighest

LSBFirst:

x: const LSBFirst

manhattan:

mapAction:

MapNotify:

x: const MapNotify

MappingBusy:

x: const MappingBusy

MappingFailed:

x: const MappingFailed

MappingKeyboard:

x: const MappingKeyboard

MappingModifier:

x: const MappingModifier

MappingNotify:

x: const MappingNotify

MappingPointer:

x: const MappingPointer

MappingSuccess:

x: const MappingSuccess

MapRequest:

x: const MapRequest

Mask:

x: type Mask

Mat2:

core: type Mat2

Mat23:

core: type Mat23

Mat3:

core: type Mat3

Mat32:

core: type Mat32

Mat34:

core: type Mat34

Mat4:

core: type Mat4

Mat43:

core: type Mat43

MaterialAttributeNames:

gltf: object MaterialAttributeNames

MaxCmapsOfScreen:

xlib: proc MaxCmapsOfScreen(s: PScreen): cint

maxFramebufferSampleCount:

rendering: proc maxFramebufferSampleCount(maxSamples = VK_SAMPLE_COUNT_8_BIT): VkSampleCountFlagBits

MemoryBlock:

rendering: object MemoryBlock

MeshAttributeNames:

gltf: object MeshAttributeNames

MinCmapsOfScreen:

xlib: proc MinCmapsOfScreen(s: PScreen): cint

MinimizedWindow:

events: EventType.MinimizedWindow

Mixer:

mixer_module: object Mixer

mixer:

mixer_module: var mixer

Mod1MapIndex:

x: const Mod1MapIndex

Mod1Mask:

x: const Mod1Mask

Mod2MapIndex:

x: const Mod2MapIndex

Mod2Mask:

x: const Mod2Mask

Mod3MapIndex:

x: const Mod3MapIndex

Mod3Mask:

x: const Mod3Mask

Mod4MapIndex:

x: const Mod4MapIndex

Mod4Mask:

x: const Mod4Mask

Mod5MapIndex:

x: const Mod5MapIndex

Mod5Mask:

x: const Mod5Mask

MotionNotify:

x: const MotionNotify

MouseButton:

events: enum MouseButton

mouseIsDown:

input: proc mouseIsDown(button: MouseButton): bool

mouseMove:

input: proc mouseMove(): Vec2i

mousePosition:

input: proc mousePosition(): Vec2f

mousePositionPixel:

input: proc mousePositionPixel(): Vec2i

MousePressed:

events: EventType.MousePressed

mousePressedButtons:

input: proc mousePressedButtons(): set[MouseButton]

MouseReleased:

events: EventType.MouseReleased

mouseReleasedButtons:

input: proc mouseReleasedButtons(): set[MouseButton]

mouseWasPressed:

mouseWasReleased:

MouseWheel:

events: EventType.MouseWheel

mouseWheel:

input: proc mouseWheel(): float32

mprintf:

sqlite3: proc mprintf(para1: cstring): cstring

MSBFirst:

x: const MSBFirst

MTLBuffer_id:

api: object MTLBuffer_id

MTLCommandQueue_id:

api: object MTLCommandQueue_id

MTLDevice_id:

api: object MTLDevice_id

MTLSharedEvent_id:

api: object MTLSharedEvent_id

MTLTexture_id:

api: object MTLTexture_id

nativeFree:

core: proc nativeFree(p: pointer)

NativeSoundDevice:

mixer_module: object NativeSoundDevice

NativeWindow:

rendering: object NativeWindow

NewKeyboard:

xi: const NewKeyboard

NewPointer:

xi: const NewPointer

NextRequest:

xlib: proc NextRequest(dpy: PDisplay): culong

NimBool2VkBool:

api: converter NimBool2VkBool(a: bool): VkBool32

nLayers:

image: template nLayers(image: Image): untyped

NoEventMask:

x: const NoEventMask

NoExpose:

x: const NoExpose

noExtensionEvent:

xi: const noExtensionEvent

Nonconvex:

x: const Nonconvex

None:

x: const None

normal:

core: proc normal[T: SomeFloat](vec: TVec2[T]): auto

normalized:

NormalState:

xutil: const NormalState

NorthEastGravity:

x: const NorthEastGravity

NorthGravity:

x: const NorthGravity

NorthWestGravity:

x: const NorthWestGravity

NoSuchExtension:

xi: const NoSuchExtension

NoSymbol:

x: const NoSymbol

NotifyAncestor:

x: const NotifyAncestor

NotifyDetailNone:

x: const NotifyDetailNone

NotifyGrab:

x: const NotifyGrab

NotifyHint:

x: const NotifyHint

NotifyInferior:

x: const NotifyInferior

NotifyNonlinear:

x: const NotifyNonlinear

NotifyNonlinearVirtual:

x: const NotifyNonlinearVirtual

NotifyNormal:

x: const NotifyNormal

NotifyPointer:

x: const NotifyPointer

NotifyPointerRoot:

x: const NotifyPointerRoot

NotifyUngrab:

x: const NotifyUngrab

NotifyVirtual:

x: const NotifyVirtual

NotifyWhileGrabbed:

x: const NotifyWhileGrabbed

NotUseful:

x: const NotUseful

NoValue:

xutil: const NoValue

O:

core: const O

Oi:

core: const Oi

Oi8:

core: const Oi8

open:

open16:

sqlite3: proc open16(filename: pointer; ppDb: var PSqlite3): int32

OpenMode:

mixer_module: enum OpenMode

OpenSoundDevice:

mixer_module: proc OpenSoundDevice(sampleRate: uint32; buffers: seq[ptr SoundData]): NativeSoundDevice

Opposite:

x: const Opposite

ortho:

core: proc ortho(left, right, top, bottom, zNear, zFar: float32): Mat4

OtherClass:

xi: const OtherClass

OutOfProximity:

xi: const OutOfProximity

OwnerGrabButtonMask:

x: const OwnerGrabButtonMask

pack:

texture_packing: proc pack[T: PixelType](images: seq[Image[T]]): tuple[atlas: Image[T], coords: seq[tuple[x: uint32, y: uint32]]]

packages:

resources: proc packages(): seq[string]

PACKAGETYPE:

core: const PACKAGETYPE

PAllHints:

xutil: const PAllHints

ParentRelative:

x: const ParentRelative

PAspect:

xutil: const PAspect

Pass:

rendering: template Pass()

PassFlat:

rendering: template PassFlat()

PAtom:

x: type PAtom

pause:

PBaseSize:

xutil: const PBaseSize

PBool:

xlib: type PBool

PByte:

xkb: type PByte

Pcint:

xlib: type Pcint

PCMFormat:

mixer_module: enum PCMFormat

PColormap:

x: type PColormap

Pcontext:

sqlite3: type Pcontext

Pcuchar:

xlib: type Pcuchar

Pcuint:

xlib: type Pcuint

Pculong:

xlib: type Pculong

PCursor:

x: type PCursor

Pcushort:

xlib: type Pcushort

PDepth:

xlib: type PDepth

PDisplay:

xlib: type PDisplay

PDrawable:

x: type PDrawable

pendingEvents:

rendering: proc pendingEvents(window: NativeWindow): seq[Event]

perlin:

noise: proc perlin(pos: Vec2f; seed: uint64 = 0): float32

PFN_vkAllocationFunction:

api: type PFN_vkAllocationFunction

PFN_vkDebugReportCallbackEXT:

api: type PFN_vkDebugReportCallbackEXT

PFN_vkDebugUtilsMessengerCallbackEXT:

api: type PFN_vkDebugUtilsMessengerCallbackEXT

PFN_vkDeviceMemoryReportCallbackEXT:

api: type PFN_vkDeviceMemoryReportCallbackEXT

PFN_vkFaultCallbackFunction:

api: type PFN_vkFaultCallbackFunction

PFN_vkFreeFunction:

api: type PFN_vkFreeFunction

PFN_vkGetInstanceProcAddrLUNARG:

api: type PFN_vkGetInstanceProcAddrLUNARG

PFN_vkInternalAllocationNotification:

api: type PFN_vkInternalAllocationNotification

PFN_vkInternalFreeNotification:

api: type PFN_vkInternalFreeNotification

PFN_vkReallocationFunction:

api: type PFN_vkReallocationFunction

PFN_vkVoidFunction:

api: type PFN_vkVoidFunction

PFont:

x: type PFont

PGC:

xlib: type PGC

PGContext:

x: type PGContext

Pipeline:

rendering: object Pipeline

PixelType:

image: type PixelType

Pixmap:

x: type Pixmap

PKeyCode:

x: type PKeyCode

PKeySym:

x: type PKeySym

PlaceOnBottom:

x: const PlaceOnBottom

PlaceOnTop:

x: const PlaceOnTop

PlanesOfScreen:

xlib: proc PlanesOfScreen(s: PScreen): cint

play:

PMask:

x: type PMask

PMaxSize:

xutil: const PMaxSize

PMinSize:

xutil: const PMinSize

PointerMotionHintMask:

x: const PointerMotionHintMask

PointerMotionMask:

x: const PointerMotionMask

PointerRoot:

x: const PointerRoot

PointerWindow:

x: const PointerWindow

Points:

collision: ColliderType.Points

pow:

PPAtom:

x: type PPAtom

PPChar:

xlib: type PPChar

PPcint:

xlib: type PPcint

PPcuchar:

xlib: type PPcuchar

PPixmap:

x: type PPixmap

PPosition:

xutil: const PPosition

PPPChar:

xlib: type PPPChar

PPPXFontStruct:

xlib: type PPPXFontStruct

PPSqlite3:

sqlite3: type PPSqlite3

PPSqlite3_Backup:

sqlite3: type PPSqlite3_Backup

PPWindow:

x: type PPWindow

PPXExtData:

xlib: type PPXExtData

PPXFontStruct:

xlib: type PPXFontStruct

PPXIconSize:

xutil: type PPXIconSize

PPXStandardColormap:

xutil: type PPXStandardColormap

PreferBlanking:

x: const PreferBlanking

PRegion:

xutil: type PRegion

prepare:

prepare16:

sqlite3: proc prepare16(db: PSqlite3; zSql: pointer; nBytes: int32; ppStmt: var PStmt; pzTail: var pointer): int32

prepare_v2:

sqlite3: proc prepare_v2(db: PSqlite3; zSql: cstring; nByte: cint; ppStmt: var PStmt; pzTail: ptr cstring): cint

PResizeInc:

xutil: const PResizeInc

Private:

xlib: object Private

progress_handler:

sqlite3: proc progress_handler(para1: PSqlite3; para2: int32; para3: proc (para1: pointer): int32 {.cdecl.}; para4: pointer)

projection:

core: proc projection(fovy, aspect, zNear, zFar: float32): Mat4

PropertyChangeMask:

x: const PropertyChangeMask

PropertyDelete:

x: const PropertyDelete

PropertyNewValue:

x: const PropertyNewValue

PropertyNotify:

x: const PropertyNotify

PropModeAppend:

x: const PropModeAppend

PropModePrepend:

x: const PropModePrepend

PropModeReplace:

x: const PropModeReplace

ProtocolRevision:

xlib: proc ProtocolRevision(dpy: PDisplay): cint

ProtocolVersion:

xlib: proc ProtocolVersion(dpy: PDisplay): cint

ProximityClass:

xi: const ProximityClass

ProximityState:

xi: const ProximityState

PScreen:

xlib: type PScreen

PScreenFormat:

xlib: type PScreenFormat

PseudoColor:

x: const PseudoColor

PSize:

xutil: const PSize

PSqlite3:

sqlite3: type PSqlite3

PSqlite3_Backup:

sqlite3: type PSqlite3_Backup

PStatus:

xlib: type PStatus

PStmt:

sqlite3: type PStmt

PTime:

x: type PTime

PtrFeedbackClass:

xi: const PtrFeedbackClass

purge:

storage: proc purge(storageType: StorageType)

PushConstant:

rendering: template PushConstant()

PValue:

sqlite3: type PValue

PValueArg:

sqlite3: type PValueArg

PVisual:

xlib: type PVisual

PVisualID:

x: type PVisualID

PWideChar:

xlib: type PWideChar

PWindow:

x: type PWindow

PWinGravity:

xutil: const PWinGravity

PWord:

xkb: type PWord

PXAnyEvent:

xlib: type PXAnyEvent

PXArc:

xlib: type PXArc

PXButtonEvent:

xlib: type PXButtonEvent

PXButtonPressedEvent:

xlib: type PXButtonPressedEvent

PXButtonReleasedEvent:

xlib: type PXButtonReleasedEvent

PXChar2b:

xlib: type PXChar2b

PXCharStruct:

xlib: type PXCharStruct

PXCirculateEvent:

xlib: type PXCirculateEvent

PXCirculateRequestEvent:

xlib: type PXCirculateRequestEvent

PXClassHint:

xutil: type PXClassHint

PXClientMessageEvent:

xlib: type PXClientMessageEvent

PXColor:

xlib: type PXColor

PXColormapEvent:

xlib: type PXColormapEvent

PXComposeStatus:

xutil: type PXComposeStatus

PXConfigureEvent:

xlib: type PXConfigureEvent

PXConfigureRequestEvent:

xlib: type PXConfigureRequestEvent

PXContext:

xutil: type PXContext

PXCreateWindowEvent:

xlib: type PXCreateWindowEvent

PXCrossingEvent:

xlib: type PXCrossingEvent

PXDestroyWindowEvent:

xlib: type PXDestroyWindowEvent

PXDisplay:

xlib: type PXDisplay

PXEDataObject:

xlib: type PXEDataObject

PXEnterWindowEvent:

xlib: type PXEnterWindowEvent

PXErrorEvent:

xlib: type PXErrorEvent

PXEvent:

xlib: type PXEvent

PXExposeEvent:

xlib: type PXExposeEvent

PXExtCodes:

xlib: type PXExtCodes

PXExtData:

xlib: type PXExtData

PXExtensionVersion:

xi: type PXExtensionVersion

PXFocusChangeEvent:

xlib: type PXFocusChangeEvent

PXFocusInEvent:

xlib: type PXFocusInEvent

PXFocusOutEvent:

xlib: type PXFocusOutEvent

PXFontProp:

xlib: type PXFontProp

PXFontSet:

xlib: type PXFontSet

PXFontSetExtents:

xlib: type PXFontSetExtents

PXFontStruct:

xlib: type PXFontStruct

PXGC:

xlib: type PXGC

PXGCValues:

xlib: type PXGCValues

PXGenericEvent:

xlib: type PXGenericEvent

PXGenericEventCookie:

xlib: type PXGenericEventCookie

PXGraphicsExposeEvent:

xlib: type PXGraphicsExposeEvent

PXGravityEvent:

xlib: type PXGravityEvent

PXHostAddress:

xlib: type PXHostAddress

PXICCallback:

xlib: type PXICCallback

PXICCEncodingStyle:

xutil: type PXICCEncodingStyle

PXIconSize:

xutil: type PXIconSize

PXID:

x: type PXID

PXImage:

xlib: type PXImage

PXIMCallback:

xlib: type PXIMCallback

PXIMCaretDirection:

xlib: type PXIMCaretDirection

PXIMCaretStyle:

xlib: type PXIMCaretStyle

PXIMFeedback:

xlib: type PXIMFeedback

PXIMHotKeyState:

xlib: type PXIMHotKeyState

PXIMHotKeyTrigger:

xlib: type PXIMHotKeyTrigger

PXIMHotKeyTriggers:

xlib: type PXIMHotKeyTriggers

PXIMPreeditCaretCallbackStruct:

xlib: type PXIMPreeditCaretCallbackStruct

PXIMPreeditDrawCallbackStruct:

xlib: type PXIMPreeditDrawCallbackStruct

PXIMPreeditState:

xlib: type PXIMPreeditState

PXIMPreeditStateNotifyCallbackStruct:

xlib: type PXIMPreeditStateNotifyCallbackStruct

PXIMResetState:

xlib: type PXIMResetState

PXIMStatusDataType:

xlib: type PXIMStatusDataType

PXIMStatusDrawCallbackStruct:

xlib: type PXIMStatusDrawCallbackStruct

PXIMStringConversionCallbackStruct:

xlib: type PXIMStringConversionCallbackStruct

PXIMStringConversionFeedback:

xlib: type PXIMStringConversionFeedback

PXIMStringConversionOperation:

xlib: type PXIMStringConversionOperation

PXIMStringConversionPosition:

xlib: type PXIMStringConversionPosition

PXIMStringConversionText:

xlib: type PXIMStringConversionText

PXIMStringConversionType:

xlib: type PXIMStringConversionType

PXIMStyle:

xlib: type PXIMStyle

PXIMStyles:

xlib: type PXIMStyles

PXIMText:

xlib: type PXIMText

PXIMValuesList:

xlib: type PXIMValuesList

PXkbAccessXNotifyEvent:

xkblib: type PXkbAccessXNotifyEvent

PXkbAction:

xkb: type PXkbAction

PXkbActionMessageEvent:

xkblib: type PXkbActionMessageEvent

PXkbAnyAction:

xkb: type PXkbAnyAction

PXkbAnyDoodadPtr:

xkb: type PXkbAnyDoodadPtr

PXkbAnyEvent:

xkblib: type PXkbAnyEvent

PXkbBehavior:

xkb: type PXkbBehavior

PXkbBellNotifyEvent:

xkblib: type PXkbBellNotifyEvent

PXkbBoundsPtr:

xkb: type PXkbBoundsPtr

PXkbChangesPtr:

xkb: type PXkbChangesPtr

PXkbClientMapPtr:

xkb: type PXkbClientMapPtr

PXkbColorPtr:

xkb: type PXkbColorPtr

PXkbCompatChangesPtr:

xkb: type PXkbCompatChangesPtr

PXkbCompatMapNotifyEvent:

xkblib: type PXkbCompatMapNotifyEvent

PXkbCompatMapPtr:

xkb: type PXkbCompatMapPtr

PXkbComponentListPtr:

xkb: type PXkbComponentListPtr

PXkbComponentNamePtr:

xkb: type PXkbComponentNamePtr

PXkbComponentNamesPtr:

xkb: type PXkbComponentNamesPtr

PXkbControlsChangesPtr:

xkb: type PXkbControlsChangesPtr

PXkbControlsNotifyEvent:

xkblib: type PXkbControlsNotifyEvent

PXkbControlsPtr:

xkb: type PXkbControlsPtr

PXkbCtrlsAction:

xkb: type PXkbCtrlsAction

PXkbDescPtr:

xkb: type PXkbDescPtr

PXkbDeviceBtnAction:

xkb: type PXkbDeviceBtnAction

PXkbDeviceChangesPtr:

xkb: type PXkbDeviceChangesPtr

PXkbDeviceInfoPtr:

xkb: type PXkbDeviceInfoPtr

PXkbDeviceLedChangesPtr:

xkb: type PXkbDeviceLedChangesPtr

PXkbDeviceLedInfoPtr:

xkb: type PXkbDeviceLedInfoPtr

PXkbDeviceValuatorAction:

xkb: type PXkbDeviceValuatorAction

PXkbDoodadPtr:

xkb: type PXkbDoodadPtr

PXkbEvent:

xkblib: type PXkbEvent

PXkbExtensionDeviceNotifyEvent:

xkblib: type PXkbExtensionDeviceNotifyEvent

PXkbGeometryPtr:

xkb: type PXkbGeometryPtr

PXkbGeometryRec:

xkb: type PXkbGeometryRec

PXkbGeometrySizesPtr:

xkb: type PXkbGeometrySizesPtr

PXkbGroupAction:

xkb: type PXkbGroupAction

PXkbIndicatorChangesPtr:

xkb: type PXkbIndicatorChangesPtr

PXkbIndicatorDoodadPtr:

xkb: type PXkbIndicatorDoodadPtr

PXkbIndicatorMapPtr:

xkb: type PXkbIndicatorMapPtr

PXkbIndicatorNotifyEvent:

xkblib: type PXkbIndicatorNotifyEvent

PXkbIndicatorPtr:

xkb: type PXkbIndicatorPtr

PXkbISOAction:

xkb: type PXkbISOAction

PXkbKbdDpyStatePtr:

xkblib: type PXkbKbdDpyStatePtr

PXkbKeyAliasPtr:

xkb: type PXkbKeyAliasPtr

PXkbKeyNamePtr:

xkb: type PXkbKeyNamePtr

PXkbKeyPtr:

xkb: type PXkbKeyPtr

PXkbKeyTypePtr:

xkb: type PXkbKeyTypePtr

PXkbKTMapEntryPtr:

xkb: type PXkbKTMapEntryPtr

PXkbLogoDoodadPtr:

xkb: type PXkbLogoDoodadPtr

PXkbMapChangesPtr:

xkb: type PXkbMapChangesPtr

PXkbMapNotifyEvent:

xkblib: type PXkbMapNotifyEvent

PXkbMessageAction:

xkb: type PXkbMessageAction

PXkbModAction:

xkb: type PXkbModAction

PXkbModsPtr:

xkb: type PXkbModsPtr

PXkbNameChangesPtr:

xkb: type PXkbNameChangesPtr

PXkbNamesNotifyEvent:

xkblib: type PXkbNamesNotifyEvent

PXkbNamesPtr:

xkb: type PXkbNamesPtr

PXkbNewKeyboardNotifyEvent:

xkblib: type PXkbNewKeyboardNotifyEvent

PXkbOutlinePtr:

xkb: type PXkbOutlinePtr

PXkbOverlayKeyPtr:

xkb: type PXkbOverlayKeyPtr

PXkbOverlayPtr:

xkb: type PXkbOverlayPtr

PXkbOverlayRowPtr:

xkb: type PXkbOverlayRowPtr

PXkbPointPtr:

xkb: type PXkbPointPtr

PXkbPropertyPtr:

xkb: type PXkbPropertyPtr

PXkbPtrAction:

xkb: type PXkbPtrAction

PXkbPtrBtnAction:

xkb: type PXkbPtrBtnAction

PXkbPtrDfltAction:

xkb: type PXkbPtrDfltAction

PXkbRedirectKeyAction:

xkb: type PXkbRedirectKeyAction

PXkbRowPtr:

xkb: type PXkbRowPtr

PXkbSectionPtr:

xkb: type PXkbSectionPtr

PXkbServerMapPtr:

xkb: type PXkbServerMapPtr

PXkbShapeDoodadPtr:

xkb: type PXkbShapeDoodadPtr

PXkbShapePtr:

xkb: type PXkbShapePtr

PXkbStateNotifyEvent:

xkblib: type PXkbStateNotifyEvent

PXkbStatePtr:

xkb: type PXkbStatePtr

PXkbSwitchScreenAction:

xkb: type PXkbSwitchScreenAction

PXkbSymInterpretPtr:

xkb: type PXkbSymInterpretPtr

PXkbSymMapPtr:

xkb: type PXkbSymMapPtr

PXkbTextDoodadPtr:

xkb: type PXkbTextDoodadPtr

PXKeyboardControl:

xlib: type PXKeyboardControl

PXKeyboardState:

xlib: type PXKeyboardState

PXKeyEvent:

xlib: type PXKeyEvent

PXKeymapEvent:

xlib: type PXKeymapEvent

PXKeyPressedEvent:

xlib: type PXKeyPressedEvent

PXKeyReleasedEvent:

xlib: type PXKeyReleasedEvent

PXLeaveWindowEvent:

xlib: type PXLeaveWindowEvent

PXMapEvent:

xlib: type PXMapEvent

PXMappingEvent:

xlib: type PXMappingEvent

PXMapRequestEvent:

xlib: type PXMapRequestEvent

PXmbTextItem:

xlib: type PXmbTextItem

PXModifierKeymap:

xlib: type PXModifierKeymap

PXMotionEvent:

xlib: type PXMotionEvent

PXNoExposeEvent:

xlib: type PXNoExposeEvent

PXOC:

xlib: type PXOC

PXOM:

xlib: type PXOM

PXOMCharSetList:

xlib: type PXOMCharSetList

PXOMFontInfo:

xlib: type PXOMFontInfo

PXOMOrientation:

xlib: type PXOMOrientation

PXOrientation:

xlib: type PXOrientation

PXPixmapFormatValues:

xlib: type PXPixmapFormatValues

PXPoint:

xlib: type PXPoint

PXPointer:

xlib: type PXPointer

PXPointerMovedEvent:

xlib: type PXPointerMovedEvent

PXPrivate:

xlib: type PXPrivate

PXPrivDisplay:

xlib: type PXPrivDisplay

PXPropertyEvent:

xlib: type PXPropertyEvent

PXRectangle:

xlib: type PXRectangle

PXRegion:

xutil: type PXRegion

PXReparentEvent:

xlib: type PXReparentEvent

PXResizeRequestEvent:

xlib: type PXResizeRequestEvent

PXrmHashBucketRec:

xlib: type PXrmHashBucketRec

PXSegment:

xlib: type PXSegment

PXSelectionClearEvent:

xlib: type PXSelectionClearEvent

PXSelectionEvent:

xlib: type PXSelectionEvent

PXSelectionRequestEvent:

xlib: type PXSelectionRequestEvent

PXServerInterpretedAddress:

xlib: type PXServerInterpretedAddress

PXSetWindowAttributes:

xlib: type PXSetWindowAttributes

PXSizeHints:

xutil: type PXSizeHints

PXStandardColormap:

xutil: type PXStandardColormap

PXTextItem:

xlib: type PXTextItem

PXTextItem16:

xlib: type PXTextItem16

PXTextProperty:

xutil: type PXTextProperty

PXTimeCoord:

xlib: type PXTimeCoord

PXUnmapEvent:

xlib: type PXUnmapEvent

PXVaNestedList:

xlib: type PXVaNestedList

PXVisibilityEvent:

xlib: type PXVisibilityEvent

PXVisualInfo:

xutil: type PXVisualInfo

PXwcTextItem:

xlib: type PXwcTextItem

PXWindowAttributes:

xlib: type PXWindowAttributes

PXWindowChanges:

xlib: type PXWindowChanges

PXWMHints:

xutil: type PXWMHints

QLength:

xlib: proc QLength(dpy: PDisplay): cint

QueuedAfterFlush:

xlib: const QueuedAfterFlush

QueuedAfterReading:

xlib: const QueuedAfterReading

QueuedAlready:

xlib: const QueuedAlready

Quit:

events: EventType.Quit

R:

core: const R

r:

core: proc r(vec: TVec): auto

r=:

core: proc r=[T](vec: var TVec; value: T)

ra:

core: proc ra(vec: TVec): auto

ra=:

core: proc ra=[T](vec: var TVec; value: T)

raa:

core: proc raa(vec: TVec): auto

raa=:

core: proc raa=[T](vec: var TVec; value: T)

raaa:

core: proc raaa(vec: TVec): auto

raaa=:

core: proc raaa=[T](vec: var TVec; value: T)

raab:

core: proc raab(vec: TVec): auto

raab=:

core: proc raab=[T](vec: var TVec; value: T)

raag:

core: proc raag(vec: TVec): auto

raag=:

core: proc raag=[T](vec: var TVec; value: T)

raar:

core: proc raar(vec: TVec): auto

raar=:

core: proc raar=[T](vec: var TVec; value: T)

rab:

core: proc rab(vec: TVec): auto

rab=:

core: proc rab=[T](vec: var TVec; value: T)

raba:

core: proc raba(vec: TVec): auto

raba=:

core: proc raba=[T](vec: var TVec; value: T)

rabb:

core: proc rabb(vec: TVec): auto

rabb=:

core: proc rabb=[T](vec: var TVec; value: T)

rabg:

core: proc rabg(vec: TVec): auto

rabg=:

core: proc rabg=[T](vec: var TVec; value: T)

rabr:

core: proc rabr(vec: TVec): auto

rabr=:

core: proc rabr=[T](vec: var TVec; value: T)

rag:

core: proc rag(vec: TVec): auto

rag=:

core: proc rag=[T](vec: var TVec; value: T)

raga:

core: proc raga(vec: TVec): auto

raga=:

core: proc raga=[T](vec: var TVec; value: T)

ragb:

core: proc ragb(vec: TVec): auto

ragb=:

core: proc ragb=[T](vec: var TVec; value: T)

ragg:

core: proc ragg(vec: TVec): auto

ragg=:

core: proc ragg=[T](vec: var TVec; value: T)

ragr:

core: proc ragr(vec: TVec): auto

ragr=:

core: proc ragr=[T](vec: var TVec; value: T)

RaiseLowest:

x: const RaiseLowest

rar:

core: proc rar(vec: TVec): auto

rar=:

core: proc rar=[T](vec: var TVec; value: T)

rara:

core: proc rara(vec: TVec): auto

rara=:

core: proc rara=[T](vec: var TVec; value: T)

rarb:

core: proc rarb(vec: TVec): auto

rarb=:

core: proc rarb=[T](vec: var TVec; value: T)

rarg:

core: proc rarg(vec: TVec): auto

rarg=:

core: proc rarg=[T](vec: var TVec; value: T)

rarr:

core: proc rarr(vec: TVec): auto

rarr=:

core: proc rarr=[T](vec: var TVec; value: T)

rayIntersectAABB:

collision: proc rayIntersectAABB(origin, dir, boxA, boxB: Vec3f): Option[(Vec3f, float32)]

rb:

core: proc rb(vec: TVec): auto

rb=:

core: proc rb=[T](vec: var TVec; value: T)

rba:

core: proc rba(vec: TVec): auto

rba=:

core: proc rba=[T](vec: var TVec; value: T)

rbaa:

core: proc rbaa(vec: TVec): auto

rbaa=:

core: proc rbaa=[T](vec: var TVec; value: T)

rbab:

core: proc rbab(vec: TVec): auto

rbab=:

core: proc rbab=[T](vec: var TVec; value: T)

rbag:

core: proc rbag(vec: TVec): auto

rbag=:

core: proc rbag=[T](vec: var TVec; value: T)

rbar:

core: proc rbar(vec: TVec): auto

rbar=:

core: proc rbar=[T](vec: var TVec; value: T)

rbb:

core: proc rbb(vec: TVec): auto

rbb=:

core: proc rbb=[T](vec: var TVec; value: T)

rbba:

core: proc rbba(vec: TVec): auto

rbba=:

core: proc rbba=[T](vec: var TVec; value: T)

rbbb:

core: proc rbbb(vec: TVec): auto

rbbb=:

core: proc rbbb=[T](vec: var TVec; value: T)

rbbg:

core: proc rbbg(vec: TVec): auto

rbbg=:

core: proc rbbg=[T](vec: var TVec; value: T)

rbbr:

core: proc rbbr(vec: TVec): auto

rbbr=:

core: proc rbbr=[T](vec: var TVec; value: T)

rbg:

core: proc rbg(vec: TVec): auto

rbg=:

core: proc rbg=[T](vec: var TVec; value: T)

rbga:

core: proc rbga(vec: TVec): auto

rbga=:

core: proc rbga=[T](vec: var TVec; value: T)

rbgb:

core: proc rbgb(vec: TVec): auto

rbgb=:

core: proc rbgb=[T](vec: var TVec; value: T)

rbgg:

core: proc rbgg(vec: TVec): auto

rbgg=:

core: proc rbgg=[T](vec: var TVec; value: T)

rbgr:

core: proc rbgr(vec: TVec): auto

rbgr=:

core: proc rbgr=[T](vec: var TVec; value: T)

rbr:

core: proc rbr(vec: TVec): auto

rbr=:

core: proc rbr=[T](vec: var TVec; value: T)

rbra:

core: proc rbra(vec: TVec): auto

rbra=:

core: proc rbra=[T](vec: var TVec; value: T)

rbrb:

core: proc rbrb(vec: TVec): auto

rbrb=:

core: proc rbrb=[T](vec: var TVec; value: T)

rbrg:

core: proc rbrg(vec: TVec): auto

rbrg=:

core: proc rbrg=[T](vec: var TVec; value: T)

rbrr:

core: proc rbrr(vec: TVec): auto

rbrr=:

core: proc rbrr=[T](vec: var TVec; value: T)

readAU:

resources: proc readAU(stream: Stream): SoundData

ReadDbEffect:

db_common: object ReadDbEffect

ReadglTF:

gltf: proc ReadglTF[TMesh, TMaterial](stream: Stream; meshAttributesMapping: static MeshAttributeNames; materialAttributesMapping: static MaterialAttributeNames): GltfData[TMesh, TMaterial]

readVorbis:

resources: proc readVorbis(stream: Stream): SoundData

recreateSwapchain:

RectangleIn:

xutil: const RectangleIn

RectangleOut:

xutil: const RectangleOut

RectanglePart:

xutil: const RectanglePart

refresh:

text: proc refresh(textbox: var Textbox)

Region:

xutil: type Region

Relative:

xi: const Relative

ReleaseByFreeingColormap:

xutil: const ReleaseByFreeingColormap

ReloadSettings:

settings: proc ReloadSettings()

render:

RenderData:

rendering: type RenderData

RenderPass:

rendering: type RenderPass

renderWithPushConstant:

ReparentNotify:

x: const ReparentNotify

ReplayKeyboard:

x: const ReplayKeyboard

ReplayPointer:

x: const ReplayPointer

ReplayThisDevice:

xi: const ReplayThisDevice

requestLoading:

background_loader: proc requestLoading(ld: var BackgroundLoader; path, package: string)

Reset:

reset:

sqlite3: proc reset(PStmt: PStmt): int32

ResizedWindow:

events: EventType.ResizedWindow

ResizeRedirectMask:

x: const ResizeRedirectMask

ResizeRequest:

x: const ResizeRequest

RESOURCEROOT:

RestoredWindow:

events: EventType.RestoredWindow

result_blob:

sqlite3: proc result_blob(para1: Pcontext; para2: pointer; para3: int32; para4: Result_func)

result_double:

sqlite3: proc result_double(para1: Pcontext; para2: float64)

result_error:

sqlite3: proc result_error(para1: Pcontext; para2: cstring; para3: int32)

result_error16:

sqlite3: proc result_error16(para1: Pcontext; para2: pointer; para3: int32)

Result_func:

sqlite3: type Result_func

result_int:

sqlite3: proc result_int(para1: Pcontext; para2: int32)

result_int64:

sqlite3: proc result_int64(para1: Pcontext; para2: int64)

result_null:

sqlite3: proc result_null(para1: Pcontext)

result_text:

sqlite3: proc result_text(para1: Pcontext; para2: cstring; para3: int32; para4: Result_func)

result_text16:

sqlite3: proc result_text16(para1: Pcontext; para2: pointer; para3: int32; para4: Result_func)

result_text16be:

sqlite3: proc result_text16be(para1: Pcontext; para2: pointer; para3: int32; para4: Result_func)

result_text16le:

sqlite3: proc result_text16le(para1: Pcontext; para2: pointer; para3: int32; para4: Result_func)

result_value:

sqlite3: proc result_value(para1: Pcontext; para2: PValue)

RetainPermanent:

x: const RetainPermanent

RetainTemporary:

x: const RetainTemporary

RevertToFollowKeyboard:

xi: const RevertToFollowKeyboard

RevertToNone:

x: const RevertToNone

RevertToParent:

x: const RevertToParent

RevertToPointerRoot:

x: const RevertToPointerRoot

rg:

core: proc rg(vec: TVec): auto

rg=:

core: proc rg=[T](vec: var TVec; value: T)

rga:

core: proc rga(vec: TVec): auto

rga=:

core: proc rga=[T](vec: var TVec; value: T)

rgaa:

core: proc rgaa(vec: TVec): auto

rgaa=:

core: proc rgaa=[T](vec: var TVec; value: T)

rgab:

core: proc rgab(vec: TVec): auto

rgab=:

core: proc rgab=[T](vec: var TVec; value: T)

rgag:

core: proc rgag(vec: TVec): auto

rgag=:

core: proc rgag=[T](vec: var TVec; value: T)

rgar:

core: proc rgar(vec: TVec): auto

rgar=:

core: proc rgar=[T](vec: var TVec; value: T)

rgb:

core: proc rgb(vec: TVec): auto

rgb=:

core: proc rgb=[T](vec: var TVec; value: T)

rgba:

core: proc rgba(vec: TVec): auto

rgba=:

core: proc rgba=[T](vec: var TVec; value: T)

rgbb:

core: proc rgbb(vec: TVec): auto

rgbb=:

core: proc rgbb=[T](vec: var TVec; value: T)

rgbg:

core: proc rgbg(vec: TVec): auto

rgbg=:

core: proc rgbg=[T](vec: var TVec; value: T)

rgbr:

core: proc rgbr(vec: TVec): auto

rgbr=:

core: proc rgbr=[T](vec: var TVec; value: T)

rgg:

core: proc rgg(vec: TVec): auto

rgg=:

core: proc rgg=[T](vec: var TVec; value: T)

rgga:

core: proc rgga(vec: TVec): auto

rgga=:

core: proc rgga=[T](vec: var TVec; value: T)

rggb:

core: proc rggb(vec: TVec): auto

rggb=:

core: proc rggb=[T](vec: var TVec; value: T)

rggg:

core: proc rggg(vec: TVec): auto

rggg=:

core: proc rggg=[T](vec: var TVec; value: T)

rggr:

core: proc rggr(vec: TVec): auto

rggr=:

core: proc rggr=[T](vec: var TVec; value: T)

rgr:

core: proc rgr(vec: TVec): auto

rgr=:

core: proc rgr=[T](vec: var TVec; value: T)

rgra:

core: proc rgra(vec: TVec): auto

rgra=:

core: proc rgra=[T](vec: var TVec; value: T)

rgrb:

core: proc rgrb(vec: TVec): auto

rgrb=:

core: proc rgrb=[T](vec: var TVec; value: T)

rgrg:

core: proc rgrg(vec: TVec): auto

rgrg=:

core: proc rgrg=[T](vec: var TVec; value: T)

rgrr:

core: proc rgrr(vec: TVec): auto

rgrr=:

core: proc rgrr=[T](vec: var TVec; value: T)

Right:

core: HorizontalAlignment.Right

RootWindow:

xlib: proc RootWindow(dpy: PDisplay; scr: cint): Window

RootWindowOfScreen:

xlib: proc RootWindowOfScreen(s: PScreen): Window

rotate:

core: proc rotate(angle: float32; a: Vec3f): Mat4

rotate2d:

core: proc rotate2d[T](angle: T): TMat3[T]

round:

row:

Row:

db_sqlite: type Row

RowCount:

core: template RowCount(m: typedesc): int

rows:

rr:

core: proc rr(vec: TVec): auto

rr=:

core: proc rr=[T](vec: var TVec; value: T)

rra:

core: proc rra(vec: TVec): auto

rra=:

core: proc rra=[T](vec: var TVec; value: T)

rraa:

core: proc rraa(vec: TVec): auto

rraa=:

core: proc rraa=[T](vec: var TVec; value: T)

rrab:

core: proc rrab(vec: TVec): auto

rrab=:

core: proc rrab=[T](vec: var TVec; value: T)

rrag:

core: proc rrag(vec: TVec): auto

rrag=:

core: proc rrag=[T](vec: var TVec; value: T)

rrar:

core: proc rrar(vec: TVec): auto

rrar=:

core: proc rrar=[T](vec: var TVec; value: T)

rrb:

core: proc rrb(vec: TVec): auto

rrb=:

core: proc rrb=[T](vec: var TVec; value: T)

rrba:

core: proc rrba(vec: TVec): auto

rrba=:

core: proc rrba=[T](vec: var TVec; value: T)

rrbb:

core: proc rrbb(vec: TVec): auto

rrbb=:

core: proc rrbb=[T](vec: var TVec; value: T)

rrbg:

core: proc rrbg(vec: TVec): auto

rrbg=:

core: proc rrbg=[T](vec: var TVec; value: T)

rrbr:

core: proc rrbr(vec: TVec): auto

rrbr=:

core: proc rrbr=[T](vec: var TVec; value: T)

rrg:

core: proc rrg(vec: TVec): auto

rrg=:

core: proc rrg=[T](vec: var TVec; value: T)

rrga:

core: proc rrga(vec: TVec): auto

rrga=:

core: proc rrga=[T](vec: var TVec; value: T)

rrgb:

core: proc rrgb(vec: TVec): auto

rrgb=:

core: proc rrgb=[T](vec: var TVec; value: T)

rrgg:

core: proc rrgg(vec: TVec): auto

rrgg=:

core: proc rrgg=[T](vec: var TVec; value: T)

rrgr:

core: proc rrgr(vec: TVec): auto

rrgr=:

core: proc rrgr=[T](vec: var TVec; value: T)

rrr:

core: proc rrr(vec: TVec): auto

rrr=:

core: proc rrr=[T](vec: var TVec; value: T)

rrra:

core: proc rrra(vec: TVec): auto

rrra=:

core: proc rrra=[T](vec: var TVec; value: T)

rrrb:

core: proc rrrb(vec: TVec): auto

rrrb=:

core: proc rrrb=[T](vec: var TVec; value: T)

rrrg:

core: proc rrrg(vec: TVec): auto

rrrg=:

core: proc rrrg=[T](vec: var TVec; value: T)

rrrr:

core: proc rrrr(vec: TVec): auto

rrrr=:

core: proc rrrr=[T](vec: var TVec; value: T)

Sample:

mixer_module: type Sample

saveCurrentActionMapping:

input: proc saveCurrentActionMapping()

scale:

scale2d:

core: proc scale2d[T](sx, sy: T): TMat3[T]

Screen:

xlib: object Screen

ScreenCount:

xlib: proc ScreenCount(dpy: PDisplay): cint

ScreenFormat:

xlib: object ScreenFormat

ScreenOfDisplay:

xlib: proc ScreenOfDisplay(dpy: PDisplay; scr: cint): PScreen

ScreenSaverActive:

x: const ScreenSaverActive

ScreenSaverReset:

x: const ScreenSaverReset

SelectionClear:

x: const SelectionClear

SelectionNotify:

x: const SelectionNotify

SelectionRequest:

x: const SelectionRequest

SendCoreEvents:

xi: const SendCoreEvents

ServerVendor:

xlib: proc ServerVendor(dpy: PDisplay): cstring

set_authorizer:

sqlite3: proc set_authorizer(para1: PSqlite3; xAuth: proc (para1: pointer; para2: int32; para3: cstring; para4: cstring; para5: cstring; para6: cstring): int32 {. cdecl.}; pUserData: pointer): int32

set_auxdata:

sqlite3: proc set_auxdata(para1: Pcontext; para2: int32; para3: pointer; para4: proc (para1: pointer) {.cdecl.})

setEncoding:

db_sqlite: proc setEncoding(connection: DbConn; encoding: string): bool

setFullscreen:

setLevel:

SetModeDelete:

x: const SetModeDelete

SetModeInsert:

x: const SetModeInsert

setMousePosition:

rendering: proc setMousePosition(window: NativeWindow; pos: Vec2i)

Setting:

setTitle:

rendering: proc setTitle(window: NativeWindow; title: string)

setupSwapchain:

rendering: proc setupSwapchain(renderPass: RenderPass; vSync: bool = false)

ShaderOutput:

rendering: template ShaderOutput()

ShiftMapIndex:

x: const ShiftMapIndex

ShiftMask:

x: const ShiftMask

showSystemCursor:

Shutdown:

steam: var Shutdown

sineSoundData:

generators: proc sineSoundData(f: float; len: float; rate: int; amplitude = 0.5'f32): SoundData

Size:

core: proc Size[T: seq](list: T): uint64

size:

rendering: proc size(window: NativeWindow): Vec2i

snd_pcm_close:

mixer_module: proc snd_pcm_close(pcm: snd_pcm_p): cint

snd_pcm_hw_params:

mixer_module: proc snd_pcm_hw_params(pcm: snd_pcm_p; params: snd_pcm_hw_params_p): cint

snd_pcm_hw_params_any:

mixer_module: proc snd_pcm_hw_params_any(pcm: snd_pcm_p; params: snd_pcm_hw_params_p): cint

snd_pcm_hw_params_free:

mixer_module: proc snd_pcm_hw_params_free(hw_params: snd_pcm_hw_params_p)

snd_pcm_hw_params_malloc:

mixer_module: proc snd_pcm_hw_params_malloc(hw_params_ptr: ptr snd_pcm_hw_params_p): cint

snd_pcm_hw_params_p:

mixer_module: type snd_pcm_hw_params_p

snd_pcm_hw_params_set_access:

mixer_module: proc snd_pcm_hw_params_set_access(pcm: snd_pcm_p; params: snd_pcm_hw_params_p; mode: AccessMode): cint

snd_pcm_hw_params_set_buffer_size:

mixer_module: proc snd_pcm_hw_params_set_buffer_size(pcm: snd_pcm_p; params: snd_pcm_hw_params_p; size: snd_pcm_uframes_t): cint

snd_pcm_hw_params_set_channels:

mixer_module: proc snd_pcm_hw_params_set_channels(pcm: snd_pcm_p; params: snd_pcm_hw_params_p; val: cuint): cint

snd_pcm_hw_params_set_format:

mixer_module: proc snd_pcm_hw_params_set_format(pcm: snd_pcm_p; params: snd_pcm_hw_params_p; format: PCMFormat): cint

snd_pcm_hw_params_set_rate:

mixer_module: proc snd_pcm_hw_params_set_rate(pcm: snd_pcm_p; params: snd_pcm_hw_params_p; val: cuint; dir: cint): cint

snd_pcm_open:

mixer_module: proc snd_pcm_open(pcm_ref: ptr snd_pcm_p; name: cstring; streamMode: StreamMode; openmode: OpenMode): cint

snd_pcm_p:

mixer_module: type snd_pcm_p

snd_pcm_recover:

mixer_module: proc snd_pcm_recover(pcm: snd_pcm_p; err: cint; silent: cint): cint

snd_pcm_sframes_t:

mixer_module: type snd_pcm_sframes_t

snd_pcm_uframes_t:

mixer_module: type snd_pcm_uframes_t

snd_pcm_writei:

mixer_module: proc snd_pcm_writei(pcm: snd_pcm_p; buffer: pointer; size: snd_pcm_uframes_t): snd_pcm_sframes_t

snprintf:

sqlite3: proc snprintf(para1: int32; para2: cstring; para3: cstring): cstring

SoundData:

mixer_module: type SoundData

SouthEastGravity:

x: const SouthEastGravity

SouthGravity:

x: const SouthGravity

SouthWestGravity:

x: const SouthWestGravity

Sphere:

collision: ColliderType.Sphere

sql:

db_common: template sql(query: string): SqlQuery

SQLite:

db_sqlite: Module db_sqlite

sqlite3_sleep:

sqlite3: proc sqlite3_sleep(t: int64): int64

SQLITE_ABORT:

sqlite3: const SQLITE_ABORT

SQLITE_ALTER_TABLE:

sqlite3: const SQLITE_ALTER_TABLE

SQLITE_ANY:

sqlite3: const SQLITE_ANY

SQLITE_ATTACH:

sqlite3: const SQLITE_ATTACH

SQLITE_AUTH:

sqlite3: const SQLITE_AUTH

SQLITE_BLOB:

sqlite3: const SQLITE_BLOB

SQLITE_BUSY:

sqlite3: const SQLITE_BUSY

SQLITE_CANTOPEN:

sqlite3: const SQLITE_CANTOPEN

SQLITE_CONSTRAINT:

sqlite3: const SQLITE_CONSTRAINT

SQLITE_COPY:

sqlite3: const SQLITE_COPY

SQLITE_CORRUPT:

sqlite3: const SQLITE_CORRUPT

SQLITE_CREATE_INDEX:

sqlite3: const SQLITE_CREATE_INDEX

SQLITE_CREATE_TABLE:

sqlite3: const SQLITE_CREATE_TABLE

SQLITE_CREATE_TEMP_INDEX:

sqlite3: const SQLITE_CREATE_TEMP_INDEX

SQLITE_CREATE_TEMP_TABLE:

sqlite3: const SQLITE_CREATE_TEMP_TABLE

SQLITE_CREATE_TEMP_TRIGGER:

sqlite3: const SQLITE_CREATE_TEMP_TRIGGER

SQLITE_CREATE_TEMP_VIEW:

sqlite3: const SQLITE_CREATE_TEMP_VIEW

SQLITE_CREATE_TRIGGER:

sqlite3: const SQLITE_CREATE_TRIGGER

SQLITE_CREATE_VIEW:

sqlite3: const SQLITE_CREATE_VIEW

SQLITE_DELETE:

sqlite3: const SQLITE_DELETE

SQLITE_DENY:

sqlite3: const SQLITE_DENY

SQLITE_DETACH:

sqlite3: const SQLITE_DETACH

SQLITE_DETERMINISTIC:

sqlite3: const SQLITE_DETERMINISTIC

SQLITE_DONE:

sqlite3: const SQLITE_DONE

SQLITE_DROP_INDEX:

sqlite3: const SQLITE_DROP_INDEX

SQLITE_DROP_TABLE:

sqlite3: const SQLITE_DROP_TABLE

SQLITE_DROP_TEMP_INDEX:

sqlite3: const SQLITE_DROP_TEMP_INDEX

SQLITE_DROP_TEMP_TABLE:

sqlite3: const SQLITE_DROP_TEMP_TABLE

SQLITE_DROP_TEMP_TRIGGER:

sqlite3: const SQLITE_DROP_TEMP_TRIGGER

SQLITE_DROP_TEMP_VIEW:

sqlite3: const SQLITE_DROP_TEMP_VIEW

SQLITE_DROP_TRIGGER:

sqlite3: const SQLITE_DROP_TRIGGER

SQLITE_DROP_VIEW:

sqlite3: const SQLITE_DROP_VIEW

SQLITE_EMPTY:

sqlite3: const SQLITE_EMPTY

SQLITE_ERROR:

sqlite3: const SQLITE_ERROR

SQLITE_FLOAT:

sqlite3: const SQLITE_FLOAT

SQLITE_FORMAT:

sqlite3: const SQLITE_FORMAT

SQLITE_FULL:

sqlite3: const SQLITE_FULL

SQLITE_IGNORE:

sqlite3: const SQLITE_IGNORE

SQLITE_INSERT:

sqlite3: const SQLITE_INSERT

SQLITE_INTEGER:

sqlite3: const SQLITE_INTEGER

SQLITE_INTERNAL:

sqlite3: const SQLITE_INTERNAL

SQLITE_INTERRUPT:

sqlite3: const SQLITE_INTERRUPT

SQLITE_IOERR:

sqlite3: const SQLITE_IOERR

SQLITE_LOCKED:

sqlite3: const SQLITE_LOCKED

SQLITE_MISMATCH:

sqlite3: const SQLITE_MISMATCH

SQLITE_MISUSE:

sqlite3: const SQLITE_MISUSE

SQLITE_NOLFS:

sqlite3: const SQLITE_NOLFS

SQLITE_NOMEM:

sqlite3: const SQLITE_NOMEM

SQLITE_NOTADB:

sqlite3: const SQLITE_NOTADB

SQLITE_NOTFOUND:

sqlite3: const SQLITE_NOTFOUND

SQLITE_NULL:

sqlite3: const SQLITE_NULL

SQLITE_OK:

sqlite3: const SQLITE_OK

SQLITE_PERM:

sqlite3: const SQLITE_PERM

SQLITE_PRAGMA:

sqlite3: const SQLITE_PRAGMA

SQLITE_PROTOCOL:

sqlite3: const SQLITE_PROTOCOL

SQLITE_RANGE:

sqlite3: const SQLITE_RANGE

SQLITE_READ:

sqlite3: const SQLITE_READ

SQLITE_READONLY:

sqlite3: const SQLITE_READONLY

SQLITE_REINDEX:

sqlite3: const SQLITE_REINDEX

SQLITE_ROW:

sqlite3: const SQLITE_ROW

SQLITE_SCHEMA:

sqlite3: const SQLITE_SCHEMA

SQLITE_SELECT:

sqlite3: const SQLITE_SELECT

SQLITE_STATIC:

sqlite3: const SQLITE_STATIC

SQLITE_TEXT:

sqlite3: const SQLITE_TEXT

SQLITE_TOOBIG:

sqlite3: const SQLITE_TOOBIG

SQLITE_TRANSACTION:

sqlite3: const SQLITE_TRANSACTION

SQLITE_TRANSIENT:

sqlite3: const SQLITE_TRANSIENT

SQLITE_UPDATE:

sqlite3: const SQLITE_UPDATE

SQLITE_UTF16:

sqlite3: const SQLITE_UTF16

SQLITE_UTF16BE:

sqlite3: const SQLITE_UTF16BE

SQLITE_UTF16LE:

sqlite3: const SQLITE_UTF16LE

SQLITE_UTF8:

sqlite3: const SQLITE_UTF8

SqlPrepared:

db_sqlite: type SqlPrepared

SqlQuery:

db_common: type SqlQuery

startMixerThread:

mixer_module: proc startMixerThread()

StateHint:

xutil: const StateHint

StaticColor:

x: const StaticColor

StaticExecChecked:

core: proc StaticExecChecked(command: string; input = ""): string

StaticGravity:

x: const StaticGravity

StaticGray:

x: const StaticGray

Status:

xlib: type Status

SteamAvailable:

steam: proc SteamAvailable(): bool

SteamClearAchievement:

steam: proc SteamClearAchievement(name: string): bool

SteamRequestCurrentStats:

steam: proc SteamRequestCurrentStats(): bool

SteamSetAchievement:

steam: proc SteamSetAchievement(name: string): bool

SteamShutdown:

steam: proc SteamShutdown()

SteamStoreStats:

steam: proc SteamStoreStats(): bool

step:

sqlite3: proc step(para1: PStmt): int32

StippleShape:

x: const StippleShape

stop:

StorageType:

storage: enum StorageType

store:

storage: proc store[T](storageType: StorageType; key: string; value: T; table = DEFAULT_KEY_VALUE_TABLE_NAME)

StreamMode:

mixer_module: enum StreamMode

StringFeedbackClass:

xi: const StringFeedbackClass

StructureNotifyMask:

x: const StructureNotifyMask

SubstructureNotifyMask:

x: const SubstructureNotifyMask

SubstructureRedirectMask:

x: const SubstructureRedirectMask

Success:

x: const Success

SURFACE_FORMAT:

rendering: const SURFACE_FORMAT

svkAllocateMemory:

rendering: proc svkAllocateMemory(size: uint64; typeIndex: uint32): VkDeviceMemory

svkCreate2DImage:

rendering: proc svkCreate2DImage(width, height: uint32; format: VkFormat; usage: openArray[VkImageUsageFlagBits]; samples = VK_SAMPLE_COUNT_1_BIT; nLayers = 1'u32): VkImage

svkCreate2DImageView:

rendering: proc svkCreate2DImageView(image: VkImage; format: VkFormat; aspect = VK_IMAGE_ASPECT_COLOR_BIT; nLayers = 1'u32; isArray = false): VkImageView

svkCreateBuffer:

rendering: proc svkCreateBuffer(size: uint64; usage: openArray[VkBufferUsageFlagBits]): VkBuffer

svkCreateFence:

rendering: proc svkCreateFence(signaled = false): VkFence

svkCreateFramebuffer:

rendering: proc svkCreateFramebuffer(renderpass: VkRenderPass; width, height: uint32; attachments: openArray[VkImageView]): VkFramebuffer

svkCreateSemaphore:

rendering: proc svkCreateSemaphore(): VkSemaphore

svkGetBufferMemoryRequirements:

rendering: proc svkGetBufferMemoryRequirements(buffer: VkBuffer): tuple[size: uint64, alignment: uint64, memoryTypes: seq[uint32]]

svkGetDeviceQueue:

rendering: proc svkGetDeviceQueue(device: VkDevice; queueFamilyIndex: uint32; qType: VkQueueFlagBits): VkQueue

svkGetImageMemoryRequirements:

rendering: proc svkGetImageMemoryRequirements(image: VkImage): tuple[size: uint64, alignment: uint64, memoryTypes: seq[uint32]]

svkGetPhysicalDeviceProperties:

rendering: proc svkGetPhysicalDeviceProperties(): VkPhysicalDeviceProperties

svkGetPhysicalDeviceSurfacePresentModesKHR:

rendering: proc svkGetPhysicalDeviceSurfacePresentModesKHR(): seq[VkPresentModeKHR]

svkGetPhysicalDeviceSurfaceSupportKHR:

rendering: proc svkGetPhysicalDeviceSurfaceSupportKHR(queueFamily: uint32): bool

svkResetFences:

rendering: proc svkResetFences(fence: VkFence)

Swapchain:

rendering: type Swapchain

SyncAll:

xi: const SyncAll

SyncBoth:

x: const SyncBoth

SyncKeyboard:

x: const SyncKeyboard

SyncPointer:

x: const SyncPointer

SyncThisDevice:

xi: const SyncThisDevice

SystemStorage:

storage: StorageType.SystemStorage

sz_xAllowDeviceEventsReq:

xi: const sz_xAllowDeviceEventsReq

sz_xChangeDeviceControlReply:

xi: const sz_xChangeDeviceControlReply

sz_xChangeDeviceControlReq:

xi: const sz_xChangeDeviceControlReq

sz_xChangeDeviceDontPropagateListReq:

xi: const sz_xChangeDeviceDontPropagateListReq

sz_xChangeDeviceKeyMappingReq:

xi: const sz_xChangeDeviceKeyMappingReq

sz_xChangeFeedbackControlReq:

xi: const sz_xChangeFeedbackControlReq

sz_xChangeKeyboardDeviceReply:

xi: const sz_xChangeKeyboardDeviceReply

sz_xChangeKeyboardDeviceReq:

xi: const sz_xChangeKeyboardDeviceReq

sz_xChangePointerDeviceReply:

xi: const sz_xChangePointerDeviceReply

sz_xChangePointerDeviceReq:

xi: const sz_xChangePointerDeviceReq

sz_xCloseDeviceReq:

xi: const sz_xCloseDeviceReq

sz_xDeviceBellReq:

xi: const sz_xDeviceBellReq

sz_xGetDeviceButtonMappingReply:

xi: const sz_xGetDeviceButtonMappingReply

sz_xGetDeviceButtonMappingReq:

xi: const sz_xGetDeviceButtonMappingReq

sz_xGetDeviceControlReply:

xi: const sz_xGetDeviceControlReply

sz_xGetDeviceControlReq:

xi: const sz_xGetDeviceControlReq

sz_xGetDeviceDontPropagateListReply:

xi: const sz_xGetDeviceDontPropagateListReply

sz_xGetDeviceDontPropagateListReq:

xi: const sz_xGetDeviceDontPropagateListReq

sz_xGetDeviceFocusReply:

xi: const sz_xGetDeviceFocusReply

sz_xGetDeviceFocusReq:

xi: const sz_xGetDeviceFocusReq

sz_xGetDeviceKeyMappingReply:

xi: const sz_xGetDeviceKeyMappingReply

sz_xGetDeviceKeyMappingReq:

xi: const sz_xGetDeviceKeyMappingReq

sz_xGetDeviceModifierMappingReq:

xi: const sz_xGetDeviceModifierMappingReq

sz_xGetDeviceMotionEventsReply:

xi: const sz_xGetDeviceMotionEventsReply

sz_xGetDeviceMotionEventsReq:

xi: const sz_xGetDeviceMotionEventsReq

sz_xGetExtensionVersionReply:

xi: const sz_xGetExtensionVersionReply

sz_xGetExtensionVersionReq:

xi: const sz_xGetExtensionVersionReq

sz_xGetFeedbackControlReply:

xi: const sz_xGetFeedbackControlReply

sz_xGetFeedbackControlReq:

xi: const sz_xGetFeedbackControlReq

sz_xGetSelectedExtensionEventsReply:

xi: const sz_xGetSelectedExtensionEventsReply

sz_xGetSelectedExtensionEventsReq:

xi: const sz_xGetSelectedExtensionEventsReq

sz_xGrabDeviceButtonReply:

xi: const sz_xGrabDeviceButtonReply

sz_xGrabDeviceButtonReq:

xi: const sz_xGrabDeviceButtonReq

sz_xGrabDeviceKeyReply:

xi: const sz_xGrabDeviceKeyReply

sz_xGrabDeviceKeyReq:

xi: const sz_xGrabDeviceKeyReq

sz_xGrabDeviceReply:

xi: const sz_xGrabDeviceReply

sz_xGrabDeviceReq:

xi: const sz_xGrabDeviceReq

sz_xListInputDevicesReply:

xi: const sz_xListInputDevicesReply

sz_xListInputDevicesReq:

xi: const sz_xListInputDevicesReq

sz_xOpenDeviceReply:

xi: const sz_xOpenDeviceReply

sz_xOpenDeviceReq:

xi: const sz_xOpenDeviceReq

sz_xQueryDeviceStateReply:

xi: const sz_xQueryDeviceStateReply

sz_xQueryDeviceStateReq:

xi: const sz_xQueryDeviceStateReq

sz_xSelectExtensionEventReq:

xi: const sz_xSelectExtensionEventReq

sz_xSendExtensionEventReq:

xi: const sz_xSendExtensionEventReq

sz_xSetDeviceButtonMappingReply:

xi: const sz_xSetDeviceButtonMappingReply

sz_xSetDeviceButtonMappingReq:

xi: const sz_xSetDeviceButtonMappingReq

sz_xSetDeviceFocusReq:

xi: const sz_xSetDeviceFocusReq

sz_xSetDeviceModeReply:

xi: const sz_xSetDeviceModeReply

sz_xSetDeviceModeReq:

xi: const sz_xSetDeviceModeReq

sz_xSetDeviceModifierMappingReply:

xi: const sz_xSetDeviceModifierMappingReply

sz_xSetDeviceModifierMappingReq:

xi: const sz_xSetDeviceModifierMappingReq

sz_xSetDeviceValuatorsReply:

xi: const sz_xSetDeviceValuatorsReply

sz_xSetDeviceValuatorsReq:

xi: const sz_xSetDeviceValuatorsReq

sz_xUngrabDeviceButtonReq:

xi: const sz_xUngrabDeviceButtonReq

sz_xUngrabDeviceKeyReq:

xi: const sz_xUngrabDeviceKeyReq

sz_xUngrabDeviceReq:

xi: const sz_xUngrabDeviceReq

Tbind_destructor_func:

sqlite3: type Tbind_destructor_func

text:

text: proc text(textbox: Textbox): seq[Rune]

text=:

Textbox:

text: object Textbox

textWidth:

text: proc textWidth(theText: seq[Rune] | string; font: FontObj): float32

TileShape:

x: const TileShape

Time:

x: type Time

TimeAndLog:

TMat:

core: type TMat

TMat2:

core: object TMat2

TMat23:

core: object TMat23

TMat3:

core: object TMat3

TMat32:

core: object TMat32

TMat34:

core: object TMat34

TMat4:

core: object TMat4

TMat43:

core: object TMat43

to:

toBits:

ToCPointer:

core: proc ToCPointer[T](list: openArray[T]): ptr T

toEnums:

Top:

core: VerticalAlignment.Top

TopIf:

x: const TopIf

total_changes:

sqlite3: proc total_changes(para1: PSqlite3): int32

toVec:

core: proc toVec(value: string; gamma = 2.2'f32): Vec4f

toVec1:

core: proc toVec1[T: SomeNumber](orig: TVec3[T] | TVec4[T]): TVec1[T]

toVec2:

toVec3:

toVec4:

core: proc toVec4[T: SomeNumber](orig: TVec3[T]; value: T = default(T)): TVec4[T]

trace:

sqlite3: proc trace(para1: PSqlite3; xTrace: proc (para1: pointer; para2: cstring) {.cdecl.}; para3: pointer): pointer

transform:

core: proc transform[T, S](points: var openArray[S]; mat: TMat4[T])

transformed:

core: proc transformed[T, S](points: openArray[S]; mat: TMat4[T]): seq[S]

translate:

translate2d:

core: proc translate2d[T](x, y: T): TMat3[T]

transposed:

TrueColor:

x: const TrueColor

tryExec:

tryInsert:

db_sqlite: proc tryInsert(db: DbConn; query: SqlQuery; pkName: string; args: varargs[string, `$`]): int64

tryInsertID:

db_sqlite: proc tryInsertID(db: DbConn; query: SqlQuery; args: varargs[string, `$`]): int64

TrySteamInit:

steam: proc TrySteamInit()

TS_Raw:

xi: const TS_Raw

TS_Scaled:

xi: const TS_Scaled

TVec:

core: type TVec

TVec1:

core: type TVec1

TVec2:

core: type TVec2

TVec3:

core: type TVec3

TVec4:

core: type TVec4

UniformBuffer:

rendering: BufferType.UniformBuffer

UniformBufferMapped:

rendering: BufferType.UniformBufferMapped

Unit2:

core: const Unit2

Unit2f:

core: const Unit2f

Unit2f32:

core: const Unit2f32

Unit2f64:

core: const Unit2f64

Unit2i:

core: const Unit2i

Unit2i16:

core: const Unit2i16

Unit2i32:

core: const Unit2i32

Unit2i64:

core: const Unit2i64

Unit2i8:

core: const Unit2i8

Unit3:

core: const Unit3

Unit3f:

core: const Unit3f

Unit3f32:

core: const Unit3f32

Unit3f64:

core: const Unit3f64

Unit3i:

core: const Unit3i

Unit3i16:

core: const Unit3i16

Unit3i32:

core: const Unit3i32

Unit3i64:

core: const Unit3i64

Unit3i8:

core: const Unit3i8

Unit4:

core: const Unit4

Unit4f:

core: const Unit4f

Unit4f32:

core: const Unit4f32

Unit4f64:

core: const Unit4f64

Unit4i:

core: const Unit4i

Unit4i16:

core: const Unit4i16

Unit4i32:

core: const Unit4i32

Unit4i64:

core: const Unit4i64

Unit4i8:

core: const Unit4i8

unmapAction:

UnmapGravity:

x: const UnmapGravity

UnmapNotify:

x: const UnmapNotify

unpause:

unsafeColumnAt:

db_sqlite: proc unsafeColumnAt(row: InstantRow; index: int32): cstring

Unsorted:

x: const Unsorted

updateAllGPUBuffers:

rendering: proc updateAllGPUBuffers[T](value: T; flush = false)

updateGPUBuffer:

rendering: proc updateGPUBuffer(gpuData: GPUData; count = 0'u64; flush = false)

updateInputs:

input: proc updateInputs(): bool

uploadImages:

rendering: proc uploadImages(renderdata: var RenderData; descriptorSet: var DescriptorSetData)

user_data:

sqlite3: proc user_data(para1: Pcontext): pointer

UserStorage:

storage: StorageType.UserStorage

UseXKeyboard:

xi: const UseXKeyboard

USPosition:

xutil: const USPosition

USSize:

xutil: const USSize

Valid:

ValuatorClass:

xi: const ValuatorClass

value_blob:

sqlite3: proc value_blob(para1: PValue): pointer

value_bytes:

sqlite3: proc value_bytes(para1: PValue): int32

value_bytes16:

sqlite3: proc value_bytes16(para1: PValue): int32

value_double:

sqlite3: proc value_double(para1: PValue): float64

value_int:

sqlite3: proc value_int(para1: PValue): int32

value_int64:

sqlite3: proc value_int64(para1: PValue): int64

value_text:

sqlite3: proc value_text(para1: PValue): cstring

value_text16:

sqlite3: proc value_text16(para1: PValue): pointer

value_text16be:

sqlite3: proc value_text16be(para1: PValue): pointer

value_text16le:

sqlite3: proc value_text16le(para1: PValue): pointer

value_type:

sqlite3: proc value_type(para1: PValue): int32

vec1:

core: proc vec1[T: SomeNumber](x: T): Vec1f

Vec1f:

core: type Vec1f

Vec1i:

core: type Vec1i

vec1i:

core: proc vec1i[T: SomeInteger](x: T): Vec1i

Vec1u:

core: type Vec1u

vec2:

Vec2f:

core: type Vec2f

Vec2i:

core: type Vec2i

vec2i:

Vec2i8:

core: type Vec2i8

vec2i8:

Vec2u:

core: type Vec2u

vec3:

Vec3f:

core: type Vec3f

Vec3i:

core: type Vec3i

vec3i:

Vec3i8:

core: type Vec3i8

vec3i8:

Vec3u:

core: type Vec3u

vec4:

Vec4f:

core: type Vec4f

Vec4i:

core: type Vec4i

vec4i:

Vec4u:

core: type Vec4u

VendorRelease:

xlib: proc VendorRelease(dpy: PDisplay): cint

version:

sqlite3: proc version(): cstring

VertexAttribute:

rendering: template VertexAttribute()

VertexBuffer:

rendering: BufferType.VertexBuffer

VertexBufferMapped:

rendering: BufferType.VertexBufferMapped

VerticalAlignment:

core: enum VerticalAlignment

verticalAlignment:

text: proc verticalAlignment(textbox: Textbox): VerticalAlignment

verticalAlignment=:

text: proc verticalAlignment=(textbox: var Textbox; value: VerticalAlignment)

VisibilityChangeMask:

x: const VisibilityChangeMask

VisibilityFullyObscured:

x: const VisibilityFullyObscured

VisibilityNotify:

x: const VisibilityNotify

VisibilityPartiallyObscured:

x: const VisibilityPartiallyObscured

VisibilityUnobscured:

x: const VisibilityUnobscured

Visual:

xlib: object Visual

VisualAllMask:

xutil: const VisualAllMask

VisualBitsPerRGBMask:

xutil: const VisualBitsPerRGBMask

VisualBlueMaskMask:

xutil: const VisualBlueMaskMask

VisualClassMask:

xutil: const VisualClassMask

VisualColormapSizeMask:

xutil: const VisualColormapSizeMask

VisualDepthMask:

xutil: const VisualDepthMask

VisualGreenMaskMask:

xutil: const VisualGreenMaskMask

VisualID:

x: type VisualID

VisualIDMask:

xutil: const VisualIDMask

VisualNoMask:

xutil: const VisualNoMask

VisualRedMaskMask:

xutil: const VisualRedMaskMask

VisualScreenMask:

xutil: const VisualScreenMask

VkAabbPositionsKHR:

api: object VkAabbPositionsKHR

VkAabbPositionsNV:

api: object VkAabbPositionsNV

VkAccelerationStructureBuildGeometryInfoKHR:

api: object VkAccelerationStructureBuildGeometryInfoKHR

VkAccelerationStructureBuildRangeInfoKHR:

api: object VkAccelerationStructureBuildRangeInfoKHR

VkAccelerationStructureBuildSizesInfoKHR:

api: object VkAccelerationStructureBuildSizesInfoKHR

VkAccelerationStructureBuildTypeKHR:

api: enum VkAccelerationStructureBuildTypeKHR

VkAccelerationStructureCaptureDescriptorDataInfoEXT:

api: object VkAccelerationStructureCaptureDescriptorDataInfoEXT

VkAccelerationStructureCompatibilityKHR:

api: enum VkAccelerationStructureCompatibilityKHR

VkAccelerationStructureCreateFlagBitsKHR:

api: enum VkAccelerationStructureCreateFlagBitsKHR

VkAccelerationStructureCreateFlagsKHR:

api: type VkAccelerationStructureCreateFlagsKHR

VkAccelerationStructureCreateInfoKHR:

api: object VkAccelerationStructureCreateInfoKHR

VkAccelerationStructureCreateInfoNV:

api: object VkAccelerationStructureCreateInfoNV

VkAccelerationStructureDeviceAddressInfoKHR:

api: object VkAccelerationStructureDeviceAddressInfoKHR

VkAccelerationStructureGeometryAabbsDataKHR:

api: object VkAccelerationStructureGeometryAabbsDataKHR

VkAccelerationStructureGeometryDataKHR:

api: object VkAccelerationStructureGeometryDataKHR

VkAccelerationStructureGeometryInstancesDataKHR:

api: object VkAccelerationStructureGeometryInstancesDataKHR

VkAccelerationStructureGeometryKHR:

api: object VkAccelerationStructureGeometryKHR

VkAccelerationStructureGeometryMotionTrianglesDataNV:

api: object VkAccelerationStructureGeometryMotionTrianglesDataNV

VkAccelerationStructureGeometryTrianglesDataKHR:

api: object VkAccelerationStructureGeometryTrianglesDataKHR

VkAccelerationStructureInfoNV:

api: object VkAccelerationStructureInfoNV

VkAccelerationStructureInstanceKHR:

api: object VkAccelerationStructureInstanceKHR

VkAccelerationStructureInstanceNV:

api: object VkAccelerationStructureInstanceNV

VkAccelerationStructureKHR:

api: type VkAccelerationStructureKHR

VkAccelerationStructureMatrixMotionInstanceNV:

api: object VkAccelerationStructureMatrixMotionInstanceNV

VkAccelerationStructureMemoryRequirementsInfoNV:

api: object VkAccelerationStructureMemoryRequirementsInfoNV

VkAccelerationStructureMemoryRequirementsTypeNV:

api: enum VkAccelerationStructureMemoryRequirementsTypeNV

VkAccelerationStructureMotionInfoFlagsNV:

api: type VkAccelerationStructureMotionInfoFlagsNV

VkAccelerationStructureMotionInfoNV:

api: object VkAccelerationStructureMotionInfoNV

VkAccelerationStructureMotionInstanceDataNV:

api: object VkAccelerationStructureMotionInstanceDataNV

VkAccelerationStructureMotionInstanceFlagsNV:

api: type VkAccelerationStructureMotionInstanceFlagsNV

VkAccelerationStructureMotionInstanceNV:

api: object VkAccelerationStructureMotionInstanceNV

VkAccelerationStructureMotionInstanceTypeNV:

api: enum VkAccelerationStructureMotionInstanceTypeNV

VkAccelerationStructureNV:

api: type VkAccelerationStructureNV

VkAccelerationStructureSRTMotionInstanceNV:

api: object VkAccelerationStructureSRTMotionInstanceNV

VkAccelerationStructureTrianglesOpacityMicromapEXT:

api: object VkAccelerationStructureTrianglesOpacityMicromapEXT

VkAccelerationStructureTypeKHR:

api: enum VkAccelerationStructureTypeKHR

VkAccelerationStructureTypeNV:

api: type VkAccelerationStructureTypeNV

VkAccelerationStructureVersionInfoKHR:

api: object VkAccelerationStructureVersionInfoKHR

VK_ACCESS_2_NONE:

api: const VK_ACCESS_2_NONE

VkAccessFlagBits:

api: enum VkAccessFlagBits

VkAccessFlagBits2:

api: enum VkAccessFlagBits2

VkAccessFlagBits2KHR:

api: type VkAccessFlagBits2KHR

VkAccessFlags:

api: type VkAccessFlags

VkAccessFlags2:

api: type VkAccessFlags2

VkAccessFlags2KHR:

api: type VkAccessFlags2KHR

vkAcquireDrmDisplayEXT:

api: var vkAcquireDrmDisplayEXT

vkAcquireNextImage2KHR:

api: var vkAcquireNextImage2KHR

VkAcquireNextImageInfoKHR:

api: object VkAcquireNextImageInfoKHR

vkAcquireNextImageKHR:

api: var vkAcquireNextImageKHR

vkAcquirePerformanceConfigurationINTEL:

api: var vkAcquirePerformanceConfigurationINTEL

VkAcquireProfilingLockFlagsKHR:

api: type VkAcquireProfilingLockFlagsKHR

VkAcquireProfilingLockInfoKHR:

api: object VkAcquireProfilingLockInfoKHR

vkAcquireProfilingLockKHR:

api: var vkAcquireProfilingLockKHR

vkAllocateCommandBuffers:

api: var vkAllocateCommandBuffers

vkAllocateDescriptorSets:

api: var vkAllocateDescriptorSets

vkAllocateMemory:

api: var vkAllocateMemory

VkAllocationCallbacks:

api: object VkAllocationCallbacks

VkAmigoProfilingSubmitInfoSEC:

api: object VkAmigoProfilingSubmitInfoSEC

VkAndroidSurfaceCreateFlagsKHR:

api: type VkAndroidSurfaceCreateFlagsKHR

VkApplicationInfo:

api: object VkApplicationInfo

VkApplicationParametersEXT:

api: object VkApplicationParametersEXT

VkAttachmentDescription:

api: object VkAttachmentDescription

VkAttachmentDescription2:

api: object VkAttachmentDescription2

VkAttachmentDescription2KHR:

api: object VkAttachmentDescription2KHR

VkAttachmentDescriptionFlagBits:

api: enum VkAttachmentDescriptionFlagBits

VkAttachmentDescriptionFlags:

api: type VkAttachmentDescriptionFlags

VkAttachmentDescriptionStencilLayout:

api: object VkAttachmentDescriptionStencilLayout

VkAttachmentDescriptionStencilLayoutKHR:

api: object VkAttachmentDescriptionStencilLayoutKHR

VkAttachmentLoadOp:

api: enum VkAttachmentLoadOp

VkAttachmentReference:

api: object VkAttachmentReference

VkAttachmentReference2:

api: object VkAttachmentReference2

VkAttachmentReference2KHR:

api: object VkAttachmentReference2KHR

VkAttachmentReferenceStencilLayout:

api: object VkAttachmentReferenceStencilLayout

VkAttachmentReferenceStencilLayoutKHR:

api: object VkAttachmentReferenceStencilLayoutKHR

VkAttachmentSampleCountInfoAMD:

api: object VkAttachmentSampleCountInfoAMD

VkAttachmentSampleCountInfoNV:

api: object VkAttachmentSampleCountInfoNV

VkAttachmentSampleLocationsEXT:

api: object VkAttachmentSampleLocationsEXT

VkAttachmentStoreOp:

api: enum VkAttachmentStoreOp

VK_ATTACHMENT_UNUSED:

api: const VK_ATTACHMENT_UNUSED

VkBaseInStructure:

api: object VkBaseInStructure

VkBaseOutStructure:

api: object VkBaseOutStructure

vkBeginCommandBuffer:

api: var vkBeginCommandBuffer

VkBindAccelerationStructureMemoryInfoNV:

api: object VkBindAccelerationStructureMemoryInfoNV

vkBindAccelerationStructureMemoryNV:

api: var vkBindAccelerationStructureMemoryNV

vkBindBufferMemory:

api: var vkBindBufferMemory

vkBindBufferMemory2:

api: var vkBindBufferMemory2

VkBindBufferMemoryDeviceGroupInfo:

api: object VkBindBufferMemoryDeviceGroupInfo

VkBindBufferMemoryDeviceGroupInfoKHR:

api: object VkBindBufferMemoryDeviceGroupInfoKHR

VkBindBufferMemoryInfo:

api: object VkBindBufferMemoryInfo

VkBindBufferMemoryInfoKHR:

api: object VkBindBufferMemoryInfoKHR

vkBindImageMemory:

api: var vkBindImageMemory

vkBindImageMemory2:

api: var vkBindImageMemory2

VkBindImageMemoryDeviceGroupInfo:

api: object VkBindImageMemoryDeviceGroupInfo

VkBindImageMemoryDeviceGroupInfoKHR:

api: object VkBindImageMemoryDeviceGroupInfoKHR

VkBindImageMemoryInfo:

api: object VkBindImageMemoryInfo

VkBindImageMemoryInfoKHR:

api: object VkBindImageMemoryInfoKHR

VkBindImageMemorySwapchainInfoKHR:

api: object VkBindImageMemorySwapchainInfoKHR

VkBindImagePlaneMemoryInfo:

api: object VkBindImagePlaneMemoryInfo

VkBindImagePlaneMemoryInfoKHR:

api: object VkBindImagePlaneMemoryInfoKHR

VkBindIndexBufferIndirectCommandNV:

api: object VkBindIndexBufferIndirectCommandNV

vkBindOpticalFlowSessionImageNV:

api: var vkBindOpticalFlowSessionImageNV

VkBindShaderGroupIndirectCommandNV:

api: object VkBindShaderGroupIndirectCommandNV

VkBindSparseInfo:

api: object VkBindSparseInfo

VkBindVertexBufferIndirectCommandNV:

api: object VkBindVertexBufferIndirectCommandNV

VkBlendFactor:

api: enum VkBlendFactor

VkBlendOp:

api: enum VkBlendOp

VkBlendOverlapEXT:

api: enum VkBlendOverlapEXT

VkBlitImageInfo2:

api: object VkBlitImageInfo2

VkBlitImageInfo2KHR:

api: object VkBlitImageInfo2KHR

VkBool32:

api: type VkBool32

VkBorderColor:

api: enum VkBorderColor

VkBuffer:

api: type VkBuffer

VkBufferCaptureDescriptorDataInfoEXT:

api: object VkBufferCaptureDescriptorDataInfoEXT

VkBufferCollectionFUCHSIA:

api: type VkBufferCollectionFUCHSIA

VkBufferCopy:

api: object VkBufferCopy

VkBufferCopy2:

api: object VkBufferCopy2

VkBufferCopy2KHR:

api: object VkBufferCopy2KHR

VkBufferCreateFlagBits:

api: enum VkBufferCreateFlagBits

VkBufferCreateFlags:

api: type VkBufferCreateFlags

VkBufferCreateInfo:

api: object VkBufferCreateInfo

VkBufferDeviceAddressCreateInfoEXT:

api: object VkBufferDeviceAddressCreateInfoEXT

VkBufferDeviceAddressInfo:

api: object VkBufferDeviceAddressInfo

VkBufferDeviceAddressInfoEXT:

api: object VkBufferDeviceAddressInfoEXT

VkBufferDeviceAddressInfoKHR:

api: object VkBufferDeviceAddressInfoKHR

VkBufferImageCopy:

api: object VkBufferImageCopy

VkBufferImageCopy2:

api: object VkBufferImageCopy2

VkBufferImageCopy2KHR:

api: object VkBufferImageCopy2KHR

VkBufferMemoryBarrier:

api: object VkBufferMemoryBarrier

VkBufferMemoryBarrier2:

api: object VkBufferMemoryBarrier2

VkBufferMemoryBarrier2KHR:

api: object VkBufferMemoryBarrier2KHR

VkBufferMemoryRequirementsInfo2:

api: object VkBufferMemoryRequirementsInfo2

VkBufferMemoryRequirementsInfo2KHR:

api: object VkBufferMemoryRequirementsInfo2KHR

VkBufferOpaqueCaptureAddressCreateInfo:

api: object VkBufferOpaqueCaptureAddressCreateInfo

VkBufferOpaqueCaptureAddressCreateInfoKHR:

api: object VkBufferOpaqueCaptureAddressCreateInfoKHR

VkBufferUsageFlagBits:

api: enum VkBufferUsageFlagBits

VkBufferUsageFlags:

api: type VkBufferUsageFlags

VkBufferView:

api: type VkBufferView

VkBufferViewCreateFlags:

api: type VkBufferViewCreateFlags

VkBufferViewCreateInfo:

api: object VkBufferViewCreateInfo

VkBuildAccelerationStructureFlagBitsKHR:

api: enum VkBuildAccelerationStructureFlagBitsKHR

VkBuildAccelerationStructureFlagBitsNV:

api: type VkBuildAccelerationStructureFlagBitsNV

VkBuildAccelerationStructureFlagsKHR:

api: type VkBuildAccelerationStructureFlagsKHR

VkBuildAccelerationStructureFlagsNV:

api: type VkBuildAccelerationStructureFlagsNV

VkBuildAccelerationStructureModeKHR:

api: enum VkBuildAccelerationStructureModeKHR

vkBuildAccelerationStructuresKHR:

api: var vkBuildAccelerationStructuresKHR

VkBuildMicromapFlagBitsEXT:

api: enum VkBuildMicromapFlagBitsEXT

VkBuildMicromapFlagsEXT:

api: type VkBuildMicromapFlagsEXT

VkBuildMicromapModeEXT:

api: enum VkBuildMicromapModeEXT

vkBuildMicromapsEXT:

api: var vkBuildMicromapsEXT

VkCalibratedTimestampInfoEXT:

api: object VkCalibratedTimestampInfoEXT

VkCheckpointData2NV:

api: object VkCheckpointData2NV

VkCheckpointDataNV:

api: object VkCheckpointDataNV

VkChromaLocation:

api: enum VkChromaLocation

VkChromaLocationKHR:

api: type VkChromaLocationKHR

VkClearAttachment:

api: object VkClearAttachment

VkClearColorValue:

api: object VkClearColorValue

VkClearDepthStencilValue:

api: object VkClearDepthStencilValue

VkClearRect:

api: object VkClearRect

VkClearValue:

api: object VkClearValue

vkCmdBeginConditionalRenderingEXT:

api: var vkCmdBeginConditionalRenderingEXT

vkCmdBeginDebugUtilsLabelEXT:

api: var vkCmdBeginDebugUtilsLabelEXT

vkCmdBeginQuery:

api: var vkCmdBeginQuery

vkCmdBeginQueryIndexedEXT:

api: var vkCmdBeginQueryIndexedEXT

vkCmdBeginRendering:

api: var vkCmdBeginRendering

vkCmdBeginRenderPass:

api: var vkCmdBeginRenderPass

vkCmdBeginRenderPass2:

api: var vkCmdBeginRenderPass2

vkCmdBeginTransformFeedbackEXT:

api: var vkCmdBeginTransformFeedbackEXT

vkCmdBindDescriptorBufferEmbeddedSamplersEXT:

api: var vkCmdBindDescriptorBufferEmbeddedSamplersEXT

vkCmdBindDescriptorBuffersEXT:

api: var vkCmdBindDescriptorBuffersEXT

vkCmdBindDescriptorSets:

api: var vkCmdBindDescriptorSets

vkCmdBindIndexBuffer:

api: var vkCmdBindIndexBuffer

vkCmdBindInvocationMaskHUAWEI:

api: var vkCmdBindInvocationMaskHUAWEI

vkCmdBindPipeline:

api: var vkCmdBindPipeline

vkCmdBindPipelineShaderGroupNV:

api: var vkCmdBindPipelineShaderGroupNV

vkCmdBindShadingRateImageNV:

api: var vkCmdBindShadingRateImageNV

vkCmdBindTransformFeedbackBuffersEXT:

api: var vkCmdBindTransformFeedbackBuffersEXT

vkCmdBindVertexBuffers:

api: var vkCmdBindVertexBuffers

vkCmdBindVertexBuffers2:

api: var vkCmdBindVertexBuffers2

vkCmdBlitImage:

api: var vkCmdBlitImage

vkCmdBlitImage2:

api: var vkCmdBlitImage2

vkCmdBuildAccelerationStructureNV:

api: var vkCmdBuildAccelerationStructureNV

vkCmdBuildAccelerationStructuresIndirectKHR:

api: var vkCmdBuildAccelerationStructuresIndirectKHR

vkCmdBuildAccelerationStructuresKHR:

api: var vkCmdBuildAccelerationStructuresKHR

vkCmdBuildMicromapsEXT:

api: var vkCmdBuildMicromapsEXT

vkCmdClearAttachments:

api: var vkCmdClearAttachments

vkCmdClearColorImage:

api: var vkCmdClearColorImage

vkCmdClearDepthStencilImage:

api: var vkCmdClearDepthStencilImage

vkCmdCopyAccelerationStructureKHR:

api: var vkCmdCopyAccelerationStructureKHR

vkCmdCopyAccelerationStructureNV:

api: var vkCmdCopyAccelerationStructureNV

vkCmdCopyAccelerationStructureToMemoryKHR:

api: var vkCmdCopyAccelerationStructureToMemoryKHR

vkCmdCopyBuffer:

api: var vkCmdCopyBuffer

vkCmdCopyBuffer2:

api: var vkCmdCopyBuffer2

vkCmdCopyBufferToImage:

api: var vkCmdCopyBufferToImage

vkCmdCopyBufferToImage2:

api: var vkCmdCopyBufferToImage2

vkCmdCopyImage:

api: var vkCmdCopyImage

vkCmdCopyImage2:

api: var vkCmdCopyImage2

vkCmdCopyImageToBuffer:

api: var vkCmdCopyImageToBuffer

vkCmdCopyImageToBuffer2:

api: var vkCmdCopyImageToBuffer2

vkCmdCopyMemoryIndirectNV:

api: var vkCmdCopyMemoryIndirectNV

vkCmdCopyMemoryToAccelerationStructureKHR:

api: var vkCmdCopyMemoryToAccelerationStructureKHR

vkCmdCopyMemoryToImageIndirectNV:

api: var vkCmdCopyMemoryToImageIndirectNV

vkCmdCopyMemoryToMicromapEXT:

api: var vkCmdCopyMemoryToMicromapEXT

vkCmdCopyMicromapEXT:

api: var vkCmdCopyMicromapEXT

vkCmdCopyMicromapToMemoryEXT:

api: var vkCmdCopyMicromapToMemoryEXT

vkCmdCopyQueryPoolResults:

api: var vkCmdCopyQueryPoolResults

vkCmdCuLaunchKernelNVX:

api: var vkCmdCuLaunchKernelNVX

vkCmdDecompressMemoryIndirectCountNV:

api: var vkCmdDecompressMemoryIndirectCountNV

vkCmdDecompressMemoryNV:

api: var vkCmdDecompressMemoryNV

vkCmdDispatch:

api: var vkCmdDispatch

vkCmdDispatchBase:

api: var vkCmdDispatchBase

vkCmdDispatchIndirect:

api: var vkCmdDispatchIndirect

vkCmdDraw:

api: var vkCmdDraw

vkCmdDrawClusterHUAWEI:

api: var vkCmdDrawClusterHUAWEI

vkCmdDrawClusterIndirectHUAWEI:

api: var vkCmdDrawClusterIndirectHUAWEI

vkCmdDrawIndexed:

api: var vkCmdDrawIndexed

vkCmdDrawIndexedIndirect:

api: var vkCmdDrawIndexedIndirect

vkCmdDrawIndexedIndirectCount:

api: var vkCmdDrawIndexedIndirectCount

vkCmdDrawIndirect:

api: var vkCmdDrawIndirect

vkCmdDrawIndirectByteCountEXT:

api: var vkCmdDrawIndirectByteCountEXT

vkCmdDrawIndirectCount:

api: var vkCmdDrawIndirectCount

vkCmdDrawMeshTasksEXT:

api: var vkCmdDrawMeshTasksEXT

vkCmdDrawMeshTasksIndirectCountEXT:

api: var vkCmdDrawMeshTasksIndirectCountEXT

vkCmdDrawMeshTasksIndirectCountNV:

api: var vkCmdDrawMeshTasksIndirectCountNV

vkCmdDrawMeshTasksIndirectEXT:

api: var vkCmdDrawMeshTasksIndirectEXT

vkCmdDrawMeshTasksIndirectNV:

api: var vkCmdDrawMeshTasksIndirectNV

vkCmdDrawMeshTasksNV:

api: var vkCmdDrawMeshTasksNV

vkCmdDrawMultiEXT:

api: var vkCmdDrawMultiEXT

vkCmdDrawMultiIndexedEXT:

api: var vkCmdDrawMultiIndexedEXT

vkCmdEndConditionalRenderingEXT:

api: var vkCmdEndConditionalRenderingEXT

vkCmdEndDebugUtilsLabelEXT:

api: var vkCmdEndDebugUtilsLabelEXT

vkCmdEndQuery:

api: var vkCmdEndQuery

vkCmdEndQueryIndexedEXT:

api: var vkCmdEndQueryIndexedEXT

vkCmdEndRendering:

api: var vkCmdEndRendering

vkCmdEndRenderPass:

api: var vkCmdEndRenderPass

vkCmdEndRenderPass2:

api: var vkCmdEndRenderPass2

vkCmdEndTransformFeedbackEXT:

api: var vkCmdEndTransformFeedbackEXT

vkCmdExecuteCommands:

api: var vkCmdExecuteCommands

vkCmdExecuteGeneratedCommandsNV:

api: var vkCmdExecuteGeneratedCommandsNV

vkCmdFillBuffer:

api: var vkCmdFillBuffer

vkCmdInsertDebugUtilsLabelEXT:

api: var vkCmdInsertDebugUtilsLabelEXT

vkCmdNextSubpass:

api: var vkCmdNextSubpass

vkCmdNextSubpass2:

api: var vkCmdNextSubpass2

vkCmdOpticalFlowExecuteNV:

api: var vkCmdOpticalFlowExecuteNV

vkCmdPipelineBarrier:

api: var vkCmdPipelineBarrier

vkCmdPipelineBarrier2:

api: var vkCmdPipelineBarrier2

vkCmdPreprocessGeneratedCommandsNV:

api: var vkCmdPreprocessGeneratedCommandsNV

vkCmdPushConstants:

api: var vkCmdPushConstants

vkCmdPushDescriptorSetKHR:

api: var vkCmdPushDescriptorSetKHR

vkCmdPushDescriptorSetWithTemplateKHR:

api: var vkCmdPushDescriptorSetWithTemplateKHR

vkCmdResetEvent:

api: var vkCmdResetEvent

vkCmdResetEvent2:

api: var vkCmdResetEvent2

vkCmdResetQueryPool:

api: var vkCmdResetQueryPool

vkCmdResolveImage:

api: var vkCmdResolveImage

vkCmdResolveImage2:

api: var vkCmdResolveImage2

vkCmdSetAlphaToCoverageEnableEXT:

api: var vkCmdSetAlphaToCoverageEnableEXT

vkCmdSetAlphaToOneEnableEXT:

api: var vkCmdSetAlphaToOneEnableEXT

vkCmdSetBlendConstants:

api: var vkCmdSetBlendConstants

vkCmdSetCheckpointNV:

api: var vkCmdSetCheckpointNV

vkCmdSetCoarseSampleOrderNV:

api: var vkCmdSetCoarseSampleOrderNV

vkCmdSetColorBlendAdvancedEXT:

api: var vkCmdSetColorBlendAdvancedEXT

vkCmdSetColorBlendEnableEXT:

api: var vkCmdSetColorBlendEnableEXT

vkCmdSetColorBlendEquationEXT:

api: var vkCmdSetColorBlendEquationEXT

vkCmdSetColorWriteEnableEXT:

api: var vkCmdSetColorWriteEnableEXT

vkCmdSetColorWriteMaskEXT:

api: var vkCmdSetColorWriteMaskEXT

vkCmdSetConservativeRasterizationModeEXT:

api: var vkCmdSetConservativeRasterizationModeEXT

vkCmdSetCoverageModulationModeNV:

api: var vkCmdSetCoverageModulationModeNV

vkCmdSetCoverageModulationTableEnableNV:

api: var vkCmdSetCoverageModulationTableEnableNV

vkCmdSetCoverageModulationTableNV:

api: var vkCmdSetCoverageModulationTableNV

vkCmdSetCoverageReductionModeNV:

api: var vkCmdSetCoverageReductionModeNV

vkCmdSetCoverageToColorEnableNV:

api: var vkCmdSetCoverageToColorEnableNV

vkCmdSetCoverageToColorLocationNV:

api: var vkCmdSetCoverageToColorLocationNV

vkCmdSetCullMode:

api: var vkCmdSetCullMode

vkCmdSetDepthBias:

api: var vkCmdSetDepthBias

vkCmdSetDepthBiasEnable:

api: var vkCmdSetDepthBiasEnable

vkCmdSetDepthBounds:

api: var vkCmdSetDepthBounds

vkCmdSetDepthBoundsTestEnable:

api: var vkCmdSetDepthBoundsTestEnable

vkCmdSetDepthClampEnableEXT:

api: var vkCmdSetDepthClampEnableEXT

vkCmdSetDepthClipEnableEXT:

api: var vkCmdSetDepthClipEnableEXT

vkCmdSetDepthClipNegativeOneToOneEXT:

api: var vkCmdSetDepthClipNegativeOneToOneEXT

vkCmdSetDepthCompareOp:

api: var vkCmdSetDepthCompareOp

vkCmdSetDepthTestEnable:

api: var vkCmdSetDepthTestEnable

vkCmdSetDepthWriteEnable:

api: var vkCmdSetDepthWriteEnable

vkCmdSetDescriptorBufferOffsetsEXT:

api: var vkCmdSetDescriptorBufferOffsetsEXT

vkCmdSetDeviceMask:

api: var vkCmdSetDeviceMask

vkCmdSetDiscardRectangleEnableEXT:

api: var vkCmdSetDiscardRectangleEnableEXT

vkCmdSetDiscardRectangleEXT:

api: var vkCmdSetDiscardRectangleEXT

vkCmdSetDiscardRectangleModeEXT:

api: var vkCmdSetDiscardRectangleModeEXT

vkCmdSetEvent:

api: var vkCmdSetEvent

vkCmdSetEvent2:

api: var vkCmdSetEvent2

vkCmdSetExclusiveScissorEnableNV:

api: var vkCmdSetExclusiveScissorEnableNV

vkCmdSetExclusiveScissorNV:

api: var vkCmdSetExclusiveScissorNV

vkCmdSetExtraPrimitiveOverestimationSizeEXT:

api: var vkCmdSetExtraPrimitiveOverestimationSizeEXT

vkCmdSetFragmentShadingRateEnumNV:

api: var vkCmdSetFragmentShadingRateEnumNV

vkCmdSetFragmentShadingRateKHR:

api: var vkCmdSetFragmentShadingRateKHR

vkCmdSetFrontFace:

api: var vkCmdSetFrontFace

vkCmdSetLineRasterizationModeEXT:

api: var vkCmdSetLineRasterizationModeEXT

vkCmdSetLineStippleEnableEXT:

api: var vkCmdSetLineStippleEnableEXT

vkCmdSetLineStippleEXT:

api: var vkCmdSetLineStippleEXT

vkCmdSetLineWidth:

api: var vkCmdSetLineWidth

vkCmdSetLogicOpEnableEXT:

api: var vkCmdSetLogicOpEnableEXT

vkCmdSetPerformanceMarkerINTEL:

api: var vkCmdSetPerformanceMarkerINTEL

vkCmdSetPerformanceOverrideINTEL:

api: var vkCmdSetPerformanceOverrideINTEL

vkCmdSetPerformanceStreamMarkerINTEL:

api: var vkCmdSetPerformanceStreamMarkerINTEL

vkCmdSetPolygonModeEXT:

api: var vkCmdSetPolygonModeEXT

vkCmdSetPrimitiveRestartEnable:

api: var vkCmdSetPrimitiveRestartEnable

vkCmdSetPrimitiveTopology:

api: var vkCmdSetPrimitiveTopology

vkCmdSetProvokingVertexModeEXT:

api: var vkCmdSetProvokingVertexModeEXT

vkCmdSetRasterizationSamplesEXT:

api: var vkCmdSetRasterizationSamplesEXT

vkCmdSetRasterizationStreamEXT:

api: var vkCmdSetRasterizationStreamEXT

vkCmdSetRasterizerDiscardEnable:

api: var vkCmdSetRasterizerDiscardEnable

vkCmdSetRayTracingPipelineStackSizeKHR:

api: var vkCmdSetRayTracingPipelineStackSizeKHR

vkCmdSetRepresentativeFragmentTestEnableNV:

api: var vkCmdSetRepresentativeFragmentTestEnableNV

vkCmdSetSampleLocationsEnableEXT:

api: var vkCmdSetSampleLocationsEnableEXT

vkCmdSetSampleLocationsEXT:

api: var vkCmdSetSampleLocationsEXT

vkCmdSetSampleMaskEXT:

api: var vkCmdSetSampleMaskEXT

vkCmdSetScissor:

api: var vkCmdSetScissor

vkCmdSetScissorWithCount:

api: var vkCmdSetScissorWithCount

vkCmdSetShadingRateImageEnableNV:

api: var vkCmdSetShadingRateImageEnableNV

vkCmdSetStencilCompareMask:

api: var vkCmdSetStencilCompareMask

vkCmdSetStencilOp:

api: var vkCmdSetStencilOp

vkCmdSetStencilReference:

api: var vkCmdSetStencilReference

vkCmdSetStencilTestEnable:

api: var vkCmdSetStencilTestEnable

vkCmdSetStencilWriteMask:

api: var vkCmdSetStencilWriteMask

vkCmdSetTessellationDomainOriginEXT:

api: var vkCmdSetTessellationDomainOriginEXT

vkCmdSetVertexInputEXT:

api: var vkCmdSetVertexInputEXT

vkCmdSetViewport:

api: var vkCmdSetViewport

vkCmdSetViewportShadingRatePaletteNV:

api: var vkCmdSetViewportShadingRatePaletteNV

vkCmdSetViewportSwizzleNV:

api: var vkCmdSetViewportSwizzleNV

vkCmdSetViewportWithCount:

api: var vkCmdSetViewportWithCount

vkCmdSetViewportWScalingEnableNV:

api: var vkCmdSetViewportWScalingEnableNV

vkCmdSetViewportWScalingNV:

api: var vkCmdSetViewportWScalingNV

vkCmdSubpassShadingHUAWEI:

api: var vkCmdSubpassShadingHUAWEI

vkCmdTraceRaysIndirect2KHR:

api: var vkCmdTraceRaysIndirect2KHR

vkCmdTraceRaysIndirectKHR:

api: var vkCmdTraceRaysIndirectKHR

vkCmdTraceRaysKHR:

api: var vkCmdTraceRaysKHR

vkCmdTraceRaysNV:

api: var vkCmdTraceRaysNV

vkCmdUpdateBuffer:

api: var vkCmdUpdateBuffer

vkCmdWaitEvents:

api: var vkCmdWaitEvents

vkCmdWaitEvents2:

api: var vkCmdWaitEvents2

vkCmdWriteAccelerationStructuresPropertiesKHR:

api: var vkCmdWriteAccelerationStructuresPropertiesKHR

vkCmdWriteAccelerationStructuresPropertiesNV:

api: var vkCmdWriteAccelerationStructuresPropertiesNV

vkCmdWriteBufferMarkerAMD:

api: var vkCmdWriteBufferMarkerAMD

vkCmdWriteMicromapsPropertiesEXT:

api: var vkCmdWriteMicromapsPropertiesEXT

vkCmdWriteTimestamp:

api: var vkCmdWriteTimestamp

vkCmdWriteTimestamp2:

api: var vkCmdWriteTimestamp2

VkCoarseSampleLocationNV:

api: object VkCoarseSampleLocationNV

VkCoarseSampleOrderCustomNV:

api: object VkCoarseSampleOrderCustomNV

VkCoarseSampleOrderTypeNV:

api: enum VkCoarseSampleOrderTypeNV

VkColorBlendAdvancedEXT:

api: object VkColorBlendAdvancedEXT

VkColorBlendEquationEXT:

api: object VkColorBlendEquationEXT

VkColorComponentFlagBits:

api: enum VkColorComponentFlagBits

VkColorComponentFlags:

api: type VkColorComponentFlags

VkColorSpaceKHR:

api: enum VkColorSpaceKHR

VkCommandBuffer:

api: type VkCommandBuffer

VkCommandBufferAllocateInfo:

api: object VkCommandBufferAllocateInfo

VkCommandBufferBeginInfo:

api: object VkCommandBufferBeginInfo

VkCommandBufferInheritanceConditionalRenderingInfoEXT:

api: object VkCommandBufferInheritanceConditionalRenderingInfoEXT

VkCommandBufferInheritanceInfo:

api: object VkCommandBufferInheritanceInfo

VkCommandBufferInheritanceRenderingInfo:

api: object VkCommandBufferInheritanceRenderingInfo

VkCommandBufferInheritanceRenderingInfoKHR:

api: object VkCommandBufferInheritanceRenderingInfoKHR

VkCommandBufferInheritanceRenderPassTransformInfoQCOM:

api: object VkCommandBufferInheritanceRenderPassTransformInfoQCOM

VkCommandBufferInheritanceViewportScissorInfoNV:

api: object VkCommandBufferInheritanceViewportScissorInfoNV

VkCommandBufferLevel:

api: enum VkCommandBufferLevel

VkCommandBufferResetFlagBits:

api: enum VkCommandBufferResetFlagBits

VkCommandBufferResetFlags:

api: type VkCommandBufferResetFlags

VkCommandBufferSubmitInfo:

api: object VkCommandBufferSubmitInfo

VkCommandBufferSubmitInfoKHR:

api: object VkCommandBufferSubmitInfoKHR

VkCommandBufferUsageFlagBits:

api: enum VkCommandBufferUsageFlagBits

VkCommandBufferUsageFlags:

api: type VkCommandBufferUsageFlags

VkCommandPool:

api: type VkCommandPool

VkCommandPoolCreateFlagBits:

api: enum VkCommandPoolCreateFlagBits

VkCommandPoolCreateFlags:

api: type VkCommandPoolCreateFlags

VkCommandPoolCreateInfo:

api: object VkCommandPoolCreateInfo

VkCommandPoolMemoryConsumption:

api: object VkCommandPoolMemoryConsumption

VkCommandPoolMemoryReservationCreateInfo:

api: object VkCommandPoolMemoryReservationCreateInfo

VkCommandPoolResetFlagBits:

api: enum VkCommandPoolResetFlagBits

VkCommandPoolResetFlags:

api: type VkCommandPoolResetFlags

VkCommandPoolTrimFlags:

api: type VkCommandPoolTrimFlags

VkCommandPoolTrimFlagsKHR:

api: type VkCommandPoolTrimFlagsKHR

VkCompareOp:

api: enum VkCompareOp

vkCompileDeferredNV:

api: var vkCompileDeferredNV

VkComponentMapping:

api: object VkComponentMapping

VkComponentSwizzle:

api: enum VkComponentSwizzle

VkComponentTypeNV:

api: enum VkComponentTypeNV

VkCompositeAlphaFlagBitsKHR:

api: enum VkCompositeAlphaFlagBitsKHR

VkCompositeAlphaFlagsKHR:

api: type VkCompositeAlphaFlagsKHR

VkComputePipelineCreateInfo:

api: object VkComputePipelineCreateInfo

VkConditionalRenderingBeginInfoEXT:

api: object VkConditionalRenderingBeginInfoEXT

VkConditionalRenderingFlagBitsEXT:

api: enum VkConditionalRenderingFlagBitsEXT

VkConditionalRenderingFlagsEXT:

api: type VkConditionalRenderingFlagsEXT

VkConformanceVersion:

api: object VkConformanceVersion

VkConformanceVersionKHR:

api: object VkConformanceVersionKHR

VkConservativeRasterizationModeEXT:

api: enum VkConservativeRasterizationModeEXT

VkCooperativeMatrixPropertiesNV:

api: object VkCooperativeMatrixPropertiesNV

VkCopyAccelerationStructureInfoKHR:

api: object VkCopyAccelerationStructureInfoKHR

vkCopyAccelerationStructureKHR:

api: var vkCopyAccelerationStructureKHR

VkCopyAccelerationStructureModeKHR:

api: enum VkCopyAccelerationStructureModeKHR

VkCopyAccelerationStructureModeNV:

api: type VkCopyAccelerationStructureModeNV

VkCopyAccelerationStructureToMemoryInfoKHR:

api: object VkCopyAccelerationStructureToMemoryInfoKHR

vkCopyAccelerationStructureToMemoryKHR:

api: var vkCopyAccelerationStructureToMemoryKHR

VkCopyBufferInfo2:

api: object VkCopyBufferInfo2

VkCopyBufferInfo2KHR:

api: object VkCopyBufferInfo2KHR

VkCopyBufferToImageInfo2:

api: object VkCopyBufferToImageInfo2

VkCopyBufferToImageInfo2KHR:

api: object VkCopyBufferToImageInfo2KHR

VkCopyCommandTransformInfoQCOM:

api: object VkCopyCommandTransformInfoQCOM

VkCopyDescriptorSet:

api: object VkCopyDescriptorSet

VkCopyImageInfo2:

api: object VkCopyImageInfo2

VkCopyImageInfo2KHR:

api: object VkCopyImageInfo2KHR

VkCopyImageToBufferInfo2:

api: object VkCopyImageToBufferInfo2

VkCopyImageToBufferInfo2KHR:

api: object VkCopyImageToBufferInfo2KHR

VkCopyMemoryIndirectCommandNV:

api: object VkCopyMemoryIndirectCommandNV

VkCopyMemoryToAccelerationStructureInfoKHR:

api: object VkCopyMemoryToAccelerationStructureInfoKHR

vkCopyMemoryToAccelerationStructureKHR:

api: var vkCopyMemoryToAccelerationStructureKHR

VkCopyMemoryToImageIndirectCommandNV:

api: object VkCopyMemoryToImageIndirectCommandNV

vkCopyMemoryToMicromapEXT:

api: var vkCopyMemoryToMicromapEXT

VkCopyMemoryToMicromapInfoEXT:

api: object VkCopyMemoryToMicromapInfoEXT

vkCopyMicromapEXT:

api: var vkCopyMicromapEXT

VkCopyMicromapInfoEXT:

api: object VkCopyMicromapInfoEXT

VkCopyMicromapModeEXT:

api: enum VkCopyMicromapModeEXT

vkCopyMicromapToMemoryEXT:

api: var vkCopyMicromapToMemoryEXT

VkCopyMicromapToMemoryInfoEXT:

api: object VkCopyMicromapToMemoryInfoEXT

VkCoverageModulationModeNV:

api: enum VkCoverageModulationModeNV

VkCoverageReductionModeNV:

api: enum VkCoverageReductionModeNV

vkCreateAccelerationStructureKHR:

api: var vkCreateAccelerationStructureKHR

vkCreateAccelerationStructureNV:

api: var vkCreateAccelerationStructureNV

vkCreateBuffer:

api: var vkCreateBuffer

vkCreateBufferView:

api: var vkCreateBufferView

vkCreateCommandPool:

api: var vkCreateCommandPool

vkCreateComputePipelines:

api: var vkCreateComputePipelines

vkCreateCuFunctionNVX:

api: var vkCreateCuFunctionNVX

vkCreateCuModuleNVX:

api: var vkCreateCuModuleNVX

vkCreateDebugReportCallbackEXT:

api: var vkCreateDebugReportCallbackEXT

vkCreateDebugUtilsMessengerEXT:

api: var vkCreateDebugUtilsMessengerEXT

vkCreateDeferredOperationKHR:

api: var vkCreateDeferredOperationKHR

vkCreateDescriptorPool:

api: var vkCreateDescriptorPool

vkCreateDescriptorSetLayout:

api: var vkCreateDescriptorSetLayout

vkCreateDescriptorUpdateTemplate:

api: var vkCreateDescriptorUpdateTemplate

vkCreateDevice:

api: var vkCreateDevice

vkCreateDisplayModeKHR:

api: var vkCreateDisplayModeKHR

vkCreateDisplayPlaneSurfaceKHR:

api: var vkCreateDisplayPlaneSurfaceKHR

vkCreateEvent:

api: var vkCreateEvent

vkCreateFence:

api: var vkCreateFence

vkCreateFramebuffer:

api: var vkCreateFramebuffer

vkCreateGraphicsPipelines:

api: var vkCreateGraphicsPipelines

vkCreateHeadlessSurfaceEXT:

api: var vkCreateHeadlessSurfaceEXT

vkCreateImage:

api: var vkCreateImage

vkCreateImageView:

api: var vkCreateImageView

vkCreateIndirectCommandsLayoutNV:

api: var vkCreateIndirectCommandsLayoutNV

vkCreateInstance:

api: var vkCreateInstance

vkCreateMicromapEXT:

api: var vkCreateMicromapEXT

vkCreateOpticalFlowSessionNV:

api: var vkCreateOpticalFlowSessionNV

vkCreatePipelineCache:

api: var vkCreatePipelineCache

vkCreatePipelineLayout:

api: var vkCreatePipelineLayout

vkCreatePrivateDataSlot:

api: var vkCreatePrivateDataSlot

vkCreateQueryPool:

api: var vkCreateQueryPool

vkCreateRayTracingPipelinesKHR:

api: var vkCreateRayTracingPipelinesKHR

vkCreateRayTracingPipelinesNV:

api: var vkCreateRayTracingPipelinesNV

vkCreateRenderPass:

api: var vkCreateRenderPass

vkCreateRenderPass2:

api: var vkCreateRenderPass2

vkCreateSampler:

api: var vkCreateSampler

vkCreateSamplerYcbcrConversion:

api: var vkCreateSamplerYcbcrConversion

vkCreateSemaphore:

api: var vkCreateSemaphore

vkCreateShaderModule:

api: var vkCreateShaderModule

vkCreateSharedSwapchainsKHR:

api: var vkCreateSharedSwapchainsKHR

vkCreateSwapchainKHR:

api: var vkCreateSwapchainKHR

vkCreateValidationCacheEXT:

api: var vkCreateValidationCacheEXT

VkCuFunctionCreateInfoNVX:

api: object VkCuFunctionCreateInfoNVX

VkCuFunctionNVX:

api: type VkCuFunctionNVX

VkCuLaunchInfoNVX:

api: object VkCuLaunchInfoNVX

VkCullModeFlagBits:

api: enum VkCullModeFlagBits

VkCullModeFlags:

api: type VkCullModeFlags

VK_CULL_MODE_FRONT_AND_BACK:

api: const VK_CULL_MODE_FRONT_AND_BACK

VK_CULL_MODE_NONE:

api: const VK_CULL_MODE_NONE

VkCuModuleCreateInfoNVX:

api: object VkCuModuleCreateInfoNVX

VkCuModuleNVX:

api: type VkCuModuleNVX

VkDebugMarkerMarkerInfoEXT:

api: object VkDebugMarkerMarkerInfoEXT

VkDebugMarkerObjectNameInfoEXT:

api: object VkDebugMarkerObjectNameInfoEXT

VkDebugMarkerObjectTagInfoEXT:

api: object VkDebugMarkerObjectTagInfoEXT

VkDebugReportCallbackCreateInfoEXT:

api: object VkDebugReportCallbackCreateInfoEXT

VkDebugReportCallbackEXT:

api: type VkDebugReportCallbackEXT

VkDebugReportFlagBitsEXT:

api: enum VkDebugReportFlagBitsEXT

VkDebugReportFlagsEXT:

api: type VkDebugReportFlagsEXT

vkDebugReportMessageEXT:

api: var vkDebugReportMessageEXT

VkDebugReportObjectTypeEXT:

api: enum VkDebugReportObjectTypeEXT

VkDebugUtilsLabelEXT:

api: object VkDebugUtilsLabelEXT

VkDebugUtilsMessageSeverityFlagBitsEXT:

api: enum VkDebugUtilsMessageSeverityFlagBitsEXT

VkDebugUtilsMessageSeverityFlagsEXT:

api: type VkDebugUtilsMessageSeverityFlagsEXT

VkDebugUtilsMessageTypeFlagBitsEXT:

api: enum VkDebugUtilsMessageTypeFlagBitsEXT

VkDebugUtilsMessageTypeFlagsEXT:

api: type VkDebugUtilsMessageTypeFlagsEXT

VkDebugUtilsMessengerCallbackDataEXT:

api: object VkDebugUtilsMessengerCallbackDataEXT

VkDebugUtilsMessengerCallbackDataFlagsEXT:

api: type VkDebugUtilsMessengerCallbackDataFlagsEXT

VkDebugUtilsMessengerCreateFlagsEXT:

api: type VkDebugUtilsMessengerCreateFlagsEXT

VkDebugUtilsMessengerCreateInfoEXT:

api: object VkDebugUtilsMessengerCreateInfoEXT

VkDebugUtilsMessengerEXT:

api: type VkDebugUtilsMessengerEXT

VkDebugUtilsObjectNameInfoEXT:

api: object VkDebugUtilsObjectNameInfoEXT

VkDebugUtilsObjectTagInfoEXT:

api: object VkDebugUtilsObjectTagInfoEXT

VkDecompressMemoryRegionNV:

api: object VkDecompressMemoryRegionNV

VkDedicatedAllocationBufferCreateInfoNV:

api: object VkDedicatedAllocationBufferCreateInfoNV

VkDedicatedAllocationImageCreateInfoNV:

api: object VkDedicatedAllocationImageCreateInfoNV

VkDedicatedAllocationMemoryAllocateInfoNV:

api: object VkDedicatedAllocationMemoryAllocateInfoNV

vkDeferredOperationJoinKHR:

api: var vkDeferredOperationJoinKHR

VkDeferredOperationKHR:

api: type VkDeferredOperationKHR

VkDependencyFlagBits:

api: enum VkDependencyFlagBits

VkDependencyFlags:

api: type VkDependencyFlags

VkDependencyInfo:

api: object VkDependencyInfo

VkDependencyInfoKHR:

api: object VkDependencyInfoKHR

VkDescriptorAddressInfoEXT:

api: object VkDescriptorAddressInfoEXT

VkDescriptorBindingFlagBits:

api: enum VkDescriptorBindingFlagBits

VkDescriptorBindingFlagBitsEXT:

api: type VkDescriptorBindingFlagBitsEXT

VkDescriptorBindingFlags:

api: type VkDescriptorBindingFlags

VkDescriptorBindingFlagsEXT:

api: type VkDescriptorBindingFlagsEXT

VkDescriptorBufferBindingInfoEXT:

api: object VkDescriptorBufferBindingInfoEXT

VkDescriptorBufferBindingPushDescriptorBufferHandleEXT:

api: object VkDescriptorBufferBindingPushDescriptorBufferHandleEXT

VkDescriptorBufferInfo:

api: object VkDescriptorBufferInfo

VkDescriptorDataEXT:

api: object VkDescriptorDataEXT

VkDescriptorGetInfoEXT:

api: object VkDescriptorGetInfoEXT

VkDescriptorImageInfo:

api: object VkDescriptorImageInfo

VkDescriptorPool:

api: type VkDescriptorPool

VkDescriptorPoolCreateFlagBits:

api: enum VkDescriptorPoolCreateFlagBits

VkDescriptorPoolCreateFlags:

api: type VkDescriptorPoolCreateFlags

VkDescriptorPoolCreateInfo:

api: object VkDescriptorPoolCreateInfo

VkDescriptorPoolInlineUniformBlockCreateInfo:

api: object VkDescriptorPoolInlineUniformBlockCreateInfo

VkDescriptorPoolInlineUniformBlockCreateInfoEXT:

api: object VkDescriptorPoolInlineUniformBlockCreateInfoEXT

VkDescriptorPoolResetFlags:

api: type VkDescriptorPoolResetFlags

VkDescriptorPoolSize:

api: object VkDescriptorPoolSize

VkDescriptorSet:

api: type VkDescriptorSet

VkDescriptorSetAllocateInfo:

api: object VkDescriptorSetAllocateInfo

VkDescriptorSetBindingReferenceVALVE:

api: object VkDescriptorSetBindingReferenceVALVE

VkDescriptorSetLayout:

api: type VkDescriptorSetLayout

VkDescriptorSetLayoutBinding:

api: object VkDescriptorSetLayoutBinding

VkDescriptorSetLayoutBindingFlagsCreateInfo:

api: object VkDescriptorSetLayoutBindingFlagsCreateInfo

VkDescriptorSetLayoutBindingFlagsCreateInfoEXT:

api: object VkDescriptorSetLayoutBindingFlagsCreateInfoEXT

VkDescriptorSetLayoutCreateFlagBits:

api: enum VkDescriptorSetLayoutCreateFlagBits

VkDescriptorSetLayoutCreateFlags:

api: type VkDescriptorSetLayoutCreateFlags

VkDescriptorSetLayoutCreateInfo:

api: object VkDescriptorSetLayoutCreateInfo

VkDescriptorSetLayoutHostMappingInfoVALVE:

api: object VkDescriptorSetLayoutHostMappingInfoVALVE

VkDescriptorSetLayoutSupport:

api: object VkDescriptorSetLayoutSupport

VkDescriptorSetLayoutSupportKHR:

api: object VkDescriptorSetLayoutSupportKHR

VkDescriptorSetVariableDescriptorCountAllocateInfo:

api: object VkDescriptorSetVariableDescriptorCountAllocateInfo

VkDescriptorSetVariableDescriptorCountAllocateInfoEXT:

api: object VkDescriptorSetVariableDescriptorCountAllocateInfoEXT

VkDescriptorSetVariableDescriptorCountLayoutSupport:

api: object VkDescriptorSetVariableDescriptorCountLayoutSupport

VkDescriptorSetVariableDescriptorCountLayoutSupportEXT:

api: object VkDescriptorSetVariableDescriptorCountLayoutSupportEXT

VkDescriptorType:

api: enum VkDescriptorType

VkDescriptorUpdateTemplate:

api: type VkDescriptorUpdateTemplate

VkDescriptorUpdateTemplateCreateFlags:

api: type VkDescriptorUpdateTemplateCreateFlags

VkDescriptorUpdateTemplateCreateFlagsKHR:

api: type VkDescriptorUpdateTemplateCreateFlagsKHR

VkDescriptorUpdateTemplateCreateInfo:

api: object VkDescriptorUpdateTemplateCreateInfo

VkDescriptorUpdateTemplateCreateInfoKHR:

api: object VkDescriptorUpdateTemplateCreateInfoKHR

VkDescriptorUpdateTemplateEntry:

api: object VkDescriptorUpdateTemplateEntry

VkDescriptorUpdateTemplateEntryKHR:

api: object VkDescriptorUpdateTemplateEntryKHR

VkDescriptorUpdateTemplateType:

api: enum VkDescriptorUpdateTemplateType

VkDescriptorUpdateTemplateTypeKHR:

api: type VkDescriptorUpdateTemplateTypeKHR

vkDestroyAccelerationStructureKHR:

api: var vkDestroyAccelerationStructureKHR

vkDestroyAccelerationStructureNV:

api: var vkDestroyAccelerationStructureNV

vkDestroyBuffer:

api: var vkDestroyBuffer

vkDestroyBufferView:

api: var vkDestroyBufferView

vkDestroyCommandPool:

api: var vkDestroyCommandPool

vkDestroyCuFunctionNVX:

api: var vkDestroyCuFunctionNVX

vkDestroyCuModuleNVX:

api: var vkDestroyCuModuleNVX

vkDestroyDebugReportCallbackEXT:

api: var vkDestroyDebugReportCallbackEXT

vkDestroyDebugUtilsMessengerEXT:

api: var vkDestroyDebugUtilsMessengerEXT

vkDestroyDeferredOperationKHR:

api: var vkDestroyDeferredOperationKHR

vkDestroyDescriptorPool:

api: var vkDestroyDescriptorPool

vkDestroyDescriptorSetLayout:

api: var vkDestroyDescriptorSetLayout

vkDestroyDescriptorUpdateTemplate:

api: var vkDestroyDescriptorUpdateTemplate

vkDestroyDevice:

api: var vkDestroyDevice

vkDestroyEvent:

api: var vkDestroyEvent

vkDestroyFence:

api: var vkDestroyFence

vkDestroyFramebuffer:

api: var vkDestroyFramebuffer

vkDestroyImage:

api: var vkDestroyImage

vkDestroyImageView:

api: var vkDestroyImageView

vkDestroyIndirectCommandsLayoutNV:

api: var vkDestroyIndirectCommandsLayoutNV

vkDestroyInstance:

api: var vkDestroyInstance

vkDestroyMicromapEXT:

api: var vkDestroyMicromapEXT

vkDestroyOpticalFlowSessionNV:

api: var vkDestroyOpticalFlowSessionNV

vkDestroyPipeline:

api: var vkDestroyPipeline

vkDestroyPipelineCache:

api: var vkDestroyPipelineCache

vkDestroyPipelineLayout:

api: var vkDestroyPipelineLayout

vkDestroyPrivateDataSlot:

api: var vkDestroyPrivateDataSlot

vkDestroyQueryPool:

api: var vkDestroyQueryPool

vkDestroyRenderPass:

api: var vkDestroyRenderPass

vkDestroySampler:

api: var vkDestroySampler

vkDestroySamplerYcbcrConversion:

api: var vkDestroySamplerYcbcrConversion

vkDestroySemaphore:

api: var vkDestroySemaphore

vkDestroyShaderModule:

api: var vkDestroyShaderModule

vkDestroySurfaceKHR:

api: var vkDestroySurfaceKHR

vkDestroySwapchainKHR:

api: var vkDestroySwapchainKHR

vkDestroyValidationCacheEXT:

api: var vkDestroyValidationCacheEXT

VkDevice:

api: type VkDevice

VkDeviceAddress:

api: type VkDeviceAddress

VkDeviceAddressBindingCallbackDataEXT:

api: object VkDeviceAddressBindingCallbackDataEXT

VkDeviceAddressBindingFlagBitsEXT:

api: enum VkDeviceAddressBindingFlagBitsEXT

VkDeviceAddressBindingFlagsEXT:

api: type VkDeviceAddressBindingFlagsEXT

VkDeviceAddressBindingTypeEXT:

api: enum VkDeviceAddressBindingTypeEXT

VkDeviceBufferMemoryRequirements:

api: object VkDeviceBufferMemoryRequirements

VkDeviceBufferMemoryRequirementsKHR:

api: object VkDeviceBufferMemoryRequirementsKHR

VkDeviceCreateFlags:

api: type VkDeviceCreateFlags

VkDeviceCreateInfo:

api: object VkDeviceCreateInfo

VkDeviceDeviceMemoryReportCreateInfoEXT:

api: object VkDeviceDeviceMemoryReportCreateInfoEXT

VkDeviceDiagnosticsConfigCreateInfoNV:

api: object VkDeviceDiagnosticsConfigCreateInfoNV

VkDeviceDiagnosticsConfigFlagBitsNV:

api: enum VkDeviceDiagnosticsConfigFlagBitsNV

VkDeviceDiagnosticsConfigFlagsNV:

api: type VkDeviceDiagnosticsConfigFlagsNV

VkDeviceEventInfoEXT:

api: object VkDeviceEventInfoEXT

VkDeviceEventTypeEXT:

api: enum VkDeviceEventTypeEXT

VkDeviceFaultAddressInfoEXT:

api: object VkDeviceFaultAddressInfoEXT

VkDeviceFaultAddressTypeEXT:

api: enum VkDeviceFaultAddressTypeEXT

VkDeviceFaultCountsEXT:

api: object VkDeviceFaultCountsEXT

VkDeviceFaultInfoEXT:

api: object VkDeviceFaultInfoEXT

VkDeviceFaultVendorBinaryHeaderVersionEXT:

api: enum VkDeviceFaultVendorBinaryHeaderVersionEXT

VkDeviceFaultVendorBinaryHeaderVersionOneEXT:

api: object VkDeviceFaultVendorBinaryHeaderVersionOneEXT

VkDeviceFaultVendorInfoEXT:

api: object VkDeviceFaultVendorInfoEXT

VkDeviceGroupBindSparseInfo:

api: object VkDeviceGroupBindSparseInfo

VkDeviceGroupBindSparseInfoKHR:

api: object VkDeviceGroupBindSparseInfoKHR

VkDeviceGroupCommandBufferBeginInfo:

api: object VkDeviceGroupCommandBufferBeginInfo

VkDeviceGroupCommandBufferBeginInfoKHR:

api: object VkDeviceGroupCommandBufferBeginInfoKHR

VkDeviceGroupDeviceCreateInfo:

api: object VkDeviceGroupDeviceCreateInfo

VkDeviceGroupDeviceCreateInfoKHR:

api: object VkDeviceGroupDeviceCreateInfoKHR

VkDeviceGroupPresentCapabilitiesKHR:

api: object VkDeviceGroupPresentCapabilitiesKHR

VkDeviceGroupPresentInfoKHR:

api: object VkDeviceGroupPresentInfoKHR

VkDeviceGroupPresentModeFlagBitsKHR:

api: enum VkDeviceGroupPresentModeFlagBitsKHR

VkDeviceGroupPresentModeFlagsKHR:

api: type VkDeviceGroupPresentModeFlagsKHR

VkDeviceGroupRenderPassBeginInfo:

api: object VkDeviceGroupRenderPassBeginInfo

VkDeviceGroupRenderPassBeginInfoKHR:

api: object VkDeviceGroupRenderPassBeginInfoKHR

VkDeviceGroupSubmitInfo:

api: object VkDeviceGroupSubmitInfo

VkDeviceGroupSubmitInfoKHR:

api: object VkDeviceGroupSubmitInfoKHR

VkDeviceGroupSwapchainCreateInfoKHR:

api: object VkDeviceGroupSwapchainCreateInfoKHR

VkDeviceImageMemoryRequirements:

api: object VkDeviceImageMemoryRequirements

VkDeviceImageMemoryRequirementsKHR:

api: object VkDeviceImageMemoryRequirementsKHR

VkDeviceMemory:

api: type VkDeviceMemory

VkDeviceMemoryOpaqueCaptureAddressInfo:

api: object VkDeviceMemoryOpaqueCaptureAddressInfo

VkDeviceMemoryOpaqueCaptureAddressInfoKHR:

api: object VkDeviceMemoryOpaqueCaptureAddressInfoKHR

VkDeviceMemoryOverallocationCreateInfoAMD:

api: object VkDeviceMemoryOverallocationCreateInfoAMD

VkDeviceMemoryReportCallbackDataEXT:

api: object VkDeviceMemoryReportCallbackDataEXT

VkDeviceMemoryReportEventTypeEXT:

api: enum VkDeviceMemoryReportEventTypeEXT

VkDeviceMemoryReportFlagsEXT:

api: type VkDeviceMemoryReportFlagsEXT

VkDeviceObjectReservationCreateInfo:

api: object VkDeviceObjectReservationCreateInfo

VkDeviceOrHostAddressConstKHR:

api: object VkDeviceOrHostAddressConstKHR

VkDeviceOrHostAddressKHR:

api: object VkDeviceOrHostAddressKHR

VkDevicePrivateDataCreateInfo:

api: object VkDevicePrivateDataCreateInfo

VkDevicePrivateDataCreateInfoEXT:

api: object VkDevicePrivateDataCreateInfoEXT

VkDeviceQueueCreateFlagBits:

api: enum VkDeviceQueueCreateFlagBits

VkDeviceQueueCreateFlags:

api: type VkDeviceQueueCreateFlags

VkDeviceQueueCreateInfo:

api: object VkDeviceQueueCreateInfo

VkDeviceQueueGlobalPriorityCreateInfoEXT:

api: object VkDeviceQueueGlobalPriorityCreateInfoEXT

VkDeviceQueueGlobalPriorityCreateInfoKHR:

api: object VkDeviceQueueGlobalPriorityCreateInfoKHR

VkDeviceQueueInfo2:

api: object VkDeviceQueueInfo2

VkDeviceSize:

api: type VkDeviceSize

vkDeviceWaitIdle:

api: var vkDeviceWaitIdle

VkDirectDriverLoadingFlagsLUNARG:

api: type VkDirectDriverLoadingFlagsLUNARG

VkDirectDriverLoadingInfoLUNARG:

api: object VkDirectDriverLoadingInfoLUNARG

VkDirectDriverLoadingListLUNARG:

api: object VkDirectDriverLoadingListLUNARG

VkDirectDriverLoadingModeLUNARG:

api: enum VkDirectDriverLoadingModeLUNARG

VkDirectFBSurfaceCreateFlagsEXT:

api: type VkDirectFBSurfaceCreateFlagsEXT

VkDiscardRectangleModeEXT:

api: enum VkDiscardRectangleModeEXT

VkDispatchIndirectCommand:

api: object VkDispatchIndirectCommand

VkDisplayEventInfoEXT:

api: object VkDisplayEventInfoEXT

VkDisplayEventTypeEXT:

api: enum VkDisplayEventTypeEXT

VkDisplayKHR:

api: type VkDisplayKHR

VkDisplayModeCreateFlagsKHR:

api: type VkDisplayModeCreateFlagsKHR

VkDisplayModeCreateInfoKHR:

api: object VkDisplayModeCreateInfoKHR

VkDisplayModeKHR:

api: type VkDisplayModeKHR

VkDisplayModeParametersKHR:

api: object VkDisplayModeParametersKHR

VkDisplayModeProperties2KHR:

api: object VkDisplayModeProperties2KHR

VkDisplayModePropertiesKHR:

api: object VkDisplayModePropertiesKHR

VkDisplayNativeHdrSurfaceCapabilitiesAMD:

api: object VkDisplayNativeHdrSurfaceCapabilitiesAMD

VkDisplayPlaneAlphaFlagBitsKHR:

api: enum VkDisplayPlaneAlphaFlagBitsKHR

VkDisplayPlaneAlphaFlagsKHR:

api: type VkDisplayPlaneAlphaFlagsKHR

VkDisplayPlaneCapabilities2KHR:

api: object VkDisplayPlaneCapabilities2KHR

VkDisplayPlaneCapabilitiesKHR:

api: object VkDisplayPlaneCapabilitiesKHR

VkDisplayPlaneInfo2KHR:

api: object VkDisplayPlaneInfo2KHR

VkDisplayPlaneProperties2KHR:

api: object VkDisplayPlaneProperties2KHR

VkDisplayPlanePropertiesKHR:

api: object VkDisplayPlanePropertiesKHR

vkDisplayPowerControlEXT:

api: var vkDisplayPowerControlEXT

VkDisplayPowerInfoEXT:

api: object VkDisplayPowerInfoEXT

VkDisplayPowerStateEXT:

api: enum VkDisplayPowerStateEXT

VkDisplayPresentInfoKHR:

api: object VkDisplayPresentInfoKHR

VkDisplayProperties2KHR:

api: object VkDisplayProperties2KHR

VkDisplayPropertiesKHR:

api: object VkDisplayPropertiesKHR

VkDisplaySurfaceCreateFlagsKHR:

api: type VkDisplaySurfaceCreateFlagsKHR

VkDisplaySurfaceCreateInfoKHR:

api: object VkDisplaySurfaceCreateInfoKHR

VkDrawIndexedIndirectCommand:

api: object VkDrawIndexedIndirectCommand

VkDrawIndirectCommand:

api: object VkDrawIndirectCommand

VkDrawMeshTasksIndirectCommandEXT:

api: object VkDrawMeshTasksIndirectCommandEXT

VkDrawMeshTasksIndirectCommandNV:

api: object VkDrawMeshTasksIndirectCommandNV

VkDriverId:

api: enum VkDriverId

VkDriverIdKHR:

api: type VkDriverIdKHR

VkDrmFormatModifierProperties2EXT:

api: object VkDrmFormatModifierProperties2EXT

VkDrmFormatModifierPropertiesEXT:

api: object VkDrmFormatModifierPropertiesEXT

VkDrmFormatModifierPropertiesList2EXT:

api: object VkDrmFormatModifierPropertiesList2EXT

VkDrmFormatModifierPropertiesListEXT:

api: object VkDrmFormatModifierPropertiesListEXT

VkDynamicState:

api: enum VkDynamicState

vkEndCommandBuffer:

api: var vkEndCommandBuffer

vkEnumerateDeviceExtensionProperties:

api: var vkEnumerateDeviceExtensionProperties

vkEnumerateDeviceLayerProperties:

api: var vkEnumerateDeviceLayerProperties

vkEnumerateInstanceExtensionProperties:

api: var vkEnumerateInstanceExtensionProperties

vkEnumerateInstanceLayerProperties:

api: var vkEnumerateInstanceLayerProperties

vkEnumerateInstanceVersion:

api: var vkEnumerateInstanceVersion

vkEnumeratePhysicalDeviceGroups:

api: var vkEnumeratePhysicalDeviceGroups

vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR:

api: var vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR

vkEnumeratePhysicalDevices:

api: var vkEnumeratePhysicalDevices

VkEvent:

api: type VkEvent

VkEventCreateFlagBits:

api: enum VkEventCreateFlagBits

VkEventCreateFlags:

api: type VkEventCreateFlags

VkEventCreateInfo:

api: object VkEventCreateInfo

VkExportFenceCreateInfo:

api: object VkExportFenceCreateInfo

VkExportFenceCreateInfoKHR:

api: object VkExportFenceCreateInfoKHR

VkExportMemoryAllocateInfo:

api: object VkExportMemoryAllocateInfo

VkExportMemoryAllocateInfoKHR:

api: object VkExportMemoryAllocateInfoKHR

VkExportMemoryAllocateInfoNV:

api: object VkExportMemoryAllocateInfoNV

VkExportMetalObjectTypeFlagBitsEXT:

api: enum VkExportMetalObjectTypeFlagBitsEXT

VkExportMetalObjectTypeFlagsEXT:

api: type VkExportMetalObjectTypeFlagsEXT

VkExportSemaphoreCreateInfo:

api: object VkExportSemaphoreCreateInfo

VkExportSemaphoreCreateInfoKHR:

api: object VkExportSemaphoreCreateInfoKHR

VkExtensionProperties:

api: object VkExtensionProperties

VkExtent2D:

api: object VkExtent2D

VkExtent3D:

api: object VkExtent3D

VkExternalBufferProperties:

api: object VkExternalBufferProperties

VkExternalBufferPropertiesKHR:

api: object VkExternalBufferPropertiesKHR

VkExternalFenceFeatureFlagBits:

api: enum VkExternalFenceFeatureFlagBits

VkExternalFenceFeatureFlagBitsKHR:

api: type VkExternalFenceFeatureFlagBitsKHR

VkExternalFenceFeatureFlags:

api: type VkExternalFenceFeatureFlags

VkExternalFenceFeatureFlagsKHR:

api: type VkExternalFenceFeatureFlagsKHR

VkExternalFenceHandleTypeFlagBits:

api: enum VkExternalFenceHandleTypeFlagBits

VkExternalFenceHandleTypeFlagBitsKHR:

api: type VkExternalFenceHandleTypeFlagBitsKHR

VkExternalFenceHandleTypeFlags:

api: type VkExternalFenceHandleTypeFlags

VkExternalFenceHandleTypeFlagsKHR:

api: type VkExternalFenceHandleTypeFlagsKHR

VkExternalFenceProperties:

api: object VkExternalFenceProperties

VkExternalFencePropertiesKHR:

api: object VkExternalFencePropertiesKHR

VkExternalImageFormatProperties:

api: object VkExternalImageFormatProperties

VkExternalImageFormatPropertiesKHR:

api: object VkExternalImageFormatPropertiesKHR

VkExternalImageFormatPropertiesNV:

api: object VkExternalImageFormatPropertiesNV

VkExternalMemoryBufferCreateInfo:

api: object VkExternalMemoryBufferCreateInfo

VkExternalMemoryBufferCreateInfoKHR:

api: object VkExternalMemoryBufferCreateInfoKHR

VkExternalMemoryFeatureFlagBits:

api: enum VkExternalMemoryFeatureFlagBits

VkExternalMemoryFeatureFlagBitsKHR:

api: type VkExternalMemoryFeatureFlagBitsKHR

VkExternalMemoryFeatureFlagBitsNV:

api: enum VkExternalMemoryFeatureFlagBitsNV

VkExternalMemoryFeatureFlags:

api: type VkExternalMemoryFeatureFlags

VkExternalMemoryFeatureFlagsKHR:

api: type VkExternalMemoryFeatureFlagsKHR

VkExternalMemoryFeatureFlagsNV:

api: type VkExternalMemoryFeatureFlagsNV

VkExternalMemoryHandleTypeFlagBits:

api: enum VkExternalMemoryHandleTypeFlagBits

VkExternalMemoryHandleTypeFlagBitsKHR:

api: type VkExternalMemoryHandleTypeFlagBitsKHR

VkExternalMemoryHandleTypeFlagBitsNV:

api: enum VkExternalMemoryHandleTypeFlagBitsNV

VkExternalMemoryHandleTypeFlags:

api: type VkExternalMemoryHandleTypeFlags

VkExternalMemoryHandleTypeFlagsKHR:

api: type VkExternalMemoryHandleTypeFlagsKHR

VkExternalMemoryHandleTypeFlagsNV:

api: type VkExternalMemoryHandleTypeFlagsNV

VkExternalMemoryImageCreateInfo:

api: object VkExternalMemoryImageCreateInfo

VkExternalMemoryImageCreateInfoKHR:

api: object VkExternalMemoryImageCreateInfoKHR

VkExternalMemoryImageCreateInfoNV:

api: object VkExternalMemoryImageCreateInfoNV

VkExternalMemoryProperties:

api: object VkExternalMemoryProperties

VkExternalMemoryPropertiesKHR:

api: object VkExternalMemoryPropertiesKHR

VkExternalSemaphoreFeatureFlagBits:

api: enum VkExternalSemaphoreFeatureFlagBits

VkExternalSemaphoreFeatureFlagBitsKHR:

api: type VkExternalSemaphoreFeatureFlagBitsKHR

VkExternalSemaphoreFeatureFlags:

api: type VkExternalSemaphoreFeatureFlags

VkExternalSemaphoreFeatureFlagsKHR:

api: type VkExternalSemaphoreFeatureFlagsKHR

VkExternalSemaphoreHandleTypeFlagBits:

api: enum VkExternalSemaphoreHandleTypeFlagBits

VkExternalSemaphoreHandleTypeFlagBitsKHR:

api: type VkExternalSemaphoreHandleTypeFlagBitsKHR

VkExternalSemaphoreHandleTypeFlags:

api: type VkExternalSemaphoreHandleTypeFlags

VkExternalSemaphoreHandleTypeFlagsKHR:

api: type VkExternalSemaphoreHandleTypeFlagsKHR

VkExternalSemaphoreProperties:

api: object VkExternalSemaphoreProperties

VkExternalSemaphorePropertiesKHR:

api: object VkExternalSemaphorePropertiesKHR

VK_FALSE:

api: const VK_FALSE

VkFaultCallbackInfo:

api: object VkFaultCallbackInfo

VkFaultData:

api: object VkFaultData

VkFaultLevel:

api: enum VkFaultLevel

VkFaultQueryBehavior:

api: enum VkFaultQueryBehavior

VkFaultType:

api: enum VkFaultType

VkFence:

api: type VkFence

VkFenceCreateFlagBits:

api: enum VkFenceCreateFlagBits

VkFenceCreateFlags:

api: type VkFenceCreateFlags

VkFenceCreateInfo:

api: object VkFenceCreateInfo

VkFenceGetFdInfoKHR:

api: object VkFenceGetFdInfoKHR

VkFenceImportFlagBits:

api: enum VkFenceImportFlagBits

VkFenceImportFlagBitsKHR:

api: type VkFenceImportFlagBitsKHR

VkFenceImportFlags:

api: type VkFenceImportFlags

VkFenceImportFlagsKHR:

api: type VkFenceImportFlagsKHR

VkFilter:

api: enum VkFilter

VkFilterCubicImageViewImageFormatPropertiesEXT:

api: object VkFilterCubicImageViewImageFormatPropertiesEXT

VkFlags:

api: type VkFlags

VkFlags64:

api: type VkFlags64

vkFlushMappedMemoryRanges:

api: var vkFlushMappedMemoryRanges

VkFormat:

api: enum VkFormat

VkFormatFeatureFlagBits:

api: enum VkFormatFeatureFlagBits

VkFormatFeatureFlagBits2:

api: enum VkFormatFeatureFlagBits2

VkFormatFeatureFlagBits2KHR:

api: type VkFormatFeatureFlagBits2KHR

VkFormatFeatureFlags:

api: type VkFormatFeatureFlags

VkFormatFeatureFlags2:

api: type VkFormatFeatureFlags2

VkFormatFeatureFlags2KHR:

api: type VkFormatFeatureFlags2KHR

VkFormatProperties:

api: object VkFormatProperties

VkFormatProperties2:

api: object VkFormatProperties2

VkFormatProperties2KHR:

api: object VkFormatProperties2KHR

VkFormatProperties3:

api: object VkFormatProperties3

VkFormatProperties3KHR:

api: object VkFormatProperties3KHR

VkFragmentShadingRateAttachmentInfoKHR:

api: object VkFragmentShadingRateAttachmentInfoKHR

VkFragmentShadingRateCombinerOpKHR:

api: enum VkFragmentShadingRateCombinerOpKHR

VkFragmentShadingRateNV:

api: enum VkFragmentShadingRateNV

VkFragmentShadingRateTypeNV:

api: enum VkFragmentShadingRateTypeNV

VkFramebuffer:

api: type VkFramebuffer

VkFramebufferAttachmentImageInfo:

api: object VkFramebufferAttachmentImageInfo

VkFramebufferAttachmentImageInfoKHR:

api: object VkFramebufferAttachmentImageInfoKHR

VkFramebufferAttachmentsCreateInfo:

api: object VkFramebufferAttachmentsCreateInfo

VkFramebufferAttachmentsCreateInfoKHR:

api: object VkFramebufferAttachmentsCreateInfoKHR

VkFramebufferCreateFlagBits:

api: enum VkFramebufferCreateFlagBits

VkFramebufferCreateFlags:

api: type VkFramebufferCreateFlags

VkFramebufferCreateInfo:

api: object VkFramebufferCreateInfo

VkFramebufferMixedSamplesCombinationNV:

api: object VkFramebufferMixedSamplesCombinationNV

vkFreeCommandBuffers:

api: var vkFreeCommandBuffers

vkFreeDescriptorSets:

api: var vkFreeDescriptorSets

vkFreeMemory:

api: var vkFreeMemory

VkFrontFace:

api: enum VkFrontFace

VkFullScreenExclusiveEXT:

api: enum VkFullScreenExclusiveEXT

VkGeneratedCommandsInfoNV:

api: object VkGeneratedCommandsInfoNV

VkGeneratedCommandsMemoryRequirementsInfoNV:

api: object VkGeneratedCommandsMemoryRequirementsInfoNV

VkGeometryAABBNV:

api: object VkGeometryAABBNV

VkGeometryDataNV:

api: object VkGeometryDataNV

VkGeometryFlagBitsKHR:

api: enum VkGeometryFlagBitsKHR

VkGeometryFlagBitsNV:

api: type VkGeometryFlagBitsNV

VkGeometryFlagsKHR:

api: type VkGeometryFlagsKHR

VkGeometryFlagsNV:

api: type VkGeometryFlagsNV

VkGeometryInstanceFlagBitsKHR:

api: enum VkGeometryInstanceFlagBitsKHR

VkGeometryInstanceFlagBitsNV:

api: type VkGeometryInstanceFlagBitsNV

VkGeometryInstanceFlagsKHR:

api: type VkGeometryInstanceFlagsKHR

VkGeometryInstanceFlagsNV:

api: type VkGeometryInstanceFlagsNV

VkGeometryNV:

api: object VkGeometryNV

VkGeometryTrianglesNV:

api: object VkGeometryTrianglesNV

VkGeometryTypeKHR:

api: enum VkGeometryTypeKHR

VkGeometryTypeNV:

api: type VkGeometryTypeNV

vkGetAccelerationStructureBuildSizesKHR:

api: var vkGetAccelerationStructureBuildSizesKHR

vkGetAccelerationStructureDeviceAddressKHR:

api: var vkGetAccelerationStructureDeviceAddressKHR

vkGetAccelerationStructureHandleNV:

api: var vkGetAccelerationStructureHandleNV

vkGetAccelerationStructureMemoryRequirementsNV:

api: var vkGetAccelerationStructureMemoryRequirementsNV

vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT:

api: var vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT

vkGetBufferDeviceAddress:

api: var vkGetBufferDeviceAddress

vkGetBufferDeviceAddressEXT:

api: var vkGetBufferDeviceAddressEXT

vkGetBufferMemoryRequirements:

api: var vkGetBufferMemoryRequirements

vkGetBufferMemoryRequirements2:

api: var vkGetBufferMemoryRequirements2

vkGetBufferOpaqueCaptureAddress:

api: var vkGetBufferOpaqueCaptureAddress

vkGetBufferOpaqueCaptureDescriptorDataEXT:

api: var vkGetBufferOpaqueCaptureDescriptorDataEXT

vkGetCalibratedTimestampsEXT:

api: var vkGetCalibratedTimestampsEXT

vkGetDeferredOperationMaxConcurrencyKHR:

api: var vkGetDeferredOperationMaxConcurrencyKHR

vkGetDeferredOperationResultKHR:

api: var vkGetDeferredOperationResultKHR

vkGetDescriptorEXT:

api: var vkGetDescriptorEXT

vkGetDescriptorSetHostMappingVALVE:

api: var vkGetDescriptorSetHostMappingVALVE

vkGetDescriptorSetLayoutBindingOffsetEXT:

api: var vkGetDescriptorSetLayoutBindingOffsetEXT

vkGetDescriptorSetLayoutHostMappingInfoVALVE:

api: var vkGetDescriptorSetLayoutHostMappingInfoVALVE

vkGetDescriptorSetLayoutSizeEXT:

api: var vkGetDescriptorSetLayoutSizeEXT

vkGetDescriptorSetLayoutSupport:

api: var vkGetDescriptorSetLayoutSupport

vkGetDeviceAccelerationStructureCompatibilityKHR:

api: var vkGetDeviceAccelerationStructureCompatibilityKHR

vkGetDeviceBufferMemoryRequirements:

api: var vkGetDeviceBufferMemoryRequirements

vkGetDeviceFaultInfoEXT:

api: var vkGetDeviceFaultInfoEXT

vkGetDeviceGroupPeerMemoryFeatures:

api: var vkGetDeviceGroupPeerMemoryFeatures

vkGetDeviceGroupPresentCapabilitiesKHR:

api: var vkGetDeviceGroupPresentCapabilitiesKHR

vkGetDeviceGroupSurfacePresentModesKHR:

api: var vkGetDeviceGroupSurfacePresentModesKHR

vkGetDeviceImageMemoryRequirements:

api: var vkGetDeviceImageMemoryRequirements

vkGetDeviceImageSparseMemoryRequirements:

api: var vkGetDeviceImageSparseMemoryRequirements

vkGetDeviceMemoryCommitment:

api: var vkGetDeviceMemoryCommitment

vkGetDeviceMemoryOpaqueCaptureAddress:

api: var vkGetDeviceMemoryOpaqueCaptureAddress

vkGetDeviceMicromapCompatibilityEXT:

api: var vkGetDeviceMicromapCompatibilityEXT

vkGetDeviceProcAddr:

api: var vkGetDeviceProcAddr

vkGetDeviceQueue:

api: var vkGetDeviceQueue

vkGetDeviceQueue2:

api: var vkGetDeviceQueue2

vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI:

api: var vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI

vkGetDisplayModeProperties2KHR:

api: var vkGetDisplayModeProperties2KHR

vkGetDisplayModePropertiesKHR:

api: var vkGetDisplayModePropertiesKHR

vkGetDisplayPlaneCapabilities2KHR:

api: var vkGetDisplayPlaneCapabilities2KHR

vkGetDisplayPlaneCapabilitiesKHR:

api: var vkGetDisplayPlaneCapabilitiesKHR

vkGetDisplayPlaneSupportedDisplaysKHR:

api: var vkGetDisplayPlaneSupportedDisplaysKHR

vkGetDrmDisplayEXT:

api: var vkGetDrmDisplayEXT

vkGetDynamicRenderingTilePropertiesQCOM:

api: var vkGetDynamicRenderingTilePropertiesQCOM

vkGetEventStatus:

api: var vkGetEventStatus

vkGetFenceFdKHR:

api: var vkGetFenceFdKHR

vkGetFenceStatus:

api: var vkGetFenceStatus

vkGetFramebufferTilePropertiesQCOM:

api: var vkGetFramebufferTilePropertiesQCOM

vkGetGeneratedCommandsMemoryRequirementsNV:

api: var vkGetGeneratedCommandsMemoryRequirementsNV

vkGetImageDrmFormatModifierPropertiesEXT:

api: var vkGetImageDrmFormatModifierPropertiesEXT

vkGetImageMemoryRequirements:

api: var vkGetImageMemoryRequirements

vkGetImageMemoryRequirements2:

api: var vkGetImageMemoryRequirements2

vkGetImageOpaqueCaptureDescriptorDataEXT:

api: var vkGetImageOpaqueCaptureDescriptorDataEXT

vkGetImageSparseMemoryRequirements:

api: var vkGetImageSparseMemoryRequirements

vkGetImageSparseMemoryRequirements2:

api: var vkGetImageSparseMemoryRequirements2

vkGetImageSubresourceLayout:

api: var vkGetImageSubresourceLayout

vkGetImageSubresourceLayout2EXT:

api: var vkGetImageSubresourceLayout2EXT

vkGetImageViewAddressNVX:

api: var vkGetImageViewAddressNVX

vkGetImageViewHandleNVX:

api: var vkGetImageViewHandleNVX

vkGetImageViewOpaqueCaptureDescriptorDataEXT:

api: var vkGetImageViewOpaqueCaptureDescriptorDataEXT

vkGetMemoryFdKHR:

api: var vkGetMemoryFdKHR

vkGetMemoryFdPropertiesKHR:

api: var vkGetMemoryFdPropertiesKHR

vkGetMemoryHostPointerPropertiesEXT:

api: var vkGetMemoryHostPointerPropertiesEXT

vkGetMemoryRemoteAddressNV:

api: var vkGetMemoryRemoteAddressNV

vkGetMicromapBuildSizesEXT:

api: var vkGetMicromapBuildSizesEXT

vkGetPastPresentationTimingGOOGLE:

api: var vkGetPastPresentationTimingGOOGLE

vkGetPerformanceParameterINTEL:

api: var vkGetPerformanceParameterINTEL

vkGetPhysicalDeviceCalibrateableTimeDomainsEXT:

api: var vkGetPhysicalDeviceCalibrateableTimeDomainsEXT

vkGetPhysicalDeviceCooperativeMatrixPropertiesNV:

api: var vkGetPhysicalDeviceCooperativeMatrixPropertiesNV

vkGetPhysicalDeviceDisplayPlaneProperties2KHR:

api: var vkGetPhysicalDeviceDisplayPlaneProperties2KHR

vkGetPhysicalDeviceDisplayPlanePropertiesKHR:

api: var vkGetPhysicalDeviceDisplayPlanePropertiesKHR

vkGetPhysicalDeviceDisplayProperties2KHR:

api: var vkGetPhysicalDeviceDisplayProperties2KHR

vkGetPhysicalDeviceDisplayPropertiesKHR:

api: var vkGetPhysicalDeviceDisplayPropertiesKHR

vkGetPhysicalDeviceExternalBufferProperties:

api: var vkGetPhysicalDeviceExternalBufferProperties

vkGetPhysicalDeviceExternalFenceProperties:

api: var vkGetPhysicalDeviceExternalFenceProperties

vkGetPhysicalDeviceExternalImageFormatPropertiesNV:

api: var vkGetPhysicalDeviceExternalImageFormatPropertiesNV

vkGetPhysicalDeviceExternalSemaphoreProperties:

api: var vkGetPhysicalDeviceExternalSemaphoreProperties

vkGetPhysicalDeviceFeatures:

api: var vkGetPhysicalDeviceFeatures

vkGetPhysicalDeviceFeatures2:

api: var vkGetPhysicalDeviceFeatures2

vkGetPhysicalDeviceFormatProperties:

api: var vkGetPhysicalDeviceFormatProperties

vkGetPhysicalDeviceFormatProperties2:

api: var vkGetPhysicalDeviceFormatProperties2

vkGetPhysicalDeviceFragmentShadingRatesKHR:

api: var vkGetPhysicalDeviceFragmentShadingRatesKHR

vkGetPhysicalDeviceImageFormatProperties:

api: var vkGetPhysicalDeviceImageFormatProperties

vkGetPhysicalDeviceImageFormatProperties2:

api: var vkGetPhysicalDeviceImageFormatProperties2

vkGetPhysicalDeviceMemoryProperties:

api: var vkGetPhysicalDeviceMemoryProperties

vkGetPhysicalDeviceMemoryProperties2:

api: var vkGetPhysicalDeviceMemoryProperties2

vkGetPhysicalDeviceMultisamplePropertiesEXT:

api: var vkGetPhysicalDeviceMultisamplePropertiesEXT

vkGetPhysicalDeviceOpticalFlowImageFormatsNV:

api: var vkGetPhysicalDeviceOpticalFlowImageFormatsNV

vkGetPhysicalDevicePresentRectanglesKHR:

api: var vkGetPhysicalDevicePresentRectanglesKHR

vkGetPhysicalDeviceProperties:

api: var vkGetPhysicalDeviceProperties

vkGetPhysicalDeviceProperties2:

api: var vkGetPhysicalDeviceProperties2

vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR:

api: var vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR

vkGetPhysicalDeviceQueueFamilyProperties:

api: var vkGetPhysicalDeviceQueueFamilyProperties

vkGetPhysicalDeviceQueueFamilyProperties2:

api: var vkGetPhysicalDeviceQueueFamilyProperties2

vkGetPhysicalDeviceSparseImageFormatProperties:

api: var vkGetPhysicalDeviceSparseImageFormatProperties

vkGetPhysicalDeviceSparseImageFormatProperties2:

api: var vkGetPhysicalDeviceSparseImageFormatProperties2

vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV:

api: var vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV

vkGetPhysicalDeviceSurfaceCapabilities2EXT:

api: var vkGetPhysicalDeviceSurfaceCapabilities2EXT

vkGetPhysicalDeviceSurfaceCapabilities2KHR:

api: var vkGetPhysicalDeviceSurfaceCapabilities2KHR

vkGetPhysicalDeviceSurfaceCapabilitiesKHR:

api: var vkGetPhysicalDeviceSurfaceCapabilitiesKHR

vkGetPhysicalDeviceSurfaceFormats2KHR:

api: var vkGetPhysicalDeviceSurfaceFormats2KHR

vkGetPhysicalDeviceSurfaceFormatsKHR:

api: var vkGetPhysicalDeviceSurfaceFormatsKHR

vkGetPhysicalDeviceSurfacePresentModesKHR:

api: var vkGetPhysicalDeviceSurfacePresentModesKHR

vkGetPhysicalDeviceSurfaceSupportKHR:

api: var vkGetPhysicalDeviceSurfaceSupportKHR

vkGetPhysicalDeviceToolProperties:

api: var vkGetPhysicalDeviceToolProperties

vkGetPipelineCacheData:

api: var vkGetPipelineCacheData

vkGetPipelineExecutableInternalRepresentationsKHR:

api: var vkGetPipelineExecutableInternalRepresentationsKHR

vkGetPipelineExecutablePropertiesKHR:

api: var vkGetPipelineExecutablePropertiesKHR

vkGetPipelineExecutableStatisticsKHR:

api: var vkGetPipelineExecutableStatisticsKHR

vkGetPipelinePropertiesEXT:

api: var vkGetPipelinePropertiesEXT

vkGetPrivateData:

api: var vkGetPrivateData

vkGetQueryPoolResults:

api: var vkGetQueryPoolResults

vkGetQueueCheckpointDataNV:

api: var vkGetQueueCheckpointDataNV

vkGetRayTracingCaptureReplayShaderGroupHandlesKHR:

api: var vkGetRayTracingCaptureReplayShaderGroupHandlesKHR

vkGetRayTracingShaderGroupHandlesKHR:

api: var vkGetRayTracingShaderGroupHandlesKHR

vkGetRayTracingShaderGroupHandlesNV:

api: var vkGetRayTracingShaderGroupHandlesNV

vkGetRayTracingShaderGroupStackSizeKHR:

api: var vkGetRayTracingShaderGroupStackSizeKHR

vkGetRefreshCycleDurationGOOGLE:

api: var vkGetRefreshCycleDurationGOOGLE

vkGetRenderAreaGranularity:

api: var vkGetRenderAreaGranularity

vkGetSamplerOpaqueCaptureDescriptorDataEXT:

api: var vkGetSamplerOpaqueCaptureDescriptorDataEXT

vkGetSemaphoreCounterValue:

api: var vkGetSemaphoreCounterValue

vkGetSemaphoreFdKHR:

api: var vkGetSemaphoreFdKHR

vkGetShaderInfoAMD:

api: var vkGetShaderInfoAMD

vkGetShaderModuleCreateInfoIdentifierEXT:

api: var vkGetShaderModuleCreateInfoIdentifierEXT

vkGetShaderModuleIdentifierEXT:

api: var vkGetShaderModuleIdentifierEXT

vkGetSwapchainCounterEXT:

api: var vkGetSwapchainCounterEXT

vkGetSwapchainImagesKHR:

api: var vkGetSwapchainImagesKHR

vkGetSwapchainStatusKHR:

api: var vkGetSwapchainStatusKHR

vkGetValidationCacheDataEXT:

api: var vkGetValidationCacheDataEXT

VkGraphicsPipelineCreateInfo:

api: object VkGraphicsPipelineCreateInfo

VkGraphicsPipelineLibraryCreateInfoEXT:

api: object VkGraphicsPipelineLibraryCreateInfoEXT

VkGraphicsPipelineLibraryFlagBitsEXT:

api: enum VkGraphicsPipelineLibraryFlagBitsEXT

VkGraphicsPipelineLibraryFlagsEXT:

api: type VkGraphicsPipelineLibraryFlagsEXT

VkGraphicsPipelineShaderGroupsCreateInfoNV:

api: object VkGraphicsPipelineShaderGroupsCreateInfoNV

VkGraphicsShaderGroupCreateInfoNV:

api: object VkGraphicsShaderGroupCreateInfoNV

VkHandle:

api: type VkHandle

VkHdrMetadataEXT:

api: object VkHdrMetadataEXT

VkHeadlessSurfaceCreateFlagsEXT:

api: type VkHeadlessSurfaceCreateFlagsEXT

VkHeadlessSurfaceCreateInfoEXT:

api: object VkHeadlessSurfaceCreateInfoEXT

VkImage:

api: type VkImage

VkImageAspectFlagBits:

api: enum VkImageAspectFlagBits

VkImageAspectFlags:

api: type VkImageAspectFlags

VkImageBlit:

api: object VkImageBlit

VkImageBlit2:

api: object VkImageBlit2

VkImageBlit2KHR:

api: object VkImageBlit2KHR

VkImageCaptureDescriptorDataInfoEXT:

api: object VkImageCaptureDescriptorDataInfoEXT

VkImageCompressionControlEXT:

api: object VkImageCompressionControlEXT

VK_IMAGE_COMPRESSION_DEFAULT_EXT:

api: const VK_IMAGE_COMPRESSION_DEFAULT_EXT

VkImageCompressionFixedRateFlagBitsEXT:

api: enum VkImageCompressionFixedRateFlagBitsEXT

VkImageCompressionFixedRateFlagsEXT:

api: type VkImageCompressionFixedRateFlagsEXT

VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT:

api: const VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT

VkImageCompressionFlagBitsEXT:

api: enum VkImageCompressionFlagBitsEXT

VkImageCompressionFlagsEXT:

api: type VkImageCompressionFlagsEXT

VkImageCompressionPropertiesEXT:

api: object VkImageCompressionPropertiesEXT

VkImageConstraintsInfoFlagBitsFUCHSIA:

api: enum VkImageConstraintsInfoFlagBitsFUCHSIA

VkImageConstraintsInfoFlagsFUCHSIA:

api: type VkImageConstraintsInfoFlagsFUCHSIA

VkImageCopy:

api: object VkImageCopy

VkImageCopy2:

api: object VkImageCopy2

VkImageCopy2KHR:

api: object VkImageCopy2KHR

VkImageCreateFlagBits:

api: enum VkImageCreateFlagBits

VkImageCreateFlags:

api: type VkImageCreateFlags

VkImageCreateInfo:

api: object VkImageCreateInfo

VkImageDrmFormatModifierExplicitCreateInfoEXT:

api: object VkImageDrmFormatModifierExplicitCreateInfoEXT

VkImageDrmFormatModifierListCreateInfoEXT:

api: object VkImageDrmFormatModifierListCreateInfoEXT

VkImageDrmFormatModifierPropertiesEXT:

api: object VkImageDrmFormatModifierPropertiesEXT

VkImageFormatConstraintsFlagsFUCHSIA:

api: type VkImageFormatConstraintsFlagsFUCHSIA

VkImageFormatListCreateInfo:

api: object VkImageFormatListCreateInfo

VkImageFormatListCreateInfoKHR:

api: object VkImageFormatListCreateInfoKHR

VkImageFormatProperties:

api: object VkImageFormatProperties

VkImageFormatProperties2:

api: object VkImageFormatProperties2

VkImageFormatProperties2KHR:

api: object VkImageFormatProperties2KHR

VkImageLayout:

api: enum VkImageLayout

VkImageMemoryBarrier:

api: object VkImageMemoryBarrier

VkImageMemoryBarrier2:

api: object VkImageMemoryBarrier2

VkImageMemoryBarrier2KHR:

api: object VkImageMemoryBarrier2KHR

VkImageMemoryRequirementsInfo2:

api: object VkImageMemoryRequirementsInfo2

VkImageMemoryRequirementsInfo2KHR:

api: object VkImageMemoryRequirementsInfo2KHR

VkImagePipeSurfaceCreateFlagsFUCHSIA:

api: type VkImagePipeSurfaceCreateFlagsFUCHSIA

VkImagePlaneMemoryRequirementsInfo:

api: object VkImagePlaneMemoryRequirementsInfo

VkImagePlaneMemoryRequirementsInfoKHR:

api: object VkImagePlaneMemoryRequirementsInfoKHR

VkImageResolve:

api: object VkImageResolve

VkImageResolve2:

api: object VkImageResolve2

VkImageResolve2KHR:

api: object VkImageResolve2KHR

VkImageSparseMemoryRequirementsInfo2:

api: object VkImageSparseMemoryRequirementsInfo2

VkImageSparseMemoryRequirementsInfo2KHR:

api: object VkImageSparseMemoryRequirementsInfo2KHR

VkImageStencilUsageCreateInfo:

api: object VkImageStencilUsageCreateInfo

VkImageStencilUsageCreateInfoEXT:

api: object VkImageStencilUsageCreateInfoEXT

VkImageSubresource:

api: object VkImageSubresource

VkImageSubresource2EXT:

api: object VkImageSubresource2EXT

VkImageSubresourceLayers:

api: object VkImageSubresourceLayers

VkImageSubresourceRange:

api: object VkImageSubresourceRange

VkImageSwapchainCreateInfoKHR:

api: object VkImageSwapchainCreateInfoKHR

VkImageTiling:

api: enum VkImageTiling

VkImageType:

api: enum VkImageType

VkImageUsageFlagBits:

api: enum VkImageUsageFlagBits

VkImageUsageFlags:

api: type VkImageUsageFlags

VkImageView:

api: type VkImageView

VkImageViewAddressPropertiesNVX:

api: object VkImageViewAddressPropertiesNVX

VkImageViewASTCDecodeModeEXT:

api: object VkImageViewASTCDecodeModeEXT

VkImageViewCaptureDescriptorDataInfoEXT:

api: object VkImageViewCaptureDescriptorDataInfoEXT

VkImageViewCreateFlagBits:

api: enum VkImageViewCreateFlagBits

VkImageViewCreateFlags:

api: type VkImageViewCreateFlags

VkImageViewCreateInfo:

api: object VkImageViewCreateInfo

VkImageViewHandleInfoNVX:

api: object VkImageViewHandleInfoNVX

VkImageViewMinLodCreateInfoEXT:

api: object VkImageViewMinLodCreateInfoEXT

VkImageViewSampleWeightCreateInfoQCOM:

api: object VkImageViewSampleWeightCreateInfoQCOM

VkImageViewSlicedCreateInfoEXT:

api: object VkImageViewSlicedCreateInfoEXT

VkImageViewType:

api: enum VkImageViewType

VkImageViewUsageCreateInfo:

api: object VkImageViewUsageCreateInfo

VkImageViewUsageCreateInfoKHR:

api: object VkImageViewUsageCreateInfoKHR

VkImportFenceFdInfoKHR:

api: object VkImportFenceFdInfoKHR

vkImportFenceFdKHR:

api: var vkImportFenceFdKHR

VkImportMemoryFdInfoKHR:

api: object VkImportMemoryFdInfoKHR

VkImportMemoryHostPointerInfoEXT:

api: object VkImportMemoryHostPointerInfoEXT

VkImportSemaphoreFdInfoKHR:

api: object VkImportSemaphoreFdInfoKHR

vkImportSemaphoreFdKHR:

api: var vkImportSemaphoreFdKHR

VkIndexType:

api: enum VkIndexType

VkIndirectCommandsLayoutCreateInfoNV:

api: object VkIndirectCommandsLayoutCreateInfoNV

VkIndirectCommandsLayoutNV:

api: type VkIndirectCommandsLayoutNV

VkIndirectCommandsLayoutTokenNV:

api: object VkIndirectCommandsLayoutTokenNV

VkIndirectCommandsLayoutUsageFlagBitsNV:

api: enum VkIndirectCommandsLayoutUsageFlagBitsNV

VkIndirectCommandsLayoutUsageFlagsNV:

api: type VkIndirectCommandsLayoutUsageFlagsNV

VkIndirectCommandsStreamNV:

api: object VkIndirectCommandsStreamNV

VkIndirectCommandsTokenTypeNV:

api: enum VkIndirectCommandsTokenTypeNV

VkIndirectStateFlagBitsNV:

api: enum VkIndirectStateFlagBitsNV

VkIndirectStateFlagsNV:

api: type VkIndirectStateFlagsNV

VkInitializePerformanceApiInfoINTEL:

api: object VkInitializePerformanceApiInfoINTEL

vkInitializePerformanceApiINTEL:

api: var vkInitializePerformanceApiINTEL

VkInputAttachmentAspectReference:

api: object VkInputAttachmentAspectReference

VkInputAttachmentAspectReferenceKHR:

api: object VkInputAttachmentAspectReferenceKHR

VkInstance:

api: type VkInstance

VkInstanceCreateFlagBits:

api: enum VkInstanceCreateFlagBits

VkInstanceCreateFlags:

api: type VkInstanceCreateFlags

VkInstanceCreateInfo:

api: object VkInstanceCreateInfo

VkInternalAllocationType:

api: enum VkInternalAllocationType

vkInvalidateMappedMemoryRanges:

api: var vkInvalidateMappedMemoryRanges

VkIOSSurfaceCreateFlagsMVK:

api: type VkIOSSurfaceCreateFlagsMVK

VkLayerProperties:

api: object VkLayerProperties

VkLineRasterizationModeEXT:

api: enum VkLineRasterizationModeEXT

VK_LOD_CLAMP_NONE:

api: const VK_LOD_CLAMP_NONE

VkLogicOp:

api: enum VkLogicOp

VK_LUID_SIZE:

api: const VK_LUID_SIZE

VK_LUID_SIZE_KHR:

api: const VK_LUID_SIZE_KHR

VkMacOSSurfaceCreateFlagsMVK:

api: type VkMacOSSurfaceCreateFlagsMVK

VK_MAKE_API_VERSION:

api: proc VK_MAKE_API_VERSION(variant: uint32; major: uint32; minor: uint32; patch: uint32): uint32

vkMapMemory:

api: var vkMapMemory

VkMappedMemoryRange:

api: object VkMappedMemoryRange

VK_MAX_DESCRIPTION_SIZE:

api: const VK_MAX_DESCRIPTION_SIZE

VK_MAX_DEVICE_GROUP_SIZE:

api: const VK_MAX_DEVICE_GROUP_SIZE

VK_MAX_DEVICE_GROUP_SIZE_KHR:

api: const VK_MAX_DEVICE_GROUP_SIZE_KHR

VK_MAX_DRIVER_INFO_SIZE:

api: const VK_MAX_DRIVER_INFO_SIZE

VK_MAX_DRIVER_INFO_SIZE_KHR:

api: const VK_MAX_DRIVER_INFO_SIZE_KHR

VK_MAX_DRIVER_NAME_SIZE:

api: const VK_MAX_DRIVER_NAME_SIZE

VK_MAX_DRIVER_NAME_SIZE_KHR:

api: const VK_MAX_DRIVER_NAME_SIZE_KHR

VK_MAX_EXTENSION_NAME_SIZE:

api: const VK_MAX_EXTENSION_NAME_SIZE

VK_MAX_GLOBAL_PRIORITY_SIZE_EXT:

api: const VK_MAX_GLOBAL_PRIORITY_SIZE_EXT

VK_MAX_GLOBAL_PRIORITY_SIZE_KHR:

api: const VK_MAX_GLOBAL_PRIORITY_SIZE_KHR

VK_MAX_MEMORY_HEAPS:

api: const VK_MAX_MEMORY_HEAPS

VK_MAX_MEMORY_TYPES:

api: const VK_MAX_MEMORY_TYPES

VK_MAX_PHYSICAL_DEVICE_NAME_SIZE:

api: const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE

VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT:

api: const VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT

VkMemoryAllocateFlagBits:

api: enum VkMemoryAllocateFlagBits

VkMemoryAllocateFlagBitsKHR:

api: type VkMemoryAllocateFlagBitsKHR

VkMemoryAllocateFlags:

api: type VkMemoryAllocateFlags

VkMemoryAllocateFlagsInfo:

api: object VkMemoryAllocateFlagsInfo

VkMemoryAllocateFlagsInfoKHR:

api: object VkMemoryAllocateFlagsInfoKHR

VkMemoryAllocateFlagsKHR:

api: type VkMemoryAllocateFlagsKHR

VkMemoryAllocateInfo:

api: object VkMemoryAllocateInfo

VkMemoryBarrier:

api: object VkMemoryBarrier

VkMemoryBarrier2:

api: object VkMemoryBarrier2

VkMemoryBarrier2KHR:

api: object VkMemoryBarrier2KHR

VkMemoryDecompressionMethodFlagBitsNV:

api: enum VkMemoryDecompressionMethodFlagBitsNV

VkMemoryDecompressionMethodFlagsNV:

api: type VkMemoryDecompressionMethodFlagsNV

VkMemoryDedicatedAllocateInfo:

api: object VkMemoryDedicatedAllocateInfo

VkMemoryDedicatedAllocateInfoKHR:

api: object VkMemoryDedicatedAllocateInfoKHR

VkMemoryDedicatedRequirements:

api: object VkMemoryDedicatedRequirements

VkMemoryDedicatedRequirementsKHR:

api: object VkMemoryDedicatedRequirementsKHR

VkMemoryFdPropertiesKHR:

api: object VkMemoryFdPropertiesKHR

VkMemoryGetFdInfoKHR:

api: object VkMemoryGetFdInfoKHR

VkMemoryGetRemoteAddressInfoNV:

api: object VkMemoryGetRemoteAddressInfoNV

VkMemoryHeap:

api: object VkMemoryHeap

VkMemoryHeapFlagBits:

api: enum VkMemoryHeapFlagBits

VkMemoryHeapFlags:

api: type VkMemoryHeapFlags

VkMemoryHostPointerPropertiesEXT:

api: object VkMemoryHostPointerPropertiesEXT

VkMemoryMapFlags:

api: type VkMemoryMapFlags

VkMemoryOpaqueCaptureAddressAllocateInfo:

api: object VkMemoryOpaqueCaptureAddressAllocateInfo

VkMemoryOpaqueCaptureAddressAllocateInfoKHR:

api: object VkMemoryOpaqueCaptureAddressAllocateInfoKHR

VkMemoryOverallocationBehaviorAMD:

api: enum VkMemoryOverallocationBehaviorAMD

VkMemoryPriorityAllocateInfoEXT:

api: object VkMemoryPriorityAllocateInfoEXT

VkMemoryPropertyFlagBits:

api: enum VkMemoryPropertyFlagBits

VkMemoryPropertyFlags:

api: type VkMemoryPropertyFlags

VkMemoryRequirements:

api: object VkMemoryRequirements

VkMemoryRequirements2:

api: object VkMemoryRequirements2

VkMemoryRequirements2KHR:

api: object VkMemoryRequirements2KHR

VkMemoryType:

api: object VkMemoryType

vkMergePipelineCaches:

api: var vkMergePipelineCaches

vkMergeValidationCachesEXT:

api: var vkMergeValidationCachesEXT

VkMetalSurfaceCreateFlagsEXT:

api: type VkMetalSurfaceCreateFlagsEXT

VkMicromapBuildInfoEXT:

api: object VkMicromapBuildInfoEXT

VkMicromapBuildSizesInfoEXT:

api: object VkMicromapBuildSizesInfoEXT

VkMicromapCreateFlagBitsEXT:

api: enum VkMicromapCreateFlagBitsEXT

VkMicromapCreateFlagsEXT:

api: type VkMicromapCreateFlagsEXT

VkMicromapCreateInfoEXT:

api: object VkMicromapCreateInfoEXT

VkMicromapEXT:

api: type VkMicromapEXT

VkMicromapTriangleEXT:

api: object VkMicromapTriangleEXT

VkMicromapTypeEXT:

api: enum VkMicromapTypeEXT

VkMicromapUsageEXT:

api: object VkMicromapUsageEXT

VkMicromapVersionInfoEXT:

api: object VkMicromapVersionInfoEXT

VkMultiDrawIndexedInfoEXT:

api: object VkMultiDrawIndexedInfoEXT

VkMultiDrawInfoEXT:

api: object VkMultiDrawInfoEXT

VkMultisampledRenderToSingleSampledInfoEXT:

api: object VkMultisampledRenderToSingleSampledInfoEXT

VkMultisamplePropertiesEXT:

api: object VkMultisamplePropertiesEXT

VkMultiviewPerViewAttributesInfoNVX:

api: object VkMultiviewPerViewAttributesInfoNVX

VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM:

api: object VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM

VkMutableDescriptorTypeCreateInfoEXT:

api: object VkMutableDescriptorTypeCreateInfoEXT

VkMutableDescriptorTypeCreateInfoVALVE:

api: object VkMutableDescriptorTypeCreateInfoVALVE

VkMutableDescriptorTypeListEXT:

api: object VkMutableDescriptorTypeListEXT

VkMutableDescriptorTypeListVALVE:

api: object VkMutableDescriptorTypeListVALVE

VkNonDispatchableHandle:

api: type VkNonDispatchableHandle

VkObjectType:

api: enum VkObjectType

VkOffset2D:

api: object VkOffset2D

VkOffset3D:

api: object VkOffset3D

VkOpacityMicromapFormatEXT:

api: enum VkOpacityMicromapFormatEXT

VkOpacityMicromapSpecialIndexEXT:

api: enum VkOpacityMicromapSpecialIndexEXT

VkOpaqueCaptureDescriptorDataCreateInfoEXT:

api: object VkOpaqueCaptureDescriptorDataCreateInfoEXT

VkOpticalFlowExecuteFlagBitsNV:

api: enum VkOpticalFlowExecuteFlagBitsNV

VkOpticalFlowExecuteFlagsNV:

api: type VkOpticalFlowExecuteFlagsNV

VkOpticalFlowExecuteInfoNV:

api: object VkOpticalFlowExecuteInfoNV

VkOpticalFlowGridSizeFlagBitsNV:

api: enum VkOpticalFlowGridSizeFlagBitsNV

VkOpticalFlowGridSizeFlagsNV:

api: type VkOpticalFlowGridSizeFlagsNV

VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV:

api: const VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV

VkOpticalFlowImageFormatInfoNV:

api: object VkOpticalFlowImageFormatInfoNV

VkOpticalFlowImageFormatPropertiesNV:

api: object VkOpticalFlowImageFormatPropertiesNV

VkOpticalFlowPerformanceLevelNV:

api: enum VkOpticalFlowPerformanceLevelNV

VkOpticalFlowSessionBindingPointNV:

api: enum VkOpticalFlowSessionBindingPointNV

VkOpticalFlowSessionCreateFlagBitsNV:

api: enum VkOpticalFlowSessionCreateFlagBitsNV

VkOpticalFlowSessionCreateFlagsNV:

api: type VkOpticalFlowSessionCreateFlagsNV

VkOpticalFlowSessionCreateInfoNV:

api: object VkOpticalFlowSessionCreateInfoNV

VkOpticalFlowSessionCreatePrivateDataInfoNV:

api: object VkOpticalFlowSessionCreatePrivateDataInfoNV

VkOpticalFlowSessionNV:

api: type VkOpticalFlowSessionNV

VkOpticalFlowUsageFlagBitsNV:

api: enum VkOpticalFlowUsageFlagBitsNV

VkOpticalFlowUsageFlagsNV:

api: type VkOpticalFlowUsageFlagsNV

VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV:

api: const VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV

VkPastPresentationTimingGOOGLE:

api: object VkPastPresentationTimingGOOGLE

VkPeerMemoryFeatureFlagBits:

api: enum VkPeerMemoryFeatureFlagBits

VkPeerMemoryFeatureFlagBitsKHR:

api: type VkPeerMemoryFeatureFlagBitsKHR

VkPeerMemoryFeatureFlags:

api: type VkPeerMemoryFeatureFlags

VkPeerMemoryFeatureFlagsKHR:

api: type VkPeerMemoryFeatureFlagsKHR

VkPerformanceConfigurationAcquireInfoINTEL:

api: object VkPerformanceConfigurationAcquireInfoINTEL

VkPerformanceConfigurationINTEL:

api: type VkPerformanceConfigurationINTEL

VkPerformanceConfigurationTypeINTEL:

api: enum VkPerformanceConfigurationTypeINTEL

VkPerformanceCounterDescriptionFlagBitsKHR:

api: enum VkPerformanceCounterDescriptionFlagBitsKHR

VkPerformanceCounterDescriptionFlagsKHR:

api: type VkPerformanceCounterDescriptionFlagsKHR

VkPerformanceCounterDescriptionKHR:

api: object VkPerformanceCounterDescriptionKHR

VkPerformanceCounterKHR:

api: object VkPerformanceCounterKHR

VkPerformanceCounterResultKHR:

api: object VkPerformanceCounterResultKHR

VkPerformanceCounterScopeKHR:

api: enum VkPerformanceCounterScopeKHR

VkPerformanceCounterStorageKHR:

api: enum VkPerformanceCounterStorageKHR

VkPerformanceCounterUnitKHR:

api: enum VkPerformanceCounterUnitKHR

VkPerformanceMarkerInfoINTEL:

api: object VkPerformanceMarkerInfoINTEL

VkPerformanceOverrideInfoINTEL:

api: object VkPerformanceOverrideInfoINTEL

VkPerformanceOverrideTypeINTEL:

api: enum VkPerformanceOverrideTypeINTEL

VkPerformanceParameterTypeINTEL:

api: enum VkPerformanceParameterTypeINTEL

VkPerformanceQueryReservationInfoKHR:

api: object VkPerformanceQueryReservationInfoKHR

VkPerformanceQuerySubmitInfoKHR:

api: object VkPerformanceQuerySubmitInfoKHR

VkPerformanceStreamMarkerInfoINTEL:

api: object VkPerformanceStreamMarkerInfoINTEL

VkPerformanceValueDataINTEL:

api: object VkPerformanceValueDataINTEL

VkPerformanceValueINTEL:

api: object VkPerformanceValueINTEL

VkPerformanceValueTypeINTEL:

api: enum VkPerformanceValueTypeINTEL

VkPhysicalDevice:

api: type VkPhysicalDevice

VkPhysicalDevice16BitStorageFeatures:

api: object VkPhysicalDevice16BitStorageFeatures

VkPhysicalDevice16BitStorageFeaturesKHR:

api: object VkPhysicalDevice16BitStorageFeaturesKHR

VkPhysicalDevice4444FormatsFeaturesEXT:

api: object VkPhysicalDevice4444FormatsFeaturesEXT

VkPhysicalDevice8BitStorageFeatures:

api: object VkPhysicalDevice8BitStorageFeatures

VkPhysicalDevice8BitStorageFeaturesKHR:

api: object VkPhysicalDevice8BitStorageFeaturesKHR

VkPhysicalDeviceAccelerationStructureFeaturesKHR:

api: object VkPhysicalDeviceAccelerationStructureFeaturesKHR

VkPhysicalDeviceAccelerationStructurePropertiesKHR:

api: object VkPhysicalDeviceAccelerationStructurePropertiesKHR

VkPhysicalDeviceAddressBindingReportFeaturesEXT:

api: object VkPhysicalDeviceAddressBindingReportFeaturesEXT

VkPhysicalDeviceAmigoProfilingFeaturesSEC:

api: object VkPhysicalDeviceAmigoProfilingFeaturesSEC

VkPhysicalDeviceASTCDecodeFeaturesEXT:

api: object VkPhysicalDeviceASTCDecodeFeaturesEXT

VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT:

api: object VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT

VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT:

api: object VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT

VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT:

api: object VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT

VkPhysicalDeviceBorderColorSwizzleFeaturesEXT:

api: object VkPhysicalDeviceBorderColorSwizzleFeaturesEXT

VkPhysicalDeviceBufferAddressFeaturesEXT:

api: object VkPhysicalDeviceBufferAddressFeaturesEXT

VkPhysicalDeviceBufferDeviceAddressFeatures:

api: object VkPhysicalDeviceBufferDeviceAddressFeatures

VkPhysicalDeviceBufferDeviceAddressFeaturesEXT:

api: object VkPhysicalDeviceBufferDeviceAddressFeaturesEXT

VkPhysicalDeviceBufferDeviceAddressFeaturesKHR:

api: object VkPhysicalDeviceBufferDeviceAddressFeaturesKHR

VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI:

api: object VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI

VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI:

api: object VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI

VkPhysicalDeviceCoherentMemoryFeaturesAMD:

api: object VkPhysicalDeviceCoherentMemoryFeaturesAMD

VkPhysicalDeviceColorWriteEnableFeaturesEXT:

api: object VkPhysicalDeviceColorWriteEnableFeaturesEXT

VkPhysicalDeviceComputeShaderDerivativesFeaturesNV:

api: object VkPhysicalDeviceComputeShaderDerivativesFeaturesNV

VkPhysicalDeviceConditionalRenderingFeaturesEXT:

api: object VkPhysicalDeviceConditionalRenderingFeaturesEXT

VkPhysicalDeviceConservativeRasterizationPropertiesEXT:

api: object VkPhysicalDeviceConservativeRasterizationPropertiesEXT

VkPhysicalDeviceCooperativeMatrixFeaturesNV:

api: object VkPhysicalDeviceCooperativeMatrixFeaturesNV

VkPhysicalDeviceCooperativeMatrixPropertiesNV:

api: object VkPhysicalDeviceCooperativeMatrixPropertiesNV

VkPhysicalDeviceCopyMemoryIndirectFeaturesNV:

api: object VkPhysicalDeviceCopyMemoryIndirectFeaturesNV

VkPhysicalDeviceCopyMemoryIndirectPropertiesNV:

api: object VkPhysicalDeviceCopyMemoryIndirectPropertiesNV

VkPhysicalDeviceCornerSampledImageFeaturesNV:

api: object VkPhysicalDeviceCornerSampledImageFeaturesNV

VkPhysicalDeviceCoverageReductionModeFeaturesNV:

api: object VkPhysicalDeviceCoverageReductionModeFeaturesNV

VkPhysicalDeviceCustomBorderColorFeaturesEXT:

api: object VkPhysicalDeviceCustomBorderColorFeaturesEXT

VkPhysicalDeviceCustomBorderColorPropertiesEXT:

api: object VkPhysicalDeviceCustomBorderColorPropertiesEXT

VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV:

api: object VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV

VkPhysicalDeviceDepthClampZeroOneFeaturesEXT:

api: object VkPhysicalDeviceDepthClampZeroOneFeaturesEXT

VkPhysicalDeviceDepthClipControlFeaturesEXT:

api: object VkPhysicalDeviceDepthClipControlFeaturesEXT

VkPhysicalDeviceDepthClipEnableFeaturesEXT:

api: object VkPhysicalDeviceDepthClipEnableFeaturesEXT

VkPhysicalDeviceDepthStencilResolveProperties:

api: object VkPhysicalDeviceDepthStencilResolveProperties

VkPhysicalDeviceDepthStencilResolvePropertiesKHR:

api: object VkPhysicalDeviceDepthStencilResolvePropertiesKHR

VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT:

api: object VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT

VkPhysicalDeviceDescriptorBufferFeaturesEXT:

api: object VkPhysicalDeviceDescriptorBufferFeaturesEXT

VkPhysicalDeviceDescriptorBufferPropertiesEXT:

api: object VkPhysicalDeviceDescriptorBufferPropertiesEXT

VkPhysicalDeviceDescriptorIndexingFeatures:

api: object VkPhysicalDeviceDescriptorIndexingFeatures

VkPhysicalDeviceDescriptorIndexingFeaturesEXT:

api: object VkPhysicalDeviceDescriptorIndexingFeaturesEXT

VkPhysicalDeviceDescriptorIndexingProperties:

api: object VkPhysicalDeviceDescriptorIndexingProperties

VkPhysicalDeviceDescriptorIndexingPropertiesEXT:

api: object VkPhysicalDeviceDescriptorIndexingPropertiesEXT

VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE:

api: object VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE

VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV:

api: object VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV

VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV:

api: object VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV

VkPhysicalDeviceDeviceMemoryReportFeaturesEXT:

api: object VkPhysicalDeviceDeviceMemoryReportFeaturesEXT

VkPhysicalDeviceDiagnosticsConfigFeaturesNV:

api: object VkPhysicalDeviceDiagnosticsConfigFeaturesNV

VkPhysicalDeviceDiscardRectanglePropertiesEXT:

api: object VkPhysicalDeviceDiscardRectanglePropertiesEXT

VkPhysicalDeviceDriverProperties:

api: object VkPhysicalDeviceDriverProperties

VkPhysicalDeviceDriverPropertiesKHR:

api: object VkPhysicalDeviceDriverPropertiesKHR

VkPhysicalDeviceDrmPropertiesEXT:

api: object VkPhysicalDeviceDrmPropertiesEXT

VkPhysicalDeviceDynamicRenderingFeatures:

api: object VkPhysicalDeviceDynamicRenderingFeatures

VkPhysicalDeviceDynamicRenderingFeaturesKHR:

api: object VkPhysicalDeviceDynamicRenderingFeaturesKHR

VkPhysicalDeviceExclusiveScissorFeaturesNV:

api: object VkPhysicalDeviceExclusiveScissorFeaturesNV

VkPhysicalDeviceExtendedDynamicState2FeaturesEXT:

api: object VkPhysicalDeviceExtendedDynamicState2FeaturesEXT

VkPhysicalDeviceExtendedDynamicState3FeaturesEXT:

api: object VkPhysicalDeviceExtendedDynamicState3FeaturesEXT

VkPhysicalDeviceExtendedDynamicState3PropertiesEXT:

api: object VkPhysicalDeviceExtendedDynamicState3PropertiesEXT

VkPhysicalDeviceExtendedDynamicStateFeaturesEXT:

api: object VkPhysicalDeviceExtendedDynamicStateFeaturesEXT

VkPhysicalDeviceExternalBufferInfo:

api: object VkPhysicalDeviceExternalBufferInfo

VkPhysicalDeviceExternalBufferInfoKHR:

api: object VkPhysicalDeviceExternalBufferInfoKHR

VkPhysicalDeviceExternalFenceInfo:

api: object VkPhysicalDeviceExternalFenceInfo

VkPhysicalDeviceExternalFenceInfoKHR:

api: object VkPhysicalDeviceExternalFenceInfoKHR

VkPhysicalDeviceExternalImageFormatInfo:

api: object VkPhysicalDeviceExternalImageFormatInfo

VkPhysicalDeviceExternalImageFormatInfoKHR:

api: object VkPhysicalDeviceExternalImageFormatInfoKHR

VkPhysicalDeviceExternalMemoryHostPropertiesEXT:

api: object VkPhysicalDeviceExternalMemoryHostPropertiesEXT

VkPhysicalDeviceExternalMemoryRDMAFeaturesNV:

api: object VkPhysicalDeviceExternalMemoryRDMAFeaturesNV

VkPhysicalDeviceExternalSemaphoreInfo:

api: object VkPhysicalDeviceExternalSemaphoreInfo

VkPhysicalDeviceExternalSemaphoreInfoKHR:

api: object VkPhysicalDeviceExternalSemaphoreInfoKHR

VkPhysicalDeviceFaultFeaturesEXT:

api: object VkPhysicalDeviceFaultFeaturesEXT

VkPhysicalDeviceFeatures:

api: object VkPhysicalDeviceFeatures

VkPhysicalDeviceFeatures2:

api: object VkPhysicalDeviceFeatures2

VkPhysicalDeviceFeatures2KHR:

api: object VkPhysicalDeviceFeatures2KHR

VkPhysicalDeviceFloat16Int8FeaturesKHR:

api: object VkPhysicalDeviceFloat16Int8FeaturesKHR

VkPhysicalDeviceFloatControlsProperties:

api: object VkPhysicalDeviceFloatControlsProperties

VkPhysicalDeviceFloatControlsPropertiesKHR:

api: object VkPhysicalDeviceFloatControlsPropertiesKHR

VkPhysicalDeviceFragmentDensityMap2FeaturesEXT:

api: object VkPhysicalDeviceFragmentDensityMap2FeaturesEXT

VkPhysicalDeviceFragmentDensityMap2PropertiesEXT:

api: object VkPhysicalDeviceFragmentDensityMap2PropertiesEXT

VkPhysicalDeviceFragmentDensityMapFeaturesEXT:

api: object VkPhysicalDeviceFragmentDensityMapFeaturesEXT

VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM:

api: object VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM

VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM:

api: object VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM

VkPhysicalDeviceFragmentDensityMapPropertiesEXT:

api: object VkPhysicalDeviceFragmentDensityMapPropertiesEXT

VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR:

api: object VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR

VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV:

api: object VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV

VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR:

api: object VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR

VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT:

api: object VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT

VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV:

api: object VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV

VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV:

api: object VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV

VkPhysicalDeviceFragmentShadingRateFeaturesKHR:

api: object VkPhysicalDeviceFragmentShadingRateFeaturesKHR

VkPhysicalDeviceFragmentShadingRateKHR:

api: object VkPhysicalDeviceFragmentShadingRateKHR

VkPhysicalDeviceFragmentShadingRatePropertiesKHR:

api: object VkPhysicalDeviceFragmentShadingRatePropertiesKHR

VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT:

api: object VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT

VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR:

api: object VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR

VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT:

api: object VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT

VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT:

api: object VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT

VkPhysicalDeviceGroupProperties:

api: object VkPhysicalDeviceGroupProperties

VkPhysicalDeviceGroupPropertiesKHR:

api: object VkPhysicalDeviceGroupPropertiesKHR

VkPhysicalDeviceHostQueryResetFeatures:

api: object VkPhysicalDeviceHostQueryResetFeatures

VkPhysicalDeviceHostQueryResetFeaturesEXT:

api: object VkPhysicalDeviceHostQueryResetFeaturesEXT

VkPhysicalDeviceIDProperties:

api: object VkPhysicalDeviceIDProperties

VkPhysicalDeviceIDPropertiesKHR:

api: object VkPhysicalDeviceIDPropertiesKHR

VkPhysicalDeviceImage2DViewOf3DFeaturesEXT:

api: object VkPhysicalDeviceImage2DViewOf3DFeaturesEXT

VkPhysicalDeviceImageCompressionControlFeaturesEXT:

api: object VkPhysicalDeviceImageCompressionControlFeaturesEXT

VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT:

api: object VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT

VkPhysicalDeviceImageDrmFormatModifierInfoEXT:

api: object VkPhysicalDeviceImageDrmFormatModifierInfoEXT

VkPhysicalDeviceImageFormatInfo2:

api: object VkPhysicalDeviceImageFormatInfo2

VkPhysicalDeviceImageFormatInfo2KHR:

api: object VkPhysicalDeviceImageFormatInfo2KHR

VkPhysicalDeviceImagelessFramebufferFeatures:

api: object VkPhysicalDeviceImagelessFramebufferFeatures

VkPhysicalDeviceImagelessFramebufferFeaturesKHR:

api: object VkPhysicalDeviceImagelessFramebufferFeaturesKHR

VkPhysicalDeviceImageProcessingFeaturesQCOM:

api: object VkPhysicalDeviceImageProcessingFeaturesQCOM

VkPhysicalDeviceImageProcessingPropertiesQCOM:

api: object VkPhysicalDeviceImageProcessingPropertiesQCOM

VkPhysicalDeviceImageRobustnessFeatures:

api: object VkPhysicalDeviceImageRobustnessFeatures

VkPhysicalDeviceImageRobustnessFeaturesEXT:

api: object VkPhysicalDeviceImageRobustnessFeaturesEXT

VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT:

api: object VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT

VkPhysicalDeviceImageViewImageFormatInfoEXT:

api: object VkPhysicalDeviceImageViewImageFormatInfoEXT

VkPhysicalDeviceImageViewMinLodFeaturesEXT:

api: object VkPhysicalDeviceImageViewMinLodFeaturesEXT

VkPhysicalDeviceIndexTypeUint8FeaturesEXT:

api: object VkPhysicalDeviceIndexTypeUint8FeaturesEXT

VkPhysicalDeviceInheritedViewportScissorFeaturesNV:

api: object VkPhysicalDeviceInheritedViewportScissorFeaturesNV

VkPhysicalDeviceInlineUniformBlockFeatures:

api: object VkPhysicalDeviceInlineUniformBlockFeatures

VkPhysicalDeviceInlineUniformBlockFeaturesEXT:

api: object VkPhysicalDeviceInlineUniformBlockFeaturesEXT

VkPhysicalDeviceInlineUniformBlockProperties:

api: object VkPhysicalDeviceInlineUniformBlockProperties

VkPhysicalDeviceInlineUniformBlockPropertiesEXT:

api: object VkPhysicalDeviceInlineUniformBlockPropertiesEXT

VkPhysicalDeviceInvocationMaskFeaturesHUAWEI:

api: object VkPhysicalDeviceInvocationMaskFeaturesHUAWEI

VkPhysicalDeviceLegacyDitheringFeaturesEXT:

api: object VkPhysicalDeviceLegacyDitheringFeaturesEXT

VkPhysicalDeviceLimits:

api: object VkPhysicalDeviceLimits

VkPhysicalDeviceLinearColorAttachmentFeaturesNV:

api: object VkPhysicalDeviceLinearColorAttachmentFeaturesNV

VkPhysicalDeviceLineRasterizationFeaturesEXT:

api: object VkPhysicalDeviceLineRasterizationFeaturesEXT

VkPhysicalDeviceLineRasterizationPropertiesEXT:

api: object VkPhysicalDeviceLineRasterizationPropertiesEXT

VkPhysicalDeviceMaintenance3Properties:

api: object VkPhysicalDeviceMaintenance3Properties

VkPhysicalDeviceMaintenance3PropertiesKHR:

api: object VkPhysicalDeviceMaintenance3PropertiesKHR

VkPhysicalDeviceMaintenance4Features:

api: object VkPhysicalDeviceMaintenance4Features

VkPhysicalDeviceMaintenance4FeaturesKHR:

api: object VkPhysicalDeviceMaintenance4FeaturesKHR

VkPhysicalDeviceMaintenance4Properties:

api: object VkPhysicalDeviceMaintenance4Properties

VkPhysicalDeviceMaintenance4PropertiesKHR:

api: object VkPhysicalDeviceMaintenance4PropertiesKHR

VkPhysicalDeviceMemoryBudgetPropertiesEXT:

api: object VkPhysicalDeviceMemoryBudgetPropertiesEXT

VkPhysicalDeviceMemoryDecompressionFeaturesNV:

api: object VkPhysicalDeviceMemoryDecompressionFeaturesNV

VkPhysicalDeviceMemoryDecompressionPropertiesNV:

api: object VkPhysicalDeviceMemoryDecompressionPropertiesNV

VkPhysicalDeviceMemoryPriorityFeaturesEXT:

api: object VkPhysicalDeviceMemoryPriorityFeaturesEXT

VkPhysicalDeviceMemoryProperties:

api: object VkPhysicalDeviceMemoryProperties

VkPhysicalDeviceMemoryProperties2:

api: object VkPhysicalDeviceMemoryProperties2

VkPhysicalDeviceMemoryProperties2KHR:

api: object VkPhysicalDeviceMemoryProperties2KHR

VkPhysicalDeviceMeshShaderFeaturesEXT:

api: object VkPhysicalDeviceMeshShaderFeaturesEXT

VkPhysicalDeviceMeshShaderFeaturesNV:

api: object VkPhysicalDeviceMeshShaderFeaturesNV

VkPhysicalDeviceMeshShaderPropertiesEXT:

api: object VkPhysicalDeviceMeshShaderPropertiesEXT

VkPhysicalDeviceMeshShaderPropertiesNV:

api: object VkPhysicalDeviceMeshShaderPropertiesNV

VkPhysicalDeviceMultiDrawFeaturesEXT:

api: object VkPhysicalDeviceMultiDrawFeaturesEXT

VkPhysicalDeviceMultiDrawPropertiesEXT:

api: object VkPhysicalDeviceMultiDrawPropertiesEXT

VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT:

api: object VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT

VkPhysicalDeviceMultiviewFeatures:

api: object VkPhysicalDeviceMultiviewFeatures

VkPhysicalDeviceMultiviewFeaturesKHR:

api: object VkPhysicalDeviceMultiviewFeaturesKHR

VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX:

api: object VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX

VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM:

api: object VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM

VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM:

api: object VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM

VkPhysicalDeviceMultiviewProperties:

api: object VkPhysicalDeviceMultiviewProperties

VkPhysicalDeviceMultiviewPropertiesKHR:

api: object VkPhysicalDeviceMultiviewPropertiesKHR

VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT:

api: object VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT

VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE:

api: object VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE

VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT:

api: object VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT

VkPhysicalDeviceOpacityMicromapFeaturesEXT:

api: object VkPhysicalDeviceOpacityMicromapFeaturesEXT

VkPhysicalDeviceOpacityMicromapPropertiesEXT:

api: object VkPhysicalDeviceOpacityMicromapPropertiesEXT

VkPhysicalDeviceOpticalFlowFeaturesNV:

api: object VkPhysicalDeviceOpticalFlowFeaturesNV

VkPhysicalDeviceOpticalFlowPropertiesNV:

api: object VkPhysicalDeviceOpticalFlowPropertiesNV

VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT:

api: object VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT

VkPhysicalDevicePCIBusInfoPropertiesEXT:

api: object VkPhysicalDevicePCIBusInfoPropertiesEXT

VkPhysicalDevicePerformanceQueryFeaturesKHR:

api: object VkPhysicalDevicePerformanceQueryFeaturesKHR

VkPhysicalDevicePerformanceQueryPropertiesKHR:

api: object VkPhysicalDevicePerformanceQueryPropertiesKHR

VkPhysicalDevicePipelineCreationCacheControlFeatures:

api: object VkPhysicalDevicePipelineCreationCacheControlFeatures

VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT:

api: object VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT

VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR:

api: object VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR

VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT:

api: object VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT

VkPhysicalDevicePipelinePropertiesFeaturesEXT:

api: object VkPhysicalDevicePipelinePropertiesFeaturesEXT

VkPhysicalDevicePipelineProtectedAccessFeaturesEXT:

api: object VkPhysicalDevicePipelineProtectedAccessFeaturesEXT

VkPhysicalDevicePipelineRobustnessFeaturesEXT:

api: object VkPhysicalDevicePipelineRobustnessFeaturesEXT

VkPhysicalDevicePipelineRobustnessPropertiesEXT:

api: object VkPhysicalDevicePipelineRobustnessPropertiesEXT

VkPhysicalDevicePointClippingProperties:

api: object VkPhysicalDevicePointClippingProperties

VkPhysicalDevicePointClippingPropertiesKHR:

api: object VkPhysicalDevicePointClippingPropertiesKHR

VkPhysicalDevicePresentBarrierFeaturesNV:

api: object VkPhysicalDevicePresentBarrierFeaturesNV

VkPhysicalDevicePresentIdFeaturesKHR:

api: object VkPhysicalDevicePresentIdFeaturesKHR

VkPhysicalDevicePresentWaitFeaturesKHR:

api: object VkPhysicalDevicePresentWaitFeaturesKHR

VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT:

api: object VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT

VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT:

api: object VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT

VkPhysicalDevicePrivateDataFeatures:

api: object VkPhysicalDevicePrivateDataFeatures

VkPhysicalDevicePrivateDataFeaturesEXT:

api: object VkPhysicalDevicePrivateDataFeaturesEXT

VkPhysicalDeviceProperties:

api: object VkPhysicalDeviceProperties

VkPhysicalDeviceProperties2:

api: object VkPhysicalDeviceProperties2

VkPhysicalDeviceProperties2KHR:

api: object VkPhysicalDeviceProperties2KHR

VkPhysicalDeviceProtectedMemoryFeatures:

api: object VkPhysicalDeviceProtectedMemoryFeatures

VkPhysicalDeviceProtectedMemoryProperties:

api: object VkPhysicalDeviceProtectedMemoryProperties

VkPhysicalDeviceProvokingVertexFeaturesEXT:

api: object VkPhysicalDeviceProvokingVertexFeaturesEXT

VkPhysicalDeviceProvokingVertexPropertiesEXT:

api: object VkPhysicalDeviceProvokingVertexPropertiesEXT

VkPhysicalDevicePushDescriptorPropertiesKHR:

api: object VkPhysicalDevicePushDescriptorPropertiesKHR

VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM:

api: object VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM

VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT:

api: object VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT

VkPhysicalDeviceRayQueryFeaturesKHR:

api: object VkPhysicalDeviceRayQueryFeaturesKHR

VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV:

api: object VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV

VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV:

api: object VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV

VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR:

api: object VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR

VkPhysicalDeviceRayTracingMotionBlurFeaturesNV:

api: object VkPhysicalDeviceRayTracingMotionBlurFeaturesNV

VkPhysicalDeviceRayTracingPipelineFeaturesKHR:

api: object VkPhysicalDeviceRayTracingPipelineFeaturesKHR

VkPhysicalDeviceRayTracingPipelinePropertiesKHR:

api: object VkPhysicalDeviceRayTracingPipelinePropertiesKHR

VkPhysicalDeviceRayTracingPropertiesNV:

api: object VkPhysicalDeviceRayTracingPropertiesNV

VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV:

api: object VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV

VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT:

api: object VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT

VkPhysicalDeviceRobustness2FeaturesEXT:

api: object VkPhysicalDeviceRobustness2FeaturesEXT

VkPhysicalDeviceRobustness2PropertiesEXT:

api: object VkPhysicalDeviceRobustness2PropertiesEXT

VkPhysicalDeviceSampleLocationsPropertiesEXT:

api: object VkPhysicalDeviceSampleLocationsPropertiesEXT

VkPhysicalDeviceSamplerFilterMinmaxProperties:

api: object VkPhysicalDeviceSamplerFilterMinmaxProperties

VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT:

api: object VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT

VkPhysicalDeviceSamplerYcbcrConversionFeatures:

api: object VkPhysicalDeviceSamplerYcbcrConversionFeatures

VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR:

api: object VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR

VkPhysicalDeviceScalarBlockLayoutFeatures:

api: object VkPhysicalDeviceScalarBlockLayoutFeatures

VkPhysicalDeviceScalarBlockLayoutFeaturesEXT:

api: object VkPhysicalDeviceScalarBlockLayoutFeaturesEXT

VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures:

api: object VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures

VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR:

api: object VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR

VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT:

api: object VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT

VkPhysicalDeviceShaderAtomicFloatFeaturesEXT:

api: object VkPhysicalDeviceShaderAtomicFloatFeaturesEXT

VkPhysicalDeviceShaderAtomicInt64Features:

api: object VkPhysicalDeviceShaderAtomicInt64Features

VkPhysicalDeviceShaderAtomicInt64FeaturesKHR:

api: object VkPhysicalDeviceShaderAtomicInt64FeaturesKHR

VkPhysicalDeviceShaderClockFeaturesKHR:

api: object VkPhysicalDeviceShaderClockFeaturesKHR

VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM:

api: object VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM

VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM:

api: object VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM

VkPhysicalDeviceShaderCoreProperties2AMD:

api: object VkPhysicalDeviceShaderCoreProperties2AMD

VkPhysicalDeviceShaderCorePropertiesAMD:

api: object VkPhysicalDeviceShaderCorePropertiesAMD

VkPhysicalDeviceShaderCorePropertiesARM:

api: object VkPhysicalDeviceShaderCorePropertiesARM

VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures:

api: object VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures

VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT:

api: object VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT

VkPhysicalDeviceShaderDrawParameterFeatures:

api: object VkPhysicalDeviceShaderDrawParameterFeatures

VkPhysicalDeviceShaderDrawParametersFeatures:

api: object VkPhysicalDeviceShaderDrawParametersFeatures

VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD:

api: object VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD

VkPhysicalDeviceShaderFloat16Int8Features:

api: object VkPhysicalDeviceShaderFloat16Int8Features

VkPhysicalDeviceShaderFloat16Int8FeaturesKHR:

api: object VkPhysicalDeviceShaderFloat16Int8FeaturesKHR

VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT:

api: object VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT

VkPhysicalDeviceShaderImageFootprintFeaturesNV:

api: object VkPhysicalDeviceShaderImageFootprintFeaturesNV

VkPhysicalDeviceShaderIntegerDotProductFeatures:

api: object VkPhysicalDeviceShaderIntegerDotProductFeatures

VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR:

api: object VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR

VkPhysicalDeviceShaderIntegerDotProductProperties:

api: object VkPhysicalDeviceShaderIntegerDotProductProperties

VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR:

api: object VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR

VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL:

api: object VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL

VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT:

api: object VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT

VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT:

api: object VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT

VkPhysicalDeviceShaderSMBuiltinsFeaturesNV:

api: object VkPhysicalDeviceShaderSMBuiltinsFeaturesNV

VkPhysicalDeviceShaderSMBuiltinsPropertiesNV:

api: object VkPhysicalDeviceShaderSMBuiltinsPropertiesNV

VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures:

api: object VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures

VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR:

api: object VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR

VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR:

api: object VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR

VkPhysicalDeviceShaderTerminateInvocationFeatures:

api: object VkPhysicalDeviceShaderTerminateInvocationFeatures

VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR:

api: object VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR

VkPhysicalDeviceShadingRateImageFeaturesNV:

api: object VkPhysicalDeviceShadingRateImageFeaturesNV

VkPhysicalDeviceShadingRateImagePropertiesNV:

api: object VkPhysicalDeviceShadingRateImagePropertiesNV

VkPhysicalDeviceSparseImageFormatInfo2:

api: object VkPhysicalDeviceSparseImageFormatInfo2

VkPhysicalDeviceSparseImageFormatInfo2KHR:

api: object VkPhysicalDeviceSparseImageFormatInfo2KHR

VkPhysicalDeviceSparseProperties:

api: object VkPhysicalDeviceSparseProperties

VkPhysicalDeviceSubgroupProperties:

api: object VkPhysicalDeviceSubgroupProperties

VkPhysicalDeviceSubgroupSizeControlFeatures:

api: object VkPhysicalDeviceSubgroupSizeControlFeatures

VkPhysicalDeviceSubgroupSizeControlFeaturesEXT:

api: object VkPhysicalDeviceSubgroupSizeControlFeaturesEXT

VkPhysicalDeviceSubgroupSizeControlProperties:

api: object VkPhysicalDeviceSubgroupSizeControlProperties

VkPhysicalDeviceSubgroupSizeControlPropertiesEXT:

api: object VkPhysicalDeviceSubgroupSizeControlPropertiesEXT

VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT:

api: object VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT

VkPhysicalDeviceSubpassShadingFeaturesHUAWEI:

api: object VkPhysicalDeviceSubpassShadingFeaturesHUAWEI

VkPhysicalDeviceSubpassShadingPropertiesHUAWEI:

api: object VkPhysicalDeviceSubpassShadingPropertiesHUAWEI

VkPhysicalDeviceSurfaceInfo2KHR:

api: object VkPhysicalDeviceSurfaceInfo2KHR

VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT:

api: object VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT

VkPhysicalDeviceSynchronization2Features:

api: object VkPhysicalDeviceSynchronization2Features

VkPhysicalDeviceSynchronization2FeaturesKHR:

api: object VkPhysicalDeviceSynchronization2FeaturesKHR

VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT:

api: object VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT

VkPhysicalDeviceTexelBufferAlignmentProperties:

api: object VkPhysicalDeviceTexelBufferAlignmentProperties

VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT:

api: object VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT

VkPhysicalDeviceTextureCompressionASTCHDRFeatures:

api: object VkPhysicalDeviceTextureCompressionASTCHDRFeatures

VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT:

api: object VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT

VkPhysicalDeviceTilePropertiesFeaturesQCOM:

api: object VkPhysicalDeviceTilePropertiesFeaturesQCOM

VkPhysicalDeviceTimelineSemaphoreFeatures:

api: object VkPhysicalDeviceTimelineSemaphoreFeatures

VkPhysicalDeviceTimelineSemaphoreFeaturesKHR:

api: object VkPhysicalDeviceTimelineSemaphoreFeaturesKHR

VkPhysicalDeviceTimelineSemaphoreProperties:

api: object VkPhysicalDeviceTimelineSemaphoreProperties

VkPhysicalDeviceTimelineSemaphorePropertiesKHR:

api: object VkPhysicalDeviceTimelineSemaphorePropertiesKHR

VkPhysicalDeviceToolProperties:

api: object VkPhysicalDeviceToolProperties

VkPhysicalDeviceToolPropertiesEXT:

api: object VkPhysicalDeviceToolPropertiesEXT

VkPhysicalDeviceTransformFeedbackFeaturesEXT:

api: object VkPhysicalDeviceTransformFeedbackFeaturesEXT

VkPhysicalDeviceTransformFeedbackPropertiesEXT:

api: object VkPhysicalDeviceTransformFeedbackPropertiesEXT

VkPhysicalDeviceType:

api: enum VkPhysicalDeviceType

VkPhysicalDeviceUniformBufferStandardLayoutFeatures:

api: object VkPhysicalDeviceUniformBufferStandardLayoutFeatures

VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR:

api: object VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR

VkPhysicalDeviceVariablePointerFeatures:

api: object VkPhysicalDeviceVariablePointerFeatures

VkPhysicalDeviceVariablePointerFeaturesKHR:

api: object VkPhysicalDeviceVariablePointerFeaturesKHR

VkPhysicalDeviceVariablePointersFeatures:

api: object VkPhysicalDeviceVariablePointersFeatures

VkPhysicalDeviceVariablePointersFeaturesKHR:

api: object VkPhysicalDeviceVariablePointersFeaturesKHR

VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT:

api: object VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT

VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT:

api: object VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT

VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT:

api: object VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT

VkPhysicalDeviceVulkan11Features:

api: object VkPhysicalDeviceVulkan11Features

VkPhysicalDeviceVulkan11Properties:

api: object VkPhysicalDeviceVulkan11Properties

VkPhysicalDeviceVulkan12Features:

api: object VkPhysicalDeviceVulkan12Features

VkPhysicalDeviceVulkan12Properties:

api: object VkPhysicalDeviceVulkan12Properties

VkPhysicalDeviceVulkan13Features:

api: object VkPhysicalDeviceVulkan13Features

VkPhysicalDeviceVulkan13Properties:

api: object VkPhysicalDeviceVulkan13Properties

VkPhysicalDeviceVulkanMemoryModelFeatures:

api: object VkPhysicalDeviceVulkanMemoryModelFeatures

VkPhysicalDeviceVulkanMemoryModelFeaturesKHR:

api: object VkPhysicalDeviceVulkanMemoryModelFeaturesKHR

VkPhysicalDeviceVulkanSC10Features:

api: object VkPhysicalDeviceVulkanSC10Features

VkPhysicalDeviceVulkanSC10Properties:

api: object VkPhysicalDeviceVulkanSC10Properties

VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR:

api: object VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR

VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT:

api: object VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT

VkPhysicalDeviceYcbcrImageArraysFeaturesEXT:

api: object VkPhysicalDeviceYcbcrImageArraysFeaturesEXT

VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures:

api: object VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures

VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR:

api: object VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR

VkPipeline:

api: type VkPipeline

VkPipelineBindPoint:

api: enum VkPipelineBindPoint

VkPipelineCache:

api: type VkPipelineCache

VkPipelineCacheCreateFlagBits:

api: enum VkPipelineCacheCreateFlagBits

VkPipelineCacheCreateFlags:

api: type VkPipelineCacheCreateFlags

VkPipelineCacheCreateInfo:

api: object VkPipelineCacheCreateInfo

VkPipelineCacheHeaderVersion:

api: enum VkPipelineCacheHeaderVersion

VkPipelineCacheHeaderVersionOne:

api: object VkPipelineCacheHeaderVersionOne

VkPipelineCacheHeaderVersionSafetyCriticalOne:

api: object VkPipelineCacheHeaderVersionSafetyCriticalOne

VkPipelineCacheSafetyCriticalIndexEntry:

api: object VkPipelineCacheSafetyCriticalIndexEntry

VkPipelineCacheStageValidationIndexEntry:

api: object VkPipelineCacheStageValidationIndexEntry

VkPipelineCacheValidationVersion:

api: enum VkPipelineCacheValidationVersion

VkPipelineColorBlendAdvancedStateCreateInfoEXT:

api: object VkPipelineColorBlendAdvancedStateCreateInfoEXT

VkPipelineColorBlendAttachmentState:

api: object VkPipelineColorBlendAttachmentState

VkPipelineColorBlendStateCreateFlagBits:

api: enum VkPipelineColorBlendStateCreateFlagBits

VkPipelineColorBlendStateCreateFlags:

api: type VkPipelineColorBlendStateCreateFlags

VkPipelineColorBlendStateCreateInfo:

api: object VkPipelineColorBlendStateCreateInfo

VkPipelineColorWriteCreateInfoEXT:

api: object VkPipelineColorWriteCreateInfoEXT

VkPipelineCompilerControlCreateInfoAMD:

api: object VkPipelineCompilerControlCreateInfoAMD

VkPipelineCompilerControlFlagsAMD:

api: type VkPipelineCompilerControlFlagsAMD

VkPipelineCoverageModulationStateCreateFlagsNV:

api: type VkPipelineCoverageModulationStateCreateFlagsNV

VkPipelineCoverageModulationStateCreateInfoNV:

api: object VkPipelineCoverageModulationStateCreateInfoNV

VkPipelineCoverageReductionStateCreateFlagsNV:

api: type VkPipelineCoverageReductionStateCreateFlagsNV

VkPipelineCoverageReductionStateCreateInfoNV:

api: object VkPipelineCoverageReductionStateCreateInfoNV

VkPipelineCoverageToColorStateCreateFlagsNV:

api: type VkPipelineCoverageToColorStateCreateFlagsNV

VkPipelineCoverageToColorStateCreateInfoNV:

api: object VkPipelineCoverageToColorStateCreateInfoNV

VkPipelineCreateFlagBits:

api: enum VkPipelineCreateFlagBits

VkPipelineCreateFlags:

api: type VkPipelineCreateFlags

VkPipelineCreationFeedback:

api: object VkPipelineCreationFeedback

VkPipelineCreationFeedbackCreateInfo:

api: object VkPipelineCreationFeedbackCreateInfo

VkPipelineCreationFeedbackCreateInfoEXT:

api: object VkPipelineCreationFeedbackCreateInfoEXT

VkPipelineCreationFeedbackEXT:

api: object VkPipelineCreationFeedbackEXT

VkPipelineCreationFeedbackFlagBits:

api: enum VkPipelineCreationFeedbackFlagBits

VkPipelineCreationFeedbackFlagBitsEXT:

api: type VkPipelineCreationFeedbackFlagBitsEXT

VkPipelineCreationFeedbackFlags:

api: type VkPipelineCreationFeedbackFlags

VkPipelineCreationFeedbackFlagsEXT:

api: type VkPipelineCreationFeedbackFlagsEXT

VkPipelineDepthStencilStateCreateFlagBits:

api: enum VkPipelineDepthStencilStateCreateFlagBits

VkPipelineDepthStencilStateCreateFlags:

api: type VkPipelineDepthStencilStateCreateFlags

VkPipelineDepthStencilStateCreateInfo:

api: object VkPipelineDepthStencilStateCreateInfo

VkPipelineDiscardRectangleStateCreateFlagsEXT:

api: type VkPipelineDiscardRectangleStateCreateFlagsEXT

VkPipelineDiscardRectangleStateCreateInfoEXT:

api: object VkPipelineDiscardRectangleStateCreateInfoEXT

VkPipelineDynamicStateCreateFlags:

api: type VkPipelineDynamicStateCreateFlags

VkPipelineDynamicStateCreateInfo:

api: object VkPipelineDynamicStateCreateInfo

VkPipelineExecutableInfoKHR:

api: object VkPipelineExecutableInfoKHR

VkPipelineExecutableInternalRepresentationKHR:

api: object VkPipelineExecutableInternalRepresentationKHR

VkPipelineExecutablePropertiesKHR:

api: object VkPipelineExecutablePropertiesKHR

VkPipelineExecutableStatisticFormatKHR:

api: enum VkPipelineExecutableStatisticFormatKHR

VkPipelineExecutableStatisticKHR:

api: object VkPipelineExecutableStatisticKHR

VkPipelineExecutableStatisticValueKHR:

api: object VkPipelineExecutableStatisticValueKHR

VkPipelineFragmentShadingRateEnumStateCreateInfoNV:

api: object VkPipelineFragmentShadingRateEnumStateCreateInfoNV

VkPipelineFragmentShadingRateStateCreateInfoKHR:

api: object VkPipelineFragmentShadingRateStateCreateInfoKHR

VkPipelineInfoEXT:

api: object VkPipelineInfoEXT

VkPipelineInfoKHR:

api: object VkPipelineInfoKHR

VkPipelineInputAssemblyStateCreateFlags:

api: type VkPipelineInputAssemblyStateCreateFlags

VkPipelineInputAssemblyStateCreateInfo:

api: object VkPipelineInputAssemblyStateCreateInfo

VkPipelineLayout:

api: type VkPipelineLayout

VkPipelineLayoutCreateFlagBits:

api: enum VkPipelineLayoutCreateFlagBits

VkPipelineLayoutCreateFlags:

api: type VkPipelineLayoutCreateFlags

VkPipelineLayoutCreateInfo:

api: object VkPipelineLayoutCreateInfo

VkPipelineLibraryCreateInfoKHR:

api: object VkPipelineLibraryCreateInfoKHR

VkPipelineMatchControl:

api: enum VkPipelineMatchControl

VkPipelineMultisampleStateCreateFlags:

api: type VkPipelineMultisampleStateCreateFlags

VkPipelineMultisampleStateCreateInfo:

api: object VkPipelineMultisampleStateCreateInfo

VkPipelineOfflineCreateInfo:

api: object VkPipelineOfflineCreateInfo

VkPipelinePoolSize:

api: object VkPipelinePoolSize

VkPipelinePropertiesIdentifierEXT:

api: object VkPipelinePropertiesIdentifierEXT

VkPipelineRasterizationConservativeStateCreateFlagsEXT:

api: type VkPipelineRasterizationConservativeStateCreateFlagsEXT

VkPipelineRasterizationConservativeStateCreateInfoEXT:

api: object VkPipelineRasterizationConservativeStateCreateInfoEXT

VkPipelineRasterizationDepthClipStateCreateFlagsEXT:

api: type VkPipelineRasterizationDepthClipStateCreateFlagsEXT

VkPipelineRasterizationDepthClipStateCreateInfoEXT:

api: object VkPipelineRasterizationDepthClipStateCreateInfoEXT

VkPipelineRasterizationLineStateCreateInfoEXT:

api: object VkPipelineRasterizationLineStateCreateInfoEXT

VkPipelineRasterizationProvokingVertexStateCreateInfoEXT:

api: object VkPipelineRasterizationProvokingVertexStateCreateInfoEXT

VkPipelineRasterizationStateCreateFlags:

api: type VkPipelineRasterizationStateCreateFlags

VkPipelineRasterizationStateCreateInfo:

api: object VkPipelineRasterizationStateCreateInfo

VkPipelineRasterizationStateRasterizationOrderAMD:

api: object VkPipelineRasterizationStateRasterizationOrderAMD

VkPipelineRasterizationStateStreamCreateFlagsEXT:

api: type VkPipelineRasterizationStateStreamCreateFlagsEXT

VkPipelineRasterizationStateStreamCreateInfoEXT:

api: object VkPipelineRasterizationStateStreamCreateInfoEXT

VkPipelineRenderingCreateInfo:

api: object VkPipelineRenderingCreateInfo

VkPipelineRenderingCreateInfoKHR:

api: object VkPipelineRenderingCreateInfoKHR

VkPipelineRepresentativeFragmentTestStateCreateInfoNV:

api: object VkPipelineRepresentativeFragmentTestStateCreateInfoNV

VkPipelineRobustnessBufferBehaviorEXT:

api: enum VkPipelineRobustnessBufferBehaviorEXT

VkPipelineRobustnessCreateInfoEXT:

api: object VkPipelineRobustnessCreateInfoEXT

VkPipelineRobustnessImageBehaviorEXT:

api: enum VkPipelineRobustnessImageBehaviorEXT

VkPipelineSampleLocationsStateCreateInfoEXT:

api: object VkPipelineSampleLocationsStateCreateInfoEXT

VkPipelineShaderStageCreateFlagBits:

api: enum VkPipelineShaderStageCreateFlagBits

VkPipelineShaderStageCreateFlags:

api: type VkPipelineShaderStageCreateFlags

VkPipelineShaderStageCreateInfo:

api: object VkPipelineShaderStageCreateInfo

VkPipelineShaderStageModuleIdentifierCreateInfoEXT:

api: object VkPipelineShaderStageModuleIdentifierCreateInfoEXT

VkPipelineShaderStageRequiredSubgroupSizeCreateInfo:

api: object VkPipelineShaderStageRequiredSubgroupSizeCreateInfo

VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT:

api: object VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT

VK_PIPELINE_STAGE_2_NONE:

api: const VK_PIPELINE_STAGE_2_NONE

VkPipelineStageFlagBits:

api: enum VkPipelineStageFlagBits

VkPipelineStageFlagBits2:

api: enum VkPipelineStageFlagBits2

VkPipelineStageFlagBits2KHR:

api: type VkPipelineStageFlagBits2KHR

VkPipelineStageFlags:

api: type VkPipelineStageFlags

VkPipelineStageFlags2:

api: type VkPipelineStageFlags2

VkPipelineStageFlags2KHR:

api: type VkPipelineStageFlags2KHR

VkPipelineTessellationDomainOriginStateCreateInfo:

api: object VkPipelineTessellationDomainOriginStateCreateInfo

VkPipelineTessellationDomainOriginStateCreateInfoKHR:

api: object VkPipelineTessellationDomainOriginStateCreateInfoKHR

VkPipelineTessellationStateCreateFlags:

api: type VkPipelineTessellationStateCreateFlags

VkPipelineTessellationStateCreateInfo:

api: object VkPipelineTessellationStateCreateInfo

VkPipelineVertexInputDivisorStateCreateInfoEXT:

api: object VkPipelineVertexInputDivisorStateCreateInfoEXT

VkPipelineVertexInputStateCreateFlags:

api: type VkPipelineVertexInputStateCreateFlags

VkPipelineVertexInputStateCreateInfo:

api: object VkPipelineVertexInputStateCreateInfo

VkPipelineViewportCoarseSampleOrderStateCreateInfoNV:

api: object VkPipelineViewportCoarseSampleOrderStateCreateInfoNV

VkPipelineViewportDepthClipControlCreateInfoEXT:

api: object VkPipelineViewportDepthClipControlCreateInfoEXT

VkPipelineViewportExclusiveScissorStateCreateInfoNV:

api: object VkPipelineViewportExclusiveScissorStateCreateInfoNV

VkPipelineViewportShadingRateImageStateCreateInfoNV:

api: object VkPipelineViewportShadingRateImageStateCreateInfoNV

VkPipelineViewportStateCreateFlags:

api: type VkPipelineViewportStateCreateFlags

VkPipelineViewportStateCreateInfo:

api: object VkPipelineViewportStateCreateInfo

VkPipelineViewportSwizzleStateCreateFlagsNV:

api: type VkPipelineViewportSwizzleStateCreateFlagsNV

VkPipelineViewportSwizzleStateCreateInfoNV:

api: object VkPipelineViewportSwizzleStateCreateInfoNV

VkPipelineViewportWScalingStateCreateInfoNV:

api: object VkPipelineViewportWScalingStateCreateInfoNV

VkPointClippingBehavior:

api: enum VkPointClippingBehavior

VkPointClippingBehaviorKHR:

api: type VkPointClippingBehaviorKHR

VkPolygonMode:

api: enum VkPolygonMode

VkPresentGravityFlagBitsEXT:

api: enum VkPresentGravityFlagBitsEXT

VkPresentGravityFlagsEXT:

api: type VkPresentGravityFlagsEXT

VkPresentIdKHR:

api: object VkPresentIdKHR

VkPresentInfoKHR:

api: object VkPresentInfoKHR

VkPresentModeKHR:

api: enum VkPresentModeKHR

VkPresentRegionKHR:

api: object VkPresentRegionKHR

VkPresentRegionsKHR:

api: object VkPresentRegionsKHR

VkPresentScalingFlagBitsEXT:

api: enum VkPresentScalingFlagBitsEXT

VkPresentScalingFlagsEXT:

api: type VkPresentScalingFlagsEXT

VkPresentTimeGOOGLE:

api: object VkPresentTimeGOOGLE

VkPresentTimesInfoGOOGLE:

api: object VkPresentTimesInfoGOOGLE

VkPrimitiveTopology:

api: enum VkPrimitiveTopology

VkPrivateDataSlot:

api: type VkPrivateDataSlot

VkPrivateDataSlotCreateFlagBits:

api: enum VkPrivateDataSlotCreateFlagBits

VkPrivateDataSlotCreateFlagBitsEXT:

api: type VkPrivateDataSlotCreateFlagBitsEXT

VkPrivateDataSlotCreateFlags:

api: type VkPrivateDataSlotCreateFlags

VkPrivateDataSlotCreateFlagsEXT:

api: type VkPrivateDataSlotCreateFlagsEXT

VkPrivateDataSlotCreateInfo:

api: object VkPrivateDataSlotCreateInfo

VkPrivateDataSlotCreateInfoEXT:

api: object VkPrivateDataSlotCreateInfoEXT

VkProtectedSubmitInfo:

api: object VkProtectedSubmitInfo

VkProvokingVertexModeEXT:

api: enum VkProvokingVertexModeEXT

VkPushConstantRange:

api: object VkPushConstantRange

VkQueryControlFlagBits:

api: enum VkQueryControlFlagBits

VkQueryControlFlags:

api: type VkQueryControlFlags

VkQueryPipelineStatisticFlagBits:

api: enum VkQueryPipelineStatisticFlagBits

VkQueryPipelineStatisticFlags:

api: type VkQueryPipelineStatisticFlags

VkQueryPool:

api: type VkQueryPool

VkQueryPoolCreateFlags:

api: type VkQueryPoolCreateFlags

VkQueryPoolCreateInfo:

api: object VkQueryPoolCreateInfo

VkQueryPoolCreateInfoINTEL:

api: object VkQueryPoolCreateInfoINTEL

VkQueryPoolPerformanceCreateInfoKHR:

api: object VkQueryPoolPerformanceCreateInfoKHR

VkQueryPoolPerformanceQueryCreateInfoINTEL:

api: object VkQueryPoolPerformanceQueryCreateInfoINTEL

VkQueryPoolSamplingModeINTEL:

api: enum VkQueryPoolSamplingModeINTEL

VkQueryResultFlagBits:

api: enum VkQueryResultFlagBits

VkQueryResultFlags:

api: type VkQueryResultFlags

VkQueryResultStatusKHR:

api: enum VkQueryResultStatusKHR

VkQueryType:

api: enum VkQueryType

VkQueue:

api: type VkQueue

vkQueueBeginDebugUtilsLabelEXT:

api: var vkQueueBeginDebugUtilsLabelEXT

vkQueueBindSparse:

api: var vkQueueBindSparse

vkQueueEndDebugUtilsLabelEXT:

api: var vkQueueEndDebugUtilsLabelEXT

VkQueueFamilyCheckpointProperties2NV:

api: object VkQueueFamilyCheckpointProperties2NV

VkQueueFamilyCheckpointPropertiesNV:

api: object VkQueueFamilyCheckpointPropertiesNV

VK_QUEUE_FAMILY_EXTERNAL:

api: const VK_QUEUE_FAMILY_EXTERNAL

VK_QUEUE_FAMILY_EXTERNAL_KHR:

api: const VK_QUEUE_FAMILY_EXTERNAL_KHR

VK_QUEUE_FAMILY_FOREIGN_EXT:

api: const VK_QUEUE_FAMILY_FOREIGN_EXT

VkQueueFamilyGlobalPriorityPropertiesEXT:

api: object VkQueueFamilyGlobalPriorityPropertiesEXT

VkQueueFamilyGlobalPriorityPropertiesKHR:

api: object VkQueueFamilyGlobalPriorityPropertiesKHR

VK_QUEUE_FAMILY_IGNORED:

api: const VK_QUEUE_FAMILY_IGNORED

VkQueueFamilyProperties:

api: object VkQueueFamilyProperties

VkQueueFamilyProperties2:

api: object VkQueueFamilyProperties2

VkQueueFamilyProperties2KHR:

api: object VkQueueFamilyProperties2KHR

VkQueueFlagBits:

api: enum VkQueueFlagBits

VkQueueFlags:

api: type VkQueueFlags

VkQueueGlobalPriorityEXT:

api: type VkQueueGlobalPriorityEXT

VkQueueGlobalPriorityKHR:

api: enum VkQueueGlobalPriorityKHR

vkQueueInsertDebugUtilsLabelEXT:

api: var vkQueueInsertDebugUtilsLabelEXT

vkQueuePresentKHR:

api: var vkQueuePresentKHR

vkQueueSetPerformanceConfigurationINTEL:

api: var vkQueueSetPerformanceConfigurationINTEL

vkQueueSubmit:

api: var vkQueueSubmit

vkQueueSubmit2:

api: var vkQueueSubmit2

vkQueueWaitIdle:

api: var vkQueueWaitIdle

VkRasterizationOrderAMD:

api: enum VkRasterizationOrderAMD

VkRayTracingInvocationReorderModeNV:

api: enum VkRayTracingInvocationReorderModeNV

VkRayTracingPipelineCreateInfoKHR:

api: object VkRayTracingPipelineCreateInfoKHR

VkRayTracingPipelineCreateInfoNV:

api: object VkRayTracingPipelineCreateInfoNV

VkRayTracingPipelineInterfaceCreateInfoKHR:

api: object VkRayTracingPipelineInterfaceCreateInfoKHR

VkRayTracingShaderGroupCreateInfoKHR:

api: object VkRayTracingShaderGroupCreateInfoKHR

VkRayTracingShaderGroupCreateInfoNV:

api: object VkRayTracingShaderGroupCreateInfoNV

VkRayTracingShaderGroupTypeKHR:

api: enum VkRayTracingShaderGroupTypeKHR

VkRayTracingShaderGroupTypeNV:

api: type VkRayTracingShaderGroupTypeNV

VkRect2D:

api: object VkRect2D

VkRectLayerKHR:

api: object VkRectLayerKHR

VkRefreshCycleDurationGOOGLE:

api: object VkRefreshCycleDurationGOOGLE

VkRefreshObjectFlagsKHR:

api: type VkRefreshObjectFlagsKHR

VkRefreshObjectKHR:

api: object VkRefreshObjectKHR

VkRefreshObjectListKHR:

api: object VkRefreshObjectListKHR

vkRegisterDeviceEventEXT:

api: var vkRegisterDeviceEventEXT

vkRegisterDisplayEventEXT:

api: var vkRegisterDisplayEventEXT

vkReleaseDisplayEXT:

api: var vkReleaseDisplayEXT

vkReleasePerformanceConfigurationINTEL:

api: var vkReleasePerformanceConfigurationINTEL

vkReleaseProfilingLockKHR:

api: var vkReleaseProfilingLockKHR

vkReleaseSwapchainImagesEXT:

api: var vkReleaseSwapchainImagesEXT

VkReleaseSwapchainImagesInfoEXT:

api: object VkReleaseSwapchainImagesInfoEXT

VK_REMAINING_3D_SLICES_EXT:

api: const VK_REMAINING_3D_SLICES_EXT

VK_REMAINING_ARRAY_LAYERS:

api: const VK_REMAINING_ARRAY_LAYERS

VK_REMAINING_MIP_LEVELS:

api: const VK_REMAINING_MIP_LEVELS

VkRemoteAddressNV:

api: type VkRemoteAddressNV

VkRenderingAttachmentInfo:

api: object VkRenderingAttachmentInfo

VkRenderingAttachmentInfoKHR:

api: object VkRenderingAttachmentInfoKHR

VkRenderingFlagBits:

api: enum VkRenderingFlagBits

VkRenderingFlagBitsKHR:

api: type VkRenderingFlagBitsKHR

VkRenderingFlags:

api: type VkRenderingFlags

VkRenderingFlagsKHR:

api: type VkRenderingFlagsKHR

VkRenderingFragmentDensityMapAttachmentInfoEXT:

api: object VkRenderingFragmentDensityMapAttachmentInfoEXT

VkRenderingFragmentShadingRateAttachmentInfoKHR:

api: object VkRenderingFragmentShadingRateAttachmentInfoKHR

VkRenderingInfo:

api: object VkRenderingInfo

VkRenderingInfoKHR:

api: object VkRenderingInfoKHR

VkRenderPass:

api: type VkRenderPass

VkRenderPassAttachmentBeginInfo:

api: object VkRenderPassAttachmentBeginInfo

VkRenderPassAttachmentBeginInfoKHR:

api: object VkRenderPassAttachmentBeginInfoKHR

VkRenderPassBeginInfo:

api: object VkRenderPassBeginInfo

VkRenderPassCreateFlagBits:

api: enum VkRenderPassCreateFlagBits

VkRenderPassCreateFlags:

api: type VkRenderPassCreateFlags

VkRenderPassCreateInfo:

api: object VkRenderPassCreateInfo

VkRenderPassCreateInfo2:

api: object VkRenderPassCreateInfo2

VkRenderPassCreateInfo2KHR:

api: object VkRenderPassCreateInfo2KHR

VkRenderPassCreationControlEXT:

api: object VkRenderPassCreationControlEXT

VkRenderPassCreationFeedbackCreateInfoEXT:

api: object VkRenderPassCreationFeedbackCreateInfoEXT

VkRenderPassCreationFeedbackInfoEXT:

api: object VkRenderPassCreationFeedbackInfoEXT

VkRenderPassFragmentDensityMapCreateInfoEXT:

api: object VkRenderPassFragmentDensityMapCreateInfoEXT

VkRenderPassInputAttachmentAspectCreateInfo:

api: object VkRenderPassInputAttachmentAspectCreateInfo

VkRenderPassInputAttachmentAspectCreateInfoKHR:

api: object VkRenderPassInputAttachmentAspectCreateInfoKHR

VkRenderPassMultiviewCreateInfo:

api: object VkRenderPassMultiviewCreateInfo

VkRenderPassMultiviewCreateInfoKHR:

api: object VkRenderPassMultiviewCreateInfoKHR

VkRenderPassSampleLocationsBeginInfoEXT:

api: object VkRenderPassSampleLocationsBeginInfoEXT

VkRenderPassSubpassFeedbackCreateInfoEXT:

api: object VkRenderPassSubpassFeedbackCreateInfoEXT

VkRenderPassSubpassFeedbackInfoEXT:

api: object VkRenderPassSubpassFeedbackInfoEXT

VkRenderPassTransformBeginInfoQCOM:

api: object VkRenderPassTransformBeginInfoQCOM

vkResetCommandBuffer:

api: var vkResetCommandBuffer

vkResetCommandPool:

api: var vkResetCommandPool

vkResetDescriptorPool:

api: var vkResetDescriptorPool

vkResetEvent:

api: var vkResetEvent

vkResetFences:

api: var vkResetFences

vkResetQueryPool:

api: var vkResetQueryPool

VkResolveImageInfo2:

api: object VkResolveImageInfo2

VkResolveImageInfo2KHR:

api: object VkResolveImageInfo2KHR

VkResolveModeFlagBits:

api: enum VkResolveModeFlagBits

VkResolveModeFlagBitsKHR:

api: type VkResolveModeFlagBitsKHR

VkResolveModeFlags:

api: type VkResolveModeFlags

VkResolveModeFlagsKHR:

api: type VkResolveModeFlagsKHR

VK_RESOLVE_MODE_NONE:

api: const VK_RESOLVE_MODE_NONE

VkResult:

api: enum VkResult

VkSampleCountFlagBits:

api: enum VkSampleCountFlagBits

VkSampleCountFlags:

api: type VkSampleCountFlags

VkSampleLocationEXT:

api: object VkSampleLocationEXT

VkSampleLocationsInfoEXT:

api: object VkSampleLocationsInfoEXT

VkSampleMask:

api: type VkSampleMask

VkSampler:

api: type VkSampler

VkSamplerAddressMode:

api: enum VkSamplerAddressMode

VkSamplerBorderColorComponentMappingCreateInfoEXT:

api: object VkSamplerBorderColorComponentMappingCreateInfoEXT

VkSamplerCaptureDescriptorDataInfoEXT:

api: object VkSamplerCaptureDescriptorDataInfoEXT

VkSamplerCreateFlagBits:

api: enum VkSamplerCreateFlagBits

VkSamplerCreateFlags:

api: type VkSamplerCreateFlags

VkSamplerCreateInfo:

api: object VkSamplerCreateInfo

VkSamplerCustomBorderColorCreateInfoEXT:

api: object VkSamplerCustomBorderColorCreateInfoEXT

VkSamplerMipmapMode:

api: enum VkSamplerMipmapMode

VkSamplerReductionMode:

api: enum VkSamplerReductionMode

VkSamplerReductionModeCreateInfo:

api: object VkSamplerReductionModeCreateInfo

VkSamplerReductionModeCreateInfoEXT:

api: object VkSamplerReductionModeCreateInfoEXT

VkSamplerReductionModeEXT:

api: type VkSamplerReductionModeEXT

VkSamplerYcbcrConversion:

api: type VkSamplerYcbcrConversion

VkSamplerYcbcrConversionCreateInfo:

api: object VkSamplerYcbcrConversionCreateInfo

VkSamplerYcbcrConversionCreateInfoKHR:

api: object VkSamplerYcbcrConversionCreateInfoKHR

VkSamplerYcbcrConversionImageFormatProperties:

api: object VkSamplerYcbcrConversionImageFormatProperties

VkSamplerYcbcrConversionImageFormatPropertiesKHR:

api: object VkSamplerYcbcrConversionImageFormatPropertiesKHR

VkSamplerYcbcrConversionInfo:

api: object VkSamplerYcbcrConversionInfo

VkSamplerYcbcrConversionInfoKHR:

api: object VkSamplerYcbcrConversionInfoKHR

VkSamplerYcbcrModelConversion:

api: enum VkSamplerYcbcrModelConversion

VkSamplerYcbcrModelConversionKHR:

api: type VkSamplerYcbcrModelConversionKHR

VkSamplerYcbcrRange:

api: enum VkSamplerYcbcrRange

VkSamplerYcbcrRangeKHR:

api: type VkSamplerYcbcrRangeKHR

VkSciSyncClientTypeNV:

api: enum VkSciSyncClientTypeNV

VkSciSyncPrimitiveTypeNV:

api: enum VkSciSyncPrimitiveTypeNV

VkScopeNV:

api: enum VkScopeNV

VkScreenSurfaceCreateFlagsQNX:

api: type VkScreenSurfaceCreateFlagsQNX

VkSemaphore:

api: type VkSemaphore

VkSemaphoreCreateFlags:

api: type VkSemaphoreCreateFlags

VkSemaphoreCreateInfo:

api: object VkSemaphoreCreateInfo

VkSemaphoreGetFdInfoKHR:

api: object VkSemaphoreGetFdInfoKHR

VkSemaphoreImportFlagBits:

api: enum VkSemaphoreImportFlagBits

VkSemaphoreImportFlagBitsKHR:

api: type VkSemaphoreImportFlagBitsKHR

VkSemaphoreImportFlags:

api: type VkSemaphoreImportFlags

VkSemaphoreImportFlagsKHR:

api: type VkSemaphoreImportFlagsKHR

VkSemaphoreSciSyncPoolNV:

api: type VkSemaphoreSciSyncPoolNV

VkSemaphoreSignalInfo:

api: object VkSemaphoreSignalInfo

VkSemaphoreSignalInfoKHR:

api: object VkSemaphoreSignalInfoKHR

VkSemaphoreSubmitInfo:

api: object VkSemaphoreSubmitInfo

VkSemaphoreSubmitInfoKHR:

api: object VkSemaphoreSubmitInfoKHR

VkSemaphoreType:

api: enum VkSemaphoreType

VkSemaphoreTypeCreateInfo:

api: object VkSemaphoreTypeCreateInfo

VkSemaphoreTypeCreateInfoKHR:

api: object VkSemaphoreTypeCreateInfoKHR

VkSemaphoreTypeKHR:

api: type VkSemaphoreTypeKHR

VkSemaphoreWaitFlagBits:

api: enum VkSemaphoreWaitFlagBits

VkSemaphoreWaitFlagBitsKHR:

api: type VkSemaphoreWaitFlagBitsKHR

VkSemaphoreWaitFlags:

api: type VkSemaphoreWaitFlags

VkSemaphoreWaitFlagsKHR:

api: type VkSemaphoreWaitFlagsKHR

VkSemaphoreWaitInfo:

api: object VkSemaphoreWaitInfo

VkSemaphoreWaitInfoKHR:

api: object VkSemaphoreWaitInfoKHR

vkSetDebugUtilsObjectNameEXT:

api: var vkSetDebugUtilsObjectNameEXT

vkSetDebugUtilsObjectTagEXT:

api: var vkSetDebugUtilsObjectTagEXT

vkSetDeviceMemoryPriorityEXT:

api: var vkSetDeviceMemoryPriorityEXT

vkSetEvent:

api: var vkSetEvent

vkSetHdrMetadataEXT:

api: var vkSetHdrMetadataEXT

vkSetLocalDimmingAMD:

api: var vkSetLocalDimmingAMD

vkSetPrivateData:

api: var vkSetPrivateData

VkSetStateFlagsIndirectCommandNV:

api: object VkSetStateFlagsIndirectCommandNV

VkShaderCorePropertiesFlagsAMD:

api: type VkShaderCorePropertiesFlagsAMD

VkShaderFloatControlsIndependence:

api: enum VkShaderFloatControlsIndependence

VkShaderFloatControlsIndependenceKHR:

api: type VkShaderFloatControlsIndependenceKHR

VkShaderGroupShaderKHR:

api: enum VkShaderGroupShaderKHR

VkShaderInfoTypeAMD:

api: enum VkShaderInfoTypeAMD

VkShaderModule:

api: type VkShaderModule

VkShaderModuleCreateFlags:

api: type VkShaderModuleCreateFlags

VkShaderModuleCreateInfo:

api: object VkShaderModuleCreateInfo

VkShaderModuleIdentifierEXT:

api: object VkShaderModuleIdentifierEXT

VkShaderModuleValidationCacheCreateInfoEXT:

api: object VkShaderModuleValidationCacheCreateInfoEXT

VkShaderResourceUsageAMD:

api: object VkShaderResourceUsageAMD

VK_SHADER_STAGE_ALL:

api: const VK_SHADER_STAGE_ALL

VK_SHADER_STAGE_ALL_GRAPHICS:

api: const VK_SHADER_STAGE_ALL_GRAPHICS

VkShaderStageFlagBits:

api: enum VkShaderStageFlagBits

VkShaderStageFlags:

api: type VkShaderStageFlags

VkShaderStatisticsInfoAMD:

api: object VkShaderStatisticsInfoAMD

VK_SHADER_UNUSED_KHR:

api: const VK_SHADER_UNUSED_KHR

VK_SHADER_UNUSED_NV:

api: const VK_SHADER_UNUSED_NV

VkShadingRatePaletteEntryNV:

api: enum VkShadingRatePaletteEntryNV

VkShadingRatePaletteNV:

api: object VkShadingRatePaletteNV

VkSharedPresentSurfaceCapabilitiesKHR:

api: object VkSharedPresentSurfaceCapabilitiesKHR

VkSharingMode:

api: enum VkSharingMode

vkSignalSemaphore:

api: var vkSignalSemaphore

VkSparseBufferMemoryBindInfo:

api: object VkSparseBufferMemoryBindInfo

VkSparseImageFormatFlagBits:

api: enum VkSparseImageFormatFlagBits

VkSparseImageFormatFlags:

api: type VkSparseImageFormatFlags

VkSparseImageFormatProperties:

api: object VkSparseImageFormatProperties

VkSparseImageFormatProperties2:

api: object VkSparseImageFormatProperties2

VkSparseImageFormatProperties2KHR:

api: object VkSparseImageFormatProperties2KHR

VkSparseImageMemoryBind:

api: object VkSparseImageMemoryBind

VkSparseImageMemoryBindInfo:

api: object VkSparseImageMemoryBindInfo

VkSparseImageMemoryRequirements:

api: object VkSparseImageMemoryRequirements

VkSparseImageMemoryRequirements2:

api: object VkSparseImageMemoryRequirements2

VkSparseImageMemoryRequirements2KHR:

api: object VkSparseImageMemoryRequirements2KHR

VkSparseImageOpaqueMemoryBindInfo:

api: object VkSparseImageOpaqueMemoryBindInfo

VkSparseMemoryBind:

api: object VkSparseMemoryBind

VkSparseMemoryBindFlagBits:

api: enum VkSparseMemoryBindFlagBits

VkSparseMemoryBindFlags:

api: type VkSparseMemoryBindFlags

VkSpecializationInfo:

api: object VkSpecializationInfo

VkSpecializationMapEntry:

api: object VkSpecializationMapEntry

VkSRTDataNV:

api: object VkSRTDataNV

VkStencilFaceFlagBits:

api: enum VkStencilFaceFlagBits

VkStencilFaceFlags:

api: type VkStencilFaceFlags

VK_STENCIL_FACE_FRONT_AND_BACK:

api: const VK_STENCIL_FACE_FRONT_AND_BACK

VkStencilOp:

api: enum VkStencilOp

VkStencilOpState:

api: object VkStencilOpState

VkStreamDescriptorSurfaceCreateFlagsGGP:

api: type VkStreamDescriptorSurfaceCreateFlagsGGP

VkStridedDeviceAddressRegionKHR:

api: object VkStridedDeviceAddressRegionKHR

VkStructureType:

api: enum VkStructureType

VkSubgroupFeatureFlagBits:

api: enum VkSubgroupFeatureFlagBits

VkSubgroupFeatureFlags:

api: type VkSubgroupFeatureFlags

vkSubmitDebugUtilsMessageEXT:

api: var vkSubmitDebugUtilsMessageEXT

VkSubmitFlagBits:

api: enum VkSubmitFlagBits

VkSubmitFlagBitsKHR:

api: type VkSubmitFlagBitsKHR

VkSubmitFlags:

api: type VkSubmitFlags

VkSubmitFlagsKHR:

api: type VkSubmitFlagsKHR

VkSubmitInfo:

api: object VkSubmitInfo

VkSubmitInfo2:

api: object VkSubmitInfo2

VkSubmitInfo2KHR:

api: object VkSubmitInfo2KHR

VkSubpassBeginInfo:

api: object VkSubpassBeginInfo

VkSubpassBeginInfoKHR:

api: object VkSubpassBeginInfoKHR

VkSubpassContents:

api: enum VkSubpassContents

VkSubpassDependency:

api: object VkSubpassDependency

VkSubpassDependency2:

api: object VkSubpassDependency2

VkSubpassDependency2KHR:

api: object VkSubpassDependency2KHR

VkSubpassDescription:

api: object VkSubpassDescription

VkSubpassDescription2:

api: object VkSubpassDescription2

VkSubpassDescription2KHR:

api: object VkSubpassDescription2KHR

VkSubpassDescriptionDepthStencilResolve:

api: object VkSubpassDescriptionDepthStencilResolve

VkSubpassDescriptionDepthStencilResolveKHR:

api: object VkSubpassDescriptionDepthStencilResolveKHR

VkSubpassDescriptionFlagBits:

api: enum VkSubpassDescriptionFlagBits

VkSubpassDescriptionFlags:

api: type VkSubpassDescriptionFlags

VkSubpassEndInfo:

api: object VkSubpassEndInfo

VkSubpassEndInfoKHR:

api: object VkSubpassEndInfoKHR

VK_SUBPASS_EXTERNAL:

api: const VK_SUBPASS_EXTERNAL

VkSubpassFragmentDensityMapOffsetEndInfoQCOM:

api: object VkSubpassFragmentDensityMapOffsetEndInfoQCOM

VkSubpassMergeStatusEXT:

api: enum VkSubpassMergeStatusEXT

VkSubpassResolvePerformanceQueryEXT:

api: object VkSubpassResolvePerformanceQueryEXT

VkSubpassSampleLocationsEXT:

api: object VkSubpassSampleLocationsEXT

VkSubpassShadingPipelineCreateInfoHUAWEI:

api: object VkSubpassShadingPipelineCreateInfoHUAWEI

VkSubresourceLayout:

api: object VkSubresourceLayout

VkSubresourceLayout2EXT:

api: object VkSubresourceLayout2EXT

VkSurfaceCapabilities2EXT:

api: object VkSurfaceCapabilities2EXT

VkSurfaceCapabilities2KHR:

api: object VkSurfaceCapabilities2KHR

VkSurfaceCapabilitiesKHR:

api: object VkSurfaceCapabilitiesKHR

VkSurfaceCapabilitiesPresentBarrierNV:

api: object VkSurfaceCapabilitiesPresentBarrierNV

VkSurfaceCounterFlagBitsEXT:

api: enum VkSurfaceCounterFlagBitsEXT

VkSurfaceCounterFlagsEXT:

api: type VkSurfaceCounterFlagsEXT

VkSurfaceFormat2KHR:

api: object VkSurfaceFormat2KHR

VkSurfaceFormatKHR:

api: object VkSurfaceFormatKHR

VkSurfaceKHR:

api: type VkSurfaceKHR

VkSurfacePresentModeCompatibilityEXT:

api: object VkSurfacePresentModeCompatibilityEXT

VkSurfacePresentModeEXT:

api: object VkSurfacePresentModeEXT

VkSurfacePresentScalingCapabilitiesEXT:

api: object VkSurfacePresentScalingCapabilitiesEXT

VkSurfaceProtectedCapabilitiesKHR:

api: object VkSurfaceProtectedCapabilitiesKHR

VkSurfaceTransformFlagBitsKHR:

api: enum VkSurfaceTransformFlagBitsKHR

VkSurfaceTransformFlagsKHR:

api: type VkSurfaceTransformFlagsKHR

VkSwapchainCounterCreateInfoEXT:

api: object VkSwapchainCounterCreateInfoEXT

VkSwapchainCreateFlagBitsKHR:

api: enum VkSwapchainCreateFlagBitsKHR

VkSwapchainCreateFlagsKHR:

api: type VkSwapchainCreateFlagsKHR

VkSwapchainCreateInfoKHR:

api: object VkSwapchainCreateInfoKHR

VkSwapchainDisplayNativeHdrCreateInfoAMD:

api: object VkSwapchainDisplayNativeHdrCreateInfoAMD

VkSwapchainImageUsageFlagBitsANDROID:

api: enum VkSwapchainImageUsageFlagBitsANDROID

VkSwapchainImageUsageFlagsANDROID:

api: type VkSwapchainImageUsageFlagsANDROID

VkSwapchainKHR:

api: type VkSwapchainKHR

VkSwapchainPresentBarrierCreateInfoNV:

api: object VkSwapchainPresentBarrierCreateInfoNV

VkSwapchainPresentFenceInfoEXT:

api: object VkSwapchainPresentFenceInfoEXT

VkSwapchainPresentModeInfoEXT:

api: object VkSwapchainPresentModeInfoEXT

VkSwapchainPresentModesCreateInfoEXT:

api: object VkSwapchainPresentModesCreateInfoEXT

VkSwapchainPresentScalingCreateInfoEXT:

api: object VkSwapchainPresentScalingCreateInfoEXT

VkSystemAllocationScope:

api: enum VkSystemAllocationScope

VkTessellationDomainOrigin:

api: enum VkTessellationDomainOrigin

VkTessellationDomainOriginKHR:

api: type VkTessellationDomainOriginKHR

VkTextureLODGatherFormatPropertiesAMD:

api: object VkTextureLODGatherFormatPropertiesAMD

VkTilePropertiesQCOM:

api: object VkTilePropertiesQCOM

VkTimeDomainEXT:

api: enum VkTimeDomainEXT

VkTimelineSemaphoreSubmitInfo:

api: object VkTimelineSemaphoreSubmitInfo

VkTimelineSemaphoreSubmitInfoKHR:

api: object VkTimelineSemaphoreSubmitInfoKHR

VkToolPurposeFlagBits:

api: enum VkToolPurposeFlagBits

VkToolPurposeFlagBitsEXT:

api: type VkToolPurposeFlagBitsEXT

VkToolPurposeFlags:

api: type VkToolPurposeFlags

VkToolPurposeFlagsEXT:

api: type VkToolPurposeFlagsEXT

VkTraceRaysIndirectCommand2KHR:

api: object VkTraceRaysIndirectCommand2KHR

VkTraceRaysIndirectCommandKHR:

api: object VkTraceRaysIndirectCommandKHR

VkTransformMatrixKHR:

api: object VkTransformMatrixKHR

VkTransformMatrixNV:

api: object VkTransformMatrixNV

vkTrimCommandPool:

api: var vkTrimCommandPool

VK_TRUE:

api: const VK_TRUE

vkUninitializePerformanceApiINTEL:

api: var vkUninitializePerformanceApiINTEL

vkUnmapMemory:

api: var vkUnmapMemory

vkUpdateDescriptorSets:

api: var vkUpdateDescriptorSets

vkUpdateDescriptorSetWithTemplate:

api: var vkUpdateDescriptorSetWithTemplate

VK_UUID_SIZE:

api: const VK_UUID_SIZE

VkValidationCacheCreateFlagsEXT:

api: type VkValidationCacheCreateFlagsEXT

VkValidationCacheCreateInfoEXT:

api: object VkValidationCacheCreateInfoEXT

VkValidationCacheEXT:

api: type VkValidationCacheEXT

VkValidationCacheHeaderVersionEXT:

api: enum VkValidationCacheHeaderVersionEXT

VkValidationCheckEXT:

api: enum VkValidationCheckEXT

VkValidationFeatureDisableEXT:

api: enum VkValidationFeatureDisableEXT

VkValidationFeatureEnableEXT:

api: enum VkValidationFeatureEnableEXT

VkValidationFeaturesEXT:

api: object VkValidationFeaturesEXT

VkValidationFlagsEXT:

api: object VkValidationFlagsEXT

VkVendorId:

api: enum VkVendorId

VkVertexInputAttributeDescription:

api: object VkVertexInputAttributeDescription

VkVertexInputAttributeDescription2EXT:

api: object VkVertexInputAttributeDescription2EXT

VkVertexInputBindingDescription:

api: object VkVertexInputBindingDescription

VkVertexInputBindingDescription2EXT:

api: object VkVertexInputBindingDescription2EXT

VkVertexInputBindingDivisorDescriptionEXT:

api: object VkVertexInputBindingDivisorDescriptionEXT

VkVertexInputRate:

api: enum VkVertexInputRate

VkVideoBeginCodingFlagsKHR:

api: type VkVideoBeginCodingFlagsKHR

VkVideoCapabilityFlagBitsKHR:

api: enum VkVideoCapabilityFlagBitsKHR

VkVideoCapabilityFlagsKHR:

api: type VkVideoCapabilityFlagsKHR

VkVideoChromaSubsamplingFlagBitsKHR:

api: enum VkVideoChromaSubsamplingFlagBitsKHR

VkVideoChromaSubsamplingFlagsKHR:

api: type VkVideoChromaSubsamplingFlagsKHR

VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR:

api: const VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR

VkVideoCodecOperationFlagBitsKHR:

api: enum VkVideoCodecOperationFlagBitsKHR

VkVideoCodecOperationFlagsKHR:

api: type VkVideoCodecOperationFlagsKHR

VK_VIDEO_CODEC_OPERATION_NONE_KHR:

api: const VK_VIDEO_CODEC_OPERATION_NONE_KHR

VkVideoCodingControlFlagBitsKHR:

api: enum VkVideoCodingControlFlagBitsKHR

VkVideoCodingControlFlagsKHR:

api: type VkVideoCodingControlFlagsKHR

VkVideoComponentBitDepthFlagBitsKHR:

api: enum VkVideoComponentBitDepthFlagBitsKHR

VkVideoComponentBitDepthFlagsKHR:

api: type VkVideoComponentBitDepthFlagsKHR

VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR:

api: const VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR

VkVideoDecodeCapabilityFlagBitsKHR:

api: enum VkVideoDecodeCapabilityFlagBitsKHR

VkVideoDecodeCapabilityFlagsKHR:

api: type VkVideoDecodeCapabilityFlagsKHR

VkVideoDecodeFlagsKHR:

api: type VkVideoDecodeFlagsKHR

VkVideoDecodeH264PictureLayoutFlagBitsKHR:

api: enum VkVideoDecodeH264PictureLayoutFlagBitsKHR

VkVideoDecodeH264PictureLayoutFlagsKHR:

api: type VkVideoDecodeH264PictureLayoutFlagsKHR

VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR:

api: const VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR

VK_VIDEO_DECODE_USAGE_DEFAULT_KHR:

api: const VK_VIDEO_DECODE_USAGE_DEFAULT_KHR

VkVideoDecodeUsageFlagBitsKHR:

api: enum VkVideoDecodeUsageFlagBitsKHR

VkVideoDecodeUsageFlagsKHR:

api: type VkVideoDecodeUsageFlagsKHR

VkVideoEncodeCapabilityFlagBitsKHR:

api: enum VkVideoEncodeCapabilityFlagBitsKHR

VkVideoEncodeCapabilityFlagsKHR:

api: type VkVideoEncodeCapabilityFlagsKHR

VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR:

api: const VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR

VkVideoEncodeContentFlagBitsKHR:

api: enum VkVideoEncodeContentFlagBitsKHR

VkVideoEncodeContentFlagsKHR:

api: type VkVideoEncodeContentFlagsKHR

VkVideoEncodeFlagsKHR:

api: type VkVideoEncodeFlagsKHR

VkVideoEncodeH264CapabilityFlagBitsEXT:

api: enum VkVideoEncodeH264CapabilityFlagBitsEXT

VkVideoEncodeH264CapabilityFlagsEXT:

api: type VkVideoEncodeH264CapabilityFlagsEXT

VkVideoEncodeH264InputModeFlagBitsEXT:

api: enum VkVideoEncodeH264InputModeFlagBitsEXT

VkVideoEncodeH264InputModeFlagsEXT:

api: type VkVideoEncodeH264InputModeFlagsEXT

VkVideoEncodeH264OutputModeFlagBitsEXT:

api: enum VkVideoEncodeH264OutputModeFlagBitsEXT

VkVideoEncodeH264OutputModeFlagsEXT:

api: type VkVideoEncodeH264OutputModeFlagsEXT

VkVideoEncodeH264RateControlStructureEXT:

api: enum VkVideoEncodeH264RateControlStructureEXT

VkVideoEncodeH265CapabilityFlagBitsEXT:

api: enum VkVideoEncodeH265CapabilityFlagBitsEXT

VkVideoEncodeH265CapabilityFlagsEXT:

api: type VkVideoEncodeH265CapabilityFlagsEXT

VkVideoEncodeH265CtbSizeFlagBitsEXT:

api: enum VkVideoEncodeH265CtbSizeFlagBitsEXT

VkVideoEncodeH265CtbSizeFlagsEXT:

api: type VkVideoEncodeH265CtbSizeFlagsEXT

VkVideoEncodeH265InputModeFlagBitsEXT:

api: enum VkVideoEncodeH265InputModeFlagBitsEXT

VkVideoEncodeH265InputModeFlagsEXT:

api: type VkVideoEncodeH265InputModeFlagsEXT

VkVideoEncodeH265OutputModeFlagBitsEXT:

api: enum VkVideoEncodeH265OutputModeFlagBitsEXT

VkVideoEncodeH265OutputModeFlagsEXT:

api: type VkVideoEncodeH265OutputModeFlagsEXT

VkVideoEncodeH265RateControlStructureEXT:

api: enum VkVideoEncodeH265RateControlStructureEXT

VkVideoEncodeH265TransformBlockSizeFlagBitsEXT:

api: enum VkVideoEncodeH265TransformBlockSizeFlagBitsEXT

VkVideoEncodeH265TransformBlockSizeFlagsEXT:

api: type VkVideoEncodeH265TransformBlockSizeFlagsEXT

VkVideoEncodeRateControlFlagsKHR:

api: type VkVideoEncodeRateControlFlagsKHR

VkVideoEncodeRateControlModeFlagBitsKHR:

api: enum VkVideoEncodeRateControlModeFlagBitsKHR

VkVideoEncodeRateControlModeFlagsKHR:

api: type VkVideoEncodeRateControlModeFlagsKHR

VkVideoEncodeTuningModeKHR:

api: enum VkVideoEncodeTuningModeKHR

VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR:

api: const VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR

VkVideoEncodeUsageFlagBitsKHR:

api: enum VkVideoEncodeUsageFlagBitsKHR

VkVideoEncodeUsageFlagsKHR:

api: type VkVideoEncodeUsageFlagsKHR

VkVideoEndCodingFlagsKHR:

api: type VkVideoEndCodingFlagsKHR

VkVideoSessionCreateFlagBitsKHR:

api: enum VkVideoSessionCreateFlagBitsKHR

VkVideoSessionCreateFlagsKHR:

api: type VkVideoSessionCreateFlagsKHR

VkVideoSessionKHR:

api: type VkVideoSessionKHR

VkVideoSessionParametersCreateFlagsKHR:

api: type VkVideoSessionParametersCreateFlagsKHR

VkVideoSessionParametersKHR:

api: type VkVideoSessionParametersKHR

VkViewport:

api: object VkViewport

VkViewportCoordinateSwizzleNV:

api: enum VkViewportCoordinateSwizzleNV

VkViewportSwizzleNV:

api: object VkViewportSwizzleNV

VkViewportWScalingNV:

api: object VkViewportWScalingNV

VkViSurfaceCreateFlagsNN:

api: type VkViSurfaceCreateFlagsNN

vkWaitForFences:

api: var vkWaitForFences

vkWaitForPresentKHR:

api: var vkWaitForPresentKHR

vkWaitSemaphores:

api: var vkWaitSemaphores

VkWaylandSurfaceCreateFlagsKHR:

api: type VkWaylandSurfaceCreateFlagsKHR

VK_WHOLE_SIZE:

api: const VK_WHOLE_SIZE

VkWin32SurfaceCreateFlagsKHR:

api: type VkWin32SurfaceCreateFlagsKHR

vkWriteAccelerationStructuresPropertiesKHR:

api: var vkWriteAccelerationStructuresPropertiesKHR

VkWriteDescriptorSet:

api: object VkWriteDescriptorSet

VkWriteDescriptorSetAccelerationStructureKHR:

api: object VkWriteDescriptorSetAccelerationStructureKHR

VkWriteDescriptorSetAccelerationStructureNV:

api: object VkWriteDescriptorSetAccelerationStructureNV

VkWriteDescriptorSetInlineUniformBlock:

api: object VkWriteDescriptorSetInlineUniformBlock

VkWriteDescriptorSetInlineUniformBlockEXT:

api: object VkWriteDescriptorSetInlineUniformBlockEXT

vkWriteMicromapsPropertiesEXT:

api: var vkWriteMicromapsPropertiesEXT

VkXcbSurfaceCreateFlagsKHR:

api: type VkXcbSurfaceCreateFlagsKHR

VkXlibSurfaceCreateFlagsKHR:

api: type VkXlibSurfaceCreateFlagsKHR

VkXYColorEXT:

api: object VkXYColorEXT

vulkan:

rendering: var vulkan

VulkanGlobals:

rendering: object VulkanGlobals

vulkanLib:

api: let vulkanLib

w:

core: proc w(vec: TVec): auto

w=:

core: proc w=[T](vec: var TVec; value: T)

walkResources:

resources: proc walkResources(dir = ""; package = DEFAULT_PACKAGE): seq[string]

WestGravity:

x: const WestGravity

WhenMapped:

x: const WhenMapped

WhitePixel:

xlib: proc WhitePixel(dpy: PDisplay; scr: cint): culong

WhitePixelOfScreen:

xlib: proc WhitePixelOfScreen(s: PScreen): culong

WidthMMOfScreen:

xlib: proc WidthMMOfScreen(s: PScreen): cint

WidthOfScreen:

xlib: proc WidthOfScreen(s: PScreen): cint

WidthValue:

xutil: const WidthValue

WindingRule:

x: const WindingRule

Window:

x: type Window

WindowGroupHint:

xutil: const WindowGroupHint

windowIsMinimized:

input: proc windowIsMinimized(): auto

windowWasResized:

input: proc windowWasResized(): auto

WithdrawnState:

xutil: const WithdrawnState

withNextFrame:

rendering: template withNextFrame(framebufferName, commandBufferName, body: untyped): untyped

withPipeline:

rendering: template withPipeline(commandbuffer: VkCommandBuffer; pipeline: Pipeline; body: untyped): untyped

withRenderPass:

rendering: template withRenderPass(theRenderPass: RenderPass; theFramebuffer: VkFramebuffer; commandbuffer: VkCommandBuffer; renderWidth: uint32; renderHeight: uint32; clearColor: Vec4f; body: untyped): untyped

withSingleUseCommandBuffer:

rendering: template withSingleUseCommandBuffer(cmd, body: untyped): untyped

withStagingBuffer:

rendering: template withStagingBuffer[T: (VkBuffer, uint64) | (VkImage, uint32, uint32, uint32)]( target: T; bufferSize: uint64; dataPointer, body: untyped): untyped

WordWrapped:

text: proc WordWrapped(text: seq[Rune]; font: FontObj; maxWidth: float32): seq[Rune]

WriteDbEffect:

db_common: object WriteDbEffect

WriteSoundData:

mixer_module: proc WriteSoundData(soundDevice: NativeSoundDevice; buffer: int)

ww:

core: proc ww(vec: TVec): auto

ww=:

core: proc ww=[T](vec: var TVec; value: T)

www:

core: proc www(vec: TVec): auto

www=:

core: proc www=[T](vec: var TVec; value: T)

wwww:

core: proc wwww(vec: TVec): auto

wwww=:

core: proc wwww=[T](vec: var TVec; value: T)

wwwx:

core: proc wwwx(vec: TVec): auto

wwwx=:

core: proc wwwx=[T](vec: var TVec; value: T)

wwwy:

core: proc wwwy(vec: TVec): auto

wwwy=:

core: proc wwwy=[T](vec: var TVec; value: T)

wwwz:

core: proc wwwz(vec: TVec): auto

wwwz=:

core: proc wwwz=[T](vec: var TVec; value: T)

wwx:

core: proc wwx(vec: TVec): auto

wwx=:

core: proc wwx=[T](vec: var TVec; value: T)

wwxw:

core: proc wwxw(vec: TVec): auto

wwxw=:

core: proc wwxw=[T](vec: var TVec; value: T)

wwxx:

core: proc wwxx(vec: TVec): auto

wwxx=:

core: proc wwxx=[T](vec: var TVec; value: T)

wwxy:

core: proc wwxy(vec: TVec): auto

wwxy=:

core: proc wwxy=[T](vec: var TVec; value: T)

wwxz:

core: proc wwxz(vec: TVec): auto

wwxz=:

core: proc wwxz=[T](vec: var TVec; value: T)

wwy:

core: proc wwy(vec: TVec): auto

wwy=:

core: proc wwy=[T](vec: var TVec; value: T)

wwyw:

core: proc wwyw(vec: TVec): auto

wwyw=:

core: proc wwyw=[T](vec: var TVec; value: T)

wwyx:

core: proc wwyx(vec: TVec): auto

wwyx=:

core: proc wwyx=[T](vec: var TVec; value: T)

wwyy:

core: proc wwyy(vec: TVec): auto

wwyy=:

core: proc wwyy=[T](vec: var TVec; value: T)

wwyz:

core: proc wwyz(vec: TVec): auto

wwyz=:

core: proc wwyz=[T](vec: var TVec; value: T)

wwz:

core: proc wwz(vec: TVec): auto

wwz=:

core: proc wwz=[T](vec: var TVec; value: T)

wwzw:

core: proc wwzw(vec: TVec): auto

wwzw=:

core: proc wwzw=[T](vec: var TVec; value: T)

wwzx:

core: proc wwzx(vec: TVec): auto

wwzx=:

core: proc wwzx=[T](vec: var TVec; value: T)

wwzy:

core: proc wwzy(vec: TVec): auto

wwzy=:

core: proc wwzy=[T](vec: var TVec; value: T)

wwzz:

core: proc wwzz(vec: TVec): auto

wwzz=:

core: proc wwzz=[T](vec: var TVec; value: T)

wx:

core: proc wx(vec: TVec): auto

wx=:

core: proc wx=[T](vec: var TVec; value: T)

wxw:

core: proc wxw(vec: TVec): auto

wxw=:

core: proc wxw=[T](vec: var TVec; value: T)

wxww:

core: proc wxww(vec: TVec): auto

wxww=:

core: proc wxww=[T](vec: var TVec; value: T)

wxwx:

core: proc wxwx(vec: TVec): auto

wxwx=:

core: proc wxwx=[T](vec: var TVec; value: T)

wxwy:

core: proc wxwy(vec: TVec): auto

wxwy=:

core: proc wxwy=[T](vec: var TVec; value: T)

wxwz:

core: proc wxwz(vec: TVec): auto

wxwz=:

core: proc wxwz=[T](vec: var TVec; value: T)

wxx:

core: proc wxx(vec: TVec): auto

wxx=:

core: proc wxx=[T](vec: var TVec; value: T)

wxxw:

core: proc wxxw(vec: TVec): auto

wxxw=:

core: proc wxxw=[T](vec: var TVec; value: T)

wxxx:

core: proc wxxx(vec: TVec): auto

wxxx=:

core: proc wxxx=[T](vec: var TVec; value: T)

wxxy:

core: proc wxxy(vec: TVec): auto

wxxy=:

core: proc wxxy=[T](vec: var TVec; value: T)

wxxz:

core: proc wxxz(vec: TVec): auto

wxxz=:

core: proc wxxz=[T](vec: var TVec; value: T)

wxy:

core: proc wxy(vec: TVec): auto

wxy=:

core: proc wxy=[T](vec: var TVec; value: T)

wxyw:

core: proc wxyw(vec: TVec): auto

wxyw=:

core: proc wxyw=[T](vec: var TVec; value: T)

wxyx:

core: proc wxyx(vec: TVec): auto

wxyx=:

core: proc wxyx=[T](vec: var TVec; value: T)

wxyy:

core: proc wxyy(vec: TVec): auto

wxyy=:

core: proc wxyy=[T](vec: var TVec; value: T)

wxyz:

core: proc wxyz(vec: TVec): auto

wxyz=:

core: proc wxyz=[T](vec: var TVec; value: T)

wxz:

core: proc wxz(vec: TVec): auto

wxz=:

core: proc wxz=[T](vec: var TVec; value: T)

wxzw:

core: proc wxzw(vec: TVec): auto

wxzw=:

core: proc wxzw=[T](vec: var TVec; value: T)

wxzx:

core: proc wxzx(vec: TVec): auto

wxzx=:

core: proc wxzx=[T](vec: var TVec; value: T)

wxzy:

core: proc wxzy(vec: TVec): auto

wxzy=:

core: proc wxzy=[T](vec: var TVec; value: T)

wxzz:

core: proc wxzz(vec: TVec): auto

wxzz=:

core: proc wxzz=[T](vec: var TVec; value: T)

wy:

core: proc wy(vec: TVec): auto

wy=:

core: proc wy=[T](vec: var TVec; value: T)

wyw:

core: proc wyw(vec: TVec): auto

wyw=:

core: proc wyw=[T](vec: var TVec; value: T)

wyww:

core: proc wyww(vec: TVec): auto

wyww=:

core: proc wyww=[T](vec: var TVec; value: T)

wywx:

core: proc wywx(vec: TVec): auto

wywx=:

core: proc wywx=[T](vec: var TVec; value: T)

wywy:

core: proc wywy(vec: TVec): auto

wywy=:

core: proc wywy=[T](vec: var TVec; value: T)

wywz:

core: proc wywz(vec: TVec): auto

wywz=:

core: proc wywz=[T](vec: var TVec; value: T)

wyx:

core: proc wyx(vec: TVec): auto

wyx=:

core: proc wyx=[T](vec: var TVec; value: T)

wyxw:

core: proc wyxw(vec: TVec): auto

wyxw=:

core: proc wyxw=[T](vec: var TVec; value: T)

wyxx:

core: proc wyxx(vec: TVec): auto

wyxx=:

core: proc wyxx=[T](vec: var TVec; value: T)

wyxy:

core: proc wyxy(vec: TVec): auto

wyxy=:

core: proc wyxy=[T](vec: var TVec; value: T)

wyxz:

core: proc wyxz(vec: TVec): auto

wyxz=:

core: proc wyxz=[T](vec: var TVec; value: T)

wyy:

core: proc wyy(vec: TVec): auto

wyy=:

core: proc wyy=[T](vec: var TVec; value: T)

wyyw:

core: proc wyyw(vec: TVec): auto

wyyw=:

core: proc wyyw=[T](vec: var TVec; value: T)

wyyx:

core: proc wyyx(vec: TVec): auto

wyyx=:

core: proc wyyx=[T](vec: var TVec; value: T)

wyyy:

core: proc wyyy(vec: TVec): auto

wyyy=:

core: proc wyyy=[T](vec: var TVec; value: T)

wyyz:

core: proc wyyz(vec: TVec): auto

wyyz=:

core: proc wyyz=[T](vec: var TVec; value: T)

wyz:

core: proc wyz(vec: TVec): auto

wyz=:

core: proc wyz=[T](vec: var TVec; value: T)

wyzw:

core: proc wyzw(vec: TVec): auto

wyzw=:

core: proc wyzw=[T](vec: var TVec; value: T)

wyzx:

core: proc wyzx(vec: TVec): auto

wyzx=:

core: proc wyzx=[T](vec: var TVec; value: T)

wyzy:

core: proc wyzy(vec: TVec): auto

wyzy=:

core: proc wyzy=[T](vec: var TVec; value: T)

wyzz:

core: proc wyzz(vec: TVec): auto

wyzz=:

core: proc wyzz=[T](vec: var TVec; value: T)

wz:

core: proc wz(vec: TVec): auto

wz=:

core: proc wz=[T](vec: var TVec; value: T)

wzw:

core: proc wzw(vec: TVec): auto

wzw=:

core: proc wzw=[T](vec: var TVec; value: T)

wzww:

core: proc wzww(vec: TVec): auto

wzww=:

core: proc wzww=[T](vec: var TVec; value: T)

wzwx:

core: proc wzwx(vec: TVec): auto

wzwx=:

core: proc wzwx=[T](vec: var TVec; value: T)

wzwy:

core: proc wzwy(vec: TVec): auto

wzwy=:

core: proc wzwy=[T](vec: var TVec; value: T)

wzwz:

core: proc wzwz(vec: TVec): auto

wzwz=:

core: proc wzwz=[T](vec: var TVec; value: T)

wzx:

core: proc wzx(vec: TVec): auto

wzx=:

core: proc wzx=[T](vec: var TVec; value: T)

wzxw:

core: proc wzxw(vec: TVec): auto

wzxw=:

core: proc wzxw=[T](vec: var TVec; value: T)

wzxx:

core: proc wzxx(vec: TVec): auto

wzxx=:

core: proc wzxx=[T](vec: var TVec; value: T)

wzxy:

core: proc wzxy(vec: TVec): auto

wzxy=:

core: proc wzxy=[T](vec: var TVec; value: T)

wzxz:

core: proc wzxz(vec: TVec): auto

wzxz=:

core: proc wzxz=[T](vec: var TVec; value: T)

wzy:

core: proc wzy(vec: TVec): auto

wzy=:

core: proc wzy=[T](vec: var TVec; value: T)

wzyw:

core: proc wzyw(vec: TVec): auto

wzyw=:

core: proc wzyw=[T](vec: var TVec; value: T)

wzyx:

core: proc wzyx(vec: TVec): auto

wzyx=:

core: proc wzyx=[T](vec: var TVec; value: T)

wzyy:

core: proc wzyy(vec: TVec): auto

wzyy=:

core: proc wzyy=[T](vec: var TVec; value: T)

wzyz:

core: proc wzyz(vec: TVec): auto

wzyz=:

core: proc wzyz=[T](vec: var TVec; value: T)

wzz:

core: proc wzz(vec: TVec): auto

wzz=:

core: proc wzz=[T](vec: var TVec; value: T)

wzzw:

core: proc wzzw(vec: TVec): auto

wzzw=:

core: proc wzzw=[T](vec: var TVec; value: T)

wzzx:

core: proc wzzx(vec: TVec): auto

wzzx=:

core: proc wzzx=[T](vec: var TVec; value: T)

wzzy:

core: proc wzzy(vec: TVec): auto

wzzy=:

core: proc wzzy=[T](vec: var TVec; value: T)

wzzz:

core: proc wzzz(vec: TVec): auto

wzzz=:

core: proc wzzz=[T](vec: var TVec; value: T)

X:

core: const X

x:

core: proc x(vec: TVec): auto

x=:

core: proc x=[T](vec: var TVec; value: T)

XActivateScreenSaver:

xlib: proc XActivateScreenSaver(para1: PDisplay): cint

XAddConnectionWatch:

xlib: proc XAddConnectionWatch(para1: PDisplay; para2: XConnectionWatchProc; para3: XPointer): Status

XAddExtension:

xlib: proc XAddExtension(para1: PDisplay): PXExtCodes

XAddHost:

xlib: proc XAddHost(para1: PDisplay; para2: PXHostAddress): cint

XAddHosts:

xlib: proc XAddHosts(para1: PDisplay; para2: PXHostAddress; para3: cint): cint

XAddPixel:

xutil: proc XAddPixel(ximage: PXImage; value: clong): cint

XAddToExtensionList:

xlib: proc XAddToExtensionList(para1: PPXExtData; para2: PXExtData): cint

XAddToSaveSet:

xlib: proc XAddToSaveSet(para1: PDisplay; para2: Window): cint

XAllocClassHint:

xutil: proc XAllocClassHint(): PXClassHint

XAllocColor:

xlib: proc XAllocColor(para1: PDisplay; para2: Colormap; para3: PXColor): Status

XAllocColorCells:

xlib: proc XAllocColorCells(para1: PDisplay; para2: Colormap; para3: XBool; para4: Pculong; para5: cuint; para6: Pculong; para7: cuint): Status

XAllocColorPlanes:

xlib: proc XAllocColorPlanes(para1: PDisplay; para2: Colormap; para3: XBool; para4: Pculong; para5: cint; para6: cint; para7: cint; para8: cint; para9: Pculong; para10: Pculong; para11: Pculong): Status

XAllocIconSize:

xutil: proc XAllocIconSize(): PXIconSize

XAllocID:

xlib: proc XAllocID(dpy: PDisplay): XID

XAllocNamedColor:

xlib: proc XAllocNamedColor(para1: PDisplay; para2: Colormap; para3: cstring; para4: PXColor; para5: PXColor): Status

XAllocSizeHints:

xutil: proc XAllocSizeHints(): PXSizeHints

XAllocStandardColormap:

xutil: proc XAllocStandardColormap(): PXStandardColormap

XAllocWMHints:

xutil: proc XAllocWMHints(): PXWMHints

XAllowEvents:

xlib: proc XAllowEvents(para1: PDisplay; para2: cint; para3: Time): cint

XAllPlanes:

xlib: proc XAllPlanes(): culong

XAnyEvent:

xlib: object XAnyEvent

XArc:

xlib: object XArc

XAutoRepeatOff:

xlib: proc XAutoRepeatOff(para1: PDisplay): cint

XAutoRepeatOn:

xlib: proc XAutoRepeatOn(para1: PDisplay): cint

XBaseFontNameListOfFontSet:

xlib: proc XBaseFontNameListOfFontSet(para1: XFontSet): cstring

XBell:

xlib: proc XBell(para1: PDisplay; para2: cint): cint

XBitmapBitOrder:

xlib: proc XBitmapBitOrder(para1: PDisplay): cint

XBitmapPad:

xlib: proc XBitmapPad(para1: PDisplay): cint

XBitmapUnit:

xlib: proc XBitmapUnit(para1: PDisplay): cint

XBlackPixel:

xlib: proc XBlackPixel(para1: PDisplay; para2: cint): culong

XBlackPixelOfScreen:

xlib: proc XBlackPixelOfScreen(para1: PScreen): culong

XBool:

xlib: type XBool

XBufferOverflow:

xlib: const XBufferOverflow

XButtonEvent:

xlib: object XButtonEvent

XButtonPressedEvent:

xlib: type XButtonPressedEvent

XButtonReleasedEvent:

xlib: type XButtonReleasedEvent

XCellsOfScreen:

xlib: proc XCellsOfScreen(para1: PScreen): cint

XChangeActivePointerGrab:

xlib: proc XChangeActivePointerGrab(para1: PDisplay; para2: cuint; para3: Cursor; para4: Time): cint

XChangeGC:

xlib: proc XChangeGC(para1: PDisplay; para2: GC; para3: culong; para4: PXGCValues): cint

XChangeKeyboardControl:

xlib: proc XChangeKeyboardControl(para1: PDisplay; para2: culong; para3: PXKeyboardControl): cint

XChangeKeyboardMapping:

xlib: proc XChangeKeyboardMapping(para1: PDisplay; para2: cint; para3: cint; para4: PKeySym; para5: cint): cint

XChangePointerControl:

xlib: proc XChangePointerControl(para1: PDisplay; para2: XBool; para3: XBool; para4: cint; para5: cint; para6: cint): cint

XChangeProperty:

xlib: proc XChangeProperty(para1: PDisplay; para2: Window; para3: Atom; para4: Atom; para5: cint; para6: cint; para7: Pcuchar; para8: cint): cint

XChangeSaveSet:

xlib: proc XChangeSaveSet(para1: PDisplay; para2: Window; para3: cint): cint

XChangeWindowAttributes:

xlib: proc XChangeWindowAttributes(para1: PDisplay; para2: Window; para3: culong; para4: PXSetWindowAttributes): cint

XChar2b:

xlib: object XChar2b

XCharStruct:

xlib: object XCharStruct

XCheckIfEvent:

xlib: proc XCheckIfEvent(para1: PDisplay; para2: PXEvent; para3: funcifevent; para4: XPointer): XBool

XCheckMaskEvent:

xlib: proc XCheckMaskEvent(para1: PDisplay; para2: clong; para3: PXEvent): XBool

XCheckTypedEvent:

xlib: proc XCheckTypedEvent(para1: PDisplay; para2: cint; para3: PXEvent): XBool

XCheckTypedWindowEvent:

xlib: proc XCheckTypedWindowEvent(para1: PDisplay; para2: Window; para3: cint; para4: PXEvent): XBool

XCheckWindowEvent:

xlib: proc XCheckWindowEvent(para1: PDisplay; para2: Window; para3: clong; para4: PXEvent): XBool

XCirculateEvent:

xlib: object XCirculateEvent

XCirculateRequestEvent:

xlib: object XCirculateRequestEvent

XCirculateSubwindows:

xlib: proc XCirculateSubwindows(para1: PDisplay; para2: Window; para3: cint): cint

XCirculateSubwindowsDown:

xlib: proc XCirculateSubwindowsDown(para1: PDisplay; para2: Window): cint

XCirculateSubwindowsUp:

xlib: proc XCirculateSubwindowsUp(para1: PDisplay; para2: Window): cint

XClassHint:

xutil: object XClassHint

XClearArea:

xlib: proc XClearArea(para1: PDisplay; para2: Window; para3: cint; para4: cint; para5: cuint; para6: cuint; para7: XBool): cint

XClearWindow:

xlib: proc XClearWindow(para1: PDisplay; para2: Window): cint

XClientMessageData:

xlib: object XClientMessageData

XClientMessageEvent:

xlib: object XClientMessageEvent

XClipBox:

xutil: proc XClipBox(para1: Region; para2: PXRectangle): cint

XCloseDisplay:

xlib: proc XCloseDisplay(para1: PDisplay): cint

XCloseIM:

xlib: proc XCloseIM(para1: XIM): Status

XCloseOM:

xlib: proc XCloseOM(para1: XOM): Status

XCNOENT:

xutil: const XCNOENT

XCNOMEM:

xutil: const XCNOMEM

XColor:

xlib: object XColor

XColormapEvent:

xlib: object XColormapEvent

XComposeStatus:

xutil: object XComposeStatus

XCompoundTextStyle:

xutil: XICCEncodingStyle.XCompoundTextStyle

XConfigureEvent:

xlib: object XConfigureEvent

XConfigureRequestEvent:

xlib: object XConfigureRequestEvent

XConfigureWindow:

xlib: proc XConfigureWindow(para1: PDisplay; para2: Window; para3: cuint; para4: PXWindowChanges): cint

XConnectionNumber:

xlib: proc XConnectionNumber(para1: PDisplay): cint

XConnectionWatchProc:

xlib: type XConnectionWatchProc

XContext:

xutil: type XContext

XContextDependentDrawing:

xlib: proc XContextDependentDrawing(para1: XFontSet): XBool

XContextualDrawing:

xlib: proc XContextualDrawing(para1: XFontSet): XBool

XConvertCase:

xutil: proc XConvertCase(para1: KeySym; para2: PKeySym; para3: PKeySym)

XConverterNotFound:

xutil: const XConverterNotFound

XConvertSelection:

xlib: proc XConvertSelection(para1: PDisplay; para2: Atom; para3: Atom; para4: Atom; para5: Window; para6: Time): cint

XCopyArea:

xlib: proc XCopyArea(para1: PDisplay; para2: Drawable; para3: Drawable; para4: GC; para5: cint; para6: cint; para7: cuint; para8: cuint; para9: cint; para10: cint): cint

XCopyColormapAndFree:

xlib: proc XCopyColormapAndFree(para1: PDisplay; para2: Colormap): Colormap

XCopyGC:

xlib: proc XCopyGC(para1: PDisplay; para2: GC; para3: culong; para4: GC): cint

XCopyPlane:

xlib: proc XCopyPlane(para1: PDisplay; para2: Drawable; para3: Drawable; para4: GC; para5: cint; para6: cint; para7: cuint; para8: cuint; para9: cint; para10: cint; para11: culong): cint

XCreateBitmapFromData:

xlib: proc XCreateBitmapFromData(para1: PDisplay; para2: Drawable; para3: cstring; para4: cuint; para5: cuint): Pixmap

XCreateColormap:

xlib: proc XCreateColormap(para1: PDisplay; para2: Window; para3: PVisual; para4: cint): Colormap

XCreateFontCursor:

xlib: proc XCreateFontCursor(para1: PDisplay; para2: cuint): Cursor

XCreateFontSet:

xlib: proc XCreateFontSet(para1: PDisplay; para2: cstring; para3: PPPChar; para4: Pcint; para5: PPChar): XFontSet

XCreateGC:

xlib: proc XCreateGC(para1: PDisplay; para2: Drawable; para3: culong; para4: PXGCValues): GC

XCreateGlyphCursor:

xlib: proc XCreateGlyphCursor(para1: PDisplay; para2: Font; para3: Font; para4: cuint; para5: cuint; para6: PXColor; para7: PXColor): Cursor

XCreateIC:

xlib: proc XCreateIC(para1: XIM): XIC

XCreateImage:

xlib: proc XCreateImage(para1: PDisplay; para2: PVisual; para3: cuint; para4: cint; para5: cint; para6: cstring; para7: cuint; para8: cuint; para9: cint; para10: cint): PXImage

XCreateOC:

xlib: proc XCreateOC(para1: XOM): XOC

XCreatePixmap:

xlib: proc XCreatePixmap(para1: PDisplay; para2: Drawable; para3: cuint; para4: cuint; para5: cuint): Pixmap

XCreatePixmapCursor:

xlib: proc XCreatePixmapCursor(para1: PDisplay; para2: Pixmap; para3: Pixmap; para4: PXColor; para5: PXColor; para6: cuint; para7: cuint): Cursor

XCreatePixmapFromBitmapData:

xlib: proc XCreatePixmapFromBitmapData(para1: PDisplay; para2: Drawable; para3: cstring; para4: cuint; para5: cuint; para6: culong; para7: culong; para8: cuint): Pixmap

XCreateRegion:

xutil: proc XCreateRegion(): Region

XCreateSimpleWindow:

xlib: proc XCreateSimpleWindow(para1: PDisplay; para2: Window; para3: cint; para4: cint; para5: cuint; para6: cuint; para7: cuint; para8: culong; para9: culong): Window

XCreateWindow:

xlib: proc XCreateWindow(para1: PDisplay; para2: Window; para3: cint; para4: cint; para5: cuint; para6: cuint; para7: cuint; para8: cint; para9: cuint; para10: PVisual; para11: culong; para12: PXSetWindowAttributes): Window

XCreateWindowEvent:

xlib: object XCreateWindowEvent

XCrossingEvent:

xlib: object XCrossingEvent

XCSUCCESS:

xutil: const XCSUCCESS

XDefaultColormap:

xlib: proc XDefaultColormap(para1: PDisplay; para2: cint): Colormap

XDefaultColormapOfScreen:

xlib: proc XDefaultColormapOfScreen(para1: PScreen): Colormap

XDefaultDepth:

xlib: proc XDefaultDepth(para1: PDisplay; para2: cint): cint

XDefaultDepthOfScreen:

xlib: proc XDefaultDepthOfScreen(para1: PScreen): cint

XDefaultGC:

xlib: proc XDefaultGC(para1: PDisplay; para2: cint): GC

XDefaultGCOfScreen:

xlib: proc XDefaultGCOfScreen(para1: PScreen): GC

XDefaultRootWindow:

xlib: proc XDefaultRootWindow(para1: PDisplay): Window

XDefaultScreen:

xlib: proc XDefaultScreen(para1: PDisplay): cint

XDefaultScreenOfDisplay:

xlib: proc XDefaultScreenOfDisplay(para1: PDisplay): PScreen

XDefaultString:

xutil: proc XDefaultString(): cstring

XDefaultVisual:

xlib: proc XDefaultVisual(para1: PDisplay; para2: cint): PVisual

XDefaultVisualOfScreen:

xlib: proc XDefaultVisualOfScreen(para1: PScreen): PVisual

XDefineCursor:

xlib: proc XDefineCursor(para1: PDisplay; para2: Window; para3: Cursor): cint

XDeleteContext:

xutil: proc XDeleteContext(para1: PDisplay; para2: XID; para3: XContext): cint

XDeleteModifiermapEntry:

xlib: proc XDeleteModifiermapEntry(para1: PXModifierKeymap; para2: KeyCode; para3: cint): PXModifierKeymap

XDeleteProperty:

xlib: proc XDeleteProperty(para1: PDisplay; para2: Window; para3: Atom): cint

XDestroyIC:

xlib: proc XDestroyIC(para1: XIC)

XDestroyImage:

xutil: proc XDestroyImage(ximage: PXImage): cint

XDestroyOC:

xlib: proc XDestroyOC(para1: XOC)

XDestroyRegion:

xutil: proc XDestroyRegion(para1: Region): cint

XDestroySubwindows:

xlib: proc XDestroySubwindows(para1: PDisplay; para2: Window): cint

XDestroyWindow:

xlib: proc XDestroyWindow(para1: PDisplay; para2: Window): cint

XDestroyWindowEvent:

xlib: object XDestroyWindowEvent

XDirectionalDependentDrawing:

xlib: proc XDirectionalDependentDrawing(para1: XFontSet): XBool

XDisableAccessControl:

xlib: proc XDisableAccessControl(para1: PDisplay): cint

XDisplay:

xlib: object XDisplay

XDisplayCells:

xlib: proc XDisplayCells(para1: PDisplay; para2: cint): cint

XDisplayHeight:

xlib: proc XDisplayHeight(para1: PDisplay; para2: cint): cint

XDisplayHeightMM:

xlib: proc XDisplayHeightMM(para1: PDisplay; para2: cint): cint

XDisplayKeycodes:

xlib: proc XDisplayKeycodes(para1: PDisplay; para2: Pcint; para3: Pcint): cint

XDisplayMotionBufferSize:

xlib: proc XDisplayMotionBufferSize(para1: PDisplay): culong

XDisplayName:

xlib: proc XDisplayName(para1: cstring): cstring

XDisplayOfIM:

xlib: proc XDisplayOfIM(para1: XIM): PDisplay

XDisplayOfOM:

xlib: proc XDisplayOfOM(para1: XOM): PDisplay

XDisplayOfScreen:

xlib: proc XDisplayOfScreen(para1: PScreen): PDisplay

XDisplayPlanes:

xlib: proc XDisplayPlanes(para1: PDisplay; para2: cint): cint

XDisplayString:

xlib: proc XDisplayString(para1: PDisplay): cstring

XDisplayWidth:

xlib: proc XDisplayWidth(para1: PDisplay; para2: cint): cint

XDisplayWidthMM:

xlib: proc XDisplayWidthMM(para1: PDisplay; para2: cint): cint

XDoesBackingStore:

xlib: proc XDoesBackingStore(para1: PScreen): cint

XDoesSaveUnders:

xlib: proc XDoesSaveUnders(para1: PScreen): XBool

XDrawArc:

xlib: proc XDrawArc(para1: PDisplay; para2: Drawable; para3: GC; para4: cint; para5: cint; para6: cuint; para7: cuint; para8: cint; para9: cint): cint

XDrawArcs:

xlib: proc XDrawArcs(para1: PDisplay; para2: Drawable; para3: GC; para4: PXArc; para5: cint): cint

XDrawImageString:

xlib: proc XDrawImageString(para1: PDisplay; para2: Drawable; para3: GC; para4: cint; para5: cint; para6: cstring; para7: cint): cint

XDrawImageString16:

xlib: proc XDrawImageString16(para1: PDisplay; para2: Drawable; para3: GC; para4: cint; para5: cint; para6: PXChar2b; para7: cint): cint

XDrawLine:

xlib: proc XDrawLine(para1: PDisplay; para2: Drawable; para3: GC; para4: cint; para5: cint; para6: cint; para7: cint): cint

XDrawLines:

xlib: proc XDrawLines(para1: PDisplay; para2: Drawable; para3: GC; para4: PXPoint; para5: cint; para6: cint): cint

XDrawPoint:

xlib: proc XDrawPoint(para1: PDisplay; para2: Drawable; para3: GC; para4: cint; para5: cint): cint

XDrawPoints:

xlib: proc XDrawPoints(para1: PDisplay; para2: Drawable; para3: GC; para4: PXPoint; para5: cint; para6: cint): cint

XDrawRectangle:

xlib: proc XDrawRectangle(para1: PDisplay; para2: Drawable; para3: GC; para4: cint; para5: cint; para6: cuint; para7: cuint): cint

XDrawRectangles:

xlib: proc XDrawRectangles(para1: PDisplay; para2: Drawable; para3: GC; para4: PXRectangle; para5: cint): cint

XDrawSegments:

xlib: proc XDrawSegments(para1: PDisplay; para2: Drawable; para3: GC; para4: PXSegment; para5: cint): cint

XDrawString:

xlib: proc XDrawString(para1: PDisplay; para2: Drawable; para3: GC; para4: cint; para5: cint; para6: cstring; para7: cint): cint

XDrawString16:

xlib: proc XDrawString16(para1: PDisplay; para2: Drawable; para3: GC; para4: cint; para5: cint; para6: PXChar2b; para7: cint): cint

XDrawText:

xlib: proc XDrawText(para1: PDisplay; para2: Drawable; para3: GC; para4: cint; para5: cint; para6: PXTextItem; para7: cint): cint

XDrawText16:

xlib: proc XDrawText16(para1: PDisplay; para2: Drawable; para3: GC; para4: cint; para5: cint; para6: PXTextItem16; para7: cint): cint

XEDataObject:

xlib: object XEDataObject

XEHeadOfExtensionList:

xlib: proc XEHeadOfExtensionList(para1: XEDataObject): PPXExtData

XEmptyRegion:

xutil: proc XEmptyRegion(para1: Region): cint

XEnableAccessControl:

xlib: proc XEnableAccessControl(para1: PDisplay): cint

XEnterWindowEvent:

xlib: type XEnterWindowEvent

XEqualRegion:

xutil: proc XEqualRegion(para1: Region; para2: Region): cint

XErrorEvent:

xlib: object XErrorEvent

XErrorHandler:

xlib: type XErrorHandler

XEvent:

xlib: object XEvent

XEventClass:

xi: type XEventClass

XEventMaskOfScreen:

xlib: proc XEventMaskOfScreen(para1: PScreen): clong

XEventsQueued:

xlib: proc XEventsQueued(para1: PDisplay; para2: cint): cint

XExposeEvent:

xlib: object XExposeEvent

XExtCodes:

xlib: object XExtCodes

XExtData:

xlib: object XExtData

XExtendedMaxRequestSize:

xlib: proc XExtendedMaxRequestSize(para1: PDisplay): clong

XExtensionVersion:

xi: object XExtensionVersion

XExtentsOfFontSet:

xlib: proc XExtentsOfFontSet(para1: XFontSet): PXFontSetExtents

XFetchBuffer:

xlib: proc XFetchBuffer(para1: PDisplay; para2: Pcint; para3: cint): cstring

XFetchBytes:

xlib: proc XFetchBytes(para1: PDisplay; para2: Pcint): cstring

XFetchName:

xlib: proc XFetchName(para1: PDisplay; para2: Window; para3: PPChar): Status

XFillArc:

xlib: proc XFillArc(para1: PDisplay; para2: Drawable; para3: GC; para4: cint; para5: cint; para6: cuint; para7: cuint; para8: cint; para9: cint): cint

XFillArcs:

xlib: proc XFillArcs(para1: PDisplay; para2: Drawable; para3: GC; para4: PXArc; para5: cint): cint

XFillPolygon:

xlib: proc XFillPolygon(para1: PDisplay; para2: Drawable; para3: GC; para4: PXPoint; para5: cint; para6: cint; para7: cint): cint

XFillRectangle:

xlib: proc XFillRectangle(para1: PDisplay; para2: Drawable; para3: GC; para4: cint; para5: cint; para6: cuint; para7: cuint): cint

XFillRectangles:

xlib: proc XFillRectangles(para1: PDisplay; para2: Drawable; para3: GC; para4: PXRectangle; para5: cint): cint

XFilterEvent:

xlib: proc XFilterEvent(para1: PXEvent; para2: Window): XBool

XFindContext:

xutil: proc XFindContext(para1: PDisplay; para2: XID; para3: XContext; para4: PXPointer): cint

XFindOnExtensionList:

xlib: proc XFindOnExtensionList(para1: PPXExtData; para2: cint): PXExtData

XFlush:

xlib: proc XFlush(para1: PDisplay): cint

XFlushGC:

xlib: proc XFlushGC(para1: PDisplay; para2: GC)

XFocusChangeEvent:

xlib: object XFocusChangeEvent

XFocusInEvent:

xlib: type XFocusInEvent

XFocusOutEvent:

xlib: type XFocusOutEvent

XFontProp:

xlib: object XFontProp

XFontSet:

xlib: type XFontSet

XFontSetExtents:

xlib: object XFontSetExtents

XFontsOfFontSet:

xlib: proc XFontsOfFontSet(para1: XFontSet; para2: PPPXFontStruct; para3: PPPChar): cint

XFontStruct:

xlib: object XFontStruct

XForceScreenSaver:

xlib: proc XForceScreenSaver(para1: PDisplay; para2: cint): cint

XFree:

xlib: proc XFree(para1: pointer): cint

XFreeColormap:

xlib: proc XFreeColormap(para1: PDisplay; para2: Colormap): cint

XFreeColors:

xlib: proc XFreeColors(para1: PDisplay; para2: Colormap; para3: Pculong; para4: cint; para5: culong): cint

XFreeCursor:

xlib: proc XFreeCursor(para1: PDisplay; para2: Cursor): cint

XFreeEventData:

xlib: proc XFreeEventData(para1: PDisplay; para2: PXGenericEventCookie)

XFreeExtensionList:

xlib: proc XFreeExtensionList(para1: PPChar): cint

XFreeFont:

xlib: proc XFreeFont(para1: PDisplay; para2: PXFontStruct): cint

XFreeFontInfo:

xlib: proc XFreeFontInfo(para1: PPChar; para2: PXFontStruct; para3: cint): cint

XFreeFontNames:

xlib: proc XFreeFontNames(para1: PPChar): cint

XFreeFontPath:

xlib: proc XFreeFontPath(para1: PPChar): cint

XFreeFontSet:

xlib: proc XFreeFontSet(para1: PDisplay; para2: XFontSet)

XFreeGC:

xlib: proc XFreeGC(para1: PDisplay; para2: GC): cint

XFreeModifiermap:

xlib: proc XFreeModifiermap(para1: PXModifierKeymap): cint

XFreePixmap:

xlib: proc XFreePixmap(para1: PDisplay; para2: Pixmap): cint

XFreeStringList:

xlib: proc XFreeStringList(para1: PPChar)

XGC:

xlib: object XGC

XGContextFromGC:

xlib: proc XGContextFromGC(para1: GC): GContext

XGCValues:

xlib: object XGCValues

XGenericEvent:

xlib: object XGenericEvent

XGenericEventCookie:

xlib: object XGenericEventCookie

XGeometry:

xlib: proc XGeometry(para1: PDisplay; para2: cint; para3: cstring; para4: cstring; para5: cuint; para6: cuint; para7: cuint; para8: cint; para9: cint; para10: Pcint; para11: Pcint; para12: Pcint; para13: Pcint): cint

XGetAtomName:

xlib: proc XGetAtomName(para1: PDisplay; para2: Atom): cstring

XGetAtomNames:

xlib: proc XGetAtomNames(para1: PDisplay; para2: PAtom; para3: cint; para4: PPChar): Status

XGetClassHint:

xutil: proc XGetClassHint(para1: PDisplay; para2: Window; para3: PXClassHint): Status

XGetCommand:

xlib: proc XGetCommand(para1: PDisplay; para2: Window; para3: PPPChar; para4: Pcint): Status

XGetDefault:

xlib: proc XGetDefault(para1: PDisplay; para2: cstring; para3: cstring): cstring

XGetErrorDatabaseText:

xlib: proc XGetErrorDatabaseText(para1: PDisplay; para2: cstring; para3: cstring; para4: cstring; para5: cstring; para6: cint): cint

XGetErrorText:

xlib: proc XGetErrorText(para1: PDisplay; para2: cint; para3: cstring; para4: cint): cint

XGetEventData:

xlib: proc XGetEventData(para1: PDisplay; para2: PXGenericEventCookie): XBool

XGetFontPath:

xlib: proc XGetFontPath(para1: PDisplay; para2: Pcint): PPChar

XGetFontProperty:

xlib: proc XGetFontProperty(para1: PXFontStruct; para2: Atom; para3: Pculong): XBool

XGetGCValues:

xlib: proc XGetGCValues(para1: PDisplay; para2: GC; para3: culong; para4: PXGCValues): Status

XGetGeometry:

xlib: proc XGetGeometry(para1: PDisplay; para2: Drawable; para3: PWindow; para4: Pcint; para5: Pcint; para6: Pcuint; para7: Pcuint; para8: Pcuint; para9: Pcuint): Status

XGetIconName:

xlib: proc XGetIconName(para1: PDisplay; para2: Window; para3: PPChar): Status

XGetIconSizes:

xutil: proc XGetIconSizes(para1: PDisplay; para2: Window; para3: PPXIconSize; para4: Pcint): Status

XGetICValues:

xlib: proc XGetICValues(para1: XIC): cstring

XGetImage:

xlib: proc XGetImage(para1: PDisplay; para2: Drawable; para3: cint; para4: cint; para5: cuint; para6: cuint; para7: culong; para8: cint): PXImage

XGetIMValues:

xlib: proc XGetIMValues(para1: XIM): cstring

XGetInputFocus:

xlib: proc XGetInputFocus(para1: PDisplay; para2: PWindow; para3: Pcint): cint

XGetKeyboardControl:

xlib: proc XGetKeyboardControl(para1: PDisplay; para2: PXKeyboardState): cint

XGetKeyboardMapping:

xlib: proc XGetKeyboardMapping(para1: PDisplay; para2: KeyCode; para3: cint; para4: Pcint): PKeySym

XGetModifierMapping:

xlib: proc XGetModifierMapping(para1: PDisplay): PXModifierKeymap

XGetMotionEvents:

xlib: proc XGetMotionEvents(para1: PDisplay; para2: Window; para3: Time; para4: Time; para5: Pcint): PXTimeCoord

XGetNormalHints:

xutil: proc XGetNormalHints(para1: PDisplay; para2: Window; para3: PXSizeHints): Status

XGetOCValues:

xlib: proc XGetOCValues(para1: XOC): cstring

XGetOMValues:

xlib: proc XGetOMValues(para1: XOM): cstring

XGetPixel:

xutil: proc XGetPixel(ximage: PXImage; x, y: cint): culong

XGetPointerControl:

xlib: proc XGetPointerControl(para1: PDisplay; para2: Pcint; para3: Pcint; para4: Pcint): cint

XGetPointerMapping:

xlib: proc XGetPointerMapping(para1: PDisplay; para2: Pcuchar; para3: cint): cint

XGetRGBColormaps:

xutil: proc XGetRGBColormaps(para1: PDisplay; para2: Window; para3: PPXStandardColormap; para4: Pcint; para5: Atom): Status

XGetScreenSaver:

xlib: proc XGetScreenSaver(para1: PDisplay; para2: Pcint; para3: Pcint; para4: Pcint; para5: Pcint): cint

XGetSelectionOwner:

xlib: proc XGetSelectionOwner(para1: PDisplay; para2: Atom): Window

XGetSizeHints:

xutil: proc XGetSizeHints(para1: PDisplay; para2: Window; para3: PXSizeHints; para4: Atom): Status

XGetStandardColormap:

xutil: proc XGetStandardColormap(para1: PDisplay; para2: Window; para3: PXStandardColormap; para4: Atom): Status

XGetSubImage:

xlib: proc XGetSubImage(para1: PDisplay; para2: Drawable; para3: cint; para4: cint; para5: cuint; para6: cuint; para7: culong; para8: cint; para9: PXImage; para10: cint; para11: cint): PXImage

XGetTextProperty:

xutil: proc XGetTextProperty(para1: PDisplay; para2: Window; para3: PXTextProperty; para4: Atom): Status

XGetTransientForHint:

xlib: proc XGetTransientForHint(para1: PDisplay; para2: Window; para3: PWindow): Status

XGetVisualInfo:

xutil: proc XGetVisualInfo(para1: PDisplay; para2: clong; para3: PXVisualInfo; para4: Pcint): PXVisualInfo

XGetWindowAttributes:

xlib: proc XGetWindowAttributes(para1: PDisplay; para2: Window; para3: PXWindowAttributes): Status

XGetWindowProperty:

xlib: proc XGetWindowProperty(para1: PDisplay; para2: Window; para3: Atom; para4: clong; para5: clong; para6: XBool; para7: Atom; para8: PAtom; para9: Pcint; para10: Pculong; para11: Pculong; para12: PPcuchar): cint

XGetWMClientMachine:

xutil: proc XGetWMClientMachine(para1: PDisplay; para2: Window; para3: PXTextProperty): Status

XGetWMColormapWindows:

xlib: proc XGetWMColormapWindows(para1: PDisplay; para2: Window; para3: PPWindow; para4: Pcint): Status

XGetWMHints:

xutil: proc XGetWMHints(para1: PDisplay; para2: Window): PXWMHints

XGetWMIconName:

xutil: proc XGetWMIconName(para1: PDisplay; para2: Window; para3: PXTextProperty): Status

XGetWMName:

xutil: proc XGetWMName(para1: PDisplay; para2: Window; para3: PXTextProperty): Status

XGetWMNormalHints:

xutil: proc XGetWMNormalHints(para1: PDisplay; para2: Window; para3: PXSizeHints; para4: ptr int): Status

XGetWMProtocols:

xlib: proc XGetWMProtocols(para1: PDisplay; para2: Window; para3: PPAtom; para4: Pcint): Status

XGetWMSizeHints:

xutil: proc XGetWMSizeHints(para1: PDisplay; para2: Window; para3: PXSizeHints; para4: ptr int; para5: Atom): Status

XGetZoomHints:

xutil: proc XGetZoomHints(para1: PDisplay; para2: Window; para3: PXSizeHints): Status

XGrabButton:

xlib: proc XGrabButton(para1: PDisplay; para2: cuint; para3: cuint; para4: Window; para5: XBool; para6: cuint; para7: cint; para8: cint; para9: Window; para10: Cursor): cint

XGrabKey:

xlib: proc XGrabKey(para1: PDisplay; para2: cint; para3: cuint; para4: Window; para5: XBool; para6: cint; para7: cint): cint

XGrabKeyboard:

xlib: proc XGrabKeyboard(para1: PDisplay; para2: Window; para3: XBool; para4: cint; para5: cint; para6: Time): cint

XGrabPointer:

xlib: proc XGrabPointer(para1: PDisplay; para2: Window; para3: XBool; para4: cuint; para5: cint; para6: cint; para7: Window; para8: Cursor; para9: Time): cint

XGrabServer:

xlib: proc XGrabServer(para1: PDisplay): cint

XGraphicsExposeEvent:

xlib: object XGraphicsExposeEvent

XGravityEvent:

xlib: object XGravityEvent

XHeightMMOfScreen:

xlib: proc XHeightMMOfScreen(para1: PScreen): cint

XHeightOfScreen:

xlib: proc XHeightOfScreen(para1: PScreen): cint

XHostAddress:

xlib: object XHostAddress

Xi:

core: const Xi

Xi8:

core: const Xi8

XI_Absent:

xi: const XI_Absent

XI_Add_XChangeDeviceControl_Major:

xi: const XI_Add_XChangeDeviceControl_Major

XI_Add_XChangeDeviceControl_Minor:

xi: const XI_Add_XChangeDeviceControl_Minor

XI_Add_XDeviceBell_Major:

xi: const XI_Add_XDeviceBell_Major

XI_Add_XDeviceBell_Minor:

xi: const XI_Add_XDeviceBell_Minor

XI_Add_XSetDeviceValuators_Major:

xi: const XI_Add_XSetDeviceValuators_Major

XI_Add_XSetDeviceValuators_Minor:

xi: const XI_Add_XSetDeviceValuators_Minor

XI_BadClass:

xi: const XI_BadClass

XI_BadDevice:

xi: const XI_BadDevice

XI_BadEvent:

xi: const XI_BadEvent

XI_BadMode:

xi: const XI_BadMode

XI_BARCODE:

xi: const XI_BARCODE

XI_BUTTONBOX:

xi: const XI_BUTTONBOX

XIC:

xlib: type XIC

XICCallback:

xlib: object XICCallback

XICCEncodingStyle:

xutil: enum XICCEncodingStyle

XIconifyWindow:

xlib: proc XIconifyWindow(para1: PDisplay; para2: Window; para3: cint): Status

XIconSize:

xutil: object XIconSize

XICProc:

xlib: type XICProc

XI_CURSORKEYS:

xi: const XI_CURSORKEYS

XID:

x: type XID

XI_DATAGLOVE:

xi: const XI_DATAGLOVE

XI_DeviceBusy:

xi: const XI_DeviceBusy

XIDProc:

xlib: type XIDProc

XI_EYETRACKER:

xi: const XI_EYETRACKER

XIfEvent:

xlib: proc XIfEvent(para1: PDisplay; para2: PXEvent; para3: funcifevent; para4: XPointer): cint

XI_FOOTMOUSE:

xi: const XI_FOOTMOUSE

XI_ID_MODULE:

xi: const XI_ID_MODULE

XI_Initial_Release_Major:

xi: const XI_Initial_Release_Major

XI_Initial_Release_Minor:

xi: const XI_Initial_Release_Minor

XI_KEYBOARD:

xi: const XI_KEYBOARD

XI_KNOB_BOX:

xi: const XI_KNOB_BOX

XIM:

xlib: type XIM

XIMAbsolutePosition:

xlib: XIMCaretDirection.XIMAbsolutePosition

XImage:

xlib: object XImage

XImageByteOrder:

xlib: proc XImageByteOrder(para1: PDisplay): cint

XIMBackwardChar:

xlib: XIMCaretDirection.XIMBackwardChar

XIMBackwardWord:

xlib: XIMCaretDirection.XIMBackwardWord

XIMBitmapType:

xlib: XIMStatusDataType.XIMBitmapType

XIMCallback:

xlib: object XIMCallback

XIMCaretDirection:

xlib: enum XIMCaretDirection

XIMCaretDown:

xlib: XIMCaretDirection.XIMCaretDown

XIMCaretStyle:

xlib: enum XIMCaretStyle

XIMCaretUp:

xlib: XIMCaretDirection.XIMCaretUp

XIMDontChange:

xlib: XIMCaretDirection.XIMDontChange

XIMFeedback:

xlib: type XIMFeedback

XIMForwardChar:

xlib: XIMCaretDirection.XIMForwardChar

XIMForwardWord:

xlib: XIMCaretDirection.XIMForwardWord

XIMHighlight:

xlib: const XIMHighlight

XIMHotKeyState:

xlib: type XIMHotKeyState

XIMHotKeyStateOFF:

xlib: const XIMHotKeyStateOFF

XIMHotKeyStateON:

xlib: const XIMHotKeyStateON

XIMHotKeyTrigger:

xlib: object XIMHotKeyTrigger

XIMHotKeyTriggers:

xlib: object XIMHotKeyTriggers

XIMInitialState:

xlib: const XIMInitialState

XIMIsInvisible:

xlib: XIMCaretStyle.XIMIsInvisible

XIMIsPrimary:

xlib: XIMCaretStyle.XIMIsPrimary

XIMIsSecondary:

xlib: XIMCaretStyle.XIMIsSecondary

XIMLineEnd:

xlib: XIMCaretDirection.XIMLineEnd

XIMLineStart:

xlib: XIMCaretDirection.XIMLineStart

XIMNextLine:

xlib: XIMCaretDirection.XIMNextLine

XIMOfIC:

xlib: proc XIMOfIC(para1: XIC): XIM

XI_MOUSE:

xi: const XI_MOUSE

XIMPreeditArea:

xlib: const XIMPreeditArea

XIMPreeditCallbacks:

xlib: const XIMPreeditCallbacks

XIMPreeditCaretCallbackStruct:

xlib: object XIMPreeditCaretCallbackStruct

XIMPreeditDisable:

xlib: const XIMPreeditDisable

XIMPreeditDrawCallbackStruct:

xlib: object XIMPreeditDrawCallbackStruct

XIMPreeditEnable:

xlib: const XIMPreeditEnable

XIMPreeditNone:

xlib: const XIMPreeditNone

XIMPreeditNothing:

xlib: const XIMPreeditNothing

XIMPreeditPosition:

xlib: const XIMPreeditPosition

XIMPreeditState:

xlib: type XIMPreeditState

XIMPreeditStateNotifyCallbackStruct:

xlib: object XIMPreeditStateNotifyCallbackStruct

XIMPreeditUnKnown:

xlib: const XIMPreeditUnKnown

XIMPreserveState:

xlib: const XIMPreserveState

XIMPreviousLine:

xlib: XIMCaretDirection.XIMPreviousLine

XIMPrimary:

xlib: const XIMPrimary

XIMProc:

xlib: type XIMProc

XIMResetState:

xlib: type XIMResetState

XIMReverse:

xlib: const XIMReverse

XIMSecondary:

xlib: const XIMSecondary

XIMStatusArea:

xlib: const XIMStatusArea

XIMStatusCallbacks:

xlib: const XIMStatusCallbacks

XIMStatusDataType:

xlib: enum XIMStatusDataType

XIMStatusDrawCallbackStruct:

xlib: object XIMStatusDrawCallbackStruct

XIMStatusNone:

xlib: const XIMStatusNone

XIMStatusNothing:

xlib: const XIMStatusNothing

XIMStringConversionBottomEdge:

xlib: const XIMStringConversionBottomEdge

XIMStringConversionBuffer:

xlib: const XIMStringConversionBuffer

XIMStringConversionCallbackStruct:

xlib: object XIMStringConversionCallbackStruct

XIMStringConversionChar:

xlib: const XIMStringConversionChar

XIMStringConversionConcealed:

xlib: const XIMStringConversionConcealed

XIMStringConversionFeedback:

xlib: type XIMStringConversionFeedback

XIMStringConversionLeftEdge:

xlib: const XIMStringConversionLeftEdge

XIMStringConversionLine:

xlib: const XIMStringConversionLine

XIMStringConversionOperation:

xlib: type XIMStringConversionOperation

XIMStringConversionPosition:

xlib: type XIMStringConversionPosition

XIMStringConversionRetrieval:

xlib: const XIMStringConversionRetrieval

XIMStringConversionRightEdge:

xlib: const XIMStringConversionRightEdge

XIMStringConversionSubstitution:

xlib: const XIMStringConversionSubstitution

XIMStringConversionText:

xlib: object XIMStringConversionText

XIMStringConversionTopEdge:

xlib: const XIMStringConversionTopEdge

XIMStringConversionType:

xlib: type XIMStringConversionType

XIMStringConversionWord:

xlib: const XIMStringConversionWord

XIMStringConversionWrapped:

xlib: const XIMStringConversionWrapped

XIMStyle:

xlib: type XIMStyle

XIMStyles:

xlib: object XIMStyles

XIMTertiary:

xlib: const XIMTertiary

XIMText:

xlib: object XIMText

XIMTextType:

xlib: XIMStatusDataType.XIMTextType

XIMUnderline:

xlib: const XIMUnderline

XIMValuesList:

xlib: object XIMValuesList

XIMVisibleToBackword:

xlib: const XIMVisibleToBackword

XIMVisibleToCenter:

xlib: const XIMVisibleToCenter

XIMVisibleToForward:

xlib: const XIMVisibleToForward

XI_NINE_KNOB:

xi: const XI_NINE_KNOB

XInitExtension:

xlib: proc XInitExtension(para1: PDisplay; para2: cstring): PXExtCodes

XInitImage:

xlib: proc XInitImage(para1: PXImage): Status

XInitThreads:

xlib: proc XInitThreads(): Status

XInput_Add_XChangeDeviceControl:

xi: const XInput_Add_XChangeDeviceControl

XInput_Add_XDeviceBell:

xi: const XInput_Add_XDeviceBell

XInput_Add_XSetDeviceValuators:

xi: const XInput_Add_XSetDeviceValuators

XInput_Initial_Release:

xi: const XInput_Initial_Release

XInsertModifiermapEntry:

xlib: proc XInsertModifiermapEntry(para1: PXModifierKeymap; para2: KeyCode; para3: cint): PXModifierKeymap

XInstallColormap:

xlib: proc XInstallColormap(para1: PDisplay; para2: Colormap): cint

XInternalConnectionNumbers:

xlib: proc XInternalConnectionNumbers(para1: PDisplay; para2: PPcint; para3: Pcint): Status

XInternAtom:

xlib: proc XInternAtom(para1: PDisplay; para2: cstring; para3: XBool): Atom

XInternAtoms:

xlib: proc XInternAtoms(para1: PDisplay; para2: PPChar; para3: cint; para4: XBool; para5: PAtom): Status

XIntersectRegion:

xutil: proc XIntersectRegion(para1: Region; para2: Region; para3: Region): cint

XIOErrorHandler:

xlib: type XIOErrorHandler

XI_ONE_KNOB:

xi: const XI_ONE_KNOB

XI_Present:

xi: const XI_Present

XI_QUADRATURE:

xi: const XI_QUADRATURE

XI_SPACEBALL:

xi: const XI_SPACEBALL

XI_TABLET:

xi: const XI_TABLET

XI_TOUCHPAD:

xi: const XI_TOUCHPAD

XI_TOUCHSCREEN:

xi: const XI_TOUCHSCREEN

XI_TRACKBALL:

xi: const XI_TRACKBALL

XK_0:

keysym: const XK_0

XK_1:

keysym: const XK_1

XK_2:

keysym: const XK_2

XK_3:

keysym: const XK_3

XK_3270_AltCursor:

keysym: const XK_3270_AltCursor

XK_3270_Attn:

keysym: const XK_3270_Attn

XK_3270_BackTab:

keysym: const XK_3270_BackTab

XK_3270_ChangeScreen:

keysym: const XK_3270_ChangeScreen

XK_3270_Copy:

keysym: const XK_3270_Copy

XK_3270_CursorBlink:

keysym: const XK_3270_CursorBlink

XK_3270_CursorSelect:

keysym: const XK_3270_CursorSelect

XK_3270_DeleteWord:

keysym: const XK_3270_DeleteWord

XK_3270_Duplicate:

keysym: const XK_3270_Duplicate

XK_3270_Enter:

keysym: const XK_3270_Enter

XK_3270_EraseEOF:

keysym: const XK_3270_EraseEOF

XK_3270_EraseInput:

keysym: const XK_3270_EraseInput

XK_3270_ExSelect:

keysym: const XK_3270_ExSelect

XK_3270_FieldMark:

keysym: const XK_3270_FieldMark

XK_3270_Ident:

keysym: const XK_3270_Ident

XK_3270_Jump:

keysym: const XK_3270_Jump

XK_3270_KeyClick:

keysym: const XK_3270_KeyClick

XK_3270_Left2:

keysym: const XK_3270_Left2

XK_3270_PA1:

keysym: const XK_3270_PA1

XK_3270_PA2:

keysym: const XK_3270_PA2

XK_3270_PA3:

keysym: const XK_3270_PA3

XK_3270_Play:

keysym: const XK_3270_Play

XK_3270_PrintScreen:

keysym: const XK_3270_PrintScreen

XK_3270_Quit:

keysym: const XK_3270_Quit

XK_3270_Record:

keysym: const XK_3270_Record

XK_3270_Reset:

keysym: const XK_3270_Reset

XK_3270_Right2:

keysym: const XK_3270_Right2

XK_3270_Rule:

keysym: const XK_3270_Rule

XK_3270_Setup:

keysym: const XK_3270_Setup

XK_3270_Test:

keysym: const XK_3270_Test

XK_4:

keysym: const XK_4

XK_5:

keysym: const XK_5

XK_6:

keysym: const XK_6

XK_7:

keysym: const XK_7

XK_8:

keysym: const XK_8

XK_9:

keysym: const XK_9

XK_a:

keysym: const XK_a

XK_aacute:

keysym: const XK_aacute

XK_abelowdot:

keysym: const XK_abelowdot

XK_abovedot:

keysym: const XK_abovedot

XK_abreve:

keysym: const XK_abreve

XK_abreveacute:

keysym: const XK_abreveacute

XK_abrevebelowdot:

keysym: const XK_abrevebelowdot

XK_abrevegrave:

keysym: const XK_abrevegrave

XK_abrevehook:

keysym: const XK_abrevehook

XK_abrevetilde:

keysym: const XK_abrevetilde

XK_AccessX_Enable:

keysym: const XK_AccessX_Enable

XK_AccessX_Feedback_Enable:

keysym: const XK_AccessX_Feedback_Enable

XK_acircumflex:

keysym: const XK_acircumflex

XK_acircumflexacute:

keysym: const XK_acircumflexacute

XK_acircumflexbelowdot:

keysym: const XK_acircumflexbelowdot

XK_acircumflexgrave:

keysym: const XK_acircumflexgrave

XK_acircumflexhook:

keysym: const XK_acircumflexhook

XK_acircumflextilde:

keysym: const XK_acircumflextilde

XK_acute:

keysym: const XK_acute

XK_adiaeresis:

keysym: const XK_adiaeresis

XK_ae:

keysym: const XK_ae

XK_agrave:

keysym: const XK_agrave

XK_ahook:

keysym: const XK_ahook

XK_Alt_L:

keysym: const XK_Alt_L

XK_Alt_R:

keysym: const XK_Alt_R

XK_amacron:

keysym: const XK_amacron

XK_ampersand:

keysym: const XK_ampersand

XK_aogonek:

keysym: const XK_aogonek

XK_apostrophe:

keysym: const XK_apostrophe

XK_approximate:

keysym: const XK_approximate

XK_Arabic_0:

keysym: const XK_Arabic_0

XK_Arabic_1:

keysym: const XK_Arabic_1

XK_Arabic_2:

keysym: const XK_Arabic_2

XK_Arabic_3:

keysym: const XK_Arabic_3

XK_Arabic_4:

keysym: const XK_Arabic_4

XK_Arabic_5:

keysym: const XK_Arabic_5

XK_Arabic_6:

keysym: const XK_Arabic_6

XK_Arabic_7:

keysym: const XK_Arabic_7

XK_Arabic_8:

keysym: const XK_Arabic_8

XK_Arabic_9:

keysym: const XK_Arabic_9

XK_Arabic_ain:

keysym: const XK_Arabic_ain

XK_Arabic_alef:

keysym: const XK_Arabic_alef

XK_Arabic_alefmaksura:

keysym: const XK_Arabic_alefmaksura

XK_Arabic_beh:

keysym: const XK_Arabic_beh

XK_Arabic_comma:

keysym: const XK_Arabic_comma

XK_Arabic_dad:

keysym: const XK_Arabic_dad

XK_Arabic_dal:

keysym: const XK_Arabic_dal

XK_Arabic_damma:

keysym: const XK_Arabic_damma

XK_Arabic_dammatan:

keysym: const XK_Arabic_dammatan

XK_Arabic_ddal:

keysym: const XK_Arabic_ddal

XK_Arabic_farsi_yeh:

keysym: const XK_Arabic_farsi_yeh

XK_Arabic_fatha:

keysym: const XK_Arabic_fatha

XK_Arabic_fathatan:

keysym: const XK_Arabic_fathatan

XK_Arabic_feh:

keysym: const XK_Arabic_feh

XK_Arabic_fullstop:

keysym: const XK_Arabic_fullstop

XK_Arabic_gaf:

keysym: const XK_Arabic_gaf

XK_Arabic_ghain:

keysym: const XK_Arabic_ghain

XK_Arabic_ha:

keysym: const XK_Arabic_ha

XK_Arabic_hah:

keysym: const XK_Arabic_hah

XK_Arabic_hamza:

keysym: const XK_Arabic_hamza

XK_Arabic_hamza_above:

keysym: const XK_Arabic_hamza_above

XK_Arabic_hamza_below:

keysym: const XK_Arabic_hamza_below

XK_Arabic_hamzaonalef:

keysym: const XK_Arabic_hamzaonalef

XK_Arabic_hamzaonwaw:

keysym: const XK_Arabic_hamzaonwaw

XK_Arabic_hamzaonyeh:

keysym: const XK_Arabic_hamzaonyeh

XK_Arabic_hamzaunderalef:

keysym: const XK_Arabic_hamzaunderalef

XK_Arabic_heh:

keysym: const XK_Arabic_heh

XK_Arabic_heh_doachashmee:

keysym: const XK_Arabic_heh_doachashmee

XK_Arabic_heh_goal:

keysym: const XK_Arabic_heh_goal

XK_Arabic_jeem:

keysym: const XK_Arabic_jeem

XK_Arabic_jeh:

keysym: const XK_Arabic_jeh

XK_Arabic_kaf:

keysym: const XK_Arabic_kaf

XK_Arabic_kasra:

keysym: const XK_Arabic_kasra

XK_Arabic_kasratan:

keysym: const XK_Arabic_kasratan

XK_Arabic_keheh:

keysym: const XK_Arabic_keheh

XK_Arabic_khah:

keysym: const XK_Arabic_khah

XK_Arabic_lam:

keysym: const XK_Arabic_lam

XK_Arabic_madda_above:

keysym: const XK_Arabic_madda_above

XK_Arabic_maddaonalef:

keysym: const XK_Arabic_maddaonalef

XK_Arabic_meem:

keysym: const XK_Arabic_meem

XK_Arabic_noon:

keysym: const XK_Arabic_noon

XK_Arabic_noon_ghunna:

keysym: const XK_Arabic_noon_ghunna

XK_Arabic_peh:

keysym: const XK_Arabic_peh

XK_Arabic_percent:

keysym: const XK_Arabic_percent

XK_Arabic_qaf:

keysym: const XK_Arabic_qaf

XK_Arabic_question_mark:

keysym: const XK_Arabic_question_mark

XK_Arabic_ra:

keysym: const XK_Arabic_ra

XK_Arabic_rreh:

keysym: const XK_Arabic_rreh

XK_Arabic_sad:

keysym: const XK_Arabic_sad

XK_Arabic_seen:

keysym: const XK_Arabic_seen

XK_Arabic_semicolon:

keysym: const XK_Arabic_semicolon

XK_Arabic_shadda:

keysym: const XK_Arabic_shadda

XK_Arabic_sheen:

keysym: const XK_Arabic_sheen

XK_Arabic_sukun:

keysym: const XK_Arabic_sukun

XK_Arabic_superscript_alef:

keysym: const XK_Arabic_superscript_alef

XK_Arabic_switch:

keysym: const XK_Arabic_switch

XK_Arabic_tah:

keysym: const XK_Arabic_tah

XK_Arabic_tatweel:

keysym: const XK_Arabic_tatweel

XK_Arabic_tcheh:

keysym: const XK_Arabic_tcheh

XK_Arabic_teh:

keysym: const XK_Arabic_teh

XK_Arabic_tehmarbuta:

keysym: const XK_Arabic_tehmarbuta

XK_Arabic_thal:

keysym: const XK_Arabic_thal

XK_Arabic_theh:

keysym: const XK_Arabic_theh

XK_Arabic_tteh:

keysym: const XK_Arabic_tteh

XK_Arabic_veh:

keysym: const XK_Arabic_veh

XK_Arabic_waw:

keysym: const XK_Arabic_waw

XK_Arabic_yeh:

keysym: const XK_Arabic_yeh

XK_Arabic_yeh_baree:

keysym: const XK_Arabic_yeh_baree

XK_Arabic_zah:

keysym: const XK_Arabic_zah

XK_Arabic_zain:

keysym: const XK_Arabic_zain

XK_aring:

keysym: const XK_aring

XK_Armenian_accent:

keysym: const XK_Armenian_accent

XK_Armenian_amanak:

keysym: const XK_Armenian_amanak

XK_Armenian_apostrophe:

keysym: const XK_Armenian_apostrophe

XK_Armenian_at:

keysym: const XK_Armenian_at

XK_Armenian_ayb:

keysym: const XK_Armenian_ayb

XK_Armenian_ben:

keysym: const XK_Armenian_ben

XK_Armenian_but:

keysym: const XK_Armenian_but

XK_Armenian_cha:

keysym: const XK_Armenian_cha

XK_Armenian_comma:

keysym: const XK_Armenian_comma

XK_Armenian_da:

keysym: const XK_Armenian_da

XK_Armenian_dot:

keysym: const XK_Armenian_dot

XK_Armenian_dza:

keysym: const XK_Armenian_dza

XK_Armenian_e:

keysym: const XK_Armenian_e

XK_Armenian_ellipsis:

keysym: const XK_Armenian_ellipsis

XK_Armenian_em_dash:

keysym: const XK_Armenian_em_dash

XK_Armenian_en_dash:

keysym: const XK_Armenian_en_dash

XK_Armenian_eternity:

keysym: const XK_Armenian_eternity

XK_Armenian_exclam:

keysym: const XK_Armenian_exclam

XK_Armenian_fe:

keysym: const XK_Armenian_fe

XK_Armenian_full_stop:

keysym: const XK_Armenian_full_stop

XK_Armenian_ghat:

keysym: const XK_Armenian_ghat

XK_Armenian_gim:

keysym: const XK_Armenian_gim

XK_Armenian_guillemotleft:

keysym: const XK_Armenian_guillemotleft

XK_Armenian_guillemotright:

keysym: const XK_Armenian_guillemotright

XK_Armenian_hi:

keysym: const XK_Armenian_hi

XK_Armenian_ho:

keysym: const XK_Armenian_ho

XK_Armenian_hyphen:

keysym: const XK_Armenian_hyphen

XK_Armenian_ini:

keysym: const XK_Armenian_ini

XK_Armenian_je:

keysym: const XK_Armenian_je

XK_Armenian_ke:

keysym: const XK_Armenian_ke

XK_Armenian_ken:

keysym: const XK_Armenian_ken

XK_Armenian_khe:

keysym: const XK_Armenian_khe

XK_Armenian_ligature_ew:

keysym: const XK_Armenian_ligature_ew

XK_Armenian_lyun:

keysym: const XK_Armenian_lyun

XK_Armenian_men:

keysym: const XK_Armenian_men

XK_Armenian_mijaket:

keysym: const XK_Armenian_mijaket

XK_Armenian_nu:

keysym: const XK_Armenian_nu

XK_Armenian_o:

keysym: const XK_Armenian_o

XK_Armenian_parenleft:

keysym: const XK_Armenian_parenleft

XK_Armenian_parenright:

keysym: const XK_Armenian_parenright

XK_Armenian_paruyk:

keysym: const XK_Armenian_paruyk

XK_Armenian_pe:

keysym: const XK_Armenian_pe

XK_Armenian_pyur:

keysym: const XK_Armenian_pyur

XK_Armenian_question:

keysym: const XK_Armenian_question

XK_Armenian_ra:

keysym: const XK_Armenian_ra

XK_Armenian_re:

keysym: const XK_Armenian_re

XK_Armenian_se:

keysym: const XK_Armenian_se

XK_Armenian_section_sign:

keysym: const XK_Armenian_section_sign

XK_Armenian_separation_mark:

keysym: const XK_Armenian_separation_mark

XK_Armenian_sha:

keysym: const XK_Armenian_sha

XK_Armenian_shesht:

keysym: const XK_Armenian_shesht

XK_Armenian_tche:

keysym: const XK_Armenian_tche

XK_Armenian_to:

keysym: const XK_Armenian_to

XK_Armenian_tsa:

keysym: const XK_Armenian_tsa

XK_Armenian_tso:

keysym: const XK_Armenian_tso

XK_Armenian_tyun:

keysym: const XK_Armenian_tyun

XK_Armenian_verjaket:

keysym: const XK_Armenian_verjaket

XK_Armenian_vev:

keysym: const XK_Armenian_vev

XK_Armenian_vo:

keysym: const XK_Armenian_vo

XK_Armenian_vyun:

keysym: const XK_Armenian_vyun

XK_Armenian_yech:

keysym: const XK_Armenian_yech

XK_Armenian_yentamna:

keysym: const XK_Armenian_yentamna

XK_Armenian_za:

keysym: const XK_Armenian_za

XK_Armenian_zhe:

keysym: const XK_Armenian_zhe

XK_asciicircum:

keysym: const XK_asciicircum

XK_asciitilde:

keysym: const XK_asciitilde

XK_asterisk:

keysym: const XK_asterisk

XK_at:

keysym: const XK_at

XK_atilde:

keysym: const XK_atilde

XK_AudibleBell_Enable:

keysym: const XK_AudibleBell_Enable

XK_b:

keysym: const XK_b

Xkb2charsToInt:

xkb: proc Xkb2charsToInt(h, L: int8): int16

XK_babovedot:

keysym: const XK_babovedot

XkbAccessXFeedbackMask:

xkb: const XkbAccessXFeedbackMask

XkbAccessXKeysMask:

xkb: const XkbAccessXKeysMask

XkbAccessXNotify:

xkb: const XkbAccessXNotify

XkbAccessXNotifyEvent:

xkblib: object XkbAccessXNotifyEvent

XkbAccessXNotifyMask:

xkb: const XkbAccessXNotifyMask

XkbAccessXOptionsMask:

xkb: const XkbAccessXOptionsMask

XkbAccessXTimeoutMask:

xkb: const XkbAccessXTimeoutMask

XK_backslash:

keysym: const XK_backslash

XK_BackSpace:

keysym: const XK_BackSpace

XkbAction:

xkb: object XkbAction

XkbActionCtrls:

xkb: proc XkbActionCtrls(a: PXkbCtrlsAction): int16

XkbActionMessage:

xkb: const XkbActionMessage

XkbActionMessageEvent:

xkblib: object XkbActionMessageEvent

XkbActionMessageLength:

xkb: const XkbActionMessageLength

XkbActionMessageMask:

xkb: const XkbActionMessageMask

XkbActionSetCtrls:

xkb: proc XkbActionSetCtrls(a: PXkbCtrlsAction; c: int8)

XkbAddDeviceLedInfo:

xkblib: proc XkbAddDeviceLedInfo(devi: PXkbDeviceInfoPtr; ledClass, ledId: int16): PXkbDeviceLedInfoPtr

XkbAddGeomColor:

xkb: proc XkbAddGeomColor(geom: PXkbGeometryPtr; spec: cstring; pixel: int16): PXkbColorPtr

XkbAddGeomDoodad:

xkb: proc XkbAddGeomDoodad(geom: PXkbGeometryPtr; section: PXkbSectionPtr; name: Atom): PXkbDoodadPtr

XkbAddGeomKey:

xkb: proc XkbAddGeomKey(row: PXkbRowPtr): PXkbKeyPtr

XkbAddGeomKeyAlias:

xkb: proc XkbAddGeomKeyAlias(geom: PXkbGeometryPtr; alias: cstring; float: cstring): PXkbKeyAliasPtr

XkbAddGeomOutline:

xkb: proc XkbAddGeomOutline(shape: PXkbShapePtr; sz_points: int16): PXkbOutlinePtr

XkbAddGeomOverlay:

xkb: proc XkbAddGeomOverlay(section: PXkbSectionPtr; name: Atom; sz_rows: int16): PXkbOverlayPtr

XkbAddGeomOverlayKey:

xkb: proc XkbAddGeomOverlayKey(overlay: PXkbOverlayPtr; row: PXkbOverlayRowPtr; over: cstring; under: cstring): PXkbOverlayKeyPtr

XkbAddGeomOverlayRow:

xkb: proc XkbAddGeomOverlayRow(overlay: PXkbOverlayPtr; row_under: int16; sz_keys: int16): PXkbOverlayRowPtr

XkbAddGeomProperty:

xkb: proc XkbAddGeomProperty(geom: PXkbGeometryPtr; name: cstring; value: cstring): PXkbPropertyPtr

XkbAddGeomRow:

xkb: proc XkbAddGeomRow(section: PXkbSectionPtr; sz_keys: int16): PXkbRowPtr

XkbAddGeomSection:

xkb: proc XkbAddGeomSection(geom: PXkbGeometryPtr; name: Atom; sz_rows: int16; sz_doodads: int16; sz_overlays: int16): PXkbSectionPtr

XkbAddGeomShape:

xkb: proc XkbAddGeomShape(geom: PXkbGeometryPtr; name: Atom; sz_outlines: int16): PXkbShapePtr

XkbAddKeyType:

xkblib: proc XkbAddKeyType(xkb: PXkbDescPtr; name: Atom; map_count: int16; want_preserve: bool; num_lvls: int16): PXkbKeyTypePtr

XkbAddSymInterpret:

xkblib: proc XkbAddSymInterpret(xkb: PXkbDescPtr; si: PXkbSymInterpretPtr; updateMap: bool; changes: PXkbChangesPtr): PXkbSymInterpretPtr

XkbAllAccessXEventsMask:

xkb: const XkbAllAccessXEventsMask

XkbAllActionMessagesMask:

xkb: const XkbAllActionMessagesMask

XkbAllBellEventsMask:

xkb: const XkbAllBellEventsMask

XkbAllBooleanCtrlsMask:

xkb: const XkbAllBooleanCtrlsMask

XkbAllClientInfoMask:

xkb: const XkbAllClientInfoMask

XkbAllCompatMapEventsMask:

xkb: const XkbAllCompatMapEventsMask

XkbAllCompatMask:

xkb: const XkbAllCompatMask

XkbAllComponentsMask:

xkb: const XkbAllComponentsMask

XkbAllControlEventsMask:

xkb: const XkbAllControlEventsMask

XkbAllControlsMask:

xkb: const XkbAllControlsMask

XkbAllEventsMask:

xkb: const XkbAllEventsMask

XkbAllExplicitMask:

xkb: const XkbAllExplicitMask

XkbAllExtensionDeviceEventsMask:

xkb: const XkbAllExtensionDeviceEventsMask

XkbAllGroups:

xkb: const XkbAllGroups

XkbAllGroupsMask:

xkb: const XkbAllGroupsMask

XkbAllIndicatorEventsMask:

xkb: const XkbAllIndicatorEventsMask

XkbAllIndicatorsMask:

xkb: const XkbAllIndicatorsMask

XkbAllMapComponentsMask:

xkb: const XkbAllMapComponentsMask

XkbAllMapEventsMask:

xkb: const XkbAllMapEventsMask

XkbAllModifiersMask:

xkb: const XkbAllModifiersMask

XkbAllNameEventsMask:

xkb: const XkbAllNameEventsMask

XkbAllNamesMask:

xkb: const XkbAllNamesMask

XkbAllNewKeyboardEventsMask:

xkb: const XkbAllNewKeyboardEventsMask

XkbAllocClientMap:

xkblib: proc XkbAllocClientMap(xkb: PXkbDescPtr; which, nTypes: int16): Status

XkbAllocCompatMap:

xkblib: proc XkbAllocCompatMap(xkb: PXkbDescPtr; which, nInterpret: int16): Status

XkbAllocControls:

xkblib: proc XkbAllocControls(xkb: PXkbDescPtr; which: int16): Status

XkbAllocDeviceInfo:

xkblib: proc XkbAllocDeviceInfo(deviceSpec, nButtons, szLeds: int16): PXkbDeviceInfoPtr

XkbAllocGeomColors:

xkb: proc XkbAllocGeomColors(geom: PXkbGeometryPtr; nColors: int16): Status

XkbAllocGeomDoodads:

xkb: proc XkbAllocGeomDoodads(geom: PXkbGeometryPtr; nDoodads: int16): Status

XkbAllocGeometry:

xkb: proc XkbAllocGeometry(xkb: PXkbDescPtr; sizes: PXkbGeometrySizesPtr): Status

XkbAllocGeomKeyAliases:

xkb: proc XkbAllocGeomKeyAliases(geom: PXkbGeometryPtr; nAliases: int16): Status

XkbAllocGeomKeys:

xkb: proc XkbAllocGeomKeys(row: PXkbRowPtr; nKeys: int16): Status

XkbAllocGeomOutlines:

xkb: proc XkbAllocGeomOutlines(shape: PXkbShapePtr; nOL: int16): Status

XkbAllocGeomOverlayKeys:

xkb: proc XkbAllocGeomOverlayKeys(row: PXkbOverlayRowPtr; num_needed: int16): Status

XkbAllocGeomOverlayRows:

xkb: proc XkbAllocGeomOverlayRows(overlay: PXkbOverlayPtr; num_needed: int16): Status

XkbAllocGeomOverlays:

xkb: proc XkbAllocGeomOverlays(section: PXkbSectionPtr; num_needed: int16): Status

XkbAllocGeomPoints:

xkb: proc XkbAllocGeomPoints(ol: PXkbOutlinePtr; nPts: int16): Status

XkbAllocGeomProps:

xkb: proc XkbAllocGeomProps(geom: PXkbGeometryPtr; nProps: int16): Status

XkbAllocGeomRows:

xkb: proc XkbAllocGeomRows(section: PXkbSectionPtr; nRows: int16): Status

XkbAllocGeomSectionDoodads:

xkb: proc XkbAllocGeomSectionDoodads(section: PXkbSectionPtr; nDoodads: int16): Status

XkbAllocGeomSections:

xkb: proc XkbAllocGeomSections(geom: PXkbGeometryPtr; nSections: int16): Status

XkbAllocGeomShapes:

xkb: proc XkbAllocGeomShapes(geom: PXkbGeometryPtr; nShapes: int16): Status

XkbAllocIndicatorMaps:

xkblib: proc XkbAllocIndicatorMaps(xkb: PXkbDescPtr): Status

XkbAllocKeyboard:

xkblib: proc XkbAllocKeyboard(): PXkbDescPtr

XkbAllocNames:

xkblib: proc XkbAllocNames(xkb: PXkbDescPtr; which: int16; nTotalRG, nTotalAliases: int16): Status

XkbAllocServerMap:

xkblib: proc XkbAllocServerMap(xkb: PXkbDescPtr; which, nActions: int16): Status

XK_ballotcross:

keysym: const XK_ballotcross

XkbAllRadioGroupsMask:

xkb: const XkbAllRadioGroupsMask

XkbAllRequiredTypes:

xkb: const XkbAllRequiredTypes

XkbAllServerInfoMask:

xkb: const XkbAllServerInfoMask

XkbAllStateComponentsMask:

xkb: const XkbAllStateComponentsMask

XkbAllStateEventsMask:

xkb: const XkbAllStateEventsMask

XkbAllVirtualModsMask:

xkb: const XkbAllVirtualModsMask

XkbAllXIClasses:

xkb: const XkbAllXIClasses

XkbAllXIIds:

xkb: const XkbAllXIIds

XkbAlphabeticIndex:

xkb: const XkbAlphabeticIndex

XkbAlphabeticMask:

xkb: const XkbAlphabeticMask

XkbAnyAction:

xkb: object XkbAnyAction

XkbAnyActionDataSize:

xkb: const XkbAnyActionDataSize

XkbAnyDoodadRec:

xkb: object XkbAnyDoodadRec

XkbAnyEvent:

xkblib: object XkbAnyEvent

XkbAnyGroup:

xkb: const XkbAnyGroup

XkbAnyGroupMask:

xkb: const XkbAnyGroupMask

XkbApplyCompatMapToKey:

xkblib: proc XkbApplyCompatMapToKey(xkb: PXkbDescPtr; key: KeyCode; changes: PXkbChangesPtr): bool

XkbApplyVirtualModChanges:

xkblib: proc XkbApplyVirtualModChanges(xkb: PXkbDescPtr; changed: int16; changes: PXkbChangesPtr): bool

XK_bar:

keysym: const XK_bar

XkbAudibleBellMask:

xkb: const XkbAudibleBellMask

XkbAX_AllOptionsMask:

xkb: const XkbAX_AllOptionsMask

XkbAX_AnyFeedback:

xkb: proc XkbAX_AnyFeedback(c: PXkbControlsPtr): int16

XkbAX_BKRejectFBMask:

xkb: const XkbAX_BKRejectFBMask

XkbAX_DumbBellFBMask:

xkb: const XkbAX_DumbBellFBMask

XkbAX_FBOptionsMask:

xkb: const XkbAX_FBOptionsMask

XkbAX_FeatureFBMask:

xkb: const XkbAX_FeatureFBMask

XkbAX_IndicatorFBMask:

xkb: const XkbAX_IndicatorFBMask

XkbAX_LatchToLockMask:

xkb: const XkbAX_LatchToLockMask

XkbAXN_AXKWarning:

xkb: const XkbAXN_AXKWarning

XkbAXN_AXKWarningMask:

xkb: const XkbAXN_AXKWarningMask

XkbAXN_BKAccept:

xkb: const XkbAXN_BKAccept

XkbAXN_BKAcceptMask:

xkb: const XkbAXN_BKAcceptMask

XkbAXN_BKReject:

xkb: const XkbAXN_BKReject

XkbAXN_BKRejectMask:

xkb: const XkbAXN_BKRejectMask

XkbAX_NeedFeedback:

xkb: proc XkbAX_NeedFeedback(c: PXkbControlsPtr; w: int16): bool

XkbAX_NeedOption:

xkb: proc XkbAX_NeedOption(c: PXkbControlsPtr; w: int16): int16

XkbAXN_SKAccept:

xkb: const XkbAXN_SKAccept

XkbAXN_SKAcceptMask:

xkb: const XkbAXN_SKAcceptMask

XkbAXN_SKPress:

xkb: const XkbAXN_SKPress

XkbAXN_SKPressMask:

xkb: const XkbAXN_SKPressMask

XkbAXN_SKReject:

xkb: const XkbAXN_SKReject

XkbAXN_SKRejectMask:

xkb: const XkbAXN_SKRejectMask

XkbAXN_SKRelease:

xkb: const XkbAXN_SKRelease

XkbAXN_SKReleaseMask:

xkb: const XkbAXN_SKReleaseMask

XkbAX_SKAcceptFBMask:

xkb: const XkbAX_SKAcceptFBMask

XkbAX_SKOptionsMask:

xkb: const XkbAX_SKOptionsMask

XkbAX_SKPressFBMask:

xkb: const XkbAX_SKPressFBMask

XkbAX_SKRejectFBMask:

xkb: const XkbAX_SKRejectFBMask

XkbAX_SKReleaseFBMask:

xkb: const XkbAX_SKReleaseFBMask

XkbAX_SlowWarnFBMask:

xkb: const XkbAX_SlowWarnFBMask

XkbAX_StickyKeysFBMask:

xkb: const XkbAX_StickyKeysFBMask

XkbAX_TwoKeysMask:

xkb: const XkbAX_TwoKeysMask

XkbBehavior:

xkb: object XkbBehavior

X_kbBell:

xkb: const X_kbBell

XkbBell:

xkblib: proc XkbBell(dpy: PDisplay; win: Window; percent: int16; name: Atom): bool

XkbBellEvent:

xkblib: proc XkbBellEvent(dpy: PDisplay; win: Window; percent: int16; name: Atom): bool

XkbBellNotify:

xkb: const XkbBellNotify

XkbBellNotifyEvent:

xkblib: object XkbBellNotifyEvent

XkbBellNotifyMask:

xkb: const XkbBellNotifyMask

XkbBounceKeysMask:

xkb: const XkbBounceKeysMask

XkbBoundsHeight:

xkb: proc XkbBoundsHeight(b: PXkbBoundsPtr): int16

XkbBoundsRec:

xkb: object XkbBoundsRec

XkbBoundsWidth:

xkb: proc XkbBoundsWidth(b: PXkbBoundsPtr): int16

XkbBuildCoreState:

xkb: proc XkbBuildCoreState(m, g: int): int

XkbChangeControls:

xkblib: proc XkbChangeControls(d: PDisplay; x: PXkbDescPtr; c: PXkbControlsChangesPtr): bool

XkbChangeDeviceInfo:

xkblib: proc XkbChangeDeviceInfo(dpy: PDisplay; desc: PXkbDeviceInfoPtr; changes: PXkbDeviceChangesPtr): bool

XkbChangeEnabledControls:

xkblib: proc XkbChangeEnabledControls(dpy: PDisplay; deviceSpec, affect, values: int16): bool

XkbChangeIndicatorMaps:

xkblib: proc XkbChangeIndicatorMaps(d: PDisplay; x: PXkbDescPtr; c: PXkbIndicatorChangesPtr): bool

XkbChangeMap:

xkblib: proc XkbChangeMap(dpy: PDisplay; desc: PXkbDescPtr; changes: PXkbMapChangesPtr): bool

XkbChangeNames:

xkblib: proc XkbChangeNames(dpy: PDisplay; xkb: PXkbDescPtr; changes: PXkbNameChangesPtr): bool

XkbChangesRec:

xkb: object XkbChangesRec

XkbChangeTypesOfKey:

xkblib: proc XkbChangeTypesOfKey(xkb: PXkbDescPtr; key, num_groups: int16; groups: int16; newTypes: ptr int16; pChanges: PXkbMapChangesPtr): Status

XkbcharToInt:

xkb: proc XkbcharToInt(v: int8): int16

XkbClampIntoRange:

xkb: const XkbClampIntoRange

XkbClientMapMask:

xkb: const XkbClientMapMask

XkbClientMapRec:

xkb: object XkbClientMapRec

XkbCMKeyGroupInfo:

xkb: proc XkbCMKeyGroupInfo(m: PXkbClientMapPtr; k: int16): int8

XkbCMKeyGroupsWidth:

xkb: proc XkbCMKeyGroupsWidth(m: PXkbClientMapPtr; k: int16): int8

XkbCMKeyGroupWidth:

xkb: proc XkbCMKeyGroupWidth(m: PXkbClientMapPtr; k: int16; g: int8): int8

XkbCMKeyNumGroups:

xkb: proc XkbCMKeyNumGroups(m: PXkbClientMapPtr; k: int16): int8

XkbCMKeyNumSyms:

xkb: proc XkbCMKeyNumSyms(m: PXkbClientMapPtr; k: int16): int16

XkbCMKeySymsOffset:

xkb: proc XkbCMKeySymsOffset(m: PXkbClientMapPtr; k: int16): int8

XkbCMKeySymsPtr:

xkb: proc XkbCMKeySymsPtr(m: PXkbClientMapPtr; k: int16): PKeySym

XkbCMKeyType:

xkb: proc XkbCMKeyType(m: PXkbClientMapPtr; k: int16; g: int8): PXkbKeyTypePtr

XkbCMKeyTypeIndex:

xkb: proc XkbCMKeyTypeIndex(m: PXkbClientMapPtr; k: int16; g: int8): int8

XkbColorRec:

xkb: object XkbColorRec

XkbCompatChangesRec:

xkb: object XkbCompatChangesRec

XkbCompatGrabModsMask:

xkb: const XkbCompatGrabModsMask

XkbCompatLookupModsMask:

xkb: const XkbCompatLookupModsMask

XkbCompatMapMask:

xkb: const XkbCompatMapMask

XkbCompatMapNotify:

xkb: const XkbCompatMapNotify

XkbCompatMapNotifyEvent:

xkblib: object XkbCompatMapNotifyEvent

XkbCompatMapNotifyMask:

xkb: const XkbCompatMapNotifyMask

XkbCompatMapRec:

xkb: object XkbCompatMapRec

XkbCompatNameMask:

xkb: const XkbCompatNameMask

XkbCompatStateMask:

xkb: const XkbCompatStateMask

XkbComponentListRec:

xkb: object XkbComponentListRec

XkbComponentNameRec:

xkb: object XkbComponentNameRec

XkbComponentNamesMask:

xkb: const XkbComponentNamesMask

XkbComponentNamesRec:

xkb: object XkbComponentNamesRec

XkbComputeEffectiveMap:

xkblib: proc XkbComputeEffectiveMap(xkb: PXkbDescPtr; theType: PXkbKeyTypePtr; map_rtrn: PByte): bool

XkbComputeRowBounds:

xkb: proc XkbComputeRowBounds(geom: PXkbGeometryPtr; section: PXkbSectionPtr; row: PXkbRowPtr): bool

XkbComputeSectionBounds:

xkb: proc XkbComputeSectionBounds(geom: PXkbGeometryPtr; section: PXkbSectionPtr): bool

XkbComputeShapeBounds:

xkb: proc XkbComputeShapeBounds(shape: PXkbShapePtr): bool

XkbComputeShapeTop:

xkb: proc XkbComputeShapeTop(shape: PXkbShapePtr; bounds: PXkbBoundsPtr): bool

XkbControlsChangesRec:

xkb: object XkbControlsChangesRec

XkbControlsEnabledMask:

xkb: const XkbControlsEnabledMask

XkbControlsMask:

xkb: const XkbControlsMask

XkbControlsNotify:

xkb: const XkbControlsNotify

XkbControlsNotifyEvent:

xkblib: object XkbControlsNotifyEvent

XkbControlsNotifyMask:

xkb: const XkbControlsNotifyMask

XkbControlsRec:

xkb: object XkbControlsRec

XkbCopyKeyType:

xkblib: proc XkbCopyKeyType(from, into: PXkbKeyTypePtr): Status

XkbCopyKeyTypes:

xkblib: proc XkbCopyKeyTypes(from, into: PXkbKeyTypePtr; num_types: int16): Status

XkbCtrlsAction:

xkb: object XkbCtrlsAction

XkbDescRec:

xkb: object XkbDescRec

XkbDeviceBell:

xkblib: proc XkbDeviceBell(dpy: PDisplay; win: Window; deviceSpec, bellClass, bellID, percent: int16; name: Atom): bool

XkbDeviceBellEvent:

xkblib: proc XkbDeviceBellEvent(dpy: PDisplay; win: Window; deviceSpec, bellClass, bellID, percent: int16; name: Atom): bool

XkbDeviceBtnAction:

xkb: object XkbDeviceBtnAction

XkbDeviceChangesRec:

xkb: object XkbDeviceChangesRec

XkbDeviceInfoRec:

xkb: object XkbDeviceInfoRec

XkbDeviceLedChangesRec:

xkb: object XkbDeviceLedChangesRec

XkbDeviceLedInfoRec:

xkb: object XkbDeviceLedInfoRec

XkbDeviceValuatorAction:

xkb: object XkbDeviceValuatorAction

XkbDF_DisableLocks:

xkb: const XkbDF_DisableLocks

XkbDfltXIClass:

xkb: const XkbDfltXIClass

XkbDfltXIId:

xkb: const XkbDfltXIId

XkbDoodadRec:

xkb: object XkbDoodadRec

XK_Begin:

keysym: const XK_Begin

XkbErr_BadClass:

xkb: const XkbErr_BadClass

XkbErr_BadDevice:

xkb: const XkbErr_BadDevice

XkbErr_BadId:

xkb: const XkbErr_BadId

XkbEvent:

xkblib: object XkbEvent

XkbEventCode:

xkb: const XkbEventCode

XkbExplicitAutoRepeatMask:

xkb: const XkbExplicitAutoRepeatMask

XkbExplicitBehaviorMask:

xkb: const XkbExplicitBehaviorMask

XkbExplicitComponentsMask:

xkb: const XkbExplicitComponentsMask

XkbExplicitInterpretMask:

xkb: const XkbExplicitInterpretMask

XkbExplicitKeyType1Mask:

xkb: const XkbExplicitKeyType1Mask

XkbExplicitKeyType2Mask:

xkb: const XkbExplicitKeyType2Mask

XkbExplicitKeyType3Mask:

xkb: const XkbExplicitKeyType3Mask

XkbExplicitKeyType4Mask:

xkb: const XkbExplicitKeyType4Mask

XkbExplicitKeyTypesMask:

xkb: const XkbExplicitKeyTypesMask

XkbExplicitVModMapMask:

xkb: const XkbExplicitVModMapMask

XkbExplicitXIClass:

xkb: proc XkbExplicitXIClass(c: int): bool

XkbExplicitXIDevice:

xkb: proc XkbExplicitXIDevice(c: int): bool

XkbExplicitXIId:

xkb: proc XkbExplicitXIId(c: int): bool

XkbExtensionDeviceNotify:

xkb: const XkbExtensionDeviceNotify

XkbExtensionDeviceNotifyEvent:

xkblib: object XkbExtensionDeviceNotifyEvent

XkbExtensionDeviceNotifyMask:

xkb: const XkbExtensionDeviceNotifyMask

XkbFindOverlayForKey:

xkb: proc XkbFindOverlayForKey(geom: PXkbGeometryPtr; wanted: PXkbSectionPtr; under: cstring): cstring

XkbForceBell:

xkblib: proc XkbForceBell(dpy: PDisplay; percent: int16): bool

XkbForceDeviceBell:

xkblib: proc XkbForceDeviceBell(dpy: PDisplay; deviceSpec, bellClass, bellID, percent: int16): bool

XkbFreeClientMap:

xkblib: proc XkbFreeClientMap(xkb: PXkbDescPtr; what: int16; freeMap: bool)

XkbFreeCompatMap:

xkblib: proc XkbFreeCompatMap(xkib: PXkbDescPtr; which: int16; freeMap: bool)

XkbFreeComponentList:

xkblib: proc XkbFreeComponentList(list: PXkbComponentListPtr)

XkbFreeControls:

xkblib: proc XkbFreeControls(xkb: PXkbDescPtr; which: int16; freeMap: bool)

XkbFreeDeviceInfo:

xkblib: proc XkbFreeDeviceInfo(devi: PXkbDeviceInfoPtr; which: int16; freeDevI: bool)

XkbFreeGeomColors:

xkb: proc XkbFreeGeomColors(geom: PXkbGeometryPtr; first: int16; count: int16; freeAll: bool)

XkbFreeGeomDoodads:

xkb: proc XkbFreeGeomDoodads(doodads: PXkbDoodadPtr; nDoodads: int16; freeAll: bool)

XkbFreeGeometry:

xkb: proc XkbFreeGeometry(geom: PXkbGeometryPtr; which: int16; freeMap: bool)

XkbFreeGeomKeyAliases:

xkb: proc XkbFreeGeomKeyAliases(geom: PXkbGeometryPtr; first: int16; count: int16; freeAll: bool)

XkbFreeGeomKeys:

xkb: proc XkbFreeGeomKeys(row: PXkbRowPtr; first: int16; count: int16; freeAll: bool)

XkbFreeGeomOutlines:

xkb: proc XkbFreeGeomOutlines(shape: PXkbShapePtr; first: int16; count: int16; freeAll: bool)

XkbFreeGeomOverlayKeys:

xkb: proc XkbFreeGeomOverlayKeys(row: PXkbOverlayRowPtr; first: int16; count: int16; freeAll: bool)

XkbFreeGeomOverlayRows:

xkb: proc XkbFreeGeomOverlayRows(overlay: PXkbOverlayPtr; first: int16; count: int16; freeAll: bool)

XkbFreeGeomOverlays:

xkb: proc XkbFreeGeomOverlays(section: PXkbSectionPtr; first: int16; count: int16; freeAll: bool)

XkbFreeGeomPoints:

xkb: proc XkbFreeGeomPoints(outline: PXkbOutlinePtr; first: int16; count: int16; freeAll: bool)

XkbFreeGeomProperties:

xkb: proc XkbFreeGeomProperties(geom: PXkbGeometryPtr; first: int16; count: int16; freeAll: bool)

XkbFreeGeomRows:

xkb: proc XkbFreeGeomRows(section: PXkbSectionPtr; first: int16; count: int16; freeAll: bool)

XkbFreeGeomSections:

xkb: proc XkbFreeGeomSections(geom: PXkbGeometryPtr; first: int16; count: int16; freeAll: bool)

XkbFreeGeomShapes:

xkb: proc XkbFreeGeomShapes(geom: PXkbGeometryPtr; first: int16; count: int16; freeAll: bool)

XkbFreeIndicatorMaps:

xkblib: proc XkbFreeIndicatorMaps(xkb: PXkbDescPtr)

XkbFreeKeyboard:

xkblib: proc XkbFreeKeyboard(xkb: PXkbDescPtr; which: int16; freeDesc: bool)

XkbFreeNames:

xkblib: proc XkbFreeNames(xkb: PXkbDescPtr; which: int16; freeMap: bool)

XkbFreeServerMap:

xkblib: proc XkbFreeServerMap(xkb: PXkbDescPtr; what: int16; freeMap: bool)

XkbGBN_AllComponentsMask:

xkb: const XkbGBN_AllComponentsMask

XkbGBN_ClientSymbolsMask:

xkb: const XkbGBN_ClientSymbolsMask

XkbGBN_CompatMapMask:

xkb: const XkbGBN_CompatMapMask

XkbGBN_GeometryMask:

xkb: const XkbGBN_GeometryMask

XkbGBN_IndicatorMapMask:

xkb: const XkbGBN_IndicatorMapMask

XkbGBN_KeyNamesMask:

xkb: const XkbGBN_KeyNamesMask

XkbGBN_OtherNamesMask:

xkb: const XkbGBN_OtherNamesMask

XkbGBN_ServerSymbolsMask:

xkb: const XkbGBN_ServerSymbolsMask

XkbGBN_SymbolsMask:

xkb: const XkbGBN_SymbolsMask

XkbGBN_TypesMask:

xkb: const XkbGBN_TypesMask

XkbGeomAllMask:

xkb: const XkbGeomAllMask

XkbGeomColorIndex:

xkb: proc XkbGeomColorIndex(g: PXkbGeometryPtr; c: PXkbColorPtr): int32

XkbGeomColorsMask:

xkb: const XkbGeomColorsMask

XkbGeomDoodadsMask:

xkb: const XkbGeomDoodadsMask

XkbGeometryMask:

xkb: const XkbGeometryMask

XkbGeometryNameMask:

xkb: const XkbGeometryNameMask

XkbGeometryRec:

xkb: object XkbGeometryRec

XkbGeometrySizesRec:

xkb: object XkbGeometrySizesRec

XkbGeomKeyAliasesMask:

xkb: const XkbGeomKeyAliasesMask

XkbGeomMaxColors:

xkb: const XkbGeomMaxColors

XkbGeomMaxLabelColors:

xkb: const XkbGeomMaxLabelColors

XkbGeomMaxPriority:

xkb: const XkbGeomMaxPriority

XkbGeomPropertiesMask:

xkb: const XkbGeomPropertiesMask

XkbGeomPtsPerMM:

xkb: const XkbGeomPtsPerMM

XkbGeomSectionsMask:

xkb: const XkbGeomSectionsMask

XkbGeomShapesMask:

xkb: const XkbGeomShapesMask

XkbGetAtomNameFunc:

xkblib: type XkbGetAtomNameFunc

XkbGetAutoRepeatRate:

xkblib: proc XkbGetAutoRepeatRate(dpy: PDisplay; deviceSpec: int16; delayRtrn, intervalRtrn: PWord): bool

XkbGetAutoResetControls:

xkblib: proc XkbGetAutoResetControls(dpy: PDisplay; auto_ctrls, auto_ctrl_values: PWord): bool

X_kbGetCompatMap:

xkb: const X_kbGetCompatMap

XkbGetCompatMap:

xkblib: proc XkbGetCompatMap(dpy: PDisplay; which: int16; xkb: PXkbDescPtr): Status

X_kbGetControls:

xkb: const X_kbGetControls

XkbGetControls:

xkblib: proc XkbGetControls(dpy: PDisplay; which: int32; desc: PXkbDescPtr): Status

XkbGetControlsChanges:

xkblib: proc XkbGetControlsChanges(d: PDisplay; x: PXkbDescPtr; c: PXkbControlsChangesPtr): Status

XkbGetDetectableAutoRepeat:

xkblib: proc XkbGetDetectableAutoRepeat(dpy: PDisplay; supported: ptr bool): bool

XkbGetDeviceButtonActions:

xkblib: proc XkbGetDeviceButtonActions(dpy: PDisplay; devi: PXkbDeviceInfoPtr; all: bool; first, nBtns: int16): Status

XkbGetDeviceIndicatorState:

xkblib: proc XkbGetDeviceIndicatorState(dpy: PDisplay; deviceSpec, ledClass, ledID: int16; pStateRtrn: PWord): Status

X_kbGetDeviceInfo:

xkb: const X_kbGetDeviceInfo

XkbGetDeviceInfo:

xkblib: proc XkbGetDeviceInfo(dpy: PDisplay; which, deviceSpec, ledClass, ledID: int16): PXkbDeviceInfoPtr

XkbGetDeviceInfoChanges:

xkblib: proc XkbGetDeviceInfoChanges(dpy: PDisplay; devi: PXkbDeviceInfoPtr; changes: PXkbDeviceChangesPtr): Status

XkbGetDeviceLedInfo:

xkblib: proc XkbGetDeviceLedInfo(dpy: PDisplay; devi: PXkbDeviceInfoPtr; ledClass, ledId, which: int16): Status

X_kbGetGeometry:

xkb: const X_kbGetGeometry

XkbGetGeometryProc:

xkb: proc XkbGetGeometryProc(dpy: PDisplay; xkb: PXkbDescPtr): Status

X_kbGetIndicatorMap:

xkb: const X_kbGetIndicatorMap

XkbGetIndicatorMap:

xkblib: proc XkbGetIndicatorMap(dpy: PDisplay; which: int32; desc: PXkbDescPtr): Status

XkbGetIndicatorMapChanges:

xkblib: proc XkbGetIndicatorMapChanges(d: PDisplay; x: PXkbDescPtr; c: PXkbIndicatorChangesPtr): Status

X_kbGetIndicatorState:

xkb: const X_kbGetIndicatorState

XkbGetIndicatorState:

xkblib: proc XkbGetIndicatorState(dpy: PDisplay; deviceSpec: int16; pStateRtrn: PWord): Status

X_kbGetKbdByName:

xkb: const X_kbGetKbdByName

XkbGetKeyActions:

xkblib: proc XkbGetKeyActions(dpy: PDisplay; first, num: int16; xkb: PXkbDescPtr): Status

XkbGetKeyBehaviors:

xkblib: proc XkbGetKeyBehaviors(dpy: PDisplay; firstKey, nKeys: int16; desc: PXkbDescPtr): Status

XkbGetKeyboard:

xkblib: proc XkbGetKeyboard(dpy: PDisplay; which, deviceSpec: int16): PXkbDescPtr

XkbGetKeyboardByName:

xkblib: proc XkbGetKeyboardByName(dpy: PDisplay; deviceSpec: int16; names: PXkbComponentNamesPtr; want, need: int16; load: bool): PXkbDescPtr

XkbGetKeyExplicitComponents:

xkblib: proc XkbGetKeyExplicitComponents(dpy: PDisplay; firstKey, nKeys: int16; desc: PXkbDescPtr): Status

XkbGetKeyModifierMap:

xkblib: proc XkbGetKeyModifierMap(dpy: PDisplay; firstKey, nKeys: int16; desc: PXkbDescPtr): Status

XkbGetKeySyms:

xkblib: proc XkbGetKeySyms(dpy: PDisplay; first, num: int16; xkb: PXkbDescPtr): Status

XkbGetKeyTypes:

xkblib: proc XkbGetKeyTypes(dpy: PDisplay; first, num: int16; xkb: PXkbDescPtr): Status

X_kbGetMap:

xkb: const X_kbGetMap

XkbGetMap:

xkblib: proc XkbGetMap(dpy: PDisplay; which, deviceSpec: int16): PXkbDescPtr

XkbGetMapChanges:

xkblib: proc XkbGetMapChanges(dpy: PDisplay; xkb: PXkbDescPtr; changes: PXkbMapChangesPtr): Status

XkbGetNamedDeviceIndicator:

xkblib: proc XkbGetNamedDeviceIndicator(dpy: PDisplay; deviceSpec, ledClass, ledID: int16; name: Atom; pNdxRtrn: ptr int16; pStateRtrn: ptr bool; pMapRtrn: PXkbIndicatorMapPtr; pRealRtrn: ptr bool): bool

XkbGetNamedGeometry:

xkb: proc XkbGetNamedGeometry(dpy: PDisplay; xkb: PXkbDescPtr; name: Atom): Status

X_kbGetNamedIndicator:

xkb: const X_kbGetNamedIndicator

XkbGetNamedIndicator:

xkblib: proc XkbGetNamedIndicator(dpy: PDisplay; name: Atom; pNdxRtrn: ptr int16; pStateRtrn: ptr bool; pMapRtrn: PXkbIndicatorMapPtr; pRealRtrn: ptr bool): bool

X_kbGetNames:

xkb: const X_kbGetNames

XkbGetNames:

xkblib: proc XkbGetNames(dpy: PDisplay; which: int16; desc: PXkbDescPtr): Status

XkbGetPerClientControls:

xkblib: proc XkbGetPerClientControls(dpy: PDisplay; ctrls: PWord): bool

X_kbGetState:

xkb: const X_kbGetState

XkbGetState:

xkblib: proc XkbGetState(dpy: PDisplay; deviceSpec: int16; rtrnState: PXkbStatePtr): Status

XkbGetUpdatedMap:

xkblib: proc XkbGetUpdatedMap(dpy: PDisplay; which: int16; desc: PXkbDescPtr): Status

XkbGetVirtualMods:

xkblib: proc XkbGetVirtualMods(dpy: PDisplay; which: int16; desc: PXkbDescPtr): Status

XkbGetXlibControls:

xkblib: proc XkbGetXlibControls(dpy: PDisplay): int16

XkbGrabModsMask:

xkb: const XkbGrabModsMask

XkbGrabStateFromRec:

xkb: proc XkbGrabStateFromRec(s: PXkbStatePtr): int

XkbGroup1Index:

xkb: const XkbGroup1Index

XkbGroup1Mask:

xkb: const XkbGroup1Mask

XkbGroup2Index:

xkb: const XkbGroup2Index

XkbGroup2Mask:

xkb: const XkbGroup2Mask

XkbGroup3Index:

xkb: const XkbGroup3Index

XkbGroup3Mask:

xkb: const XkbGroup3Mask

XkbGroup4Index:

xkb: const XkbGroup4Index

XkbGroup4Mask:

xkb: const XkbGroup4Mask

XkbGroupAction:

xkb: object XkbGroupAction

XkbGroupBaseMask:

xkb: const XkbGroupBaseMask

XkbGroupCompatMask:

xkb: const XkbGroupCompatMask

XkbGroupForCoreState:

xkb: proc XkbGroupForCoreState(s: int): int

XkbGroupLatchMask:

xkb: const XkbGroupLatchMask

XkbGroupLock:

xkb: proc XkbGroupLock(s: PXkbStatePtr): int8

XkbGroupLockMask:

xkb: const XkbGroupLockMask

XkbGroupNamesMask:

xkb: const XkbGroupNamesMask

XkbGroupStateMask:

xkb: const XkbGroupStateMask

XkbGroupsWrapMask:

xkb: const XkbGroupsWrapMask

XkbIgnoreExtension:

xkblib: proc XkbIgnoreExtension(ignore: bool): bool

XkbIgnoreGroupLockMask:

xkb: const XkbIgnoreGroupLockMask

XkbIgnoreLockModsMask:

xkb: const XkbIgnoreLockModsMask

XkbIM_InUse:

xkb: proc XkbIM_InUse(i: PXkbIndicatorMapPtr): bool

XkbIM_IsAuto:

xkb: proc XkbIM_IsAuto(i: PXkbIndicatorMapPtr): bool

XkbIM_LEDDrivesKB:

xkb: const XkbIM_LEDDrivesKB

XkbIM_NoAutomatic:

xkb: const XkbIM_NoAutomatic

XkbIM_NoExplicit:

xkb: const XkbIM_NoExplicit

XkbIM_UseAnyGroup:

xkb: const XkbIM_UseAnyGroup

XkbIM_UseAnyMods:

xkb: const XkbIM_UseAnyMods

XkbIM_UseBase:

xkb: const XkbIM_UseBase

XkbIM_UseCompat:

xkb: const XkbIM_UseCompat

XkbIM_UseEffective:

xkb: const XkbIM_UseEffective

XkbIM_UseLatched:

xkb: const XkbIM_UseLatched

XkbIM_UseLocked:

xkb: const XkbIM_UseLocked

XkbIM_UseNone:

xkb: const XkbIM_UseNone

XkbIndicatorChangesRec:

xkb: object XkbIndicatorChangesRec

XkbIndicatorDoodad:

xkb: const XkbIndicatorDoodad

XkbIndicatorDoodadOffColor:

xkb: proc XkbIndicatorDoodadOffColor(g: PXkbGeometryPtr; d: PXkbIndicatorDoodadPtr): PXkbColorPtr

XkbIndicatorDoodadOnColor:

xkb: proc XkbIndicatorDoodadOnColor(g: PXkbGeometryPtr; d: PXkbIndicatorDoodadPtr): PXkbColorPtr

XkbIndicatorDoodadRec:

xkb: object XkbIndicatorDoodadRec

XkbIndicatorDoodadShape:

xkb: proc XkbIndicatorDoodadShape(g: PXkbGeometryPtr; d: PXkbIndicatorDoodadPtr): PXkbShapeDoodadPtr

XkbIndicatorMapMask:

xkb: const XkbIndicatorMapMask

XkbIndicatorMapNotify:

xkb: const XkbIndicatorMapNotify

XkbIndicatorMapNotifyMask:

xkb: const XkbIndicatorMapNotifyMask

XkbIndicatorMapRec:

xkb: object XkbIndicatorMapRec

XkbIndicatorNamesMask:

xkb: const XkbIndicatorNamesMask

XkbIndicatorNotifyEvent:

xkblib: object XkbIndicatorNotifyEvent

XkbIndicatorRec:

xkb: object XkbIndicatorRec

XkbIndicatorStateNotify:

xkb: const XkbIndicatorStateNotify

XkbIndicatorStateNotifyMask:

xkb: const XkbIndicatorStateNotifyMask

XkbInitCanonicalKeyTypes:

xkblib: proc XkbInitCanonicalKeyTypes(xkb: PXkbDescPtr; which: int16; keypadVMod: int16): Status

XkbInternalModsMask:

xkb: const XkbInternalModsMask

XkbInternAtomFunc:

xkblib: type XkbInternAtomFunc

XkbIntTo2chars:

xkb: proc XkbIntTo2chars(i: int16; h, L: var int8)

XkbIsGroupAction:

xkb: proc XkbIsGroupAction(a: PXkbAnyAction): bool

XkbIsLegalGroup:

xkb: proc XkbIsLegalGroup(g: int): bool

XkbIsLegalKeycode:

xkb: proc XkbIsLegalKeycode(k: int): bool

XkbIsModAction:

xkb: proc XkbIsModAction(a: PXkbAnyAction): bool

XkbISOAction:

xkb: object XkbISOAction

XkbIsPtrAction:

xkb: proc XkbIsPtrAction(a: PXkbAnyAction): bool

XkbKbdDpyStateRec:

xkblib: object XkbKbdDpyStateRec

XkbKB_Default:

xkb: const XkbKB_Default

XkbKB_Lock:

xkb: const XkbKB_Lock

XkbKB_OpMask:

xkb: const XkbKB_OpMask

XkbKB_Overlay1:

xkb: const XkbKB_Overlay1

XkbKB_Overlay2:

xkb: const XkbKB_Overlay2

XkbKB_Permanent:

xkb: const XkbKB_Permanent

XkbKB_RadioGroup:

xkb: const XkbKB_RadioGroup

XkbKB_RGAllowNone:

xkb: const XkbKB_RGAllowNone

XkbKeyAction:

xkb: proc XkbKeyAction(d: PXkbDescPtr; k: int16; n: int16): PXkbAction

XkbKeyActionEntry:

xkb: proc XkbKeyActionEntry(d: PXkbDescPtr; k: int16; sl: int16; g: int8): int8

XkbKeyActionsMask:

xkb: const XkbKeyActionsMask

XkbKeyActionsPtr:

xkb: proc XkbKeyActionsPtr(d: PXkbDescPtr; k: int16): PXkbAction

XkbKeyAliasesMask:

xkb: const XkbKeyAliasesMask

XkbKeyAliasRec:

xkb: object XkbKeyAliasRec

XkbKeyBehaviorsMask:

xkb: const XkbKeyBehaviorsMask

XkbKeyboard:

xkb: const XkbKeyboard

XkbKeycodeInRange:

xkb: proc XkbKeycodeInRange(d: PXkbDescPtr; k: int16): bool

XkbKeycodesNameMask:

xkb: const XkbKeycodesNameMask

XkbKeycodeToKeysym:

xkblib: proc XkbKeycodeToKeysym(dpy: PDisplay; kc: KeyCode; group, level: int16): KeySym

XkbKeyColor:

xkb: proc XkbKeyColor(g: PXkbGeometryPtr; k: PXkbKeyPtr): PXkbColorPtr

XkbKeyGroupInfo:

xkb: proc XkbKeyGroupInfo(d: PXkbDescPtr; k: int16): int8

XkbKeyGroupsWidth:

xkb: proc XkbKeyGroupsWidth(d: PXkbDescPtr; k: int16): int8

XkbKeyGroupWidth:

xkb: proc XkbKeyGroupWidth(d: PXkbDescPtr; k: int16; g: int8): int8

XkbKeyHasActions:

xkb: proc XkbKeyHasActions(d: PXkbDescPtr; k: int16): bool

XkbKeyKeyType:

xkb: proc XkbKeyKeyType(d: PXkbDescPtr; k: int16; g: int8): PXkbKeyTypePtr

XkbKeyKeyTypeIndex:

xkb: proc XkbKeyKeyTypeIndex(d: PXkbDescPtr; k: int16; g: int8): int8

XkbKeyNameLength:

xkb: const XkbKeyNameLength

XkbKeyNameRec:

xkb: object XkbKeyNameRec

XkbKeyNamesMask:

xkb: const XkbKeyNamesMask

XkbKeyNumActions:

xkb: proc XkbKeyNumActions(d: PXkbDescPtr; k: int16): int16

XkbKeyNumGroups:

xkb: proc XkbKeyNumGroups(d: PXkbDescPtr; k: int16): int8

XkbKeyNumSyms:

xkb: proc XkbKeyNumSyms(d: PXkbDescPtr; k: int16): int16

XkbKeypadIndex:

xkb: const XkbKeypadIndex

XkbKeypadMask:

xkb: const XkbKeypadMask

XkbKeyRec:

xkb: object XkbKeyRec

XkbKeyShape:

xkb: proc XkbKeyShape(g: PXkbGeometryPtr; k: PXkbKeyPtr): PXkbShapeDoodadPtr

XkbKeySym:

xkb: proc XkbKeySym(d: PXkbDescPtr; k: int16; n: int16): KeySym

XkbKeySymEntry:

xkb: proc XkbKeySymEntry(d: PXkbDescPtr; k: int16; sl: int16; g: int8): KeySym

XkbKeySymsMask:

xkb: const XkbKeySymsMask

XkbKeySymsPtr:

xkb: proc XkbKeySymsPtr(d: PXkbDescPtr; k: int16): PKeySym

XkbKeysymToModifiers:

xkblib: proc XkbKeysymToModifiers(dpy: PDisplay; ks: KeySym): int16

XkbKeyTypeNamesMask:

xkb: const XkbKeyTypeNamesMask

XkbKeyTypeRec:

xkb: object XkbKeyTypeRec

XkbKeyTypesForCoreSymbols:

xkblib: proc XkbKeyTypesForCoreSymbols(xkb: PXkbDescPtr; map_width: int16; core_syms: PKeySym; protected: int16; types_inout: ptr int16; xkb_syms_rtrn: PKeySym): int16

XkbKeyTypesMask:

xkb: const XkbKeyTypesMask

XkbKTLevelNamesMask:

xkb: const XkbKTLevelNamesMask

XkbKTMapEntryRec:

xkb: object XkbKTMapEntryRec

XkbLastRequiredType:

xkb: const XkbLastRequiredType

XkbLatchGroup:

xkblib: proc XkbLatchGroup(dpy: PDisplay; deviceSpec, group: int16): bool

X_kbLatchLockState:

xkb: const X_kbLatchLockState

XkbLatchModifiers:

xkblib: proc XkbLatchModifiers(dpy: PDisplay; deviceSpec, affect, values: int16): bool

XkbLC_AllComposeControls:

xkblib: const XkbLC_AllComposeControls

XkbLC_AllControls:

xkblib: const XkbLC_AllControls

XkbLC_AlphanumericKeys:

xkb: const XkbLC_AlphanumericKeys

XkbLC_AlternateGroup:

xkb: const XkbLC_AlternateGroup

XkbLC_AlwaysConsumeShiftAndLock:

xkblib: const XkbLC_AlwaysConsumeShiftAndLock

XkbLC_BeepOnComposeFail:

xkblib: const XkbLC_BeepOnComposeFail

XkbLC_ComposeLED:

xkblib: const XkbLC_ComposeLED

XkbLC_ConsumeKeysOnComposeFail:

xkblib: const XkbLC_ConsumeKeysOnComposeFail

XkbLC_ConsumeLookupMods:

xkblib: const XkbLC_ConsumeLookupMods

XkbLC_ControlFallback:

xkblib: const XkbLC_ControlFallback

XkbLC_Default:

xkb: const XkbLC_Default

XkbLC_ForceLatin1Lookup:

xkblib: const XkbLC_ForceLatin1Lookup

XkbLC_FunctionKeys:

xkb: const XkbLC_FunctionKeys

XkbLC_Hidden:

xkb: const XkbLC_Hidden

XkbLC_IgnoreNewKeyboards:

xkblib: const XkbLC_IgnoreNewKeyboards

XkbLC_KeypadKeys:

xkb: const XkbLC_KeypadKeys

XkbLC_ModifierKeys:

xkb: const XkbLC_ModifierKeys

XkbLC_Partial:

xkb: const XkbLC_Partial

XkbLegalXIBellClass:

xkb: proc XkbLegalXIBellClass(c: int): bool

XkbLegalXILedClass:

xkb: proc XkbLegalXILedClass(c: int): bool

XkbLibraryVersion:

xkblib: proc XkbLibraryVersion(libMajorRtrn, libMinorRtrn: ptr int16): bool

X_kbListComponents:

xkb: const X_kbListComponents

XkbListComponents:

xkblib: proc XkbListComponents(dpy: PDisplay; deviceSpec: int16; ptrns: PXkbComponentNamesPtr; max_inout: ptr int16): PXkbComponentListPtr

XkbLockGroup:

xkblib: proc XkbLockGroup(dpy: PDisplay; deviceSpec, group: int16): bool

XkbLockModifiers:

xkblib: proc XkbLockModifiers(dpy: PDisplay; deviceSpec, affect, values: int16): bool

XkbLogoDoodad:

xkb: const XkbLogoDoodad

XkbLogoDoodadColor:

xkb: proc XkbLogoDoodadColor(g: PXkbGeometryPtr; d: PXkbLogoDoodadPtr): PXkbColorPtr

XkbLogoDoodadRec:

xkb: object XkbLogoDoodadRec

XkbLogoDoodadShape:

xkb: proc XkbLogoDoodadShape(g: PXkbGeometryPtr; d: PXkbLogoDoodadPtr): PXkbShapeDoodadPtr

XkbLookupKeyBinding:

xkblib: proc XkbLookupKeyBinding(dpy: PDisplay; sym_rtrn: KeySym; mods: int16; buffer: cstring; nbytes: int16; extra_rtrn: ptr int16): int16

XkbLookupKeySym:

xkblib: proc XkbLookupKeySym(dpy: PDisplay; keycode: KeyCode; modifiers, modifiers_return: int16; keysym_return: PKeySym): bool

XkbLookupModsMask:

xkb: const XkbLookupModsMask

XkbMajorVersion:

xkb: const XkbMajorVersion

XkbMapChangesRec:

xkb: object XkbMapChangesRec

XkbMapNotify:

xkb: const XkbMapNotify

XkbMapNotifyEvent:

xkblib: object XkbMapNotifyEvent

XkbMapNotifyMask:

xkb: const XkbMapNotifyMask

XkbMaxKbdGroup:

xkb: const XkbMaxKbdGroup

XkbMaxKeyCount:

xkb: const XkbMaxKeyCount

XkbMaxKeyTypes:

xkb: const XkbMaxKeyTypes

XkbMaxLegalKeyCode:

xkb: const XkbMaxLegalKeyCode

XkbMaxMouseKeysBtn:

xkb: const XkbMaxMouseKeysBtn

XkbMaxRadioGroups:

xkb: const XkbMaxRadioGroups

XkbMaxRedirectCount:

xkb: const XkbMaxRedirectCount

XkbMaxShiftLevel:

xkb: const XkbMaxShiftLevel

XkbMaxSymsPerKey:

xkb: const XkbMaxSymsPerKey

XkbMessageAction:

xkb: object XkbMessageAction

XkbMinLegalKeyCode:

xkb: const XkbMinLegalKeyCode

XkbMinorVersion:

xkb: const XkbMinorVersion

XkbModAction:

xkb: object XkbModAction

XkbModActionVMods:

xkb: proc XkbModActionVMods(a: PXkbModAction): int16

XkbModifierBaseMask:

xkb: const XkbModifierBaseMask

XkbModifierLatchMask:

xkb: const XkbModifierLatchMask

XkbModifierLockMask:

xkb: const XkbModifierLockMask

XkbModifierMapMask:

xkb: const XkbModifierMapMask

XkbModifierStateMask:

xkb: const XkbModifierStateMask

XkbModLocks:

xkb: proc XkbModLocks(s: PXkbStatePtr): int8

XkbModsRec:

xkb: object XkbModsRec

XkbMouseKeysAccelMask:

xkb: const XkbMouseKeysAccelMask

XkbMouseKeysMask:

xkb: const XkbMouseKeysMask

XkbName:

xkb: const XkbName

XkbNameChangesRec:

xkb: object XkbNameChangesRec

XkbNamesMask:

xkb: const XkbNamesMask

XkbNamesNotify:

xkb: const XkbNamesNotify

XkbNamesNotifyEvent:

xkblib: object XkbNamesNotifyEvent

XkbNamesNotifyMask:

xkb: const XkbNamesNotifyMask

XkbNamesRec:

xkb: object XkbNamesRec

XkbNewKeyboardNotify:

xkb: const XkbNewKeyboardNotify

XkbNewKeyboardNotifyEvent:

xkblib: object XkbNewKeyboardNotifyEvent

XkbNewKeyboardNotifyMask:

xkb: const XkbNewKeyboardNotifyMask

XkbNKN_DeviceIDMask:

xkb: const XkbNKN_DeviceIDMask

XkbNKN_GeometryMask:

xkb: const XkbNKN_GeometryMask

XkbNKN_KeycodesMask:

xkb: const XkbNKN_KeycodesMask

XkbNoIndicator:

xkb: const XkbNoIndicator

XkbNoModifier:

xkb: const XkbNoModifier

XkbNoModifierMask:

xkb: const XkbNoModifierMask

XkbNoShape:

xkb: const XkbNoShape

XkbNoShiftLevel:

xkb: const XkbNoShiftLevel

XkbNoteControlsChanges:

xkblib: proc XkbNoteControlsChanges(old: PXkbControlsChangesPtr; new: PXkbControlsNotifyEvent; wanted: int16)

XkbNoteDeviceChanges:

xkblib: proc XkbNoteDeviceChanges(old: PXkbDeviceChangesPtr; new: PXkbExtensionDeviceNotifyEvent; wanted: int16)

XkbNoteIndicatorMapChanges:

xkblib: proc XkbNoteIndicatorMapChanges(o, n: PXkbIndicatorChangesPtr; w: int16)

XkbNoteIndicatorStateChanges:

xkblib: proc XkbNoteIndicatorStateChanges(o, n: PXkbIndicatorChangesPtr; w: int16)

XkbNoteMapChanges:

xkblib: proc XkbNoteMapChanges(old: PXkbMapChangesPtr; new: PXkbMapNotifyEvent; wanted: int16)

XkbNoteNameChanges:

xkblib: proc XkbNoteNameChanges(old: PXkbNameChangesPtr; new: PXkbNamesNotifyEvent; wanted: int16)

XkbNumberErrors:

xkb: const XkbNumberErrors

XkbNumberEvents:

xkb: const XkbNumberEvents

XkbNumGroups:

xkb: proc XkbNumGroups(g: int16): int16

XkbNumIndicators:

xkb: const XkbNumIndicators

XkbNumKbdGroups:

xkb: const XkbNumKbdGroups

XkbNumKeys:

xkb: proc XkbNumKeys(d: PXkbDescPtr): int8

XkbNumModifiers:

xkb: const XkbNumModifiers

XkbNumRequiredTypes:

xkb: const XkbNumRequiredTypes

XkbNumVirtualMods:

xkb: const XkbNumVirtualMods

XkbOD_BadLibraryVersion:

xkblib: const XkbOD_BadLibraryVersion

XkbOD_BadServerVersion:

xkblib: const XkbOD_BadServerVersion

XkbOD_ConnectionRefused:

xkblib: const XkbOD_ConnectionRefused

XkbOD_NonXkbServer:

xkblib: const XkbOD_NonXkbServer

XkbOD_Success:

xkblib: const XkbOD_Success

XkbOneLevelIndex:

xkb: const XkbOneLevelIndex

XkbOneLevelMask:

xkb: const XkbOneLevelMask

XkbOpenDisplay:

xkblib: proc XkbOpenDisplay(name: cstring; ev_rtrn, err_rtrn, major_rtrn, minor_rtrn, reason: ptr int16): PDisplay

XK_botintegral:

keysym: const XK_botintegral

XK_botleftparens:

keysym: const XK_botleftparens

XK_botleftsqbracket:

keysym: const XK_botleftsqbracket

XK_botleftsummation:

keysym: const XK_botleftsummation

XK_botrightparens:

keysym: const XK_botrightparens

XK_botrightsqbracket:

keysym: const XK_botrightsqbracket

XK_botrightsummation:

keysym: const XK_botrightsummation

XK_botvertsummationconnector:

keysym: const XK_botvertsummationconnector

XK_BounceKeys_Enable:

keysym: const XK_BounceKeys_Enable

XkbOutlineDoodad:

xkb: const XkbOutlineDoodad

XkbOutlineIndex:

xkb: proc XkbOutlineIndex(s: PXkbShapePtr; o: PXkbOutlinePtr): int32

XkbOutlineRec:

xkb: object XkbOutlineRec

XkbOutOfRangeGroupAction:

xkb: proc XkbOutOfRangeGroupAction(g: int16): int16

XkbOutOfRangeGroupInfo:

xkb: proc XkbOutOfRangeGroupInfo(g: int16): int16

XkbOutOfRangeGroupNumber:

xkb: proc XkbOutOfRangeGroupNumber(g: int16): int16

XkbOverlay1Mask:

xkb: const XkbOverlay1Mask

XkbOverlay2Mask:

xkb: const XkbOverlay2Mask

XkbOverlayKeyRec:

xkb: object XkbOverlayKeyRec

XkbOverlayRec:

xkb: object XkbOverlayRec

XkbOverlayRowRec:

xkb: object XkbOverlayRowRec

XkbPCF_AllFlagsMask:

xkb: const XkbPCF_AllFlagsMask

XkbPCF_AutoResetControlsMask:

xkb: const XkbPCF_AutoResetControlsMask

XkbPCF_DetectableAutoRepeatMask:

xkb: const XkbPCF_DetectableAutoRepeatMask

XkbPCF_GrabsUseXKBStateMask:

xkb: const XkbPCF_GrabsUseXKBStateMask

XkbPCF_LookupStateWhenGrabbed:

xkb: const XkbPCF_LookupStateWhenGrabbed

XkbPCF_SendEventUsesXKBState:

xkb: const XkbPCF_SendEventUsesXKBState

X_kbPerClientFlags:

xkb: const X_kbPerClientFlags

XkbPerKeyBitArraySize:

xkb: const XkbPerKeyBitArraySize

XkbPerKeyRepeatMask:

xkb: const XkbPerKeyRepeatMask

XkbPhysSymbolsNameMask:

xkb: const XkbPhysSymbolsNameMask

XkbPointerButtonMask:

xkb: const XkbPointerButtonMask

XkbPointRec:

xkb: object XkbPointRec

XkbPropertyRec:

xkb: object XkbPropertyRec

XkbPtrAction:

xkb: object XkbPtrAction

XkbPtrActionX:

xkb: proc XkbPtrActionX(a: PXkbPtrAction): int16

XkbPtrActionY:

xkb: proc XkbPtrActionY(a: PXkbPtrAction): int16

XkbPtrBtnAction:

xkb: object XkbPtrBtnAction

XkbPtrDfltAction:

xkb: object XkbPtrDfltAction

XkbQueryExtension:

xkblib: proc XkbQueryExtension(dpy: PDisplay; opcodeReturn, eventBaseReturn, errorBaseReturn, majorRtrn, minorRtrn: ptr int16): bool

XK_braceleft:

keysym: const XK_braceleft

XK_braceright:

keysym: const XK_braceright

XK_bracketleft:

keysym: const XK_bracketleft

XK_bracketright:

keysym: const XK_bracketright

XK_Break:

keysym: const XK_Break

XkbRedirectIntoRange:

xkb: const XkbRedirectIntoRange

XkbRedirectKeyAction:

xkb: object XkbRedirectKeyAction

XkbRefreshKeyboardMapping:

xkblib: proc XkbRefreshKeyboardMapping(event: PXkbMapNotifyEvent): Status

XkbRepeatKeysMask:

xkb: const XkbRepeatKeysMask

XkbResizeDeviceButtonActions:

xkblib: proc XkbResizeDeviceButtonActions(devi: PXkbDeviceInfoPtr; newTotal: int16): Status

XkbResizeKeyActions:

xkblib: proc XkbResizeKeyActions(desc: PXkbDescPtr; forKey, actsNeeded: int16): PXkbAction

XkbResizeKeySyms:

xkblib: proc XkbResizeKeySyms(desc: PXkbDescPtr; forKey, symsNeeded: int16): PKeySym

XkbResizeKeyType:

xkblib: proc XkbResizeKeyType(xkb: PXkbDescPtr; type_ndx, map_count: int16; want_preserve: bool; new_num_lvls: int16): Status

XK_breve:

keysym: const XK_breve

XkbRGMaxMembers:

xkb: const XkbRGMaxMembers

XkbRGNamesMask:

xkb: const XkbRGNamesMask

XK_brokenbar:

keysym: const XK_brokenbar

XkbRowRec:

xkb: object XkbRowRec

XkbSA_ActionMessage:

xkb: const XkbSA_ActionMessage

XkbSA_AffectDfltBtn:

xkb: const XkbSA_AffectDfltBtn

XkbSA_BreakLatch:

xkb: const XkbSA_BreakLatch

XkbSA_ClearLocks:

xkb: const XkbSA_ClearLocks

XkbSA_DeviceBtn:

xkb: const XkbSA_DeviceBtn

XkbSA_DeviceValuator:

xkb: const XkbSA_DeviceValuator

XkbSA_DfltBtnAbsolute:

xkb: const XkbSA_DfltBtnAbsolute

XkbSAGroup:

xkb: proc XkbSAGroup(a: PXkbGroupAction): int8

XkbSA_GroupAbsolute:

xkb: const XkbSA_GroupAbsolute

XkbSA_IgnoreVal:

xkb: const XkbSA_IgnoreVal

XkbSA_ISOAffectMask:

xkb: const XkbSA_ISOAffectMask

XkbSA_ISODfltIsGroup:

xkb: const XkbSA_ISODfltIsGroup

XkbSA_ISOLock:

xkb: const XkbSA_ISOLock

XkbSA_ISONoAffectCtrls:

xkb: const XkbSA_ISONoAffectCtrls

XkbSA_ISONoAffectGroup:

xkb: const XkbSA_ISONoAffectGroup

XkbSA_ISONoAffectMods:

xkb: const XkbSA_ISONoAffectMods

XkbSA_ISONoAffectPtr:

xkb: const XkbSA_ISONoAffectPtr

XkbSA_LastAction:

xkb: const XkbSA_LastAction

XkbSA_LatchGroup:

xkb: const XkbSA_LatchGroup

XkbSA_LatchMods:

xkb: const XkbSA_LatchMods

XkbSA_LatchToLock:

xkb: const XkbSA_LatchToLock

XkbSA_LockControls:

xkb: const XkbSA_LockControls

XkbSA_LockDeviceBtn:

xkb: const XkbSA_LockDeviceBtn

XkbSA_LockGroup:

xkb: const XkbSA_LockGroup

XkbSA_LockMods:

xkb: const XkbSA_LockMods

XkbSA_LockNoLock:

xkb: const XkbSA_LockNoLock

XkbSA_LockNoUnlock:

xkb: const XkbSA_LockNoUnlock

XkbSA_LockPtrBtn:

xkb: const XkbSA_LockPtrBtn

XkbSA_MessageGenKeyEvent:

xkb: const XkbSA_MessageGenKeyEvent

XkbSA_MessageOnPress:

xkb: const XkbSA_MessageOnPress

XkbSA_MessageOnRelease:

xkb: const XkbSA_MessageOnRelease

XkbSA_MoveAbsoluteX:

xkb: const XkbSA_MoveAbsoluteX

XkbSA_MoveAbsoluteY:

xkb: const XkbSA_MoveAbsoluteY

XkbSA_MovePtr:

xkb: const XkbSA_MovePtr

XkbSA_NoAcceleration:

xkb: const XkbSA_NoAcceleration

XkbSA_NoAction:

xkb: const XkbSA_NoAction

XkbSA_NumActions:

xkb: const XkbSA_NumActions

XkbSA_PtrBtn:

xkb: const XkbSA_PtrBtn

XkbSAPtrDfltValue:

xkb: proc XkbSAPtrDfltValue(a: PXkbPtrDfltAction): int8

XkbSA_RedirectKey:

xkb: const XkbSA_RedirectKey

XkbSARedirectSetVMods:

xkb: proc XkbSARedirectSetVMods(a: PXkbRedirectKeyAction; m: int8)

XkbSARedirectSetVModsMask:

xkb: proc XkbSARedirectSetVModsMask(a: PXkbRedirectKeyAction; m: int8)

XkbSARedirectVMods:

xkb: proc XkbSARedirectVMods(a: PXkbRedirectKeyAction): int16

XkbSARedirectVModsMask:

xkb: proc XkbSARedirectVModsMask(a: PXkbRedirectKeyAction): int16

XkbSAScreen:

xkb: proc XkbSAScreen(a: PXkbSwitchScreenAction): int8

XkbSA_SetControls:

xkb: const XkbSA_SetControls

XkbSA_SetGroup:

xkb: const XkbSA_SetGroup

XkbSASetGroupProc:

xkb: proc XkbSASetGroupProc(a: PXkbGroupAction; g: int8)

XkbSA_SetMods:

xkb: const XkbSA_SetMods

XkbSA_SetPtrDflt:

xkb: const XkbSA_SetPtrDflt

XkbSASetPtrDfltValue:

xkb: proc XkbSASetPtrDfltValue(a: PXkbPtrDfltAction; c: pointer)

XkbSASetScreen:

xkb: proc XkbSASetScreen(a: PXkbSwitchScreenAction; s: pointer)

XkbSA_SetValAbsolute:

xkb: const XkbSA_SetValAbsolute

XkbSA_SetValCenter:

xkb: const XkbSA_SetValCenter

XkbSA_SetValMax:

xkb: const XkbSA_SetValMax

XkbSA_SetValMin:

xkb: const XkbSA_SetValMin

XkbSA_SetValRelative:

xkb: const XkbSA_SetValRelative

XkbSA_SwitchAbsolute:

xkb: const XkbSA_SwitchAbsolute

XkbSA_SwitchApplication:

xkb: const XkbSA_SwitchApplication

XkbSA_SwitchScreen:

xkb: const XkbSA_SwitchScreen

XkbSA_Terminate:

xkb: const XkbSA_Terminate

XkbSA_UseDfltButton:

xkb: const XkbSA_UseDfltButton

XkbSA_UseModMapMods:

xkb: const XkbSA_UseModMapMods

XkbSA_ValOp:

xkb: proc XkbSA_ValOp(a: int): int

XkbSA_ValOpMask:

xkb: const XkbSA_ValOpMask

XkbSA_ValScale:

xkb: proc XkbSA_ValScale(a: int): int

XkbSA_ValScaleMask:

xkb: const XkbSA_ValScaleMask

XkbSA_XFree86Private:

xkb: const XkbSA_XFree86Private

XkbSectionRec:

xkb: object XkbSectionRec

XkbSelectEventDetails:

xkblib: proc XkbSelectEventDetails(dpy: PDisplay; deviceID, eventType: int16; affect, details: int32): bool

X_kbSelectEvents:

xkb: const X_kbSelectEvents

XkbSelectEvents:

xkblib: proc XkbSelectEvents(dpy: PDisplay; deviceID, affect, values: int16): bool

XkbServerMapMask:

xkb: const XkbServerMapMask

XkbServerMapRec:

xkb: object XkbServerMapRec

XkbSetAtomFuncs:

xkblib: proc XkbSetAtomFuncs(getAtom: XkbInternAtomFunc; getName: XkbGetAtomNameFunc)

XkbSetAutoRepeatRate:

xkblib: proc XkbSetAutoRepeatRate(dpy: PDisplay; deviceSpec, delay, interval: int16): bool

XkbSetAutoResetControls:

xkblib: proc XkbSetAutoResetControls(dpy: PDisplay; changes: int16; auto_ctrls, auto_values: PWord): bool

X_kbSetCompatMap:

xkb: const X_kbSetCompatMap

XkbSetCompatMap:

xkblib: proc XkbSetCompatMap(dpy: PDisplay; which: int16; xkb: PXkbDescPtr; updateActions: bool): bool

X_kbSetControls:

xkb: const X_kbSetControls

XkbSetControls:

xkblib: proc XkbSetControls(dpy: PDisplay; which: int32; desc: PXkbDescPtr): bool

X_kbSetDebuggingFlags:

xkb: const X_kbSetDebuggingFlags

XkbSetDebuggingFlags:

xkblib: proc XkbSetDebuggingFlags(dpy: PDisplay; mask, flags: int16; msg: cstring; ctrls_mask, ctrls, rtrn_flags, rtrn_ctrls: int16): bool

XkbSetDetectableAutoRepeat:

xkblib: proc XkbSetDetectableAutoRepeat(dpy: PDisplay; detectable: bool; supported: ptr bool): bool

XkbSetDeviceButtonActions:

xkblib: proc XkbSetDeviceButtonActions(dpy: PDisplay; devi: PXkbDeviceInfoPtr; first, nBtns: int16): bool

X_kbSetDeviceInfo:

xkb: const X_kbSetDeviceInfo

XkbSetDeviceInfo:

xkblib: proc XkbSetDeviceInfo(dpy: PDisplay; which: int16; devi: PXkbDeviceInfoPtr): bool

XkbSetDeviceLedInfo:

xkblib: proc XkbSetDeviceLedInfo(dpy: PDisplay; devi: PXkbDeviceInfoPtr; ledClass, ledID, which: int16): bool

X_kbSetGeometry:

xkb: const X_kbSetGeometry

XkbSetGeometryProc:

xkb: proc XkbSetGeometryProc(dpy: PDisplay; deviceSpec: int16; geom: PXkbGeometryPtr): Status

XkbSetGroupInfo:

xkb: proc XkbSetGroupInfo(g, w, n: int16): int16

XkbSetIgnoreLockMods:

xkblib: proc XkbSetIgnoreLockMods(dpy: PDisplay; deviceSpec, affectReal, realValues, affectVirtual, virtualValues: int16): bool

XkbSetIndicatorDoodadOffColor:

xkb: proc XkbSetIndicatorDoodadOffColor(g: PXkbGeometryPtr; d: PXkbIndicatorDoodadPtr; c: PXkbColorPtr)

XkbSetIndicatorDoodadOnColor:

xkb: proc XkbSetIndicatorDoodadOnColor(g: PXkbGeometryPtr; d: PXkbIndicatorDoodadPtr; c: PXkbColorPtr)

XkbSetIndicatorDoodadShape:

xkb: proc XkbSetIndicatorDoodadShape(g: PXkbGeometryPtr; d: PXkbIndicatorDoodadPtr; s: PXkbShapeDoodadPtr)

X_kbSetIndicatorMap:

xkb: const X_kbSetIndicatorMap

XkbSetIndicatorMap:

xkblib: proc XkbSetIndicatorMap(dpy: PDisplay; which: int32; desc: PXkbDescPtr): bool

XkbSetKeyColor:

xkb: proc XkbSetKeyColor(g: PXkbGeometryPtr; k: PXkbKeyPtr; c: PXkbColorPtr)

XkbSetKeyShape:

xkb: proc XkbSetKeyShape(g: PXkbGeometryPtr; k: PXkbKeyPtr; s: PXkbShapeDoodadPtr)

XkbSetLogoDoodadColor:

xkb: proc XkbSetLogoDoodadColor(g: PXkbGeometryPtr; d: PXkbLogoDoodadPtr; c: PXkbColorPtr)

XkbSetLogoDoodadShape:

xkb: proc XkbSetLogoDoodadShape(g: PXkbGeometryPtr; d: PXkbLogoDoodadPtr; s: PXkbShapeDoodadPtr)

X_kbSetMap:

xkb: const X_kbSetMap

XkbSetMap:

xkblib: proc XkbSetMap(dpy: PDisplay; which: int16; desc: PXkbDescPtr): bool

XkbSetModActionVMods:

xkb: proc XkbSetModActionVMods(a: PXkbModAction; v: int8)

XkbSetNamedDeviceIndicator:

xkblib: proc XkbSetNamedDeviceIndicator(dpy: PDisplay; deviceSpec, ledClass, ledID: int16; name: Atom; changeState, state, createNewMap: bool; pMap: PXkbIndicatorMapPtr): bool

X_kbSetNamedIndicator:

xkb: const X_kbSetNamedIndicator

XkbSetNamedIndicator:

xkblib: proc XkbSetNamedIndicator(dpy: PDisplay; name: Atom; changeState, state, createNewMap: bool; pMap: PXkbIndicatorMapPtr): bool

X_kbSetNames:

xkb: const X_kbSetNames

XkbSetNames:

xkblib: proc XkbSetNames(dpy: PDisplay; which, firstType, nTypes: int16; desc: PXkbDescPtr): bool

XkbSetNumGroups:

xkb: proc XkbSetNumGroups(g, n: int16): int16

XkbSetPerClientControls:

xkblib: proc XkbSetPerClientControls(dpy: PDisplay; change: int16; values: PWord): bool

XkbSetPtrActionX:

xkb: proc XkbSetPtrActionX(a: PXkbPtrAction; x: int8)

XkbSetPtrActionY:

xkb: proc XkbSetPtrActionY(a: PXkbPtrAction; y: int8)

XkbSetServerInternalMods:

xkblib: proc XkbSetServerInternalMods(dpy: PDisplay; deviceSpec, affectReal, realValues, affectVirtual, virtualValues: int16): bool

XkbSetShapeDoodadColor:

xkb: proc XkbSetShapeDoodadColor(g: PXkbGeometryPtr; d: PXkbShapeDoodadPtr; c: PXkbColorPtr)

XkbSetShapeDoodadShape:

xkb: proc XkbSetShapeDoodadShape(g: PXkbGeometryPtr; d: PXkbShapeDoodadPtr; s: PXkbShapePtr)

XkbSetTextDoodadColor:

xkb: proc XkbSetTextDoodadColor(g: PXkbGeometryPtr; d: PXkbTextDoodadPtr; c: PXkbColorPtr)

XkbSetXlibControls:

xkblib: proc XkbSetXlibControls(dpy: PDisplay; affect, values: int16): int16

XkbShapeDoodadColor:

xkb: proc XkbShapeDoodadColor(g: PXkbGeometryPtr; d: PXkbShapeDoodadPtr): PXkbColorPtr

XkbShapeDoodadRec:

xkb: object XkbShapeDoodadRec

XkbShapeDoodadShape:

xkb: proc XkbShapeDoodadShape(g: PXkbGeometryPtr; d: PXkbShapeDoodadPtr): PXkbShapePtr

XkbShapeRec:

xkb: object XkbShapeRec

XkbShiftLevel:

xkb: proc XkbShiftLevel(n: int8): int8

XkbShiftLevelMask:

xkb: proc XkbShiftLevelMask(n: int8): int8

XkbSI_AllOf:

xkb: const XkbSI_AllOf

XkbSI_AnyOf:

xkb: const XkbSI_AnyOf

XkbSI_AnyOfOrNone:

xkb: const XkbSI_AnyOfOrNone

XkbSI_AutoRepeat:

xkb: const XkbSI_AutoRepeat

XkbSI_Exactly:

xkb: const XkbSI_Exactly

XkbSI_LevelOneOnly:

xkb: const XkbSI_LevelOneOnly

XkbSI_LockingKey:

xkb: const XkbSI_LockingKey

XkbSingleXIClass:

xkb: proc XkbSingleXIClass(c: int): bool

XkbSingleXIId:

xkb: proc XkbSingleXIId(c: int): bool

XkbSI_NoneOf:

xkb: const XkbSI_NoneOf

XkbSI_OpMask:

xkb: const XkbSI_OpMask

XkbSlowKeysMask:

xkb: const XkbSlowKeysMask

XkbSMKeyActionsPtr:

xkb: proc XkbSMKeyActionsPtr(m: PXkbServerMapPtr; k: int16): PXkbAction

XkbSolidDoodad:

xkb: const XkbSolidDoodad

XkbStateFieldFromRec:

xkb: proc XkbStateFieldFromRec(s: PXkbStatePtr): int

XkbStateGroup:

xkb: proc XkbStateGroup(s: PXkbStatePtr): int16

XkbStateMods:

xkb: proc XkbStateMods(s: PXkbStatePtr): int16

XkbStateNotify:

xkb: const XkbStateNotify

XkbStateNotifyEvent:

xkblib: object XkbStateNotifyEvent

XkbStateNotifyMask:

xkb: const XkbStateNotifyMask

XkbStateRec:

xkb: object XkbStateRec

XkbStickyKeysMask:

xkb: const XkbStickyKeysMask

XkbSwitchScreenAction:

xkb: object XkbSwitchScreenAction

XkbSymbolsNameMask:

xkb: const XkbSymbolsNameMask

XkbSymInterpMask:

xkb: const XkbSymInterpMask

XkbSymInterpretRec:

xkb: object XkbSymInterpretRec

XkbSymMapRec:

xkb: object XkbSymMapRec

XkbTextDoodad:

xkb: const XkbTextDoodad

XkbTextDoodadColor:

xkb: proc XkbTextDoodadColor(g: PXkbGeometryPtr; d: PXkbTextDoodadPtr): PXkbColorPtr

XkbTextDoodadRec:

xkb: object XkbTextDoodadRec

XkbToControl:

xkblib: proc XkbToControl(c: int8): int8

XkbTranslateKeyCode:

xkblib: proc XkbTranslateKeyCode(xkb: PXkbDescPtr; keycode: KeyCode; modifiers, modifiers_return: int16; keysym_return: PKeySym): bool

XkbTranslateKeySym:

xkblib: proc XkbTranslateKeySym(dpy: PDisplay; sym_return: KeySym; modifiers: int16; buffer: cstring; nbytes: int16; extra_rtrn: ptr int16): int16

XkbTwoLevelIndex:

xkb: const XkbTwoLevelIndex

XkbTwoLevelMask:

xkb: const XkbTwoLevelMask

XkbTypesNameMask:

xkb: const XkbTypesNameMask

XkbUnknownDoodad:

xkb: const XkbUnknownDoodad

XkbUpdateMapFromCore:

xkblib: proc XkbUpdateMapFromCore(xkb: PXkbDescPtr; first_key: KeyCode; num_keys, map_width: int16; core_keysyms: PKeySym; changes: PXkbChangesPtr): bool

XkbUseCoreKbd:

xkb: const XkbUseCoreKbd

XkbUseCorePtr:

xkb: const XkbUseCorePtr

X_kbUseExtension:

xkb: const X_kbUseExtension

XkbUseExtension:

xkblib: proc XkbUseExtension(dpy: PDisplay; major_rtrn, minor_rtrn: ptr int16): bool

XkbVirtualModMapMask:

xkb: const XkbVirtualModMapMask

XkbVirtualModNamesMask:

xkb: const XkbVirtualModNamesMask

XkbVirtualModsMask:

xkb: const XkbVirtualModsMask

XkbVirtualModsToReal:

xkblib: proc XkbVirtualModsToReal(dpy: PDisplay; virtual_mask: int16; mask_rtrn: PWord): bool

XkbWrapIntoRange:

xkb: const XkbWrapIntoRange

XkbXI_AllDeviceFeaturesMask:

xkb: const XkbXI_AllDeviceFeaturesMask

XkbXI_AllFeaturesMask:

xkb: const XkbXI_AllFeaturesMask

XkbXI_ButtonActionsMask:

xkb: const XkbXI_ButtonActionsMask

XkbXI_DevHasBtnActs:

xkb: proc XkbXI_DevHasBtnActs(d: PXkbDeviceInfoPtr): bool

XkbXI_DevHasLeds:

xkb: proc XkbXI_DevHasLeds(d: PXkbDeviceInfoPtr): bool

XkbXI_IndicatorMapsMask:

xkb: const XkbXI_IndicatorMapsMask

XkbXI_IndicatorNamesMask:

xkb: const XkbXI_IndicatorNamesMask

XkbXI_IndicatorsMask:

xkb: const XkbXI_IndicatorsMask

XkbXI_IndicatorStateMask:

xkb: const XkbXI_IndicatorStateMask

XkbXI_KeyboardsMask:

xkb: const XkbXI_KeyboardsMask

XkbXI_LegalDevBtn:

xkb: proc XkbXI_LegalDevBtn(d: PXkbDeviceInfoPtr; b: int16): bool

XkbXINone:

xkb: const XkbXINone

XkbXI_UnsupportedFeatureMask:

xkb: const XkbXI_UnsupportedFeatureMask

XK_Byelorussian_shortu:

keysym: const XK_Byelorussian_shortu

XK_c:

keysym: const XK_c

XKc_A:

keysym: const XKc_A

XKc_Aacute:

keysym: const XKc_Aacute

XKc_Abelowdot:

keysym: const XKc_Abelowdot

XK_cabovedot:

keysym: const XK_cabovedot

XKc_Abreve:

keysym: const XKc_Abreve

XKc_Abreveacute:

keysym: const XKc_Abreveacute

XKc_Abrevebelowdot:

keysym: const XKc_Abrevebelowdot

XKc_Abrevegrave:

keysym: const XKc_Abrevegrave

XKc_Abrevehook:

keysym: const XKc_Abrevehook

XKc_Abrevetilde:

keysym: const XKc_Abrevetilde

XKc_Acircumflex:

keysym: const XKc_Acircumflex

XKc_Acircumflexacute:

keysym: const XKc_Acircumflexacute

XKc_Acircumflexbelowdot:

keysym: const XKc_Acircumflexbelowdot

XKc_Acircumflexgrave:

keysym: const XKc_Acircumflexgrave

XKc_Acircumflexhook:

keysym: const XKc_Acircumflexhook

XKc_Acircumflextilde:

keysym: const XKc_Acircumflextilde

XK_cacute:

keysym: const XK_cacute

XKc_Adiaeresis:

keysym: const XKc_Adiaeresis

XKc_AE:

keysym: const XKc_AE

XKc_Agrave:

keysym: const XKc_Agrave

XKc_Ahook:

keysym: const XKc_Ahook

XKc_Amacron:

keysym: const XKc_Amacron

XK_Cancel:

keysym: const XK_Cancel

XKc_Aogonek:

keysym: const XKc_Aogonek

XK_Caps_Lock:

keysym: const XK_Caps_Lock

XK_careof:

keysym: const XK_careof

XK_caret:

keysym: const XK_caret

XKc_Aring:

keysym: const XKc_Aring

XKc_Armenian_AT:

keysym: const XKc_Armenian_AT

XKc_Armenian_AYB:

keysym: const XKc_Armenian_AYB

XKc_Armenian_BEN:

keysym: const XKc_Armenian_BEN

XKc_Armenian_CHA:

keysym: const XKc_Armenian_CHA

XKc_Armenian_DA:

keysym: const XKc_Armenian_DA

XKc_Armenian_DZA:

keysym: const XKc_Armenian_DZA

XKc_Armenian_E:

keysym: const XKc_Armenian_E

XKc_Armenian_FE:

keysym: const XKc_Armenian_FE

XKc_Armenian_GHAT:

keysym: const XKc_Armenian_GHAT

XKc_Armenian_GIM:

keysym: const XKc_Armenian_GIM

XKc_Armenian_HI:

keysym: const XKc_Armenian_HI

XKc_Armenian_HO:

keysym: const XKc_Armenian_HO

XKc_Armenian_INI:

keysym: const XKc_Armenian_INI

XKc_Armenian_JE:

keysym: const XKc_Armenian_JE

XKc_Armenian_KE:

keysym: const XKc_Armenian_KE

XKc_Armenian_KEN:

keysym: const XKc_Armenian_KEN

XKc_Armenian_KHE:

keysym: const XKc_Armenian_KHE

XKc_Armenian_LYUN:

keysym: const XKc_Armenian_LYUN

XKc_Armenian_MEN:

keysym: const XKc_Armenian_MEN

XKc_Armenian_NU:

keysym: const XKc_Armenian_NU

XKc_Armenian_O:

keysym: const XKc_Armenian_O

XKc_Armenian_PE:

keysym: const XKc_Armenian_PE

XKc_Armenian_PYUR:

keysym: const XKc_Armenian_PYUR

XKc_Armenian_RA:

keysym: const XKc_Armenian_RA

XKc_Armenian_RE:

keysym: const XKc_Armenian_RE

XKc_Armenian_SE:

keysym: const XKc_Armenian_SE

XKc_Armenian_SHA:

keysym: const XKc_Armenian_SHA

XKc_Armenian_TCHE:

keysym: const XKc_Armenian_TCHE

XKc_Armenian_TO:

keysym: const XKc_Armenian_TO

XKc_Armenian_TSA:

keysym: const XKc_Armenian_TSA

XKc_Armenian_TSO:

keysym: const XKc_Armenian_TSO

XKc_Armenian_TYUN:

keysym: const XKc_Armenian_TYUN

XKc_Armenian_VEV:

keysym: const XKc_Armenian_VEV

XKc_Armenian_VO:

keysym: const XKc_Armenian_VO

XKc_Armenian_VYUN:

keysym: const XKc_Armenian_VYUN

XKc_Armenian_YECH:

keysym: const XKc_Armenian_YECH

XKc_Armenian_ZA:

keysym: const XKc_Armenian_ZA

XKc_Armenian_ZHE:

keysym: const XKc_Armenian_ZHE

XK_caron:

keysym: const XK_caron

XKc_Atilde:

keysym: const XKc_Atilde

XKc_B:

keysym: const XKc_B

XKc_Babovedot:

keysym: const XKc_Babovedot

XKc_Byelorussian_SHORTU:

keysym: const XKc_Byelorussian_SHORTU

XKc_C:

keysym: const XKc_C

XKc_Cabovedot:

keysym: const XKc_Cabovedot

XKc_Cacute:

keysym: const XKc_Cacute

XK_ccaron:

keysym: const XK_ccaron

XKc_Ccaron:

keysym: const XKc_Ccaron

XKc_Ccedilla:

keysym: const XKc_Ccedilla

XKc_Ccedillaabovedot:

keysym: const XKc_Ccedillaabovedot

XKc_Ccircumflex:

keysym: const XKc_Ccircumflex

XK_ccedilla:

keysym: const XK_ccedilla

XK_ccedillaabovedot:

keysym: const XK_ccedillaabovedot

XK_ccircumflex:

keysym: const XK_ccircumflex

XKc_Cyrillic_A:

keysym: const XKc_Cyrillic_A

XKc_Cyrillic_BE:

keysym: const XKc_Cyrillic_BE

XKc_Cyrillic_CHE:

keysym: const XKc_Cyrillic_CHE

XKc_Cyrillic_CHE_descender:

keysym: const XKc_Cyrillic_CHE_descender

XKc_Cyrillic_CHE_vertstroke:

keysym: const XKc_Cyrillic_CHE_vertstroke

XKc_Cyrillic_DE:

keysym: const XKc_Cyrillic_DE

XKc_Cyrillic_DZHE:

keysym: const XKc_Cyrillic_DZHE

XKc_Cyrillic_E:

keysym: const XKc_Cyrillic_E

XKc_Cyrillic_EF:

keysym: const XKc_Cyrillic_EF

XKc_Cyrillic_EL:

keysym: const XKc_Cyrillic_EL

XKc_Cyrillic_EM:

keysym: const XKc_Cyrillic_EM

XKc_Cyrillic_EN:

keysym: const XKc_Cyrillic_EN

XKc_Cyrillic_EN_descender:

keysym: const XKc_Cyrillic_EN_descender

XKc_Cyrillic_ER:

keysym: const XKc_Cyrillic_ER

XKc_Cyrillic_ES:

keysym: const XKc_Cyrillic_ES

XKc_Cyrillic_GHE:

keysym: const XKc_Cyrillic_GHE

XKc_Cyrillic_GHE_bar:

keysym: const XKc_Cyrillic_GHE_bar

XKc_Cyrillic_HA:

keysym: const XKc_Cyrillic_HA

XKc_Cyrillic_HA_descender:

keysym: const XKc_Cyrillic_HA_descender

XKc_Cyrillic_HARDSIGN:

keysym: const XKc_Cyrillic_HARDSIGN

XKc_Cyrillic_I:

keysym: const XKc_Cyrillic_I

XKc_Cyrillic_IE:

keysym: const XKc_Cyrillic_IE

XKc_Cyrillic_I_macron:

keysym: const XKc_Cyrillic_I_macron

XKc_Cyrillic_IO:

keysym: const XKc_Cyrillic_IO

XKc_Cyrillic_JE:

keysym: const XKc_Cyrillic_JE

XKc_Cyrillic_KA:

keysym: const XKc_Cyrillic_KA

XKc_Cyrillic_KA_descender:

keysym: const XKc_Cyrillic_KA_descender

XKc_Cyrillic_KA_vertstroke:

keysym: const XKc_Cyrillic_KA_vertstroke

XKc_Cyrillic_LJE:

keysym: const XKc_Cyrillic_LJE

XKc_Cyrillic_NJE:

keysym: const XKc_Cyrillic_NJE

XKc_Cyrillic_O:

keysym: const XKc_Cyrillic_O

XKc_Cyrillic_O_bar:

keysym: const XKc_Cyrillic_O_bar

XKc_Cyrillic_PE:

keysym: const XKc_Cyrillic_PE

XKc_Cyrillic_SCHWA:

keysym: const XKc_Cyrillic_SCHWA

XKc_Cyrillic_SHA:

keysym: const XKc_Cyrillic_SHA

XKc_Cyrillic_SHCHA:

keysym: const XKc_Cyrillic_SHCHA

XKc_Cyrillic_SHHA:

keysym: const XKc_Cyrillic_SHHA

XKc_Cyrillic_SHORTI:

keysym: const XKc_Cyrillic_SHORTI

XKc_Cyrillic_SOFTSIGN:

keysym: const XKc_Cyrillic_SOFTSIGN

XKc_Cyrillic_TE:

keysym: const XKc_Cyrillic_TE

XKc_Cyrillic_TSE:

keysym: const XKc_Cyrillic_TSE

XKc_Cyrillic_U:

keysym: const XKc_Cyrillic_U

XKc_Cyrillic_U_macron:

keysym: const XKc_Cyrillic_U_macron

XKc_Cyrillic_U_straight:

keysym: const XKc_Cyrillic_U_straight

XKc_Cyrillic_U_straight_bar:

keysym: const XKc_Cyrillic_U_straight_bar

XKc_Cyrillic_VE:

keysym: const XKc_Cyrillic_VE

XKc_Cyrillic_YA:

keysym: const XKc_Cyrillic_YA

XKc_Cyrillic_YERU:

keysym: const XKc_Cyrillic_YERU

XKc_Cyrillic_YU:

keysym: const XKc_Cyrillic_YU

XKc_Cyrillic_ZE:

keysym: const XKc_Cyrillic_ZE

XKc_Cyrillic_ZHE:

keysym: const XKc_Cyrillic_ZHE

XKc_Cyrillic_ZHE_descender:

keysym: const XKc_Cyrillic_ZHE_descender

XKc_D:

keysym: const XKc_D

XKc_Dabovedot:

keysym: const XKc_Dabovedot

XKc_Dcaron:

keysym: const XKc_Dcaron

XKc_Dstroke:

keysym: const XKc_Dstroke

XKc_E:

keysym: const XKc_E

XKc_Eabovedot:

keysym: const XKc_Eabovedot

XKc_Eacute:

keysym: const XKc_Eacute

XKc_Ebelowdot:

keysym: const XKc_Ebelowdot

XKc_Ecaron:

keysym: const XKc_Ecaron

XKc_Ecircumflex:

keysym: const XKc_Ecircumflex

XKc_Ecircumflexacute:

keysym: const XKc_Ecircumflexacute

XKc_Ecircumflexbelowdot:

keysym: const XKc_Ecircumflexbelowdot

XKc_Ecircumflexgrave:

keysym: const XKc_Ecircumflexgrave

XKc_Ecircumflexhook:

keysym: const XKc_Ecircumflexhook

XKc_Ecircumflextilde:

keysym: const XKc_Ecircumflextilde

XKc_Ediaeresis:

keysym: const XKc_Ediaeresis

XK_cedilla:

keysym: const XK_cedilla

XKc_Egrave:

keysym: const XKc_Egrave

XKc_Ehook:

keysym: const XKc_Ehook

XKc_Emacron:

keysym: const XKc_Emacron

XKc_ENG:

keysym: const XKc_ENG

XK_cent:

keysym: const XK_cent

XKc_Eogonek:

keysym: const XKc_Eogonek

XKc_ETH:

keysym: const XKc_ETH

XKc_Etilde:

keysym: const XKc_Etilde

XKc_F:

keysym: const XKc_F

XKc_Fabovedot:

keysym: const XKc_Fabovedot

XKc_G:

keysym: const XKc_G

XKc_Gabovedot:

keysym: const XKc_Gabovedot

XKc_Gbreve:

keysym: const XKc_Gbreve

XKc_Gcaron:

keysym: const XKc_Gcaron

XKc_Gcedilla:

keysym: const XKc_Gcedilla

XKc_Gcircumflex:

keysym: const XKc_Gcircumflex

XKc_Greek_ALPHA:

keysym: const XKc_Greek_ALPHA

XKc_Greek_ALPHAaccent:

keysym: const XKc_Greek_ALPHAaccent

XKc_Greek_BETA:

keysym: const XKc_Greek_BETA

XKc_Greek_CHI:

keysym: const XKc_Greek_CHI

XKc_Greek_DELTA:

keysym: const XKc_Greek_DELTA

XKc_Greek_EPSILON:

keysym: const XKc_Greek_EPSILON

XKc_Greek_EPSILONaccent:

keysym: const XKc_Greek_EPSILONaccent

XKc_Greek_ETA:

keysym: const XKc_Greek_ETA

XKc_Greek_ETAaccent:

keysym: const XKc_Greek_ETAaccent

XKc_Greek_GAMMA:

keysym: const XKc_Greek_GAMMA

XKc_Greek_IOTA:

keysym: const XKc_Greek_IOTA

XKc_Greek_IOTAaccent:

keysym: const XKc_Greek_IOTAaccent

XKc_Greek_IOTAdiaeresis:

keysym: const XKc_Greek_IOTAdiaeresis

XKc_Greek_IOTAdieresis:

keysym: const XKc_Greek_IOTAdieresis

XKc_Greek_KAPPA:

keysym: const XKc_Greek_KAPPA

XKc_Greek_LAMBDA:

keysym: const XKc_Greek_LAMBDA

XKc_Greek_LAMDA:

keysym: const XKc_Greek_LAMDA

XKc_Greek_MU:

keysym: const XKc_Greek_MU

XKc_Greek_NU:

keysym: const XKc_Greek_NU

XKc_Greek_OMEGA:

keysym: const XKc_Greek_OMEGA

XKc_Greek_OMEGAaccent:

keysym: const XKc_Greek_OMEGAaccent

XKc_Greek_OMICRON:

keysym: const XKc_Greek_OMICRON

XKc_Greek_OMICRONaccent:

keysym: const XKc_Greek_OMICRONaccent

XKc_Greek_PHI:

keysym: const XKc_Greek_PHI

XKc_Greek_PI:

keysym: const XKc_Greek_PI

XKc_Greek_PSI:

keysym: const XKc_Greek_PSI

XKc_Greek_RHO:

keysym: const XKc_Greek_RHO

XKc_Greek_SIGMA:

keysym: const XKc_Greek_SIGMA

XKc_Greek_TAU:

keysym: const XKc_Greek_TAU

XKc_Greek_THETA:

keysym: const XKc_Greek_THETA

XKc_Greek_UPSILON:

keysym: const XKc_Greek_UPSILON

XKc_Greek_UPSILONaccent:

keysym: const XKc_Greek_UPSILONaccent

XKc_Greek_UPSILONdieresis:

keysym: const XKc_Greek_UPSILONdieresis

XKc_Greek_XI:

keysym: const XKc_Greek_XI

XKc_Greek_ZETA:

keysym: const XKc_Greek_ZETA

XKc_Gtilde:

keysym: const XKc_Gtilde

XKc_H:

keysym: const XKc_H

XKc_Hcircumflex:

keysym: const XKc_Hcircumflex

XK_checkmark:

keysym: const XK_checkmark

XKc_Hstroke:

keysym: const XKc_Hstroke

XKc_I:

keysym: const XKc_I

XKc_Iabovedot:

keysym: const XKc_Iabovedot

XKc_Iacute:

keysym: const XKc_Iacute

XKc_Ibelowdot:

keysym: const XKc_Ibelowdot

XKc_Ibreve:

keysym: const XKc_Ibreve

XKc_Icircumflex:

keysym: const XKc_Icircumflex

XKc_Idiaeresis:

keysym: const XKc_Idiaeresis

XKc_IE:

keysym: const XKc_IE

XKc_Igrave:

keysym: const XKc_Igrave

XKc_Ihook:

keysym: const XKc_Ihook

XKc_Imacron:

keysym: const XKc_Imacron

XKc_Iogonek:

keysym: const XKc_Iogonek

XK_circle:

keysym: const XK_circle

XKc_Itilde:

keysym: const XKc_Itilde

XKc_J:

keysym: const XKc_J

XKc_Jcircumflex:

keysym: const XKc_Jcircumflex

XKc_K:

keysym: const XKc_K

XKc_kana_A:

keysym: const XKc_kana_A

XKc_kana_CHI:

keysym: const XKc_kana_CHI

XKc_kana_E:

keysym: const XKc_kana_E

XKc_kana_FU:

keysym: const XKc_kana_FU

XKc_kana_HA:

keysym: const XKc_kana_HA

XKc_kana_HE:

keysym: const XKc_kana_HE

XKc_kana_HI:

keysym: const XKc_kana_HI

XKc_kana_HO:

keysym: const XKc_kana_HO

XKc_kana_HU:

keysym: const XKc_kana_HU

XKc_kana_I:

keysym: const XKc_kana_I

XKc_kana_KA:

keysym: const XKc_kana_KA

XKc_kana_KE:

keysym: const XKc_kana_KE

XKc_kana_KI:

keysym: const XKc_kana_KI

XKc_kana_KO:

keysym: const XKc_kana_KO

XKc_kana_KU:

keysym: const XKc_kana_KU

XKc_kana_MA:

keysym: const XKc_kana_MA

XKc_kana_ME:

keysym: const XKc_kana_ME

XKc_kana_MI:

keysym: const XKc_kana_MI

XKc_kana_MO:

keysym: const XKc_kana_MO

XKc_kana_MU:

keysym: const XKc_kana_MU

XKc_kana_N:

keysym: const XKc_kana_N

XKc_kana_NA:

keysym: const XKc_kana_NA

XKc_kana_NE:

keysym: const XKc_kana_NE

XKc_kana_NI:

keysym: const XKc_kana_NI

XKc_kana_NO:

keysym: const XKc_kana_NO

XKc_kana_NU:

keysym: const XKc_kana_NU

XKc_kana_O:

keysym: const XKc_kana_O

XKc_kana_RA:

keysym: const XKc_kana_RA

XKc_kana_RE:

keysym: const XKc_kana_RE

XKc_kana_RI:

keysym: const XKc_kana_RI

XKc_kana_RO:

keysym: const XKc_kana_RO

XKc_kana_RU:

keysym: const XKc_kana_RU

XKc_kana_SA:

keysym: const XKc_kana_SA

XKc_kana_SE:

keysym: const XKc_kana_SE

XKc_kana_SHI:

keysym: const XKc_kana_SHI

XKc_kana_SO:

keysym: const XKc_kana_SO

XKc_kana_SU:

keysym: const XKc_kana_SU

XKc_kana_TA:

keysym: const XKc_kana_TA

XKc_kana_TE:

keysym: const XKc_kana_TE

XKc_kana_TI:

keysym: const XKc_kana_TI

XKc_kana_TO:

keysym: const XKc_kana_TO

XKc_kana_TSU:

keysym: const XKc_kana_TSU

XKc_kana_TU:

keysym: const XKc_kana_TU

XKc_kana_U:

keysym: const XKc_kana_U

XKc_kana_WA:

keysym: const XKc_kana_WA

XKc_kana_WO:

keysym: const XKc_kana_WO

XKc_kana_YA:

keysym: const XKc_kana_YA

XKc_kana_YO:

keysym: const XKc_kana_YO

XKc_kana_YU:

keysym: const XKc_kana_YU

XKc_Kcedilla:

keysym: const XKc_Kcedilla

XKc_L:

keysym: const XKc_L

XKc_Lacute:

keysym: const XKc_Lacute

XKc_Lbelowdot:

keysym: const XKc_Lbelowdot

XKc_Lcaron:

keysym: const XKc_Lcaron

XKc_Lcedilla:

keysym: const XKc_Lcedilla

XK_Clear:

keysym: const XK_Clear

XKc_Lstroke:

keysym: const XKc_Lstroke

XKc_Lstrokebelowdot:

keysym: const XKc_Lstrokebelowdot

XK_club:

keysym: const XK_club

XKc_M:

keysym: const XKc_M

XKc_Mabovedot:

keysym: const XKc_Mabovedot

XKc_Macedonia_DSE:

keysym: const XKc_Macedonia_DSE

XKc_Macedonia_GJE:

keysym: const XKc_Macedonia_GJE

XKc_Macedonia_KJE:

keysym: const XKc_Macedonia_KJE

XKc_N:

keysym: const XKc_N

XKc_Nacute:

keysym: const XKc_Nacute

XKc_Ncaron:

keysym: const XKc_Ncaron

XKc_Ncedilla:

keysym: const XKc_Ncedilla

XKc_Ntilde:

keysym: const XKc_Ntilde

XKc_O:

keysym: const XKc_O

XKc_Oacute:

keysym: const XKc_Oacute

XKc_Obarred:

keysym: const XKc_Obarred

XKc_Obelowdot:

keysym: const XKc_Obelowdot

XKc_Ocaron:

keysym: const XKc_Ocaron

XKc_Ocircumflex:

keysym: const XKc_Ocircumflex

XKc_Ocircumflexacute:

keysym: const XKc_Ocircumflexacute

XKc_Ocircumflexbelowdot:

keysym: const XKc_Ocircumflexbelowdot

XKc_Ocircumflexgrave:

keysym: const XKc_Ocircumflexgrave

XKc_Ocircumflexhook:

keysym: const XKc_Ocircumflexhook

XKc_Ocircumflextilde:

keysym: const XKc_Ocircumflextilde

XK_Codeinput:

keysym: const XK_Codeinput

XKc_Odiaeresis:

keysym: const XKc_Odiaeresis

XKc_Odoubleacute:

keysym: const XKc_Odoubleacute

XKc_OE:

keysym: const XKc_OE

XKc_Ograve:

keysym: const XKc_Ograve

XKc_Ohook:

keysym: const XKc_Ohook

XKc_Ohorn:

keysym: const XKc_Ohorn

XKc_Ohornacute:

keysym: const XKc_Ohornacute

XKc_Ohornbelowdot:

keysym: const XKc_Ohornbelowdot

XKc_Ohorngrave:

keysym: const XKc_Ohorngrave

XKc_Ohornhook:

keysym: const XKc_Ohornhook

XKc_Ohorntilde:

keysym: const XKc_Ohorntilde

XK_colon:

keysym: const XK_colon

XK_ColonSign:

keysym: const XK_ColonSign

XKc_Omacron:

keysym: const XKc_Omacron

XK_combining_acute:

keysym: const XK_combining_acute

XK_combining_belowdot:

keysym: const XK_combining_belowdot

XK_combining_grave:

keysym: const XK_combining_grave

XK_combining_hook:

keysym: const XK_combining_hook

XK_combining_tilde:

keysym: const XK_combining_tilde

XK_comma:

keysym: const XK_comma

XK_Control_L:

keysym: const XK_Control_L

XK_Control_R:

keysym: const XK_Control_R

XKc_Ooblique:

keysym: const XKc_Ooblique

XK_copyright:

keysym: const XK_copyright

XKc_Oslash:

keysym: const XKc_Oslash

XKc_Otilde:

keysym: const XKc_Otilde

XKc_P:

keysym: const XKc_P

XKc_Pabovedot:

keysym: const XKc_Pabovedot

XKc_Q:

keysym: const XKc_Q

XKc_Qabovedot:

keysym: const XKc_Qabovedot

XKc_R:

keysym: const XKc_R

XKc_Racute:

keysym: const XKc_Racute

XKc_Rcaron:

keysym: const XKc_Rcaron

XKc_Rcedilla:

keysym: const XKc_Rcedilla

XK_CruzeiroSign:

keysym: const XK_CruzeiroSign

XKc_S:

keysym: const XKc_S

XKc_Sabovedot:

keysym: const XKc_Sabovedot

XKc_Sacute:

keysym: const XKc_Sacute

XKc_Scaron:

keysym: const XKc_Scaron

XKc_Scedilla:

keysym: const XKc_Scedilla

XKc_SCHWA:

keysym: const XKc_SCHWA

XKc_Scircumflex:

keysym: const XKc_Scircumflex

XKc_Serbian_DJE:

keysym: const XKc_Serbian_DJE

XKc_Serbian_DZE:

keysym: const XKc_Serbian_DZE

XKc_Serbian_JE:

keysym: const XKc_Serbian_JE

XKc_Serbian_LJE:

keysym: const XKc_Serbian_LJE

XKc_Serbian_NJE:

keysym: const XKc_Serbian_NJE

XKc_Serbian_TSHE:

keysym: const XKc_Serbian_TSHE

XKc_T:

keysym: const XKc_T

XKc_Tabovedot:

keysym: const XKc_Tabovedot

XKc_Tcaron:

keysym: const XKc_Tcaron

XKc_Tcedilla:

keysym: const XKc_Tcedilla

XKc_THORN:

keysym: const XKc_THORN

XKc_Tslash:

keysym: const XKc_Tslash

XKc_U:

keysym: const XKc_U

XKc_Uacute:

keysym: const XKc_Uacute

XKc_Ubelowdot:

keysym: const XKc_Ubelowdot

XKc_Ubreve:

keysym: const XKc_Ubreve

XKc_Ucircumflex:

keysym: const XKc_Ucircumflex

XKc_Udiaeresis:

keysym: const XKc_Udiaeresis

XKc_Udoubleacute:

keysym: const XKc_Udoubleacute

XKc_Ugrave:

keysym: const XKc_Ugrave

XKc_Uhook:

keysym: const XKc_Uhook

XKc_Uhorn:

keysym: const XKc_Uhorn

XKc_Uhornacute:

keysym: const XKc_Uhornacute

XKc_Uhornbelowdot:

keysym: const XKc_Uhornbelowdot

XKc_Uhorngrave:

keysym: const XKc_Uhorngrave

XKc_Uhornhook:

keysym: const XKc_Uhornhook

XKc_Uhorntilde:

keysym: const XKc_Uhorntilde

XKc_Ukrainian_GHE_WITH_UPTURN:

keysym: const XKc_Ukrainian_GHE_WITH_UPTURN

XKc_Ukrainian_I:

keysym: const XKc_Ukrainian_I

XKc_Ukrainian_IE:

keysym: const XKc_Ukrainian_IE

XKc_Ukrainian_YI:

keysym: const XKc_Ukrainian_YI

XKc_Ukranian_I:

keysym: const XKc_Ukranian_I

XKc_Ukranian_JE:

keysym: const XKc_Ukranian_JE

XKc_Ukranian_YI:

keysym: const XKc_Ukranian_YI

XKc_Umacron:

keysym: const XKc_Umacron

XKc_UO:

keysym: const XKc_UO

XKc_Uogonek:

keysym: const XKc_Uogonek

XKc_Uring:

keysym: const XKc_Uring

XK_currency:

keysym: const XK_currency

XK_cursor:

keysym: const XK_cursor

XKc_Utilde:

keysym: const XKc_Utilde

XKc_V:

keysym: const XKc_V

XKc_W:

keysym: const XKc_W

XKc_Wacute:

keysym: const XKc_Wacute

XKc_Wcircumflex:

keysym: const XKc_Wcircumflex

XKc_Wdiaeresis:

keysym: const XKc_Wdiaeresis

XKc_Wgrave:

keysym: const XKc_Wgrave

XKc_X:

keysym: const XKc_X

XKc_Xabovedot:

keysym: const XKc_Xabovedot

XKc_Y:

keysym: const XKc_Y

XKc_Yacute:

keysym: const XKc_Yacute

XKc_Ybelowdot:

keysym: const XKc_Ybelowdot

XKc_Ycircumflex:

keysym: const XKc_Ycircumflex

XKc_Ydiaeresis:

keysym: const XKc_Ydiaeresis

XKc_Ygrave:

keysym: const XKc_Ygrave

XKc_Yhook:

keysym: const XKc_Yhook

XK_Cyrillic_a:

keysym: const XK_Cyrillic_a

XK_Cyrillic_be:

keysym: const XK_Cyrillic_be

XK_Cyrillic_che:

keysym: const XK_Cyrillic_che

XK_Cyrillic_che_descender:

keysym: const XK_Cyrillic_che_descender

XK_Cyrillic_che_vertstroke:

keysym: const XK_Cyrillic_che_vertstroke

XK_Cyrillic_de:

keysym: const XK_Cyrillic_de

XK_Cyrillic_dzhe:

keysym: const XK_Cyrillic_dzhe

XK_Cyrillic_e:

keysym: const XK_Cyrillic_e

XK_Cyrillic_ef:

keysym: const XK_Cyrillic_ef

XK_Cyrillic_el:

keysym: const XK_Cyrillic_el

XK_Cyrillic_em:

keysym: const XK_Cyrillic_em

XK_Cyrillic_en:

keysym: const XK_Cyrillic_en

XK_Cyrillic_en_descender:

keysym: const XK_Cyrillic_en_descender

XK_Cyrillic_er:

keysym: const XK_Cyrillic_er

XK_Cyrillic_es:

keysym: const XK_Cyrillic_es

XK_Cyrillic_ghe:

keysym: const XK_Cyrillic_ghe

XK_Cyrillic_ghe_bar:

keysym: const XK_Cyrillic_ghe_bar

XK_Cyrillic_ha:

keysym: const XK_Cyrillic_ha

XK_Cyrillic_ha_descender:

keysym: const XK_Cyrillic_ha_descender

XK_Cyrillic_hardsign:

keysym: const XK_Cyrillic_hardsign

XK_Cyrillic_i:

keysym: const XK_Cyrillic_i

XK_Cyrillic_ie:

keysym: const XK_Cyrillic_ie

XK_Cyrillic_i_macron:

keysym: const XK_Cyrillic_i_macron

XK_Cyrillic_io:

keysym: const XK_Cyrillic_io

XK_Cyrillic_je:

keysym: const XK_Cyrillic_je

XK_Cyrillic_ka:

keysym: const XK_Cyrillic_ka

XK_Cyrillic_ka_descender:

keysym: const XK_Cyrillic_ka_descender

XK_Cyrillic_ka_vertstroke:

keysym: const XK_Cyrillic_ka_vertstroke

XK_Cyrillic_lje:

keysym: const XK_Cyrillic_lje

XK_Cyrillic_nje:

keysym: const XK_Cyrillic_nje

XK_Cyrillic_o:

keysym: const XK_Cyrillic_o

XK_Cyrillic_o_bar:

keysym: const XK_Cyrillic_o_bar

XK_Cyrillic_pe:

keysym: const XK_Cyrillic_pe

XK_Cyrillic_schwa:

keysym: const XK_Cyrillic_schwa

XK_Cyrillic_sha:

keysym: const XK_Cyrillic_sha

XK_Cyrillic_shcha:

keysym: const XK_Cyrillic_shcha

XK_Cyrillic_shha:

keysym: const XK_Cyrillic_shha

XK_Cyrillic_shorti:

keysym: const XK_Cyrillic_shorti

XK_Cyrillic_softsign:

keysym: const XK_Cyrillic_softsign

XK_Cyrillic_te:

keysym: const XK_Cyrillic_te

XK_Cyrillic_tse:

keysym: const XK_Cyrillic_tse

XK_Cyrillic_u:

keysym: const XK_Cyrillic_u

XK_Cyrillic_u_macron:

keysym: const XK_Cyrillic_u_macron

XK_Cyrillic_u_straight:

keysym: const XK_Cyrillic_u_straight

XK_Cyrillic_u_straight_bar:

keysym: const XK_Cyrillic_u_straight_bar

XK_Cyrillic_ve:

keysym: const XK_Cyrillic_ve

XK_Cyrillic_ya:

keysym: const XK_Cyrillic_ya

XK_Cyrillic_yeru:

keysym: const XK_Cyrillic_yeru

XK_Cyrillic_yu:

keysym: const XK_Cyrillic_yu

XK_Cyrillic_ze:

keysym: const XK_Cyrillic_ze

XK_Cyrillic_zhe:

keysym: const XK_Cyrillic_zhe

XK_Cyrillic_zhe_descender:

keysym: const XK_Cyrillic_zhe_descender

XKc_Ytilde:

keysym: const XKc_Ytilde

XKc_Z:

keysym: const XKc_Z

XKc_Zabovedot:

keysym: const XKc_Zabovedot

XKc_Zacute:

keysym: const XKc_Zacute

XKc_Zcaron:

keysym: const XKc_Zcaron

XKc_Zstroke:

keysym: const XKc_Zstroke

XK_d:

keysym: const XK_d

XK_dabovedot:

keysym: const XK_dabovedot

XK_dagger:

keysym: const XK_dagger

XK_dcaron:

keysym: const XK_dcaron

XK_dead_abovedot:

keysym: const XK_dead_abovedot

XK_dead_abovering:

keysym: const XK_dead_abovering

XK_dead_acute:

keysym: const XK_dead_acute

XK_dead_belowdot:

keysym: const XK_dead_belowdot

XK_dead_breve:

keysym: const XK_dead_breve

XK_dead_caron:

keysym: const XK_dead_caron

XK_dead_cedilla:

keysym: const XK_dead_cedilla

XK_dead_circumflex:

keysym: const XK_dead_circumflex

XK_dead_diaeresis:

keysym: const XK_dead_diaeresis

XK_dead_doubleacute:

keysym: const XK_dead_doubleacute

XK_dead_grave:

keysym: const XK_dead_grave

XK_dead_hook:

keysym: const XK_dead_hook

XK_dead_horn:

keysym: const XK_dead_horn

XK_dead_iota:

keysym: const XK_dead_iota

XK_dead_macron:

keysym: const XK_dead_macron

XK_dead_ogonek:

keysym: const XK_dead_ogonek

XK_dead_semivoiced_sound:

keysym: const XK_dead_semivoiced_sound

XK_dead_tilde:

keysym: const XK_dead_tilde

XK_dead_voiced_sound:

keysym: const XK_dead_voiced_sound

XK_decimalpoint:

keysym: const XK_decimalpoint

XK_degree:

keysym: const XK_degree

XK_Delete:

keysym: const XK_Delete

XK_diaeresis:

keysym: const XK_diaeresis

XK_diamond:

keysym: const XK_diamond

XK_digitspace:

keysym: const XK_digitspace

XK_division:

keysym: const XK_division

XK_dollar:

keysym: const XK_dollar

XK_DongSign:

keysym: const XK_DongSign

XK_doubbaselinedot:

keysym: const XK_doubbaselinedot

XK_doubleacute:

keysym: const XK_doubleacute

XK_doubledagger:

keysym: const XK_doubledagger

XK_doublelowquotemark:

keysym: const XK_doublelowquotemark

XK_Down:

keysym: const XK_Down

XK_downarrow:

keysym: const XK_downarrow

XK_downcaret:

keysym: const XK_downcaret

XK_downshoe:

keysym: const XK_downshoe

XK_downstile:

keysym: const XK_downstile

XK_downtack:

keysym: const XK_downtack

XK_dstroke:

keysym: const XK_dstroke

XK_e:

keysym: const XK_e

XK_eabovedot:

keysym: const XK_eabovedot

XK_eacute:

keysym: const XK_eacute

XK_ebelowdot:

keysym: const XK_ebelowdot

XK_ecaron:

keysym: const XK_ecaron

XK_ecircumflex:

keysym: const XK_ecircumflex

XK_ecircumflexacute:

keysym: const XK_ecircumflexacute

XK_ecircumflexbelowdot:

keysym: const XK_ecircumflexbelowdot

XK_ecircumflexgrave:

keysym: const XK_ecircumflexgrave

XK_ecircumflexhook:

keysym: const XK_ecircumflexhook

XK_ecircumflextilde:

keysym: const XK_ecircumflextilde

XK_EcuSign:

keysym: const XK_EcuSign

XK_ediaeresis:

keysym: const XK_ediaeresis

XK_egrave:

keysym: const XK_egrave

XK_ehook:

keysym: const XK_ehook

XK_Eisu_Shift:

keysym: const XK_Eisu_Shift

XK_Eisu_toggle:

keysym: const XK_Eisu_toggle

XK_ellipsis:

keysym: const XK_ellipsis

XK_em3space:

keysym: const XK_em3space

XK_em4space:

keysym: const XK_em4space

XK_emacron:

keysym: const XK_emacron

XK_emdash:

keysym: const XK_emdash

XK_emfilledcircle:

keysym: const XK_emfilledcircle

XK_emfilledrect:

keysym: const XK_emfilledrect

XK_emopencircle:

keysym: const XK_emopencircle

XK_emopenrectangle:

keysym: const XK_emopenrectangle

XK_emspace:

keysym: const XK_emspace

XK_End:

keysym: const XK_End

XK_endash:

keysym: const XK_endash

XK_enfilledcircbullet:

keysym: const XK_enfilledcircbullet

XK_enfilledsqbullet:

keysym: const XK_enfilledsqbullet

XK_eng:

keysym: const XK_eng

XK_enopencircbullet:

keysym: const XK_enopencircbullet

XK_enopensquarebullet:

keysym: const XK_enopensquarebullet

XK_enspace:

keysym: const XK_enspace

XK_eogonek:

keysym: const XK_eogonek

XK_equal:

keysym: const XK_equal

XK_Escape:

keysym: const XK_Escape

XK_eth:

keysym: const XK_eth

XK_etilde:

keysym: const XK_etilde

XK_EuroSign:

keysym: const XK_EuroSign

XK_exclam:

keysym: const XK_exclam

XK_exclamdown:

keysym: const XK_exclamdown

XK_Execute:

keysym: const XK_Execute

XKEYBOARD:

xi: const XKEYBOARD

XKeyboardControl:

xlib: object XKeyboardControl

XKeyboardState:

xlib: object XKeyboardState

XKeycodeToKeysym:

xlib: proc XKeycodeToKeysym(para1: PDisplay; para2: KeyCode; para3: cint): KeySym

XKeyEvent:

xlib: object XKeyEvent

XKeymapEvent:

xlib: object XKeymapEvent

XKeyPressedEvent:

xlib: type XKeyPressedEvent

XKeyReleasedEvent:

xlib: type XKeyReleasedEvent

XKeysymToKeycode:

xlib: proc XKeysymToKeycode(para1: PDisplay; para2: KeySym): KeyCode

XKeysymToString:

xlib: proc XKeysymToString(para1: KeySym): cstring

XK_f:

keysym: const XK_f

XK_F1:

keysym: const XK_F1

XK_F10:

keysym: const XK_F10

XK_F11:

keysym: const XK_F11

XK_F12:

keysym: const XK_F12

XK_F13:

keysym: const XK_F13

XK_F14:

keysym: const XK_F14

XK_F15:

keysym: const XK_F15

XK_F16:

keysym: const XK_F16

XK_F17:

keysym: const XK_F17

XK_F18:

keysym: const XK_F18

XK_F19:

keysym: const XK_F19

XK_F2:

keysym: const XK_F2

XK_F20:

keysym: const XK_F20

XK_F21:

keysym: const XK_F21

XK_F22:

keysym: const XK_F22

XK_F23:

keysym: const XK_F23

XK_F24:

keysym: const XK_F24

XK_F25:

keysym: const XK_F25

XK_F26:

keysym: const XK_F26

XK_F27:

keysym: const XK_F27

XK_F28:

keysym: const XK_F28

XK_F29:

keysym: const XK_F29

XK_F3:

keysym: const XK_F3

XK_F30:

keysym: const XK_F30

XK_F31:

keysym: const XK_F31

XK_F32:

keysym: const XK_F32

XK_F33:

keysym: const XK_F33

XK_F34:

keysym: const XK_F34

XK_F35:

keysym: const XK_F35

XK_F4:

keysym: const XK_F4

XK_F5:

keysym: const XK_F5

XK_F6:

keysym: const XK_F6

XK_F7:

keysym: const XK_F7

XK_F8:

keysym: const XK_F8

XK_F9:

keysym: const XK_F9

XK_fabovedot:

keysym: const XK_fabovedot

XK_Farsi_0:

keysym: const XK_Farsi_0

XK_Farsi_1:

keysym: const XK_Farsi_1

XK_Farsi_2:

keysym: const XK_Farsi_2

XK_Farsi_3:

keysym: const XK_Farsi_3

XK_Farsi_4:

keysym: const XK_Farsi_4

XK_Farsi_5:

keysym: const XK_Farsi_5

XK_Farsi_6:

keysym: const XK_Farsi_6

XK_Farsi_7:

keysym: const XK_Farsi_7

XK_Farsi_8:

keysym: const XK_Farsi_8

XK_Farsi_9:

keysym: const XK_Farsi_9

XK_Farsi_yeh:

keysym: const XK_Farsi_yeh

XK_femalesymbol:

keysym: const XK_femalesymbol

XK_FFrancSign:

keysym: const XK_FFrancSign

XK_figdash:

keysym: const XK_figdash

XK_filledlefttribullet:

keysym: const XK_filledlefttribullet

XK_filledrectbullet:

keysym: const XK_filledrectbullet

XK_filledrighttribullet:

keysym: const XK_filledrighttribullet

XK_filledtribulletdown:

keysym: const XK_filledtribulletdown

XK_filledtribulletup:

keysym: const XK_filledtribulletup

XK_Find:

keysym: const XK_Find

XK_First_Virtual_Screen:

keysym: const XK_First_Virtual_Screen

XK_fiveeighths:

keysym: const XK_fiveeighths

XK_fivesixths:

keysym: const XK_fivesixths

XK_fourfifths:

keysym: const XK_fourfifths

XK_function:

keysym: const XK_function

XK_g:

keysym: const XK_g

XK_gabovedot:

keysym: const XK_gabovedot

XK_gbreve:

keysym: const XK_gbreve

XK_gcaron:

keysym: const XK_gcaron

XK_gcedilla:

keysym: const XK_gcedilla

XK_gcircumflex:

keysym: const XK_gcircumflex

XK_Georgian_an:

keysym: const XK_Georgian_an

XK_Georgian_ban:

keysym: const XK_Georgian_ban

XK_Georgian_can:

keysym: const XK_Georgian_can

XK_Georgian_char:

keysym: const XK_Georgian_char

XK_Georgian_chin:

keysym: const XK_Georgian_chin

XK_Georgian_cil:

keysym: const XK_Georgian_cil

XK_Georgian_don:

keysym: const XK_Georgian_don

XK_Georgian_en:

keysym: const XK_Georgian_en

XK_Georgian_fi:

keysym: const XK_Georgian_fi

XK_Georgian_gan:

keysym: const XK_Georgian_gan

XK_Georgian_ghan:

keysym: const XK_Georgian_ghan

XK_Georgian_hae:

keysym: const XK_Georgian_hae

XK_Georgian_har:

keysym: const XK_Georgian_har

XK_Georgian_he:

keysym: const XK_Georgian_he

XK_Georgian_hie:

keysym: const XK_Georgian_hie

XK_Georgian_hoe:

keysym: const XK_Georgian_hoe

XK_Georgian_in:

keysym: const XK_Georgian_in

XK_Georgian_jhan:

keysym: const XK_Georgian_jhan

XK_Georgian_jil:

keysym: const XK_Georgian_jil

XK_Georgian_kan:

keysym: const XK_Georgian_kan

XK_Georgian_khar:

keysym: const XK_Georgian_khar

XK_Georgian_las:

keysym: const XK_Georgian_las

XK_Georgian_man:

keysym: const XK_Georgian_man

XK_Georgian_nar:

keysym: const XK_Georgian_nar

XK_Georgian_on:

keysym: const XK_Georgian_on

XK_Georgian_par:

keysym: const XK_Georgian_par

XK_Georgian_phar:

keysym: const XK_Georgian_phar

XK_Georgian_qar:

keysym: const XK_Georgian_qar

XK_Georgian_rae:

keysym: const XK_Georgian_rae

XK_Georgian_san:

keysym: const XK_Georgian_san

XK_Georgian_shin:

keysym: const XK_Georgian_shin

XK_Georgian_tan:

keysym: const XK_Georgian_tan

XK_Georgian_tar:

keysym: const XK_Georgian_tar

XK_Georgian_un:

keysym: const XK_Georgian_un

XK_Georgian_vin:

keysym: const XK_Georgian_vin

XK_Georgian_we:

keysym: const XK_Georgian_we

XK_Georgian_xan:

keysym: const XK_Georgian_xan

XK_Georgian_zen:

keysym: const XK_Georgian_zen

XK_Georgian_zhar:

keysym: const XK_Georgian_zhar

XK_grave:

keysym: const XK_grave

XK_greater:

keysym: const XK_greater

XK_greaterthanequal:

keysym: const XK_greaterthanequal

XK_Greek_accentdieresis:

keysym: const XK_Greek_accentdieresis

XK_Greek_alpha:

keysym: const XK_Greek_alpha

XK_Greek_alphaaccent:

keysym: const XK_Greek_alphaaccent

XK_Greek_beta:

keysym: const XK_Greek_beta

XK_Greek_chi:

keysym: const XK_Greek_chi

XK_Greek_delta:

keysym: const XK_Greek_delta

XK_Greek_epsilon:

keysym: const XK_Greek_epsilon

XK_Greek_epsilonaccent:

keysym: const XK_Greek_epsilonaccent

XK_Greek_eta:

keysym: const XK_Greek_eta

XK_Greek_etaaccent:

keysym: const XK_Greek_etaaccent

XK_Greek_finalsmallsigma:

keysym: const XK_Greek_finalsmallsigma

XK_Greek_gamma:

keysym: const XK_Greek_gamma

XK_Greek_horizbar:

keysym: const XK_Greek_horizbar

XK_Greek_iota:

keysym: const XK_Greek_iota

XK_Greek_iotaaccent:

keysym: const XK_Greek_iotaaccent

XK_Greek_iotaaccentdieresis:

keysym: const XK_Greek_iotaaccentdieresis

XK_Greek_iotadieresis:

keysym: const XK_Greek_iotadieresis

XK_Greek_kappa:

keysym: const XK_Greek_kappa

XK_Greek_lambda:

keysym: const XK_Greek_lambda

XK_Greek_lamda:

keysym: const XK_Greek_lamda

XK_Greek_mu:

keysym: const XK_Greek_mu

XK_Greek_nu:

keysym: const XK_Greek_nu

XK_Greek_omega:

keysym: const XK_Greek_omega

XK_Greek_omegaaccent:

keysym: const XK_Greek_omegaaccent

XK_Greek_omicron:

keysym: const XK_Greek_omicron

XK_Greek_omicronaccent:

keysym: const XK_Greek_omicronaccent

XK_Greek_phi:

keysym: const XK_Greek_phi

XK_Greek_pi:

keysym: const XK_Greek_pi

XK_Greek_psi:

keysym: const XK_Greek_psi

XK_Greek_rho:

keysym: const XK_Greek_rho

XK_Greek_sigma:

keysym: const XK_Greek_sigma

XK_Greek_switch:

keysym: const XK_Greek_switch

XK_Greek_tau:

keysym: const XK_Greek_tau

XK_Greek_theta:

keysym: const XK_Greek_theta

XK_Greek_upsilon:

keysym: const XK_Greek_upsilon

XK_Greek_upsilonaccent:

keysym: const XK_Greek_upsilonaccent

XK_Greek_upsilonaccentdieresis:

keysym: const XK_Greek_upsilonaccentdieresis

XK_Greek_upsilondieresis:

keysym: const XK_Greek_upsilondieresis

XK_Greek_xi:

keysym: const XK_Greek_xi

XK_Greek_zeta:

keysym: const XK_Greek_zeta

XK_gtilde:

keysym: const XK_gtilde

XK_guillemotleft:

keysym: const XK_guillemotleft

XK_guillemotright:

keysym: const XK_guillemotright

XK_h:

keysym: const XK_h

XK_hairspace:

keysym: const XK_hairspace

XK_Hangul:

keysym: const XK_Hangul

XK_Hangul_A:

keysym: const XK_Hangul_A

XK_Hangul_AE:

keysym: const XK_Hangul_AE

XK_Hangul_AraeA:

keysym: const XK_Hangul_AraeA

XK_Hangul_AraeAE:

keysym: const XK_Hangul_AraeAE

XK_Hangul_Banja:

keysym: const XK_Hangul_Banja

XK_Hangul_Cieuc:

keysym: const XK_Hangul_Cieuc

XK_Hangul_Codeinput:

keysym: const XK_Hangul_Codeinput

XK_Hangul_Dikeud:

keysym: const XK_Hangul_Dikeud

XK_Hangul_E:

keysym: const XK_Hangul_E

XK_Hangul_End:

keysym: const XK_Hangul_End

XK_Hangul_EO:

keysym: const XK_Hangul_EO

XK_Hangul_EU:

keysym: const XK_Hangul_EU

XK_Hangul_Hanja:

keysym: const XK_Hangul_Hanja

XK_Hangul_Hieuh:

keysym: const XK_Hangul_Hieuh

XK_Hangul_I:

keysym: const XK_Hangul_I

XK_Hangul_Ieung:

keysym: const XK_Hangul_Ieung

XK_Hangul_Jamo:

keysym: const XK_Hangul_Jamo

XK_Hangul_J_Cieuc:

keysym: const XK_Hangul_J_Cieuc

XK_Hangul_J_Dikeud:

keysym: const XK_Hangul_J_Dikeud

XK_Hangul_Jeonja:

keysym: const XK_Hangul_Jeonja

XK_Hangul_J_Hieuh:

keysym: const XK_Hangul_J_Hieuh

XK_Hangul_Jieuj:

keysym: const XK_Hangul_Jieuj

XK_Hangul_J_Ieung:

keysym: const XK_Hangul_J_Ieung

XK_Hangul_J_Jieuj:

keysym: const XK_Hangul_J_Jieuj

XK_Hangul_J_Khieuq:

keysym: const XK_Hangul_J_Khieuq

XK_Hangul_J_Kiyeog:

keysym: const XK_Hangul_J_Kiyeog

XK_Hangul_J_KiyeogSios:

keysym: const XK_Hangul_J_KiyeogSios

XK_Hangul_J_KkogjiDalrinIeung:

keysym: const XK_Hangul_J_KkogjiDalrinIeung

XK_Hangul_J_Mieum:

keysym: const XK_Hangul_J_Mieum

XK_Hangul_J_Nieun:

keysym: const XK_Hangul_J_Nieun

XK_Hangul_J_NieunHieuh:

keysym: const XK_Hangul_J_NieunHieuh

XK_Hangul_J_NieunJieuj:

keysym: const XK_Hangul_J_NieunJieuj

XK_Hangul_J_PanSios:

keysym: const XK_Hangul_J_PanSios

XK_Hangul_J_Phieuf:

keysym: const XK_Hangul_J_Phieuf

XK_Hangul_J_Pieub:

keysym: const XK_Hangul_J_Pieub

XK_Hangul_J_PieubSios:

keysym: const XK_Hangul_J_PieubSios

XK_Hangul_J_Rieul:

keysym: const XK_Hangul_J_Rieul

XK_Hangul_J_RieulHieuh:

keysym: const XK_Hangul_J_RieulHieuh

XK_Hangul_J_RieulKiyeog:

keysym: const XK_Hangul_J_RieulKiyeog

XK_Hangul_J_RieulMieum:

keysym: const XK_Hangul_J_RieulMieum

XK_Hangul_J_RieulPhieuf:

keysym: const XK_Hangul_J_RieulPhieuf

XK_Hangul_J_RieulPieub:

keysym: const XK_Hangul_J_RieulPieub

XK_Hangul_J_RieulSios:

keysym: const XK_Hangul_J_RieulSios

XK_Hangul_J_RieulTieut:

keysym: const XK_Hangul_J_RieulTieut

XK_Hangul_J_Sios:

keysym: const XK_Hangul_J_Sios

XK_Hangul_J_SsangKiyeog:

keysym: const XK_Hangul_J_SsangKiyeog

XK_Hangul_J_SsangSios:

keysym: const XK_Hangul_J_SsangSios

XK_Hangul_J_Tieut:

keysym: const XK_Hangul_J_Tieut

XK_Hangul_J_YeorinHieuh:

keysym: const XK_Hangul_J_YeorinHieuh

XK_Hangul_Khieuq:

keysym: const XK_Hangul_Khieuq

XK_Hangul_Kiyeog:

keysym: const XK_Hangul_Kiyeog

XK_Hangul_KiyeogSios:

keysym: const XK_Hangul_KiyeogSios

XK_Hangul_KkogjiDalrinIeung:

keysym: const XK_Hangul_KkogjiDalrinIeung

XK_Hangul_Mieum:

keysym: const XK_Hangul_Mieum

XK_Hangul_MultipleCandidate:

keysym: const XK_Hangul_MultipleCandidate

XK_Hangul_Nieun:

keysym: const XK_Hangul_Nieun

XK_Hangul_NieunHieuh:

keysym: const XK_Hangul_NieunHieuh

XK_Hangul_NieunJieuj:

keysym: const XK_Hangul_NieunJieuj

XK_Hangul_O:

keysym: const XK_Hangul_O

XK_Hangul_OE:

keysym: const XK_Hangul_OE

XK_Hangul_PanSios:

keysym: const XK_Hangul_PanSios

XK_Hangul_Phieuf:

keysym: const XK_Hangul_Phieuf

XK_Hangul_Pieub:

keysym: const XK_Hangul_Pieub

XK_Hangul_PieubSios:

keysym: const XK_Hangul_PieubSios

XK_Hangul_PostHanja:

keysym: const XK_Hangul_PostHanja

XK_Hangul_PreHanja:

keysym: const XK_Hangul_PreHanja

XK_Hangul_PreviousCandidate:

keysym: const XK_Hangul_PreviousCandidate

XK_Hangul_Rieul:

keysym: const XK_Hangul_Rieul

XK_Hangul_RieulHieuh:

keysym: const XK_Hangul_RieulHieuh

XK_Hangul_RieulKiyeog:

keysym: const XK_Hangul_RieulKiyeog

XK_Hangul_RieulMieum:

keysym: const XK_Hangul_RieulMieum

XK_Hangul_RieulPhieuf:

keysym: const XK_Hangul_RieulPhieuf

XK_Hangul_RieulPieub:

keysym: const XK_Hangul_RieulPieub

XK_Hangul_RieulSios:

keysym: const XK_Hangul_RieulSios

XK_Hangul_RieulTieut:

keysym: const XK_Hangul_RieulTieut

XK_Hangul_RieulYeorinHieuh:

keysym: const XK_Hangul_RieulYeorinHieuh

XK_Hangul_Romaja:

keysym: const XK_Hangul_Romaja

XK_Hangul_SingleCandidate:

keysym: const XK_Hangul_SingleCandidate

XK_Hangul_Sios:

keysym: const XK_Hangul_Sios

XK_Hangul_Special:

keysym: const XK_Hangul_Special

XK_Hangul_SsangDikeud:

keysym: const XK_Hangul_SsangDikeud

XK_Hangul_SsangJieuj:

keysym: const XK_Hangul_SsangJieuj

XK_Hangul_SsangKiyeog:

keysym: const XK_Hangul_SsangKiyeog

XK_Hangul_SsangPieub:

keysym: const XK_Hangul_SsangPieub

XK_Hangul_SsangSios:

keysym: const XK_Hangul_SsangSios

XK_Hangul_Start:

keysym: const XK_Hangul_Start

XK_Hangul_SunkyeongeumMieum:

keysym: const XK_Hangul_SunkyeongeumMieum

XK_Hangul_SunkyeongeumPhieuf:

keysym: const XK_Hangul_SunkyeongeumPhieuf

XK_Hangul_SunkyeongeumPieub:

keysym: const XK_Hangul_SunkyeongeumPieub

XK_Hangul_switch:

keysym: const XK_Hangul_switch

XK_Hangul_Tieut:

keysym: const XK_Hangul_Tieut

XK_Hangul_U:

keysym: const XK_Hangul_U

XK_Hangul_WA:

keysym: const XK_Hangul_WA

XK_Hangul_WAE:

keysym: const XK_Hangul_WAE

XK_Hangul_WE:

keysym: const XK_Hangul_WE

XK_Hangul_WEO:

keysym: const XK_Hangul_WEO

XK_Hangul_WI:

keysym: const XK_Hangul_WI

XK_Hangul_YA:

keysym: const XK_Hangul_YA

XK_Hangul_YAE:

keysym: const XK_Hangul_YAE

XK_Hangul_YE:

keysym: const XK_Hangul_YE

XK_Hangul_YEO:

keysym: const XK_Hangul_YEO

XK_Hangul_YeorinHieuh:

keysym: const XK_Hangul_YeorinHieuh

XK_Hangul_YI:

keysym: const XK_Hangul_YI

XK_Hangul_YO:

keysym: const XK_Hangul_YO

XK_Hangul_YU:

keysym: const XK_Hangul_YU

XK_Hankaku:

keysym: const XK_Hankaku

XK_hcircumflex:

keysym: const XK_hcircumflex

XK_heart:

keysym: const XK_heart

XK_hebrew_aleph:

keysym: const XK_hebrew_aleph

XK_hebrew_ayin:

keysym: const XK_hebrew_ayin

XK_hebrew_bet:

keysym: const XK_hebrew_bet

XK_hebrew_beth:

keysym: const XK_hebrew_beth

XK_hebrew_chet:

keysym: const XK_hebrew_chet

XK_hebrew_dalet:

keysym: const XK_hebrew_dalet

XK_hebrew_daleth:

keysym: const XK_hebrew_daleth

XK_hebrew_doublelowline:

keysym: const XK_hebrew_doublelowline

XK_hebrew_finalkaph:

keysym: const XK_hebrew_finalkaph

XK_hebrew_finalmem:

keysym: const XK_hebrew_finalmem

XK_hebrew_finalnun:

keysym: const XK_hebrew_finalnun

XK_hebrew_finalpe:

keysym: const XK_hebrew_finalpe

XK_hebrew_finalzade:

keysym: const XK_hebrew_finalzade

XK_hebrew_finalzadi:

keysym: const XK_hebrew_finalzadi

XK_hebrew_gimel:

keysym: const XK_hebrew_gimel

XK_hebrew_gimmel:

keysym: const XK_hebrew_gimmel

XK_hebrew_he:

keysym: const XK_hebrew_he

XK_hebrew_het:

keysym: const XK_hebrew_het

XK_hebrew_kaph:

keysym: const XK_hebrew_kaph

XK_hebrew_kuf:

keysym: const XK_hebrew_kuf

XK_hebrew_lamed:

keysym: const XK_hebrew_lamed

XK_hebrew_mem:

keysym: const XK_hebrew_mem

XK_hebrew_nun:

keysym: const XK_hebrew_nun

XK_hebrew_pe:

keysym: const XK_hebrew_pe

XK_hebrew_qoph:

keysym: const XK_hebrew_qoph

XK_hebrew_resh:

keysym: const XK_hebrew_resh

XK_hebrew_samech:

keysym: const XK_hebrew_samech

XK_hebrew_samekh:

keysym: const XK_hebrew_samekh

XK_hebrew_shin:

keysym: const XK_hebrew_shin

XK_Hebrew_switch:

keysym: const XK_Hebrew_switch

XK_hebrew_taf:

keysym: const XK_hebrew_taf

XK_hebrew_taw:

keysym: const XK_hebrew_taw

XK_hebrew_tet:

keysym: const XK_hebrew_tet

XK_hebrew_teth:

keysym: const XK_hebrew_teth

XK_hebrew_waw:

keysym: const XK_hebrew_waw

XK_hebrew_yod:

keysym: const XK_hebrew_yod

XK_hebrew_zade:

keysym: const XK_hebrew_zade

XK_hebrew_zadi:

keysym: const XK_hebrew_zadi

XK_hebrew_zain:

keysym: const XK_hebrew_zain

XK_hebrew_zayin:

keysym: const XK_hebrew_zayin

XK_Help:

keysym: const XK_Help

XK_Henkan:

keysym: const XK_Henkan

XK_Henkan_Mode:

keysym: const XK_Henkan_Mode

XK_hexagram:

keysym: const XK_hexagram

XK_Hiragana:

keysym: const XK_Hiragana

XK_Hiragana_Katakana:

keysym: const XK_Hiragana_Katakana

XK_Home:

keysym: const XK_Home

XK_horizconnector:

keysym: const XK_horizconnector

XK_hstroke:

keysym: const XK_hstroke

XK_Hyper_L:

keysym: const XK_Hyper_L

XK_Hyper_R:

keysym: const XK_Hyper_R

XK_hyphen:

keysym: const XK_hyphen

XK_i:

keysym: const XK_i

XK_iacute:

keysym: const XK_iacute

XK_ibelowdot:

keysym: const XK_ibelowdot

XK_ibreve:

keysym: const XK_ibreve

XK_icircumflex:

keysym: const XK_icircumflex

XK_identical:

keysym: const XK_identical

XK_idiaeresis:

keysym: const XK_idiaeresis

XK_idotless:

keysym: const XK_idotless

XK_ie:

keysym: const XK_ie

XK_ifonlyif:

keysym: const XK_ifonlyif

XK_igrave:

keysym: const XK_igrave

XK_ihook:

keysym: const XK_ihook

XKillClient:

xlib: proc XKillClient(para1: PDisplay; para2: XID): cint

XK_imacron:

keysym: const XK_imacron

XK_implies:

keysym: const XK_implies

XK_includedin:

keysym: const XK_includedin

XK_includes:

keysym: const XK_includes

XK_infinity:

keysym: const XK_infinity

XK_Insert:

keysym: const XK_Insert

XK_integral:

keysym: const XK_integral

XK_intersection:

keysym: const XK_intersection

XK_iogonek:

keysym: const XK_iogonek

XK_ISO_Center_Object:

keysym: const XK_ISO_Center_Object

XK_ISO_Continuous_Underline:

keysym: const XK_ISO_Continuous_Underline

XK_ISO_Discontinuous_Underline:

keysym: const XK_ISO_Discontinuous_Underline

XK_ISO_Emphasize:

keysym: const XK_ISO_Emphasize

XK_ISO_Enter:

keysym: const XK_ISO_Enter

XK_ISO_Fast_Cursor_Down:

keysym: const XK_ISO_Fast_Cursor_Down

XK_ISO_Fast_Cursor_Left:

keysym: const XK_ISO_Fast_Cursor_Left

XK_ISO_Fast_Cursor_Right:

keysym: const XK_ISO_Fast_Cursor_Right

XK_ISO_Fast_Cursor_Up:

keysym: const XK_ISO_Fast_Cursor_Up

XK_ISO_First_Group:

keysym: const XK_ISO_First_Group

XK_ISO_First_Group_Lock:

keysym: const XK_ISO_First_Group_Lock

XK_ISO_Group_Latch:

keysym: const XK_ISO_Group_Latch

XK_ISO_Group_Lock:

keysym: const XK_ISO_Group_Lock

XK_ISO_Group_Shift:

keysym: const XK_ISO_Group_Shift

XK_ISO_Last_Group:

keysym: const XK_ISO_Last_Group

XK_ISO_Last_Group_Lock:

keysym: const XK_ISO_Last_Group_Lock

XK_ISO_Left_Tab:

keysym: const XK_ISO_Left_Tab

XK_ISO_Level2_Latch:

keysym: const XK_ISO_Level2_Latch

XK_ISO_Level3_Latch:

keysym: const XK_ISO_Level3_Latch

XK_ISO_Level3_Lock:

keysym: const XK_ISO_Level3_Lock

XK_ISO_Level3_Shift:

keysym: const XK_ISO_Level3_Shift

XK_ISO_Lock:

keysym: const XK_ISO_Lock

XK_ISO_Move_Line_Down:

keysym: const XK_ISO_Move_Line_Down

XK_ISO_Move_Line_Up:

keysym: const XK_ISO_Move_Line_Up

XK_ISO_Next_Group:

keysym: const XK_ISO_Next_Group

XK_ISO_Next_Group_Lock:

keysym: const XK_ISO_Next_Group_Lock

XK_ISO_Partial_Line_Down:

keysym: const XK_ISO_Partial_Line_Down

XK_ISO_Partial_Line_Up:

keysym: const XK_ISO_Partial_Line_Up

XK_ISO_Partial_Space_Left:

keysym: const XK_ISO_Partial_Space_Left

XK_ISO_Partial_Space_Right:

keysym: const XK_ISO_Partial_Space_Right

XK_ISO_Prev_Group:

keysym: const XK_ISO_Prev_Group

XK_ISO_Prev_Group_Lock:

keysym: const XK_ISO_Prev_Group_Lock

XK_ISO_Release_Both_Margins:

keysym: const XK_ISO_Release_Both_Margins

XK_ISO_Release_Margin_Left:

keysym: const XK_ISO_Release_Margin_Left

XK_ISO_Release_Margin_Right:

keysym: const XK_ISO_Release_Margin_Right

XK_ISO_Set_Margin_Left:

keysym: const XK_ISO_Set_Margin_Left

XK_ISO_Set_Margin_Right:

keysym: const XK_ISO_Set_Margin_Right

XK_itilde:

keysym: const XK_itilde

XK_j:

keysym: const XK_j

XK_jcircumflex:

keysym: const XK_jcircumflex

XK_jot:

keysym: const XK_jot

XK_k:

keysym: const XK_k

XK_kana_a:

keysym: const XK_kana_a

XK_kana_closingbracket:

keysym: const XK_kana_closingbracket

XK_kana_comma:

keysym: const XK_kana_comma

XK_kana_conjunctive:

keysym: const XK_kana_conjunctive

XK_kana_e:

keysym: const XK_kana_e

XK_kana_fullstop:

keysym: const XK_kana_fullstop

XK_kana_i:

keysym: const XK_kana_i

XK_Kana_Lock:

keysym: const XK_Kana_Lock

XK_kana_middledot:

keysym: const XK_kana_middledot

XK_kana_o:

keysym: const XK_kana_o

XK_kana_openingbracket:

keysym: const XK_kana_openingbracket

XK_Kana_Shift:

keysym: const XK_Kana_Shift

XK_kana_switch:

keysym: const XK_kana_switch

XK_kana_tsu:

keysym: const XK_kana_tsu

XK_kana_tu:

keysym: const XK_kana_tu

XK_kana_u:

keysym: const XK_kana_u

XK_kana_ya:

keysym: const XK_kana_ya

XK_kana_yo:

keysym: const XK_kana_yo

XK_kana_yu:

keysym: const XK_kana_yu

XK_Kanji:

keysym: const XK_Kanji

XK_Kanji_Bangou:

keysym: const XK_Kanji_Bangou

XK_kappa:

keysym: const XK_kappa

XK_Katakana:

keysym: const XK_Katakana

XK_kcedilla:

keysym: const XK_kcedilla

XK_Korean_Won:

keysym: const XK_Korean_Won

XK_KP_0:

keysym: const XK_KP_0

XK_KP_1:

keysym: const XK_KP_1

XK_KP_2:

keysym: const XK_KP_2

XK_KP_3:

keysym: const XK_KP_3

XK_KP_4:

keysym: const XK_KP_4

XK_KP_5:

keysym: const XK_KP_5

XK_KP_6:

keysym: const XK_KP_6

XK_KP_7:

keysym: const XK_KP_7

XK_KP_8:

keysym: const XK_KP_8

XK_KP_9:

keysym: const XK_KP_9

XK_KP_Add:

keysym: const XK_KP_Add

XK_KP_Begin:

keysym: const XK_KP_Begin

XK_KP_Decimal:

keysym: const XK_KP_Decimal

XK_KP_Delete:

keysym: const XK_KP_Delete

XK_KP_Divide:

keysym: const XK_KP_Divide

XK_KP_Down:

keysym: const XK_KP_Down

XK_KP_End:

keysym: const XK_KP_End

XK_KP_Enter:

keysym: const XK_KP_Enter

XK_KP_Equal:

keysym: const XK_KP_Equal

XK_KP_F1:

keysym: const XK_KP_F1

XK_KP_F2:

keysym: const XK_KP_F2

XK_KP_F3:

keysym: const XK_KP_F3

XK_KP_F4:

keysym: const XK_KP_F4

XK_KP_Home:

keysym: const XK_KP_Home

XK_KP_Insert:

keysym: const XK_KP_Insert

XK_KP_Left:

keysym: const XK_KP_Left

XK_KP_Multiply:

keysym: const XK_KP_Multiply

XK_KP_Next:

keysym: const XK_KP_Next

XK_KP_Page_Down:

keysym: const XK_KP_Page_Down

XK_KP_Page_Up:

keysym: const XK_KP_Page_Up

XK_KP_Prior:

keysym: const XK_KP_Prior

XK_KP_Right:

keysym: const XK_KP_Right

XK_KP_Separator:

keysym: const XK_KP_Separator

XK_KP_Space:

keysym: const XK_KP_Space

XK_KP_Subtract:

keysym: const XK_KP_Subtract

XK_KP_Tab:

keysym: const XK_KP_Tab

XK_KP_Up:

keysym: const XK_KP_Up

XK_kra:

keysym: const XK_kra

XK_l:

keysym: const XK_l

XK_L1:

keysym: const XK_L1

XK_L10:

keysym: const XK_L10

XK_L2:

keysym: const XK_L2

XK_L3:

keysym: const XK_L3

XK_L4:

keysym: const XK_L4

XK_L5:

keysym: const XK_L5

XK_L6:

keysym: const XK_L6

XK_L7:

keysym: const XK_L7

XK_L8:

keysym: const XK_L8

XK_L9:

keysym: const XK_L9

XK_lacute:

keysym: const XK_lacute

XK_Last_Virtual_Screen:

keysym: const XK_Last_Virtual_Screen

XK_latincross:

keysym: const XK_latincross

XK_lbelowdot:

keysym: const XK_lbelowdot

XK_lcaron:

keysym: const XK_lcaron

XK_lcedilla:

keysym: const XK_lcedilla

XK_Left:

keysym: const XK_Left

XK_leftanglebracket:

keysym: const XK_leftanglebracket

XK_leftarrow:

keysym: const XK_leftarrow

XK_leftcaret:

keysym: const XK_leftcaret

XK_leftdoublequotemark:

keysym: const XK_leftdoublequotemark

XK_leftmiddlecurlybrace:

keysym: const XK_leftmiddlecurlybrace

XK_leftopentriangle:

keysym: const XK_leftopentriangle

XK_leftpointer:

keysym: const XK_leftpointer

XK_leftradical:

keysym: const XK_leftradical

XK_leftshoe:

keysym: const XK_leftshoe

XK_leftsinglequotemark:

keysym: const XK_leftsinglequotemark

XK_lefttack:

keysym: const XK_lefttack

XK_less:

keysym: const XK_less

XK_lessthanequal:

keysym: const XK_lessthanequal

XK_Linefeed:

keysym: const XK_Linefeed

XK_LiraSign:

keysym: const XK_LiraSign

XK_logicaland:

keysym: const XK_logicaland

XK_logicalor:

keysym: const XK_logicalor

XK_lstroke:

keysym: const XK_lstroke

XK_lstrokebelowdot:

keysym: const XK_lstrokebelowdot

XK_m:

keysym: const XK_m

XK_mabovedot:

keysym: const XK_mabovedot

XK_Macedonia_dse:

keysym: const XK_Macedonia_dse

XK_Macedonia_gje:

keysym: const XK_Macedonia_gje

XK_Macedonia_kje:

keysym: const XK_Macedonia_kje

XK_macron:

keysym: const XK_macron

XK_Mae_Koho:

keysym: const XK_Mae_Koho

XK_malesymbol:

keysym: const XK_malesymbol

XK_maltesecross:

keysym: const XK_maltesecross

XK_marker:

keysym: const XK_marker

XK_masculine:

keysym: const XK_masculine

XK_Massyo:

keysym: const XK_Massyo

XK_Menu:

keysym: const XK_Menu

XK_Meta_L:

keysym: const XK_Meta_L

XK_Meta_R:

keysym: const XK_Meta_R

XK_MillSign:

keysym: const XK_MillSign

XK_minus:

keysym: const XK_minus

XK_minutes:

keysym: const XK_minutes

XK_Mode_switch:

keysym: const XK_Mode_switch

XK_MouseKeys_Accel_Enable:

keysym: const XK_MouseKeys_Accel_Enable

XK_MouseKeys_Enable:

keysym: const XK_MouseKeys_Enable

XK_mu:

keysym: const XK_mu

XK_Muhenkan:

keysym: const XK_Muhenkan

XK_Multi_key:

keysym: const XK_Multi_key

XK_MultipleCandidate:

keysym: const XK_MultipleCandidate

XK_multiply:

keysym: const XK_multiply

XK_musicalflat:

keysym: const XK_musicalflat

XK_musicalsharp:

keysym: const XK_musicalsharp

XK_n:

keysym: const XK_n

XK_nabla:

keysym: const XK_nabla

XK_nacute:

keysym: const XK_nacute

XK_NairaSign:

keysym: const XK_NairaSign

XK_ncaron:

keysym: const XK_ncaron

XK_ncedilla:

keysym: const XK_ncedilla

XK_NewSheqelSign:

keysym: const XK_NewSheqelSign

XK_Next:

keysym: const XK_Next

XK_Next_Virtual_Screen:

keysym: const XK_Next_Virtual_Screen

XK_nobreakspace:

keysym: const XK_nobreakspace

XK_notequal:

keysym: const XK_notequal

XK_notsign:

keysym: const XK_notsign

XK_ntilde:

keysym: const XK_ntilde

XK_numbersign:

keysym: const XK_numbersign

XK_numerosign:

keysym: const XK_numerosign

XK_Num_Lock:

keysym: const XK_Num_Lock

XK_o:

keysym: const XK_o

XK_oacute:

keysym: const XK_oacute

XK_obarred:

keysym: const XK_obarred

XK_obelowdot:

keysym: const XK_obelowdot

XK_ocaron:

keysym: const XK_ocaron

XK_ocircumflex:

keysym: const XK_ocircumflex

XK_ocircumflexacute:

keysym: const XK_ocircumflexacute

XK_ocircumflexbelowdot:

keysym: const XK_ocircumflexbelowdot

XK_ocircumflexgrave:

keysym: const XK_ocircumflexgrave

XK_ocircumflexhook:

keysym: const XK_ocircumflexhook

XK_ocircumflextilde:

keysym: const XK_ocircumflextilde

XK_odiaeresis:

keysym: const XK_odiaeresis

XK_odoubleacute:

keysym: const XK_odoubleacute

XK_oe:

keysym: const XK_oe

XK_ogonek:

keysym: const XK_ogonek

XK_ograve:

keysym: const XK_ograve

XK_ohook:

keysym: const XK_ohook

XK_ohorn:

keysym: const XK_ohorn

XK_ohornacute:

keysym: const XK_ohornacute

XK_ohornbelowdot:

keysym: const XK_ohornbelowdot

XK_ohorngrave:

keysym: const XK_ohorngrave

XK_ohornhook:

keysym: const XK_ohornhook

XK_ohorntilde:

keysym: const XK_ohorntilde

XK_omacron:

keysym: const XK_omacron

XK_oneeighth:

keysym: const XK_oneeighth

XK_onefifth:

keysym: const XK_onefifth

XK_onehalf:

keysym: const XK_onehalf

XK_onequarter:

keysym: const XK_onequarter

XK_onesixth:

keysym: const XK_onesixth

XK_onesuperior:

keysym: const XK_onesuperior

XK_onethird:

keysym: const XK_onethird

XK_ooblique:

keysym: const XK_ooblique

XK_openrectbullet:

keysym: const XK_openrectbullet

XK_openstar:

keysym: const XK_openstar

XK_opentribulletdown:

keysym: const XK_opentribulletdown

XK_opentribulletup:

keysym: const XK_opentribulletup

XK_ordfeminine:

keysym: const XK_ordfeminine

XK_oslash:

keysym: const XK_oslash

XK_otilde:

keysym: const XK_otilde

XK_overbar:

keysym: const XK_overbar

XK_Overlay1_Enable:

keysym: const XK_Overlay1_Enable

XK_Overlay2_Enable:

keysym: const XK_Overlay2_Enable

XK_overline:

keysym: const XK_overline

XK_p:

keysym: const XK_p

XK_pabovedot:

keysym: const XK_pabovedot

XK_Page_Down:

keysym: const XK_Page_Down

XK_Page_Up:

keysym: const XK_Page_Up

XK_paragraph:

keysym: const XK_paragraph

XK_parenleft:

keysym: const XK_parenleft

XK_parenright:

keysym: const XK_parenright

XK_partialderivative:

keysym: const XK_partialderivative

XK_Pause:

keysym: const XK_Pause

XK_percent:

keysym: const XK_percent

XK_period:

keysym: const XK_period

XK_periodcentered:

keysym: const XK_periodcentered

XK_PesetaSign:

keysym: const XK_PesetaSign

XK_phonographcopyright:

keysym: const XK_phonographcopyright

XK_plus:

keysym: const XK_plus

XK_plusminus:

keysym: const XK_plusminus

XK_Pointer_Accelerate:

keysym: const XK_Pointer_Accelerate

XK_Pointer_Button1:

keysym: const XK_Pointer_Button1

XK_Pointer_Button2:

keysym: const XK_Pointer_Button2

XK_Pointer_Button3:

keysym: const XK_Pointer_Button3

XK_Pointer_Button4:

keysym: const XK_Pointer_Button4

XK_Pointer_Button5:

keysym: const XK_Pointer_Button5

XK_Pointer_Button_Dflt:

keysym: const XK_Pointer_Button_Dflt

XK_Pointer_DblClick1:

keysym: const XK_Pointer_DblClick1

XK_Pointer_DblClick2:

keysym: const XK_Pointer_DblClick2

XK_Pointer_DblClick3:

keysym: const XK_Pointer_DblClick3

XK_Pointer_DblClick4:

keysym: const XK_Pointer_DblClick4

XK_Pointer_DblClick5:

keysym: const XK_Pointer_DblClick5

XK_Pointer_DblClick_Dflt:

keysym: const XK_Pointer_DblClick_Dflt

XK_Pointer_DfltBtnNext:

keysym: const XK_Pointer_DfltBtnNext

XK_Pointer_DfltBtnPrev:

keysym: const XK_Pointer_DfltBtnPrev

XK_Pointer_Down:

keysym: const XK_Pointer_Down

XK_Pointer_DownLeft:

keysym: const XK_Pointer_DownLeft

XK_Pointer_DownRight:

keysym: const XK_Pointer_DownRight

XK_Pointer_Drag1:

keysym: const XK_Pointer_Drag1

XK_Pointer_Drag2:

keysym: const XK_Pointer_Drag2

XK_Pointer_Drag3:

keysym: const XK_Pointer_Drag3

XK_Pointer_Drag4:

keysym: const XK_Pointer_Drag4

XK_Pointer_Drag5:

keysym: const XK_Pointer_Drag5

XK_Pointer_Drag_Dflt:

keysym: const XK_Pointer_Drag_Dflt

XK_Pointer_EnableKeys:

keysym: const XK_Pointer_EnableKeys

XK_Pointer_Left:

keysym: const XK_Pointer_Left

XK_Pointer_Right:

keysym: const XK_Pointer_Right

XK_Pointer_Up:

keysym: const XK_Pointer_Up

XK_Pointer_UpLeft:

keysym: const XK_Pointer_UpLeft

XK_Pointer_UpRight:

keysym: const XK_Pointer_UpRight

XK_prescription:

keysym: const XK_prescription

XK_PreviousCandidate:

keysym: const XK_PreviousCandidate

XK_Prev_Virtual_Screen:

keysym: const XK_Prev_Virtual_Screen

XK_Print:

keysym: const XK_Print

XK_Prior:

keysym: const XK_Prior

XK_prolongedsound:

keysym: const XK_prolongedsound

XK_punctspace:

keysym: const XK_punctspace

XK_q:

keysym: const XK_q

XK_qabovedot:

keysym: const XK_qabovedot

XK_quad:

keysym: const XK_quad

XK_question:

keysym: const XK_question

XK_questiondown:

keysym: const XK_questiondown

XK_quotedbl:

keysym: const XK_quotedbl

XK_quoteleft:

keysym: const XK_quoteleft

XK_quoteright:

keysym: const XK_quoteright

XK_r:

keysym: const XK_r

XK_R1:

keysym: const XK_R1

XK_R10:

keysym: const XK_R10

XK_R11:

keysym: const XK_R11

XK_R12:

keysym: const XK_R12

XK_R13:

keysym: const XK_R13

XK_R14:

keysym: const XK_R14

XK_R15:

keysym: const XK_R15

XK_R2:

keysym: const XK_R2

XK_R3:

keysym: const XK_R3

XK_R4:

keysym: const XK_R4

XK_R5:

keysym: const XK_R5

XK_R6:

keysym: const XK_R6

XK_R7:

keysym: const XK_R7

XK_R8:

keysym: const XK_R8

XK_R9:

keysym: const XK_R9

XK_racute:

keysym: const XK_racute

XK_radical:

keysym: const XK_radical

XK_rcaron:

keysym: const XK_rcaron

XK_rcedilla:

keysym: const XK_rcedilla

XK_Redo:

keysym: const XK_Redo

XK_registered:

keysym: const XK_registered

XK_RepeatKeys_Enable:

keysym: const XK_RepeatKeys_Enable

XK_Return:

keysym: const XK_Return

XK_Right:

keysym: const XK_Right

XK_rightanglebracket:

keysym: const XK_rightanglebracket

XK_rightarrow:

keysym: const XK_rightarrow

XK_rightcaret:

keysym: const XK_rightcaret

XK_rightdoublequotemark:

keysym: const XK_rightdoublequotemark

XK_rightmiddlecurlybrace:

keysym: const XK_rightmiddlecurlybrace

XK_rightmiddlesummation:

keysym: const XK_rightmiddlesummation

XK_rightopentriangle:

keysym: const XK_rightopentriangle

XK_rightpointer:

keysym: const XK_rightpointer

XK_rightshoe:

keysym: const XK_rightshoe

XK_rightsinglequotemark:

keysym: const XK_rightsinglequotemark

XK_righttack:

keysym: const XK_righttack

XK_Romaji:

keysym: const XK_Romaji

XK_RupeeSign:

keysym: const XK_RupeeSign

XK_s:

keysym: const XK_s

XK_sabovedot:

keysym: const XK_sabovedot

XK_sacute:

keysym: const XK_sacute

XK_scaron:

keysym: const XK_scaron

XK_scedilla:

keysym: const XK_scedilla

XK_schwa:

keysym: const XK_schwa

XK_scircumflex:

keysym: const XK_scircumflex

XK_script_switch:

keysym: const XK_script_switch

XK_Scroll_Lock:

keysym: const XK_Scroll_Lock

XK_seconds:

keysym: const XK_seconds

XK_section:

keysym: const XK_section

XK_Select:

keysym: const XK_Select

XK_semicolon:

keysym: const XK_semicolon

XK_semivoicedsound:

keysym: const XK_semivoicedsound

XK_Serbian_dje:

keysym: const XK_Serbian_dje

XK_Serbian_dze:

keysym: const XK_Serbian_dze

XK_Serbian_je:

keysym: const XK_Serbian_je

XK_Serbian_lje:

keysym: const XK_Serbian_lje

XK_Serbian_nje:

keysym: const XK_Serbian_nje

XK_Serbian_tshe:

keysym: const XK_Serbian_tshe

XK_seveneighths:

keysym: const XK_seveneighths

XK_Shift_L:

keysym: const XK_Shift_L

XK_Shift_Lock:

keysym: const XK_Shift_Lock

XK_Shift_R:

keysym: const XK_Shift_R

XK_signaturemark:

keysym: const XK_signaturemark

XK_signifblank:

keysym: const XK_signifblank

XK_similarequal:

keysym: const XK_similarequal

XK_SingleCandidate:

keysym: const XK_SingleCandidate

XK_singlelowquotemark:

keysym: const XK_singlelowquotemark

XK_slash:

keysym: const XK_slash

XK_SlowKeys_Enable:

keysym: const XK_SlowKeys_Enable

XK_space:

keysym: const XK_space

XK_ssharp:

keysym: const XK_ssharp

XK_sterling:

keysym: const XK_sterling

XK_StickyKeys_Enable:

keysym: const XK_StickyKeys_Enable

XK_Super_L:

keysym: const XK_Super_L

XK_Super_R:

keysym: const XK_Super_R

XK_Sys_Req:

keysym: const XK_Sys_Req

XK_t:

keysym: const XK_t

XK_Tab:

keysym: const XK_Tab

XK_tabovedot:

keysym: const XK_tabovedot

XK_tcaron:

keysym: const XK_tcaron

XK_tcedilla:

keysym: const XK_tcedilla

XK_telephone:

keysym: const XK_telephone

XK_telephonerecorder:

keysym: const XK_telephonerecorder

XK_Terminate_Server:

keysym: const XK_Terminate_Server

XK_Thai_baht:

keysym: const XK_Thai_baht

XK_Thai_bobaimai:

keysym: const XK_Thai_bobaimai

XK_Thai_chochan:

keysym: const XK_Thai_chochan

XK_Thai_chochang:

keysym: const XK_Thai_chochang

XK_Thai_choching:

keysym: const XK_Thai_choching

XK_Thai_chochoe:

keysym: const XK_Thai_chochoe

XK_Thai_dochada:

keysym: const XK_Thai_dochada

XK_Thai_dodek:

keysym: const XK_Thai_dodek

XK_Thai_fofa:

keysym: const XK_Thai_fofa

XK_Thai_fofan:

keysym: const XK_Thai_fofan

XK_Thai_hohip:

keysym: const XK_Thai_hohip

XK_Thai_honokhuk:

keysym: const XK_Thai_honokhuk

XK_Thai_khokhai:

keysym: const XK_Thai_khokhai

XK_Thai_khokhon:

keysym: const XK_Thai_khokhon

XK_Thai_khokhuat:

keysym: const XK_Thai_khokhuat

XK_Thai_khokhwai:

keysym: const XK_Thai_khokhwai

XK_Thai_khorakhang:

keysym: const XK_Thai_khorakhang

XK_Thai_kokai:

keysym: const XK_Thai_kokai

XK_Thai_lakkhangyao:

keysym: const XK_Thai_lakkhangyao

XK_Thai_lekchet:

keysym: const XK_Thai_lekchet

XK_Thai_lekha:

keysym: const XK_Thai_lekha

XK_Thai_lekhok:

keysym: const XK_Thai_lekhok

XK_Thai_lekkao:

keysym: const XK_Thai_lekkao

XK_Thai_leknung:

keysym: const XK_Thai_leknung

XK_Thai_lekpaet:

keysym: const XK_Thai_lekpaet

XK_Thai_leksam:

keysym: const XK_Thai_leksam

XK_Thai_leksi:

keysym: const XK_Thai_leksi

XK_Thai_leksong:

keysym: const XK_Thai_leksong

XK_Thai_leksun:

keysym: const XK_Thai_leksun

XK_Thai_lochula:

keysym: const XK_Thai_lochula

XK_Thai_loling:

keysym: const XK_Thai_loling

XK_Thai_lu:

keysym: const XK_Thai_lu

XK_Thai_maichattawa:

keysym: const XK_Thai_maichattawa

XK_Thai_maiek:

keysym: const XK_Thai_maiek

XK_Thai_maihanakat:

keysym: const XK_Thai_maihanakat

XK_Thai_maihanakat_maitho:

keysym: const XK_Thai_maihanakat_maitho

XK_Thai_maitaikhu:

keysym: const XK_Thai_maitaikhu

XK_Thai_maitho:

keysym: const XK_Thai_maitho

XK_Thai_maitri:

keysym: const XK_Thai_maitri

XK_Thai_maiyamok:

keysym: const XK_Thai_maiyamok

XK_Thai_moma:

keysym: const XK_Thai_moma

XK_Thai_ngongu:

keysym: const XK_Thai_ngongu

XK_Thai_nikhahit:

keysym: const XK_Thai_nikhahit

XK_Thai_nonen:

keysym: const XK_Thai_nonen

XK_Thai_nonu:

keysym: const XK_Thai_nonu

XK_Thai_oang:

keysym: const XK_Thai_oang

XK_Thai_paiyannoi:

keysym: const XK_Thai_paiyannoi

XK_Thai_phinthu:

keysym: const XK_Thai_phinthu

XK_Thai_phophan:

keysym: const XK_Thai_phophan

XK_Thai_phophung:

keysym: const XK_Thai_phophung

XK_Thai_phosamphao:

keysym: const XK_Thai_phosamphao

XK_Thai_popla:

keysym: const XK_Thai_popla

XK_Thai_rorua:

keysym: const XK_Thai_rorua

XK_Thai_ru:

keysym: const XK_Thai_ru

XK_Thai_saraa:

keysym: const XK_Thai_saraa

XK_Thai_saraaa:

keysym: const XK_Thai_saraaa

XK_Thai_saraae:

keysym: const XK_Thai_saraae

XK_Thai_saraaimaimalai:

keysym: const XK_Thai_saraaimaimalai

XK_Thai_saraaimaimuan:

keysym: const XK_Thai_saraaimaimuan

XK_Thai_saraam:

keysym: const XK_Thai_saraam

XK_Thai_sarae:

keysym: const XK_Thai_sarae

XK_Thai_sarai:

keysym: const XK_Thai_sarai

XK_Thai_saraii:

keysym: const XK_Thai_saraii

XK_Thai_sarao:

keysym: const XK_Thai_sarao

XK_Thai_sarau:

keysym: const XK_Thai_sarau

XK_Thai_saraue:

keysym: const XK_Thai_saraue

XK_Thai_sarauee:

keysym: const XK_Thai_sarauee

XK_Thai_sarauu:

keysym: const XK_Thai_sarauu

XK_Thai_sorusi:

keysym: const XK_Thai_sorusi

XK_Thai_sosala:

keysym: const XK_Thai_sosala

XK_Thai_soso:

keysym: const XK_Thai_soso

XK_Thai_sosua:

keysym: const XK_Thai_sosua

XK_Thai_thanthakhat:

keysym: const XK_Thai_thanthakhat

XK_Thai_thonangmontho:

keysym: const XK_Thai_thonangmontho

XK_Thai_thophuthao:

keysym: const XK_Thai_thophuthao

XK_Thai_thothahan:

keysym: const XK_Thai_thothahan

XK_Thai_thothan:

keysym: const XK_Thai_thothan

XK_Thai_thothong:

keysym: const XK_Thai_thothong

XK_Thai_thothung:

keysym: const XK_Thai_thothung

XK_Thai_topatak:

keysym: const XK_Thai_topatak

XK_Thai_totao:

keysym: const XK_Thai_totao

XK_Thai_wowaen:

keysym: const XK_Thai_wowaen

XK_Thai_yoyak:

keysym: const XK_Thai_yoyak

XK_Thai_yoying:

keysym: const XK_Thai_yoying

XK_therefore:

keysym: const XK_therefore

XK_thinspace:

keysym: const XK_thinspace

XK_thorn:

keysym: const XK_thorn

XK_threeeighths:

keysym: const XK_threeeighths

XK_threefifths:

keysym: const XK_threefifths

XK_threequarters:

keysym: const XK_threequarters

XK_threesuperior:

keysym: const XK_threesuperior

XK_topintegral:

keysym: const XK_topintegral

XK_topleftparens:

keysym: const XK_topleftparens

XK_topleftradical:

keysym: const XK_topleftradical

XK_topleftsqbracket:

keysym: const XK_topleftsqbracket

XK_topleftsummation:

keysym: const XK_topleftsummation

XK_toprightparens:

keysym: const XK_toprightparens

XK_toprightsqbracket:

keysym: const XK_toprightsqbracket

XK_toprightsummation:

keysym: const XK_toprightsummation

XK_topvertsummationconnector:

keysym: const XK_topvertsummationconnector

XK_Touroku:

keysym: const XK_Touroku

XK_trademark:

keysym: const XK_trademark

XK_trademarkincircle:

keysym: const XK_trademarkincircle

XK_tslash:

keysym: const XK_tslash

XK_twofifths:

keysym: const XK_twofifths

XK_twosuperior:

keysym: const XK_twosuperior

XK_twothirds:

keysym: const XK_twothirds

XK_u:

keysym: const XK_u

XK_uacute:

keysym: const XK_uacute

XK_ubelowdot:

keysym: const XK_ubelowdot

XK_ubreve:

keysym: const XK_ubreve

XK_ucircumflex:

keysym: const XK_ucircumflex

XK_udiaeresis:

keysym: const XK_udiaeresis

XK_udoubleacute:

keysym: const XK_udoubleacute

XK_ugrave:

keysym: const XK_ugrave

XK_uhook:

keysym: const XK_uhook

XK_uhorn:

keysym: const XK_uhorn

XK_uhornacute:

keysym: const XK_uhornacute

XK_uhornbelowdot:

keysym: const XK_uhornbelowdot

XK_uhorngrave:

keysym: const XK_uhorngrave

XK_uhornhook:

keysym: const XK_uhornhook

XK_uhorntilde:

keysym: const XK_uhorntilde

XK_Ukrainian_ghe_with_upturn:

keysym: const XK_Ukrainian_ghe_with_upturn

XK_Ukrainian_i:

keysym: const XK_Ukrainian_i

XK_Ukrainian_ie:

keysym: const XK_Ukrainian_ie

XK_Ukrainian_yi:

keysym: const XK_Ukrainian_yi

XK_Ukranian_i:

keysym: const XK_Ukranian_i

XK_Ukranian_je:

keysym: const XK_Ukranian_je

XK_Ukranian_yi:

keysym: const XK_Ukranian_yi

XK_umacron:

keysym: const XK_umacron

XK_underbar:

keysym: const XK_underbar

XK_underscore:

keysym: const XK_underscore

XK_Undo:

keysym: const XK_Undo

XK_union:

keysym: const XK_union

XK_uo:

keysym: const XK_uo

XK_uogonek:

keysym: const XK_uogonek

XK_Up:

keysym: const XK_Up

XK_uparrow:

keysym: const XK_uparrow

XK_upcaret:

keysym: const XK_upcaret

XK_upshoe:

keysym: const XK_upshoe

XK_upstile:

keysym: const XK_upstile

XK_uptack:

keysym: const XK_uptack

XK_uring:

keysym: const XK_uring

XK_utilde:

keysym: const XK_utilde

XK_v:

keysym: const XK_v

XK_variation:

keysym: const XK_variation

XK_vertconnector:

keysym: const XK_vertconnector

XK_voicedsound:

keysym: const XK_voicedsound

XK_VoidSymbol:

keysym: const XK_VoidSymbol

XK_w:

keysym: const XK_w

XK_wacute:

keysym: const XK_wacute

XK_wcircumflex:

keysym: const XK_wcircumflex

XK_wdiaeresis:

keysym: const XK_wdiaeresis

XK_wgrave:

keysym: const XK_wgrave

XK_WonSign:

keysym: const XK_WonSign

XK_x:

keysym: const XK_x

XK_xabovedot:

keysym: const XK_xabovedot

XK_y:

keysym: const XK_y

XK_yacute:

keysym: const XK_yacute

XK_ybelowdot:

keysym: const XK_ybelowdot

XK_ycircumflex:

keysym: const XK_ycircumflex

XK_ydiaeresis:

keysym: const XK_ydiaeresis

XK_yen:

keysym: const XK_yen

XK_ygrave:

keysym: const XK_ygrave

XK_yhook:

keysym: const XK_yhook

XK_ytilde:

keysym: const XK_ytilde

XK_z:

keysym: const XK_z

XK_zabovedot:

keysym: const XK_zabovedot

XK_zacute:

keysym: const XK_zacute

XK_zcaron:

keysym: const XK_zcaron

XK_Zenkaku:

keysym: const XK_Zenkaku

XK_Zenkaku_Hankaku:

keysym: const XK_Zenkaku_Hankaku

XK_Zen_Koho:

keysym: const XK_Zen_Koho

XK_zstroke:

keysym: const XK_zstroke

XLastKnownRequestProcessed:

xlib: proc XLastKnownRequestProcessed(para1: PDisplay): culong

XLeaveWindowEvent:

xlib: type XLeaveWindowEvent

XlibSpecificationRelease:

xlib: const XlibSpecificationRelease

XListDepths:

xlib: proc XListDepths(para1: PDisplay; para2: cint; para3: Pcint): Pcint

XListExtensions:

xlib: proc XListExtensions(para1: PDisplay; para2: Pcint): PPChar

XListFonts:

xlib: proc XListFonts(para1: PDisplay; para2: cstring; para3: cint; para4: Pcint): PPChar

XListFontsWithInfo:

xlib: proc XListFontsWithInfo(para1: PDisplay; para2: cstring; para3: cint; para4: Pcint; para5: PPXFontStruct): PPChar

XListHosts:

xlib: proc XListHosts(para1: PDisplay; para2: Pcint; para3: PBool): PXHostAddress

XListInstalledColormaps:

xlib: proc XListInstalledColormaps(para1: PDisplay; para2: Window; para3: Pcint): PColormap

XListPixmapFormats:

xlib: proc XListPixmapFormats(para1: PDisplay; para2: Pcint): PXPixmapFormatValues

XListProperties:

xlib: proc XListProperties(para1: PDisplay; para2: Window; para3: Pcint): PAtom

XLoadFont:

xlib: proc XLoadFont(para1: PDisplay; para2: cstring): Font

XLoadQueryFont:

xlib: proc XLoadQueryFont(para1: PDisplay; para2: cstring): PXFontStruct

XLocaleNotSupported:

xutil: const XLocaleNotSupported

XLocaleOfFontSet:

xlib: proc XLocaleOfFontSet(para1: XFontSet): cstring

XLocaleOfIM:

xlib: proc XLocaleOfIM(para1: XIM): cstring

XLocaleOfOM:

xlib: proc XLocaleOfOM(para1: XOM): cstring

XLockDisplay:

xlib: proc XLockDisplay(para1: PDisplay)

XLookupBoth:

xlib: const XLookupBoth

XLookupChars:

xlib: const XLookupChars

XLookupColor:

xlib: proc XLookupColor(para1: PDisplay; para2: Colormap; para3: cstring; para4: PXColor; para5: PXColor): Status

XLookupKeysym:

xlib: proc XLookupKeysym(para1: PXKeyEvent; para2: cint): KeySym

XLookupKeySymVal:

xlib: const XLookupKeySymVal

XLookupNone:

xlib: const XLookupNone

XLookupString:

xutil: proc XLookupString(para1: PXKeyEvent; para2: cstring; para3: cint; para4: PKeySym; para5: PXComposeStatus): cint

XLowerWindow:

xlib: proc XLowerWindow(para1: PDisplay; para2: Window): cint

XMapEvent:

xlib: object XMapEvent

XMappingEvent:

xlib: object XMappingEvent

XMapRaised:

xlib: proc XMapRaised(para1: PDisplay; para2: Window): cint

XMapRequestEvent:

xlib: object XMapRequestEvent

XMapSubwindows:

xlib: proc XMapSubwindows(para1: PDisplay; para2: Window): cint

XMapWindow:

xlib: proc XMapWindow(para1: PDisplay; para2: Window): cint

XMaskEvent:

xlib: proc XMaskEvent(para1: PDisplay; para2: clong; para3: PXEvent): cint

XMatchVisualInfo:

xutil: proc XMatchVisualInfo(para1: PDisplay; para2: cint; para3: cint; para4: cint; para5: PXVisualInfo): Status

XMaxCmapsOfScreen:

xlib: proc XMaxCmapsOfScreen(para1: PScreen): cint

XMaxRequestSize:

xlib: proc XMaxRequestSize(para1: PDisplay): clong

XmbDrawImageString:

xlib: proc XmbDrawImageString(para1: PDisplay; para2: Drawable; para3: XFontSet; para4: GC; para5: cint; para6: cint; para7: cstring; para8: cint)

XmbDrawString:

xlib: proc XmbDrawString(para1: PDisplay; para2: Drawable; para3: XFontSet; para4: GC; para5: cint; para6: cint; para7: cstring; para8: cint)

XmbDrawText:

xlib: proc XmbDrawText(para1: PDisplay; para2: Drawable; para3: GC; para4: cint; para5: cint; para6: PXmbTextItem; para7: cint)

XmbLookupString:

xlib: proc XmbLookupString(para1: XIC; para2: PXKeyPressedEvent; para3: cstring; para4: cint; para5: PKeySym; para6: PStatus): cint

XmbResetIC:

xlib: proc XmbResetIC(para1: XIC): cstring

XmbSetWMProperties:

xutil: proc XmbSetWMProperties(para1: PDisplay; para2: Window; para3: cstring; para4: cstring; para5: PPChar; para6: cint; para7: PXSizeHints; para8: PXWMHints; para9: PXClassHint)

XmbTextEscapement:

xlib: proc XmbTextEscapement(para1: XFontSet; para2: cstring; para3: cint): cint

XmbTextExtents:

xlib: proc XmbTextExtents(para1: XFontSet; para2: cstring; para3: cint; para4: PXRectangle; para5: PXRectangle): cint

XmbTextItem:

xlib: object XmbTextItem

XmbTextListToTextProperty:

xutil: proc XmbTextListToTextProperty(para1: PDisplay; para2: PPChar; para3: cint; para4: XICCEncodingStyle; para5: PXTextProperty): cint

XmbTextPerCharExtents:

xlib: proc XmbTextPerCharExtents(para1: XFontSet; para2: cstring; para3: cint; para4: PXRectangle; para5: PXRectangle; para6: cint; para7: Pcint; para8: PXRectangle; para9: PXRectangle): Status

XmbTextPropertyToTextList:

xutil: proc XmbTextPropertyToTextList(para1: PDisplay; para2: PXTextProperty; para3: PPPChar; para4: Pcint): cint

XMinCmapsOfScreen:

xlib: proc XMinCmapsOfScreen(para1: PScreen): cint

XModifierKeymap:

xlib: object XModifierKeymap

XMotionEvent:

xlib: object XMotionEvent

XMoveResizeWindow:

xlib: proc XMoveResizeWindow(para1: PDisplay; para2: Window; para3: cint; para4: cint; para5: cuint; para6: cuint): cint

XMoveWindow:

xlib: proc XMoveWindow(para1: PDisplay; para2: Window; para3: cint; para4: cint): cint

XNArea:

xlib: const XNArea

XNAreaNeeded:

xlib: const XNAreaNeeded

XNBackground:

xlib: const XNBackground

XNBackgroundPixmap:

xlib: const XNBackgroundPixmap

XNBaseFontName:

xlib: const XNBaseFontName

XNClientWindow:

xlib: const XNClientWindow

XNColormap:

xlib: const XNColormap

XNContextualDrawing:

xlib: const XNContextualDrawing

XNCursor:

xlib: const XNCursor

XNDefaultString:

xlib: const XNDefaultString

XNDestroyCallback:

xlib: const XNDestroyCallback

XNDirectionalDependentDrawing:

xlib: const XNDirectionalDependentDrawing

XNegative:

xutil: const XNegative

XNewModifiermap:

xlib: proc XNewModifiermap(para1: cint): PXModifierKeymap

XNextEvent:

xlib: proc XNextEvent(para1: PDisplay; para2: PXEvent): cint

XNextRequest:

xlib: proc XNextRequest(para1: PDisplay): culong

XNFilterEvents:

xlib: const XNFilterEvents

XNFocusWindow:

xlib: const XNFocusWindow

XNFontInfo:

xlib: const XNFontInfo

XNFontSet:

xlib: const XNFontSet

XNForeground:

xlib: const XNForeground

XNGeometryCallback:

xlib: const XNGeometryCallback

XNHotKey:

xlib: const XNHotKey

XNHotKeyState:

xlib: const XNHotKeyState

XNInputStyle:

xlib: const XNInputStyle

XNLineSpace:

xlib: const XNLineSpace

XNMissingCharSet:

xlib: const XNMissingCharSet

XNoExposeEvent:

xlib: object XNoExposeEvent

XNOMAutomatic:

xlib: const XNOMAutomatic

XNoMemory:

xutil: const XNoMemory

XNoOp:

xlib: proc XNoOp(para1: PDisplay): cint

XNOrientation:

xlib: const XNOrientation

XNPreeditAttributes:

xlib: const XNPreeditAttributes

XNPreeditCaretCallback:

xlib: const XNPreeditCaretCallback

XNPreeditDoneCallback:

xlib: const XNPreeditDoneCallback

XNPreeditDrawCallback:

xlib: const XNPreeditDrawCallback

XNPreeditStartCallback:

xlib: const XNPreeditStartCallback

XNPreeditState:

xlib: const XNPreeditState

XNPreeditStateNotifyCallback:

xlib: const XNPreeditStateNotifyCallback

XNQueryICValuesList:

xlib: const XNQueryICValuesList

XNQueryIMValuesList:

xlib: const XNQueryIMValuesList

XNQueryInputStyle:

xlib: const XNQueryInputStyle

XNQueryOrientation:

xlib: const XNQueryOrientation

XNR6PreeditCallback:

xlib: const XNR6PreeditCallback

XNRequiredCharSet:

xlib: const XNRequiredCharSet

XNResetState:

xlib: const XNResetState

XNResourceClass:

xlib: const XNResourceClass

XNResourceName:

xlib: const XNResourceName

XNSeparatorofNestedList:

xlib: const XNSeparatorofNestedList

XNSpotLocation:

xlib: const XNSpotLocation

XNStatusAttributes:

xlib: const XNStatusAttributes

XNStatusDoneCallback:

xlib: const XNStatusDoneCallback

XNStatusDrawCallback:

xlib: const XNStatusDrawCallback

XNStatusStartCallback:

xlib: const XNStatusStartCallback

XNStdColormap:

xlib: const XNStdColormap

XNStringConversion:

xlib: const XNStringConversion

XNStringConversionCallback:

xlib: const XNStringConversionCallback

XNVaNestedList:

xlib: const XNVaNestedList

XNVisiblePosition:

xlib: const XNVisiblePosition

XOC:

xlib: object XOC

XOffsetRegion:

xutil: proc XOffsetRegion(para1: Region; para2: cint; para3: cint): cint

XOM:

xlib: object XOM

XOMCharSetList:

xlib: object XOMCharSetList

XOMFontInfo:

xlib: object XOMFontInfo

XOMOfOC:

xlib: proc XOMOfOC(para1: XOC): XOM

XOMOrientation:

xlib: object XOMOrientation

XOMOrientation_Context:

xlib: XOrientation.XOMOrientation_Context

XOMOrientation_LTR_TTB:

xlib: XOrientation.XOMOrientation_LTR_TTB

XOMOrientation_RTL_TTB:

xlib: XOrientation.XOMOrientation_RTL_TTB

XOMOrientation_TTB_LTR:

xlib: XOrientation.XOMOrientation_TTB_LTR

XOMOrientation_TTB_RTL:

xlib: XOrientation.XOMOrientation_TTB_RTL

XOpenDisplay:

xlib: proc XOpenDisplay(para1: cstring): PDisplay

XOpenIM:

xlib: proc XOpenIM(para1: PDisplay; para2: PXrmHashBucketRec; para3: cstring; para4: cstring): XIM

XOpenOM:

xlib: proc XOpenOM(para1: PDisplay; para2: PXrmHashBucketRec; para3: cstring; para4: cstring): XOM

XOrientation:

xlib: enum XOrientation

XParseColor:

xlib: proc XParseColor(para1: PDisplay; para2: Colormap; para3: cstring; para4: PXColor): Status

XParseGeometry:

xlib: proc XParseGeometry(para1: cstring; para2: Pcint; para3: Pcint; para4: Pcuint; para5: Pcuint): cint

XPeekEvent:

xlib: proc XPeekEvent(para1: PDisplay; para2: PXEvent): cint

XPeekIfEvent:

xlib: proc XPeekIfEvent(para1: PDisplay; para2: PXEvent; para3: funcifevent; para4: XPointer): cint

XPending:

xlib: proc XPending(para1: PDisplay): cint

XPixmapFormatValues:

xlib: object XPixmapFormatValues

XPlanesOfScreen:

xlib: proc XPlanesOfScreen(para1: PScreen): cint

XPoint:

xlib: object XPoint

XPOINTER:

xi: const XPOINTER

XPointer:

xlib: type XPointer

XPointerMovedEvent:

xlib: type XPointerMovedEvent

XPointInRegion:

xutil: proc XPointInRegion(para1: Region; para2: cint; para3: cint): XBool

XPolygonRegion:

xutil: proc XPolygonRegion(para1: PXPoint; para2: cint; para3: cint): Region

XPrivDisplay:

xlib: object XPrivDisplay

XProcessInternalConnection:

xlib: proc XProcessInternalConnection(para1: PDisplay; para2: cint)

XPropertyEvent:

xlib: object XPropertyEvent

X_PROTOCOL:

x: const X_PROTOCOL

X_PROTOCOL_REVISION:

x: const X_PROTOCOL_REVISION

XProtocolRevision:

xlib: proc XProtocolRevision(para1: PDisplay): cint

XProtocolVersion:

xlib: proc XProtocolVersion(para1: PDisplay): cint

XPutBackEvent:

xlib: proc XPutBackEvent(para1: PDisplay; para2: PXEvent): cint

XPutImage:

xlib: proc XPutImage(para1: PDisplay; para2: Drawable; para3: GC; para4: PXImage; para5: cint; para6: cint; para7: cint; para8: cint; para9: cuint; para10: cuint): cint

XPutPixel:

xutil: proc XPutPixel(ximage: PXImage; x, y: cint; pixel: culong): cint

XQLength:

xlib: proc XQLength(para1: PDisplay): cint

XQueryBestCursor:

xlib: proc XQueryBestCursor(para1: PDisplay; para2: Drawable; para3: cuint; para4: cuint; para5: Pcuint; para6: Pcuint): Status

XQueryBestSize:

xlib: proc XQueryBestSize(para1: PDisplay; para2: cint; para3: Drawable; para4: cuint; para5: cuint; para6: Pcuint; para7: Pcuint): Status

XQueryBestStipple:

xlib: proc XQueryBestStipple(para1: PDisplay; para2: Drawable; para3: cuint; para4: cuint; para5: Pcuint; para6: Pcuint): Status

XQueryBestTile:

xlib: proc XQueryBestTile(para1: PDisplay; para2: Drawable; para3: cuint; para4: cuint; para5: Pcuint; para6: Pcuint): Status

XQueryColor:

xlib: proc XQueryColor(para1: PDisplay; para2: Colormap; para3: PXColor): cint

XQueryColors:

xlib: proc XQueryColors(para1: PDisplay; para2: Colormap; para3: PXColor; para4: cint): cint

XQueryExtension:

xlib: proc XQueryExtension(para1: PDisplay; para2: cstring; para3: Pcint; para4: Pcint; para5: Pcint): XBool

XQueryFont:

xlib: proc XQueryFont(para1: PDisplay; para2: XID): PXFontStruct

XQueryKeymap:

xlib: proc XQueryKeymap(para1: PDisplay; para2: chararr32): cint

XQueryPointer:

xlib: proc XQueryPointer(para1: PDisplay; para2: Window; para3: PWindow; para4: PWindow; para5: Pcint; para6: Pcint; para7: Pcint; para8: Pcint; para9: Pcuint): XBool

XQueryTextExtents:

xlib: proc XQueryTextExtents(para1: PDisplay; para2: XID; para3: cstring; para4: cint; para5: Pcint; para6: Pcint; para7: Pcint; para8: PXCharStruct): cint

XQueryTextExtents16:

xlib: proc XQueryTextExtents16(para1: PDisplay; para2: XID; para3: PXChar2b; para4: cint; para5: Pcint; para6: Pcint; para7: Pcint; para8: PXCharStruct): cint

XQueryTree:

xlib: proc XQueryTree(para1: PDisplay; para2: Window; para3: PWindow; para4: PWindow; para5: PPWindow; para6: Pcuint): Status

XRaiseWindow:

xlib: proc XRaiseWindow(para1: PDisplay; para2: Window): cint

XReadBitmapFile:

xlib: proc XReadBitmapFile(para1: PDisplay; para2: Drawable; para3: cstring; para4: Pcuint; para5: Pcuint; para6: PPixmap; para7: Pcint; para8: Pcint): cint

XReadBitmapFileData:

xlib: proc XReadBitmapFileData(para1: cstring; para2: Pcuint; para3: Pcuint; para4: PPcuchar; para5: Pcint; para6: Pcint): cint

XRebindKeysym:

xlib: proc XRebindKeysym(para1: PDisplay; para2: KeySym; para3: PKeySym; para4: cint; para5: Pcuchar; para6: cint): cint

XRecolorCursor:

xlib: proc XRecolorCursor(para1: PDisplay; para2: Cursor; para3: PXColor; para4: PXColor): cint

XReconfigureWMWindow:

xlib: proc XReconfigureWMWindow(para1: PDisplay; para2: Window; para3: cint; para4: cuint; para5: PXWindowChanges): Status

XRectangle:

xlib: object XRectangle

XRectInRegion:

xutil: proc XRectInRegion(para1: Region; para2: cint; para3: cint; para4: cuint; para5: cuint): cint

XRefreshKeyboardMapping:

xlib: proc XRefreshKeyboardMapping(para1: PXMappingEvent): cint

XRegion:

xutil: object XRegion

XRegisterIMInstantiateCallback:

xlib: proc XRegisterIMInstantiateCallback(para1: PDisplay; para2: PXrmHashBucketRec; para3: cstring; para4: cstring; para5: XIDProc; para6: XPointer): XBool

XRemoveConnectionWatch:

xlib: proc XRemoveConnectionWatch(para1: PDisplay; para2: XConnectionWatchProc; para3: XPointer)

XRemoveFromSaveSet:

xlib: proc XRemoveFromSaveSet(para1: PDisplay; para2: Window): cint

XRemoveHost:

xlib: proc XRemoveHost(para1: PDisplay; para2: PXHostAddress): cint

XRemoveHosts:

xlib: proc XRemoveHosts(para1: PDisplay; para2: PXHostAddress; para3: cint): cint

XReparentEvent:

xlib: object XReparentEvent

XReparentWindow:

xlib: proc XReparentWindow(para1: PDisplay; para2: Window; para3: Window; para4: cint; para5: cint): cint

XResetScreenSaver:

xlib: proc XResetScreenSaver(para1: PDisplay): cint

XResizeRequestEvent:

xlib: object XResizeRequestEvent

XResizeWindow:

xlib: proc XResizeWindow(para1: PDisplay; para2: Window; para3: cuint; para4: cuint): cint

XResourceManagerString:

xlib: proc XResourceManagerString(para1: PDisplay): cstring

XRestackWindows:

xlib: proc XRestackWindows(para1: PDisplay; para2: PWindow; para3: cint): cint

XrmHashBucketRec:

xlib: object XrmHashBucketRec

XrmInitialize:

xlib: proc XrmInitialize()

XRootWindow:

xlib: proc XRootWindow(para1: PDisplay; para2: cint): Window

XRootWindowOfScreen:

xlib: proc XRootWindowOfScreen(para1: PScreen): Window

XRotateBuffers:

xlib: proc XRotateBuffers(para1: PDisplay; para2: cint): cint

XRotateWindowProperties:

xlib: proc XRotateWindowProperties(para1: PDisplay; para2: Window; para3: PAtom; para4: cint; para5: cint): cint

XSaveContext:

xutil: proc XSaveContext(para1: PDisplay; para2: XID; para3: XContext; para4: cstring): cint

XScreenCount:

xlib: proc XScreenCount(para1: PDisplay): cint

XScreenNumberOfScreen:

xlib: proc XScreenNumberOfScreen(para1: PScreen): cint

XScreenOfDisplay:

xlib: proc XScreenOfDisplay(para1: PDisplay; para2: cint): PScreen

XScreenResourceString:

xlib: proc XScreenResourceString(para1: PScreen): cstring

XSegment:

xlib: object XSegment

XSelectInput:

xlib: proc XSelectInput(para1: PDisplay; para2: Window; para3: clong): cint

XSelectionClearEvent:

xlib: object XSelectionClearEvent

XSelectionEvent:

xlib: object XSelectionEvent

XSelectionRequestEvent:

xlib: object XSelectionRequestEvent

XSendEvent:

xlib: proc XSendEvent(para1: PDisplay; para2: Window; para3: XBool; para4: clong; para5: PXEvent): Status

XServerInterpretedAddress:

xlib: object XServerInterpretedAddress

XServerVendor:

xlib: proc XServerVendor(para1: PDisplay): cstring

XSetAccessControl:

xlib: proc XSetAccessControl(para1: PDisplay; para2: cint): cint

XSetAfterFunction:

xlib: proc XSetAfterFunction(para1: PDisplay; para2: funcdisp): funcdisp

XSetArcMode:

xlib: proc XSetArcMode(para1: PDisplay; para2: GC; para3: cint): cint

XSetAuthorization:

xlib: proc XSetAuthorization(para1: cstring; para2: cint; para3: cstring; para4: cint)

XSetBackground:

xlib: proc XSetBackground(para1: PDisplay; para2: GC; para3: culong): cint

XSetClassHint:

xutil: proc XSetClassHint(para1: PDisplay; para2: Window; para3: PXClassHint): cint

XSetClipMask:

xlib: proc XSetClipMask(para1: PDisplay; para2: GC; para3: Pixmap): cint

XSetClipOrigin:

xlib: proc XSetClipOrigin(para1: PDisplay; para2: GC; para3: cint; para4: cint): cint

XSetClipRectangles:

xlib: proc XSetClipRectangles(para1: PDisplay; para2: GC; para3: cint; para4: cint; para5: PXRectangle; para6: cint; para7: cint): cint

XSetCloseDownMode:

xlib: proc XSetCloseDownMode(para1: PDisplay; para2: cint): cint

XSetCommand:

xlib: proc XSetCommand(para1: PDisplay; para2: Window; para3: PPChar; para4: cint): cint

XSetDashes:

xlib: proc XSetDashes(para1: PDisplay; para2: GC; para3: cint; para4: cstring; para5: cint): cint

XSetErrorHandler:

xlib: proc XSetErrorHandler(para1: XErrorHandler): XErrorHandler

XSetFillRule:

xlib: proc XSetFillRule(para1: PDisplay; para2: GC; para3: cint): cint

XSetFillStyle:

xlib: proc XSetFillStyle(para1: PDisplay; para2: GC; para3: cint): cint

XSetFont:

xlib: proc XSetFont(para1: PDisplay; para2: GC; para3: Font): cint

XSetFontPath:

xlib: proc XSetFontPath(para1: PDisplay; para2: PPChar; para3: cint): cint

XSetForeground:

xlib: proc XSetForeground(para1: PDisplay; para2: GC; para3: culong): cint

XSetFunction:

xlib: proc XSetFunction(para1: PDisplay; para2: GC; para3: cint): cint

XSetGraphicsExposures:

xlib: proc XSetGraphicsExposures(para1: PDisplay; para2: GC; para3: XBool): cint

XSetICFocus:

xlib: proc XSetICFocus(para1: XIC)

XSetIconName:

xlib: proc XSetIconName(para1: PDisplay; para2: Window; para3: cstring): cint

XSetIconSizes:

xutil: proc XSetIconSizes(para1: PDisplay; para2: Window; para3: PXIconSize; para4: cint): cint

XSetICValues:

xlib: proc XSetICValues(para1: XIC): cstring

XSetIMValues:

xlib: proc XSetIMValues(para1: XIM): cstring

XSetInputFocus:

xlib: proc XSetInputFocus(para1: PDisplay; para2: Window; para3: cint; para4: Time): cint

XSetIOErrorHandler:

xlib: proc XSetIOErrorHandler(para1: XIOErrorHandler): XIOErrorHandler

XSetLineAttributes:

xlib: proc XSetLineAttributes(para1: PDisplay; para2: GC; para3: cuint; para4: cint; para5: cint; para6: cint): cint

XSetLocaleModifiers:

xlib: proc XSetLocaleModifiers(para1: cstring): cstring

XSetModifierMapping:

xlib: proc XSetModifierMapping(para1: PDisplay; para2: PXModifierKeymap): cint

XSetNormalHints:

xutil: proc XSetNormalHints(para1: PDisplay; para2: Window; para3: PXSizeHints): cint

XSetOCValues:

xlib: proc XSetOCValues(para1: XOC): cstring

XSetOMValues:

xlib: proc XSetOMValues(para1: XOM): cstring

XSetPlaneMask:

xlib: proc XSetPlaneMask(para1: PDisplay; para2: GC; para3: culong): cint

XSetPointerMapping:

xlib: proc XSetPointerMapping(para1: PDisplay; para2: Pcuchar; para3: cint): cint

XSetRegion:

xutil: proc XSetRegion(para1: PDisplay; para2: GC; para3: Region): cint

XSetRGBColormaps:

xutil: proc XSetRGBColormaps(para1: PDisplay; para2: Window; para3: PXStandardColormap; para4: cint; para5: Atom)

XSetScreenSaver:

xlib: proc XSetScreenSaver(para1: PDisplay; para2: cint; para3: cint; para4: cint; para5: cint): cint

XSetSelectionOwner:

xlib: proc XSetSelectionOwner(para1: PDisplay; para2: Atom; para3: Window; para4: Time): cint

XSetSizeHints:

xutil: proc XSetSizeHints(para1: PDisplay; para2: Window; para3: PXSizeHints; para4: Atom): cint

XSetStandardColormap:

xutil: proc XSetStandardColormap(para1: PDisplay; para2: Window; para3: PXStandardColormap; para4: Atom)

XSetStandardProperties:

xutil: proc XSetStandardProperties(para1: PDisplay; para2: Window; para3: cstring; para4: cstring; para5: Pixmap; para6: PPChar; para7: cint; para8: PXSizeHints): cint

XSetState:

xlib: proc XSetState(para1: PDisplay; para2: GC; para3: culong; para4: culong; para5: cint; para6: culong): cint

XSetStipple:

xlib: proc XSetStipple(para1: PDisplay; para2: GC; para3: Pixmap): cint

XSetSubwindowMode:

xlib: proc XSetSubwindowMode(para1: PDisplay; para2: GC; para3: cint): cint

XSetTextProperty:

xutil: proc XSetTextProperty(para1: PDisplay; para2: Window; para3: PXTextProperty; para4: Atom)

XSetTile:

xlib: proc XSetTile(para1: PDisplay; para2: GC; para3: Pixmap): cint

XSetTransientForHint:

xlib: proc XSetTransientForHint(para1: PDisplay; para2: Window; para3: Window): cint

XSetTSOrigin:

xlib: proc XSetTSOrigin(para1: PDisplay; para2: GC; para3: cint; para4: cint): cint

XSetWindowAttributes:

xlib: object XSetWindowAttributes

XSetWindowBackground:

xlib: proc XSetWindowBackground(para1: PDisplay; para2: Window; para3: culong): cint

XSetWindowBackgroundPixmap:

xlib: proc XSetWindowBackgroundPixmap(para1: PDisplay; para2: Window; para3: Pixmap): cint

XSetWindowBorder:

xlib: proc XSetWindowBorder(para1: PDisplay; para2: Window; para3: culong): cint

XSetWindowBorderPixmap:

xlib: proc XSetWindowBorderPixmap(para1: PDisplay; para2: Window; para3: Pixmap): cint

XSetWindowBorderWidth:

xlib: proc XSetWindowBorderWidth(para1: PDisplay; para2: Window; para3: cuint): cint

XSetWindowColormap:

xlib: proc XSetWindowColormap(para1: PDisplay; para2: Window; para3: Colormap): cint

XSetWMClientMachine:

xutil: proc XSetWMClientMachine(para1: PDisplay; para2: Window; para3: PXTextProperty)

XSetWMColormapWindows:

xlib: proc XSetWMColormapWindows(para1: PDisplay; para2: Window; para3: PWindow; para4: cint): Status

XSetWMHints:

xutil: proc XSetWMHints(para1: PDisplay; para2: Window; para3: PXWMHints): cint

XSetWMIconName:

xutil: proc XSetWMIconName(para1: PDisplay; para2: Window; para3: PXTextProperty)

XSetWMName:

xutil: proc XSetWMName(para1: PDisplay; para2: Window; para3: PXTextProperty)

XSetWMNormalHints:

xutil: proc XSetWMNormalHints(para1: PDisplay; para2: Window; para3: PXSizeHints)

XSetWMProperties:

xutil: proc XSetWMProperties(para1: PDisplay; para2: Window; para3: PXTextProperty; para4: PXTextProperty; para5: PPChar; para6: cint; para7: PXSizeHints; para8: PXWMHints; para9: PXClassHint)

XSetWMProtocols:

xlib: proc XSetWMProtocols(para1: PDisplay; para2: Window; para3: PAtom; para4: cint): Status

XSetWMSizeHints:

xutil: proc XSetWMSizeHints(para1: PDisplay; para2: Window; para3: PXSizeHints; para4: Atom)

XSetZoomHints:

xutil: proc XSetZoomHints(para1: PDisplay; para2: Window; para3: PXSizeHints): cint

XShrinkRegion:

xutil: proc XShrinkRegion(para1: Region; para2: cint; para3: cint): cint

XSizeHints:

xutil: object XSizeHints

XStandardColormap:

xutil: object XStandardColormap

XStdICCTextStyle:

xutil: XICCEncodingStyle.XStdICCTextStyle

XStoreBuffer:

xlib: proc XStoreBuffer(para1: PDisplay; para2: cstring; para3: cint; para4: cint): cint

XStoreBytes:

xlib: proc XStoreBytes(para1: PDisplay; para2: cstring; para3: cint): cint

XStoreColor:

xlib: proc XStoreColor(para1: PDisplay; para2: Colormap; para3: PXColor): cint

XStoreColors:

xlib: proc XStoreColors(para1: PDisplay; para2: Colormap; para3: PXColor; para4: cint): cint

XStoreName:

xlib: proc XStoreName(para1: PDisplay; para2: Window; para3: cstring): cint

XStoreNamedColor:

xlib: proc XStoreNamedColor(para1: PDisplay; para2: Colormap; para3: cstring; para4: culong; para5: cint): cint

XStringListToTextProperty:

xutil: proc XStringListToTextProperty(para1: PPChar; para2: cint; para3: PXTextProperty): Status

XStringStyle:

xutil: XICCEncodingStyle.XStringStyle

XStringToKeysym:

xlib: proc XStringToKeysym(para1: cstring): KeySym

XSubImage:

xutil: proc XSubImage(ximage: PXImage; x, y: cint; width, height: cuint): PXImage

XSubtractRegion:

xutil: proc XSubtractRegion(para1: Region; para2: Region; para3: Region): cint

XSupportsLocale:

xlib: proc XSupportsLocale(): XBool

XSync:

xlib: proc XSync(para1: PDisplay; para2: XBool): cint

XSynchronize:

xlib: proc XSynchronize(para1: PDisplay; para2: XBool): funcdisp

XTextExtents:

xlib: proc XTextExtents(para1: PXFontStruct; para2: cstring; para3: cint; para4: Pcint; para5: Pcint; para6: Pcint; para7: PXCharStruct): cint

XTextExtents16:

xlib: proc XTextExtents16(para1: PXFontStruct; para2: PXChar2b; para3: cint; para4: Pcint; para5: Pcint; para6: Pcint; para7: PXCharStruct): cint

XTextItem:

xlib: object XTextItem

XTextItem16:

xlib: object XTextItem16

XTextProperty:

xutil: object XTextProperty

XTextPropertyToStringList:

xutil: proc XTextPropertyToStringList(para1: PXTextProperty; para2: PPPChar; para3: Pcint): Status

XTextStyle:

xutil: XICCEncodingStyle.XTextStyle

XTextWidth:

xlib: proc XTextWidth(para1: PXFontStruct; para2: cstring; para3: cint): cint

XTextWidth16:

xlib: proc XTextWidth16(para1: PXFontStruct; para2: PXChar2b; para3: cint): cint

XTimeCoord:

xlib: object XTimeCoord

XTranslateCoordinates:

xlib: proc XTranslateCoordinates(para1: PDisplay; para2: Window; para3: Window; para4: cint; para5: cint; para6: Pcint; para7: Pcint; para8: PWindow): XBool

XUndefineCursor:

xlib: proc XUndefineCursor(para1: PDisplay; para2: Window): cint

XUngrabButton:

xlib: proc XUngrabButton(para1: PDisplay; para2: cuint; para3: cuint; para4: Window): cint

XUngrabKey:

xlib: proc XUngrabKey(para1: PDisplay; para2: cint; para3: cuint; para4: Window): cint

XUngrabKeyboard:

xlib: proc XUngrabKeyboard(para1: PDisplay; para2: Time): cint

XUngrabPointer:

xlib: proc XUngrabPointer(para1: PDisplay; para2: Time): cint

XUngrabServer:

xlib: proc XUngrabServer(para1: PDisplay): cint

XUninstallColormap:

xlib: proc XUninstallColormap(para1: PDisplay; para2: Colormap): cint

XUnionRectWithRegion:

xutil: proc XUnionRectWithRegion(para1: PXRectangle; para2: Region; para3: Region): cint

XUnionRegion:

xutil: proc XUnionRegion(para1: Region; para2: Region; para3: Region): cint

XUnloadFont:

xlib: proc XUnloadFont(para1: PDisplay; para2: Font): cint

XUnlockDisplay:

xlib: proc XUnlockDisplay(para1: PDisplay)

XUnmapEvent:

xlib: object XUnmapEvent

XUnmapSubwindows:

xlib: proc XUnmapSubwindows(para1: PDisplay; para2: Window): cint

XUnmapWindow:

xlib: proc XUnmapWindow(para1: PDisplay; para2: Window): cint

XUnregisterIMInstantiateCallback:

xlib: proc XUnregisterIMInstantiateCallback(para1: PDisplay; para2: PXrmHashBucketRec; para3: cstring; para4: cstring; para5: XIDProc; para6: XPointer): XBool

XUnsetICFocus:

xlib: proc XUnsetICFocus(para1: XIC)

XUrgencyHint:

xutil: const XUrgencyHint

Xutf8DrawImageString:

xlib: proc Xutf8DrawImageString(para1: PDisplay; para2: Drawable; para3: XFontSet; para4: GC; para5: cint; para6: cint; para7: cstring; para8: cint)

Xutf8DrawString:

xlib: proc Xutf8DrawString(para1: PDisplay; para2: Drawable; para3: XFontSet; para4: GC; para5: cint; para6: cint; para7: cstring; para8: cint)

Xutf8DrawText:

xlib: proc Xutf8DrawText(para1: PDisplay; para2: Drawable; para3: GC; para4: cint; para5: cint; para6: PXmbTextItem; para7: cint)

Xutf8LookupString:

xlib: proc Xutf8LookupString(para1: XIC; para2: PXKeyPressedEvent; para3: cstring; para4: cint; para5: PKeySym; para6: PStatus): cint

Xutf8ResetIC:

xlib: proc Xutf8ResetIC(para1: XIC): cstring

Xutf8SetWMProperties:

xutil: proc Xutf8SetWMProperties(para1: PDisplay; para2: Window; para3: cstring; para4: cstring; para5: PPChar; para6: cint; para7: PXSizeHints; para8: PXWMHints; para9: PXClassHint)

XUTF8StringStyle:

xutil: XICCEncodingStyle.XUTF8StringStyle

Xutf8TextEscapement:

xlib: proc Xutf8TextEscapement(para1: XFontSet; para2: cstring; para3: cint): cint

Xutf8TextExtents:

xlib: proc Xutf8TextExtents(para1: XFontSet; para2: cstring; para3: cint; para4: PXRectangle; para5: PXRectangle): cint

Xutf8TextListToTextProperty:

xutil: proc Xutf8TextListToTextProperty(para1: PDisplay; para2: PPChar; para3: cint; para4: XICCEncodingStyle; para5: PXTextProperty): cint

Xutf8TextPerCharExtents:

xlib: proc Xutf8TextPerCharExtents(para1: XFontSet; para2: cstring; para3: cint; para4: PXRectangle; para5: PXRectangle; para6: cint; para7: Pcint; para8: PXRectangle; para9: PXRectangle): Status

Xutf8TextPropertyToTextList:

xutil: proc Xutf8TextPropertyToTextList(para1: PDisplay; para2: PXTextProperty; para3: PPPChar; para4: Pcint): cint

XVaCreateNestedList:

xlib: proc XVaCreateNestedList(unused: cint): XVaNestedList

XValue:

xutil: const XValue

XVaNestedList:

xlib: type XVaNestedList

XVendorRelease:

xlib: proc XVendorRelease(para1: PDisplay): cint

XVisibilityEvent:

xlib: object XVisibilityEvent

XVisualIDFromVisual:

xlib: proc XVisualIDFromVisual(para1: PVisual): VisualID

XVisualInfo:

xutil: object XVisualInfo

xw:

core: proc xw(vec: TVec): auto

xw=:

core: proc xw=[T](vec: var TVec; value: T)

XWarpPointer:

xlib: proc XWarpPointer(para1: PDisplay; para2: Window; para3: Window; para4: cint; para5: cint; para6: cuint; para7: cuint; para8: cint; para9: cint): cint

XwcDrawImageString:

xlib: proc XwcDrawImageString(para1: PDisplay; para2: Drawable; para3: XFontSet; para4: GC; para5: cint; para6: cint; para7: PWideChar; para8: cint)

XwcDrawString:

xlib: proc XwcDrawString(para1: PDisplay; para2: Drawable; para3: XFontSet; para4: GC; para5: cint; para6: cint; para7: PWideChar; para8: cint)

XwcDrawText:

xlib: proc XwcDrawText(para1: PDisplay; para2: Drawable; para3: GC; para4: cint; para5: cint; para6: PXwcTextItem; para7: cint)

XwcFreeStringList:

xutil: proc XwcFreeStringList(para1: ptr ptr int16)

XwcLookupString:

xlib: proc XwcLookupString(para1: XIC; para2: PXKeyPressedEvent; para3: PWideChar; para4: cint; para5: PKeySym; para6: PStatus): cint

XwcResetIC:

xlib: proc XwcResetIC(para1: XIC): PWideChar

XwcTextEscapement:

xlib: proc XwcTextEscapement(para1: XFontSet; para2: PWideChar; para3: cint): cint

XwcTextExtents:

xlib: proc XwcTextExtents(para1: XFontSet; para2: PWideChar; para3: cint; para4: PXRectangle; para5: PXRectangle): cint

XwcTextItem:

xlib: object XwcTextItem

XwcTextListToTextProperty:

xutil: proc XwcTextListToTextProperty(para1: PDisplay; para2: ptr ptr int16; para3: cint; para4: XICCEncodingStyle; para5: PXTextProperty): cint

XwcTextPerCharExtents:

xlib: proc XwcTextPerCharExtents(para1: XFontSet; para2: PWideChar; para3: cint; para4: PXRectangle; para5: PXRectangle; para6: cint; para7: Pcint; para8: PXRectangle; para9: PXRectangle): Status

XwcTextPropertyToTextList:

xutil: proc XwcTextPropertyToTextList(para1: PDisplay; para2: PXTextProperty; para3: ptr ptr ptr int16; para4: Pcint): cint

XWhitePixel:

xlib: proc XWhitePixel(para1: PDisplay; para2: cint): culong

XWhitePixelOfScreen:

xlib: proc XWhitePixelOfScreen(para1: PScreen): culong

XWidthMMOfScreen:

xlib: proc XWidthMMOfScreen(para1: PScreen): cint

XWidthOfScreen:

xlib: proc XWidthOfScreen(para1: PScreen): cint

XWindowAttributes:

xlib: object XWindowAttributes

XWindowChanges:

xlib: object XWindowChanges

XWindowEvent:

xlib: proc XWindowEvent(para1: PDisplay; para2: Window; para3: clong; para4: PXEvent): cint

XWithdrawWindow:

xlib: proc XWithdrawWindow(para1: PDisplay; para2: Window; para3: cint): Status

XWMGeometry:

xutil: proc XWMGeometry(para1: PDisplay; para2: cint; para3: cstring; para4: cstring; para5: cuint; para6: PXSizeHints; para7: Pcint; para8: Pcint; para9: Pcint; para10: Pcint; para11: Pcint): cint

XWMHints:

xutil: object XWMHints

XWriteBitmapFile:

xlib: proc XWriteBitmapFile(para1: PDisplay; para2: cstring; para3: Pixmap; para4: cuint; para5: cuint; para6: cint; para7: cint): cint

xww:

core: proc xww(vec: TVec): auto

xww=:

core: proc xww=[T](vec: var TVec; value: T)

xwww:

core: proc xwww(vec: TVec): auto

xwww=:

core: proc xwww=[T](vec: var TVec; value: T)

xwwx:

core: proc xwwx(vec: TVec): auto

xwwx=:

core: proc xwwx=[T](vec: var TVec; value: T)

xwwy:

core: proc xwwy(vec: TVec): auto

xwwy=:

core: proc xwwy=[T](vec: var TVec; value: T)

xwwz:

core: proc xwwz(vec: TVec): auto

xwwz=:

core: proc xwwz=[T](vec: var TVec; value: T)

xwx:

core: proc xwx(vec: TVec): auto

xwx=:

core: proc xwx=[T](vec: var TVec; value: T)

xwxw:

core: proc xwxw(vec: TVec): auto

xwxw=:

core: proc xwxw=[T](vec: var TVec; value: T)

xwxx:

core: proc xwxx(vec: TVec): auto

xwxx=:

core: proc xwxx=[T](vec: var TVec; value: T)

xwxy:

core: proc xwxy(vec: TVec): auto

xwxy=:

core: proc xwxy=[T](vec: var TVec; value: T)

xwxz:

core: proc xwxz(vec: TVec): auto

xwxz=:

core: proc xwxz=[T](vec: var TVec; value: T)

xwy:

core: proc xwy(vec: TVec): auto

xwy=:

core: proc xwy=[T](vec: var TVec; value: T)

xwyw:

core: proc xwyw(vec: TVec): auto

xwyw=:

core: proc xwyw=[T](vec: var TVec; value: T)

xwyx:

core: proc xwyx(vec: TVec): auto

xwyx=:

core: proc xwyx=[T](vec: var TVec; value: T)

xwyy:

core: proc xwyy(vec: TVec): auto

xwyy=:

core: proc xwyy=[T](vec: var TVec; value: T)

xwyz:

core: proc xwyz(vec: TVec): auto

xwyz=:

core: proc xwyz=[T](vec: var TVec; value: T)

xwz:

core: proc xwz(vec: TVec): auto

xwz=:

core: proc xwz=[T](vec: var TVec; value: T)

xwzw:

core: proc xwzw(vec: TVec): auto

xwzw=:

core: proc xwzw=[T](vec: var TVec; value: T)

xwzx:

core: proc xwzx(vec: TVec): auto

xwzx=:

core: proc xwzx=[T](vec: var TVec; value: T)

xwzy:

core: proc xwzy(vec: TVec): auto

xwzy=:

core: proc xwzy=[T](vec: var TVec; value: T)

xwzz:

core: proc xwzz(vec: TVec): auto

xwzz=:

core: proc xwzz=[T](vec: var TVec; value: T)

xx:

core: proc xx(vec: TVec): auto

xx=:

core: proc xx=[T](vec: var TVec; value: T)

XXorRegion:

xutil: proc XXorRegion(para1: Region; para2: Region; para3: Region): cint

xxw:

core: proc xxw(vec: TVec): auto

xxw=:

core: proc xxw=[T](vec: var TVec; value: T)

xxww:

core: proc xxww(vec: TVec): auto

xxww=:

core: proc xxww=[T](vec: var TVec; value: T)

xxwx:

core: proc xxwx(vec: TVec): auto

xxwx=:

core: proc xxwx=[T](vec: var TVec; value: T)

xxwy:

core: proc xxwy(vec: TVec): auto

xxwy=:

core: proc xxwy=[T](vec: var TVec; value: T)

xxwz:

core: proc xxwz(vec: TVec): auto

xxwz=:

core: proc xxwz=[T](vec: var TVec; value: T)

xxx:

core: proc xxx(vec: TVec): auto

xxx=:

core: proc xxx=[T](vec: var TVec; value: T)

xxxw:

core: proc xxxw(vec: TVec): auto

xxxw=:

core: proc xxxw=[T](vec: var TVec; value: T)

xxxx:

core: proc xxxx(vec: TVec): auto

xxxx=:

core: proc xxxx=[T](vec: var TVec; value: T)

xxxy:

core: proc xxxy(vec: TVec): auto

xxxy=:

core: proc xxxy=[T](vec: var TVec; value: T)

xxxz:

core: proc xxxz(vec: TVec): auto

xxxz=:

core: proc xxxz=[T](vec: var TVec; value: T)

xxy:

core: proc xxy(vec: TVec): auto

xxy=:

core: proc xxy=[T](vec: var TVec; value: T)

xxyw:

core: proc xxyw(vec: TVec): auto

xxyw=:

core: proc xxyw=[T](vec: var TVec; value: T)

xxyx:

core: proc xxyx(vec: TVec): auto

xxyx=:

core: proc xxyx=[T](vec: var TVec; value: T)

xxyy:

core: proc xxyy(vec: TVec): auto

xxyy=:

core: proc xxyy=[T](vec: var TVec; value: T)

xxyz:

core: proc xxyz(vec: TVec): auto

xxyz=:

core: proc xxyz=[T](vec: var TVec; value: T)

xxz:

core: proc xxz(vec: TVec): auto

xxz=:

core: proc xxz=[T](vec: var TVec; value: T)

xxzw:

core: proc xxzw(vec: TVec): auto

xxzw=:

core: proc xxzw=[T](vec: var TVec; value: T)

xxzx:

core: proc xxzx(vec: TVec): auto

xxzx=:

core: proc xxzx=[T](vec: var TVec; value: T)

xxzy:

core: proc xxzy(vec: TVec): auto

xxzy=:

core: proc xxzy=[T](vec: var TVec; value: T)

xxzz:

core: proc xxzz(vec: TVec): auto

xxzz=:

core: proc xxzz=[T](vec: var TVec; value: T)

XY:

core: const XY

xy:

core: proc xy(vec: TVec): auto

xy=:

core: proc xy=[T](vec: var TVec; value: T)

XYBitmap:

x: const XYBitmap

XYi:

core: const XYi

XYi8:

core: const XYi8

XYPixmap:

x: const XYPixmap

xyw:

core: proc xyw(vec: TVec): auto

xyw=:

core: proc xyw=[T](vec: var TVec; value: T)

xyww:

core: proc xyww(vec: TVec): auto

xyww=:

core: proc xyww=[T](vec: var TVec; value: T)

xywx:

core: proc xywx(vec: TVec): auto

xywx=:

core: proc xywx=[T](vec: var TVec; value: T)

xywy:

core: proc xywy(vec: TVec): auto

xywy=:

core: proc xywy=[T](vec: var TVec; value: T)

xywz:

core: proc xywz(vec: TVec): auto

xywz=:

core: proc xywz=[T](vec: var TVec; value: T)

xyx:

core: proc xyx(vec: TVec): auto

xyx=:

core: proc xyx=[T](vec: var TVec; value: T)

xyxw:

core: proc xyxw(vec: TVec): auto

xyxw=:

core: proc xyxw=[T](vec: var TVec; value: T)

xyxx:

core: proc xyxx(vec: TVec): auto

xyxx=:

core: proc xyxx=[T](vec: var TVec; value: T)

xyxy:

core: proc xyxy(vec: TVec): auto

xyxy=:

core: proc xyxy=[T](vec: var TVec; value: T)

xyxz:

core: proc xyxz(vec: TVec): auto

xyxz=:

core: proc xyxz=[T](vec: var TVec; value: T)

xyy:

core: proc xyy(vec: TVec): auto

xyy=:

core: proc xyy=[T](vec: var TVec; value: T)

xyyw:

core: proc xyyw(vec: TVec): auto

xyyw=:

core: proc xyyw=[T](vec: var TVec; value: T)

xyyx:

core: proc xyyx(vec: TVec): auto

xyyx=:

core: proc xyyx=[T](vec: var TVec; value: T)

xyyy:

core: proc xyyy(vec: TVec): auto

xyyy=:

core: proc xyyy=[T](vec: var TVec; value: T)

xyyz:

core: proc xyyz(vec: TVec): auto

xyyz=:

core: proc xyyz=[T](vec: var TVec; value: T)

XYZ:

core: const XYZ

xyz:

core: proc xyz(vec: TVec): auto

xyz=:

core: proc xyz=[T](vec: var TVec; value: T)

XYZi:

core: const XYZi

XYZi8:

core: const XYZi8

xyzw:

core: proc xyzw(vec: TVec): auto

xyzw=:

core: proc xyzw=[T](vec: var TVec; value: T)

xyzx:

core: proc xyzx(vec: TVec): auto

xyzx=:

core: proc xyzx=[T](vec: var TVec; value: T)

xyzy:

core: proc xyzy(vec: TVec): auto

xyzy=:

core: proc xyzy=[T](vec: var TVec; value: T)

xyzz:

core: proc xyzz(vec: TVec): auto

xyzz=:

core: proc xyzz=[T](vec: var TVec; value: T)

XZ:

core: const XZ

xz:

core: proc xz(vec: TVec): auto

xz=:

core: proc xz=[T](vec: var TVec; value: T)

XZi:

core: const XZi

XZi8:

core: const XZi8

xzw:

core: proc xzw(vec: TVec): auto

xzw=:

core: proc xzw=[T](vec: var TVec; value: T)

xzww:

core: proc xzww(vec: TVec): auto

xzww=:

core: proc xzww=[T](vec: var TVec; value: T)

xzwx:

core: proc xzwx(vec: TVec): auto

xzwx=:

core: proc xzwx=[T](vec: var TVec; value: T)

xzwy:

core: proc xzwy(vec: TVec): auto

xzwy=:

core: proc xzwy=[T](vec: var TVec; value: T)

xzwz:

core: proc xzwz(vec: TVec): auto

xzwz=:

core: proc xzwz=[T](vec: var TVec; value: T)

xzx:

core: proc xzx(vec: TVec): auto

xzx=:

core: proc xzx=[T](vec: var TVec; value: T)

xzxw:

core: proc xzxw(vec: TVec): auto

xzxw=:

core: proc xzxw=[T](vec: var TVec; value: T)

xzxx:

core: proc xzxx(vec: TVec): auto

xzxx=:

core: proc xzxx=[T](vec: var TVec; value: T)

xzxy:

core: proc xzxy(vec: TVec): auto

xzxy=:

core: proc xzxy=[T](vec: var TVec; value: T)

xzxz:

core: proc xzxz(vec: TVec): auto

xzxz=:

core: proc xzxz=[T](vec: var TVec; value: T)

xzy:

core: proc xzy(vec: TVec): auto

xzy=:

core: proc xzy=[T](vec: var TVec; value: T)

xzyw:

core: proc xzyw(vec: TVec): auto

xzyw=:

core: proc xzyw=[T](vec: var TVec; value: T)

xzyx:

core: proc xzyx(vec: TVec): auto

xzyx=:

core: proc xzyx=[T](vec: var TVec; value: T)

xzyy:

core: proc xzyy(vec: TVec): auto

xzyy=:

core: proc xzyy=[T](vec: var TVec; value: T)

xzyz:

core: proc xzyz(vec: TVec): auto

xzyz=:

core: proc xzyz=[T](vec: var TVec; value: T)

xzz:

core: proc xzz(vec: TVec): auto

xzz=:

core: proc xzz=[T](vec: var TVec; value: T)

xzzw:

core: proc xzzw(vec: TVec): auto

xzzw=:

core: proc xzzw=[T](vec: var TVec; value: T)

xzzx:

core: proc xzzx(vec: TVec): auto

xzzx=:

core: proc xzzx=[T](vec: var TVec; value: T)

xzzy:

core: proc xzzy(vec: TVec): auto

xzzy=:

core: proc xzzy=[T](vec: var TVec; value: T)

xzzz:

core: proc xzzz(vec: TVec): auto

xzzz=:

core: proc xzzz=[T](vec: var TVec; value: T)

Y:

core: const Y

y:

core: proc y(vec: TVec): auto

y=:

core: proc y=[T](vec: var TVec; value: T)

Yi:

core: const Yi

Yi8:

core: const Yi8

YNegative:

xutil: const YNegative

YSorted:

x: const YSorted

YValue:

xutil: const YValue

yw:

core: proc yw(vec: TVec): auto

yw=:

core: proc yw=[T](vec: var TVec; value: T)

yww:

core: proc yww(vec: TVec): auto

yww=:

core: proc yww=[T](vec: var TVec; value: T)

ywww:

core: proc ywww(vec: TVec): auto

ywww=:

core: proc ywww=[T](vec: var TVec; value: T)

ywwx:

core: proc ywwx(vec: TVec): auto

ywwx=:

core: proc ywwx=[T](vec: var TVec; value: T)

ywwy:

core: proc ywwy(vec: TVec): auto

ywwy=:

core: proc ywwy=[T](vec: var TVec; value: T)

ywwz:

core: proc ywwz(vec: TVec): auto

ywwz=:

core: proc ywwz=[T](vec: var TVec; value: T)

ywx:

core: proc ywx(vec: TVec): auto

ywx=:

core: proc ywx=[T](vec: var TVec; value: T)

ywxw:

core: proc ywxw(vec: TVec): auto

ywxw=:

core: proc ywxw=[T](vec: var TVec; value: T)

ywxx:

core: proc ywxx(vec: TVec): auto

ywxx=:

core: proc ywxx=[T](vec: var TVec; value: T)

ywxy:

core: proc ywxy(vec: TVec): auto

ywxy=:

core: proc ywxy=[T](vec: var TVec; value: T)

ywxz:

core: proc ywxz(vec: TVec): auto

ywxz=:

core: proc ywxz=[T](vec: var TVec; value: T)

ywy:

core: proc ywy(vec: TVec): auto

ywy=:

core: proc ywy=[T](vec: var TVec; value: T)

ywyw:

core: proc ywyw(vec: TVec): auto

ywyw=:

core: proc ywyw=[T](vec: var TVec; value: T)

ywyx:

core: proc ywyx(vec: TVec): auto

ywyx=:

core: proc ywyx=[T](vec: var TVec; value: T)

ywyy:

core: proc ywyy(vec: TVec): auto

ywyy=:

core: proc ywyy=[T](vec: var TVec; value: T)

ywyz:

core: proc ywyz(vec: TVec): auto

ywyz=:

core: proc ywyz=[T](vec: var TVec; value: T)

ywz:

core: proc ywz(vec: TVec): auto

ywz=:

core: proc ywz=[T](vec: var TVec; value: T)

ywzw:

core: proc ywzw(vec: TVec): auto

ywzw=:

core: proc ywzw=[T](vec: var TVec; value: T)

ywzx:

core: proc ywzx(vec: TVec): auto

ywzx=:

core: proc ywzx=[T](vec: var TVec; value: T)

ywzy:

core: proc ywzy(vec: TVec): auto

ywzy=:

core: proc ywzy=[T](vec: var TVec; value: T)

ywzz:

core: proc ywzz(vec: TVec): auto

ywzz=:

core: proc ywzz=[T](vec: var TVec; value: T)

yx:

core: proc yx(vec: TVec): auto

yx=:

core: proc yx=[T](vec: var TVec; value: T)

YXBanded:

x: const YXBanded

YXSorted:

x: const YXSorted

yxw:

core: proc yxw(vec: TVec): auto

yxw=:

core: proc yxw=[T](vec: var TVec; value: T)

yxww:

core: proc yxww(vec: TVec): auto

yxww=:

core: proc yxww=[T](vec: var TVec; value: T)

yxwx:

core: proc yxwx(vec: TVec): auto

yxwx=:

core: proc yxwx=[T](vec: var TVec; value: T)

yxwy:

core: proc yxwy(vec: TVec): auto

yxwy=:

core: proc yxwy=[T](vec: var TVec; value: T)

yxwz:

core: proc yxwz(vec: TVec): auto

yxwz=:

core: proc yxwz=[T](vec: var TVec; value: T)

yxx:

core: proc yxx(vec: TVec): auto

yxx=:

core: proc yxx=[T](vec: var TVec; value: T)

yxxw:

core: proc yxxw(vec: TVec): auto

yxxw=:

core: proc yxxw=[T](vec: var TVec; value: T)

yxxx:

core: proc yxxx(vec: TVec): auto

yxxx=:

core: proc yxxx=[T](vec: var TVec; value: T)

yxxy:

core: proc yxxy(vec: TVec): auto

yxxy=:

core: proc yxxy=[T](vec: var TVec; value: T)

yxxz:

core: proc yxxz(vec: TVec): auto

yxxz=:

core: proc yxxz=[T](vec: var TVec; value: T)

yxy:

core: proc yxy(vec: TVec): auto

yxy=:

core: proc yxy=[T](vec: var TVec; value: T)

yxyw:

core: proc yxyw(vec: TVec): auto

yxyw=:

core: proc yxyw=[T](vec: var TVec; value: T)

yxyx:

core: proc yxyx(vec: TVec): auto

yxyx=:

core: proc yxyx=[T](vec: var TVec; value: T)

yxyy:

core: proc yxyy(vec: TVec): auto

yxyy=:

core: proc yxyy=[T](vec: var TVec; value: T)

yxyz:

core: proc yxyz(vec: TVec): auto

yxyz=:

core: proc yxyz=[T](vec: var TVec; value: T)

yxz:

core: proc yxz(vec: TVec): auto

yxz=:

core: proc yxz=[T](vec: var TVec; value: T)

yxzw:

core: proc yxzw(vec: TVec): auto

yxzw=:

core: proc yxzw=[T](vec: var TVec; value: T)

yxzx:

core: proc yxzx(vec: TVec): auto

yxzx=:

core: proc yxzx=[T](vec: var TVec; value: T)

yxzy:

core: proc yxzy(vec: TVec): auto

yxzy=:

core: proc yxzy=[T](vec: var TVec; value: T)

yxzz:

core: proc yxzz(vec: TVec): auto

yxzz=:

core: proc yxzz=[T](vec: var TVec; value: T)

yy:

core: proc yy(vec: TVec): auto

yy=:

core: proc yy=[T](vec: var TVec; value: T)

yyw:

core: proc yyw(vec: TVec): auto

yyw=:

core: proc yyw=[T](vec: var TVec; value: T)

yyww:

core: proc yyww(vec: TVec): auto

yyww=:

core: proc yyww=[T](vec: var TVec; value: T)

yywx:

core: proc yywx(vec: TVec): auto

yywx=:

core: proc yywx=[T](vec: var TVec; value: T)

yywy:

core: proc yywy(vec: TVec): auto

yywy=:

core: proc yywy=[T](vec: var TVec; value: T)

yywz:

core: proc yywz(vec: TVec): auto

yywz=:

core: proc yywz=[T](vec: var TVec; value: T)

yyx:

core: proc yyx(vec: TVec): auto

yyx=:

core: proc yyx=[T](vec: var TVec; value: T)

yyxw:

core: proc yyxw(vec: TVec): auto

yyxw=:

core: proc yyxw=[T](vec: var TVec; value: T)

yyxx:

core: proc yyxx(vec: TVec): auto

yyxx=:

core: proc yyxx=[T](vec: var TVec; value: T)

yyxy:

core: proc yyxy(vec: TVec): auto

yyxy=:

core: proc yyxy=[T](vec: var TVec; value: T)

yyxz:

core: proc yyxz(vec: TVec): auto

yyxz=:

core: proc yyxz=[T](vec: var TVec; value: T)

yyy:

core: proc yyy(vec: TVec): auto

yyy=:

core: proc yyy=[T](vec: var TVec; value: T)

yyyw:

core: proc yyyw(vec: TVec): auto

yyyw=:

core: proc yyyw=[T](vec: var TVec; value: T)

yyyx:

core: proc yyyx(vec: TVec): auto

yyyx=:

core: proc yyyx=[T](vec: var TVec; value: T)

yyyy:

core: proc yyyy(vec: TVec): auto

yyyy=:

core: proc yyyy=[T](vec: var TVec; value: T)

yyyz:

core: proc yyyz(vec: TVec): auto

yyyz=:

core: proc yyyz=[T](vec: var TVec; value: T)

yyz:

core: proc yyz(vec: TVec): auto

yyz=:

core: proc yyz=[T](vec: var TVec; value: T)

yyzw:

core: proc yyzw(vec: TVec): auto

yyzw=:

core: proc yyzw=[T](vec: var TVec; value: T)

yyzx:

core: proc yyzx(vec: TVec): auto

yyzx=:

core: proc yyzx=[T](vec: var TVec; value: T)

yyzy:

core: proc yyzy(vec: TVec): auto

yyzy=:

core: proc yyzy=[T](vec: var TVec; value: T)

yyzz:

core: proc yyzz(vec: TVec): auto

yyzz=:

core: proc yyzz=[T](vec: var TVec; value: T)

YZ:

core: const YZ

yz:

core: proc yz(vec: TVec): auto

yz=:

core: proc yz=[T](vec: var TVec; value: T)

YZi:

core: const YZi

YZi8:

core: const YZi8

yzw:

core: proc yzw(vec: TVec): auto

yzw=:

core: proc yzw=[T](vec: var TVec; value: T)

yzww:

core: proc yzww(vec: TVec): auto

yzww=:

core: proc yzww=[T](vec: var TVec; value: T)

yzwx:

core: proc yzwx(vec: TVec): auto

yzwx=:

core: proc yzwx=[T](vec: var TVec; value: T)

yzwy:

core: proc yzwy(vec: TVec): auto

yzwy=:

core: proc yzwy=[T](vec: var TVec; value: T)

yzwz:

core: proc yzwz(vec: TVec): auto

yzwz=:

core: proc yzwz=[T](vec: var TVec; value: T)

yzx:

core: proc yzx(vec: TVec): auto

yzx=:

core: proc yzx=[T](vec: var TVec; value: T)

yzxw:

core: proc yzxw(vec: TVec): auto

yzxw=:

core: proc yzxw=[T](vec: var TVec; value: T)

yzxx:

core: proc yzxx(vec: TVec): auto

yzxx=:

core: proc yzxx=[T](vec: var TVec; value: T)

yzxy:

core: proc yzxy(vec: TVec): auto

yzxy=:

core: proc yzxy=[T](vec: var TVec; value: T)

yzxz:

core: proc yzxz(vec: TVec): auto

yzxz=:

core: proc yzxz=[T](vec: var TVec; value: T)

yzy:

core: proc yzy(vec: TVec): auto

yzy=:

core: proc yzy=[T](vec: var TVec; value: T)

yzyw:

core: proc yzyw(vec: TVec): auto

yzyw=:

core: proc yzyw=[T](vec: var TVec; value: T)

yzyx:

core: proc yzyx(vec: TVec): auto

yzyx=:

core: proc yzyx=[T](vec: var TVec; value: T)

yzyy:

core: proc yzyy(vec: TVec): auto

yzyy=:

core: proc yzyy=[T](vec: var TVec; value: T)

yzyz:

core: proc yzyz(vec: TVec): auto

yzyz=:

core: proc yzyz=[T](vec: var TVec; value: T)

yzz:

core: proc yzz(vec: TVec): auto

yzz=:

core: proc yzz=[T](vec: var TVec; value: T)

yzzw:

core: proc yzzw(vec: TVec): auto

yzzw=:

core: proc yzzw=[T](vec: var TVec; value: T)

yzzx:

core: proc yzzx(vec: TVec): auto

yzzx=:

core: proc yzzx=[T](vec: var TVec; value: T)

yzzy:

core: proc yzzy(vec: TVec): auto

yzzy=:

core: proc yzzy=[T](vec: var TVec; value: T)

yzzz:

core: proc yzzz(vec: TVec): auto

yzzz=:

core: proc yzzz=[T](vec: var TVec; value: T)

Z:

core: const Z

z:

core: proc z(vec: TVec): auto

z=:

core: proc z=[T](vec: var TVec; value: T)

Zi:

core: const Zi

Zi8:

core: const Zi8

ZoomState:

xutil: const ZoomState

ZPixmap:

x: const ZPixmap

zw:

core: proc zw(vec: TVec): auto

zw=:

core: proc zw=[T](vec: var TVec; value: T)

zww:

core: proc zww(vec: TVec): auto

zww=:

core: proc zww=[T](vec: var TVec; value: T)

zwww:

core: proc zwww(vec: TVec): auto

zwww=:

core: proc zwww=[T](vec: var TVec; value: T)

zwwx:

core: proc zwwx(vec: TVec): auto

zwwx=:

core: proc zwwx=[T](vec: var TVec; value: T)

zwwy:

core: proc zwwy(vec: TVec): auto

zwwy=:

core: proc zwwy=[T](vec: var TVec; value: T)

zwwz:

core: proc zwwz(vec: TVec): auto

zwwz=:

core: proc zwwz=[T](vec: var TVec; value: T)

zwx:

core: proc zwx(vec: TVec): auto

zwx=:

core: proc zwx=[T](vec: var TVec; value: T)

zwxw:

core: proc zwxw(vec: TVec): auto

zwxw=:

core: proc zwxw=[T](vec: var TVec; value: T)

zwxx:

core: proc zwxx(vec: TVec): auto

zwxx=:

core: proc zwxx=[T](vec: var TVec; value: T)

zwxy:

core: proc zwxy(vec: TVec): auto

zwxy=:

core: proc zwxy=[T](vec: var TVec; value: T)

zwxz:

core: proc zwxz(vec: TVec): auto

zwxz=:

core: proc zwxz=[T](vec: var TVec; value: T)

zwy:

core: proc zwy(vec: TVec): auto

zwy=:

core: proc zwy=[T](vec: var TVec; value: T)

zwyw:

core: proc zwyw(vec: TVec): auto

zwyw=:

core: proc zwyw=[T](vec: var TVec; value: T)

zwyx:

core: proc zwyx(vec: TVec): auto

zwyx=:

core: proc zwyx=[T](vec: var TVec; value: T)

zwyy:

core: proc zwyy(vec: TVec): auto

zwyy=:

core: proc zwyy=[T](vec: var TVec; value: T)

zwyz:

core: proc zwyz(vec: TVec): auto

zwyz=:

core: proc zwyz=[T](vec: var TVec; value: T)

zwz:

core: proc zwz(vec: TVec): auto

zwz=:

core: proc zwz=[T](vec: var TVec; value: T)

zwzw:

core: proc zwzw(vec: TVec): auto

zwzw=:

core: proc zwzw=[T](vec: var TVec; value: T)

zwzx:

core: proc zwzx(vec: TVec): auto

zwzx=:

core: proc zwzx=[T](vec: var TVec; value: T)

zwzy:

core: proc zwzy(vec: TVec): auto

zwzy=:

core: proc zwzy=[T](vec: var TVec; value: T)

zwzz:

core: proc zwzz(vec: TVec): auto

zwzz=:

core: proc zwzz=[T](vec: var TVec; value: T)

zx:

core: proc zx(vec: TVec): auto

zx=:

core: proc zx=[T](vec: var TVec; value: T)

zxw:

core: proc zxw(vec: TVec): auto

zxw=:

core: proc zxw=[T](vec: var TVec; value: T)

zxww:

core: proc zxww(vec: TVec): auto

zxww=:

core: proc zxww=[T](vec: var TVec; value: T)

zxwx:

core: proc zxwx(vec: TVec): auto

zxwx=:

core: proc zxwx=[T](vec: var TVec; value: T)

zxwy:

core: proc zxwy(vec: TVec): auto

zxwy=:

core: proc zxwy=[T](vec: var TVec; value: T)

zxwz:

core: proc zxwz(vec: TVec): auto

zxwz=:

core: proc zxwz=[T](vec: var TVec; value: T)

zxx:

core: proc zxx(vec: TVec): auto

zxx=:

core: proc zxx=[T](vec: var TVec; value: T)

zxxw:

core: proc zxxw(vec: TVec): auto

zxxw=:

core: proc zxxw=[T](vec: var TVec; value: T)

zxxx:

core: proc zxxx(vec: TVec): auto

zxxx=:

core: proc zxxx=[T](vec: var TVec; value: T)

zxxy:

core: proc zxxy(vec: TVec): auto

zxxy=:

core: proc zxxy=[T](vec: var TVec; value: T)

zxxz:

core: proc zxxz(vec: TVec): auto

zxxz=:

core: proc zxxz=[T](vec: var TVec; value: T)

zxy:

core: proc zxy(vec: TVec): auto

zxy=:

core: proc zxy=[T](vec: var TVec; value: T)

zxyw:

core: proc zxyw(vec: TVec): auto

zxyw=:

core: proc zxyw=[T](vec: var TVec; value: T)

zxyx:

core: proc zxyx(vec: TVec): auto

zxyx=:

core: proc zxyx=[T](vec: var TVec; value: T)

zxyy:

core: proc zxyy(vec: TVec): auto

zxyy=:

core: proc zxyy=[T](vec: var TVec; value: T)

zxyz:

core: proc zxyz(vec: TVec): auto

zxyz=:

core: proc zxyz=[T](vec: var TVec; value: T)

zxz:

core: proc zxz(vec: TVec): auto

zxz=:

core: proc zxz=[T](vec: var TVec; value: T)

zxzw:

core: proc zxzw(vec: TVec): auto

zxzw=:

core: proc zxzw=[T](vec: var TVec; value: T)

zxzx:

core: proc zxzx(vec: TVec): auto

zxzx=:

core: proc zxzx=[T](vec: var TVec; value: T)

zxzy:

core: proc zxzy(vec: TVec): auto

zxzy=:

core: proc zxzy=[T](vec: var TVec; value: T)

zxzz:

core: proc zxzz(vec: TVec): auto

zxzz=:

core: proc zxzz=[T](vec: var TVec; value: T)

zy:

core: proc zy(vec: TVec): auto

zy=:

core: proc zy=[T](vec: var TVec; value: T)

zyw:

core: proc zyw(vec: TVec): auto

zyw=:

core: proc zyw=[T](vec: var TVec; value: T)

zyww:

core: proc zyww(vec: TVec): auto

zyww=:

core: proc zyww=[T](vec: var TVec; value: T)

zywx:

core: proc zywx(vec: TVec): auto

zywx=:

core: proc zywx=[T](vec: var TVec; value: T)

zywy:

core: proc zywy(vec: TVec): auto

zywy=:

core: proc zywy=[T](vec: var TVec; value: T)

zywz:

core: proc zywz(vec: TVec): auto

zywz=:

core: proc zywz=[T](vec: var TVec; value: T)

zyx:

core: proc zyx(vec: TVec): auto

zyx=:

core: proc zyx=[T](vec: var TVec; value: T)

zyxw:

core: proc zyxw(vec: TVec): auto

zyxw=:

core: proc zyxw=[T](vec: var TVec; value: T)

zyxx:

core: proc zyxx(vec: TVec): auto

zyxx=:

core: proc zyxx=[T](vec: var TVec; value: T)

zyxy:

core: proc zyxy(vec: TVec): auto

zyxy=:

core: proc zyxy=[T](vec: var TVec; value: T)

zyxz:

core: proc zyxz(vec: TVec): auto

zyxz=:

core: proc zyxz=[T](vec: var TVec; value: T)

zyy:

core: proc zyy(vec: TVec): auto

zyy=:

core: proc zyy=[T](vec: var TVec; value: T)

zyyw:

core: proc zyyw(vec: TVec): auto

zyyw=:

core: proc zyyw=[T](vec: var TVec; value: T)

zyyx:

core: proc zyyx(vec: TVec): auto

zyyx=:

core: proc zyyx=[T](vec: var TVec; value: T)

zyyy:

core: proc zyyy(vec: TVec): auto

zyyy=:

core: proc zyyy=[T](vec: var TVec; value: T)

zyyz:

core: proc zyyz(vec: TVec): auto

zyyz=:

core: proc zyyz=[T](vec: var TVec; value: T)

zyz:

core: proc zyz(vec: TVec): auto

zyz=:

core: proc zyz=[T](vec: var TVec; value: T)

zyzw:

core: proc zyzw(vec: TVec): auto

zyzw=:

core: proc zyzw=[T](vec: var TVec; value: T)

zyzx:

core: proc zyzx(vec: TVec): auto

zyzx=:

core: proc zyzx=[T](vec: var TVec; value: T)

zyzy:

core: proc zyzy(vec: TVec): auto

zyzy=:

core: proc zyzy=[T](vec: var TVec; value: T)

zyzz:

core: proc zyzz(vec: TVec): auto

zyzz=:

core: proc zyzz=[T](vec: var TVec; value: T)

zz:

core: proc zz(vec: TVec): auto

zz=:

core: proc zz=[T](vec: var TVec; value: T)

zzw:

core: proc zzw(vec: TVec): auto

zzw=:

core: proc zzw=[T](vec: var TVec; value: T)

zzww:

core: proc zzww(vec: TVec): auto

zzww=:

core: proc zzww=[T](vec: var TVec; value: T)

zzwx:

core: proc zzwx(vec: TVec): auto

zzwx=:

core: proc zzwx=[T](vec: var TVec; value: T)

zzwy:

core: proc zzwy(vec: TVec): auto

zzwy=:

core: proc zzwy=[T](vec: var TVec; value: T)

zzwz:

core: proc zzwz(vec: TVec): auto

zzwz=:

core: proc zzwz=[T](vec: var TVec; value: T)

zzx:

core: proc zzx(vec: TVec): auto

zzx=:

core: proc zzx=[T](vec: var TVec; value: T)

zzxw:

core: proc zzxw(vec: TVec): auto

zzxw=:

core: proc zzxw=[T](vec: var TVec; value: T)

zzxx:

core: proc zzxx(vec: TVec): auto

zzxx=:

core: proc zzxx=[T](vec: var TVec; value: T)

zzxy:

core: proc zzxy(vec: TVec): auto

zzxy=:

core: proc zzxy=[T](vec: var TVec; value: T)

zzxz:

core: proc zzxz(vec: TVec): auto

zzxz=:

core: proc zzxz=[T](vec: var TVec; value: T)

zzy:

core: proc zzy(vec: TVec): auto

zzy=:

core: proc zzy=[T](vec: var TVec; value: T)

zzyw:

core: proc zzyw(vec: TVec): auto

zzyw=:

core: proc zzyw=[T](vec: var TVec; value: T)

zzyx:

core: proc zzyx(vec: TVec): auto

zzyx=:

core: proc zzyx=[T](vec: var TVec; value: T)

zzyy:

core: proc zzyy(vec: TVec): auto

zzyy=:

core: proc zzyy=[T](vec: var TVec; value: T)

zzyz:

core: proc zzyz(vec: TVec): auto

zzyz=:

core: proc zzyz=[T](vec: var TVec; value: T)

zzz:

core: proc zzz(vec: TVec): auto

zzz=:

core: proc zzz=[T](vec: var TVec; value: T)

zzzw:

core: proc zzzw(vec: TVec): auto

zzzw=:

core: proc zzzw=[T](vec: var TVec; value: T)

zzzx:

core: proc zzzx(vec: TVec): auto

zzzx=:

core: proc zzzx=[T](vec: var TVec; value: T)

zzzy:

core: proc zzzy(vec: TVec): auto

zzzy=:

core: proc zzzy=[T](vec: var TVec; value: T)

zzzz:

core: proc zzzz(vec: TVec): auto

zzzz=:

core: proc zzzz=[T](vec: var TVec; value: T)