Index

API symbols

`$`:

`*=`:

`*`:

parsetoml: macro `?*`(x: untyped): untyped

parsetoml: proc `{}=`(node: TomlValueRef; keys: varargs[string]; value: TomlValueRef)

`{}`:

parsetoml: proc `{}`(node: TomlValueRef; keys: varargs[string]): TomlValueRef

a:

core: template a[T: TVec](v: T): untyped

a=:

core: template a=[T: TVec; S](v: T; a: S): untyped

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:

core: enum AccessMode

actionDown:

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

ActionMap:

core: object ActionMap

actionPressed:

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

actionReleased:

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

actionValue:

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

xi: const AddToList

addToPipeline:

font: proc addToPipeline(font: Font; renderdata: RenderData; pipeline: Pipeline)

addTrack:

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:

alignedTo:

core: proc alignedTo[T: SomeInteger](value: T; alignment: T): T

alignment:

text: proc alignment(textbuffer: var TextBuffer; textHandle: TextHandle; alignment: TextAlignment)

AllHints:

xutil: const AllHints

AllocAll:

x: const AllocAll

allocateNewMemoryBlock:

memory: proc allocateNewMemoryBlock(size: uint64; mType: uint32): MemoryBlock

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:

anchor:

text: proc anchor(textbuffer: var TextBuffer; textHandle: TextHandle; anchor: Vec2f)

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:

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

asGPUArray:

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

asGPUValue:

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

asMat3:

core: proc asMat3(m: Mat4): 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

AudioLevel:

core: type AudioLevel

AUDIO_SAMPLE_RATE:

audioWorker:

AutoRepeatModeDefault:

x: const AutoRepeatModeDefault

AutoRepeatModeOff:

x: const AutoRepeatModeOff

AutoRepeatModeOn:

x: const AutoRepeatModeOn

await:

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

B:

core: const B

b:

core: template b[T: TVec](v: T): untyped

b=:

core: template b=[T: TVec; S](v: T; a: S): untyped

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)

BackgroundLoader:

core: object BackgroundLoader

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:

vulkan_wrappers: 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: type BGRA

bgra:

core: proc bgra(vec: TVec): auto

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:

bindTo:

font: proc bindTo(font: Font; pipeline: Pipeline; commandbuffer: VkCommandBuffer)

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:

core: object Buffer

BUFFER_ALIGNMENT:

core: const BUFFER_ALIGNMENT

BUFFER_ALLOCATION_SIZE:

core: const BUFFER_ALLOCATION_SIZE

BufferType:

core: 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:

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:

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:

swapchain: proc clearSwapchain()

ClientMessage:

x: const ClientMessage

ClipByChildren:

x: const ClipByChildren

close:

CloseSoundDevice:

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]

color:

text: proc color(textbuffer: var TextBuffer; textHandle: TextHandle; color: Vec4f)

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:

ControlMapIndex:

x: const ControlMapIndex

ControlMask:

x: const ControlMask

Convex:

x: const Convex

CoordModeOrigin:

x: const CoordModeOrigin

CoordModePrevious:

x: const CoordModePrevious

copy:

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:

renderpasses: 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:

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

CreateNotify:

x: const CreateNotify

createPipeline:

shaders: proc createPipeline[TShader](shader: static 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:

vulkan_wrappers: 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

debugAssert:

core: template debugAssert(expr: untyped; msg = ""): untyped

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

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

delete:

parsetoml: proc delete(obj: TomlValueRef; key: string)

DeleteFromList:

xi: const DeleteFromList

deleteMessage:

rendering: var deleteMessage

Depth:

xlib: object Depth

DEPTH_FORMAT:

core: const DEPTH_FORMAT

DescriptorSet:

core: template DescriptorSet(index: DescriptorSetIndex)

DescriptorSetData:

core: object DescriptorSetData

DescriptorSetIndex:

core: type DescriptorSetIndex

destroy:

rendering: proc destroy(window: NativeWindow)

DestroyAll:

x: const DestroyAll

DestroyNotify:

x: const DestroyNotify

destroyPipeline:

shaders: proc destroyPipeline(pipeline: Pipeline)

destroyRenderData:

memory: proc destroyRenderData(renderData: RenderData)

destroyRenderPass:

renderpasses: proc destroyRenderPass(renderPass: RenderPass)

destroySwapchain:

swapchain: proc destroySwapchain(swapchain: Swapchain)

destroyVulkan:

rendering: proc destroyVulkan()

destroyWindow:

rendering: proc destroyWindow(window: NativeWindow)

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:

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

dump:

parsetoml: proc dump(table: TomlTableRef; indentLevel: int = 0)

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:

core: type Engine

engine:

core: proc engine(): Engine

ENGINE_LOGLEVEL:

core: const ENGINE_LOGLEVEL

engine_obj_internal:

core: var engine_obj_internal

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:

EventMaskOfScreen:

xlib: proc EventMaskOfScreen(s: PScreen): clong

EventType:

exec:

execAffectedRows:

existsKey:

parsetoml: proc existsKey(node: TomlValueRef; key: string): bool

Expose:

x: const Expose

ExposureMask:

x: const ExposureMask

F:

xlib: object F

f32:

fadeTo:

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:

FillOpaqueStippled:

x: const FillOpaqueStippled

FillSolid:

x: const FillSolid

FillStippled:

x: const FillStippled

FillTiled:

x: const FillTiled

finalize:

FirstExtensionError:

x: const FirstExtensionError

memory: proc flushAllMemory(renderData: RenderData)

flushBuffer:

memory: 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

FontRightToLeft:

x: const FontRightToLeft

ForgetGravity:

x: const ForgetGravity

frameHeight:

swapchain: proc frameHeight(): uint32

frameWidth:

swapchain: proc frameWidth(): uint32

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: template g[T: TVec](v: T): untyped

g=:

core: template g=[T: TVec; S](v: T; a: S): untyped

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:

core: proc getAspectRatio(): float32

get_auxdata:

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

getBestPhysicalDevice:

vulkan_wrappers: proc getBestPhysicalDevice(instance: VkInstance): VkPhysicalDevice

getBiggestInt:

parsetoml: proc getBiggestInt(n: TomlValueRef; default: int64 = 0): int64

getBindingNumber:

vulkan_wrappers: proc getBindingNumber[T](field: static string): uint32

getBool:

parsetoml: proc getBool(n: TomlValueRef; default: bool = false): bool

getBufferType:

getDescriptorCount:

vulkan_wrappers: proc getDescriptorCount[T](): uint32

getDescriptorType:

vulkan_wrappers: proc getDescriptorType[T](): VkDescriptorType

getElems:

parsetoml: proc getElems(n: TomlValueRef; default: seq[TomlValueRef] = @[]): seq[TomlValueRef]

getFloat:

parsetoml: proc getFloat(n: TomlValueRef; default: float = 0.0): float

getInt:

parsetoml: proc getInt(n: TomlValueRef; default: int = 0): int

getLevel:

getLoaded:

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

getLoadedData:

getMousePosition:

rendering: proc getMousePosition(window: NativeWindow): Vec2i

getOrDefault:

parsetoml: proc getOrDefault(node: TomlValueRef; key: string): TomlValueRef

getQueueFamily:

vulkan_wrappers: proc getQueueFamily(pDevice: VkPhysicalDevice; surface: VkSurfaceKHR; qType: VkQueueFlagBits): uint32

getRow:

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

getStr:

parsetoml: proc getStr(n: TomlValueRef; default: string = ""): string

get_table:

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

getTable:

parsetoml: proc getTable(n: TomlValueRef; default = new(TomlTableRef)): TomlTableRef

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)

GotFocus:

GPUArray:

core: object GPUArray

GPUData:

core: type GPUData

GPUValue:

core: 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:

core: 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

hash:

hasKey:

parsetoml: proc hasKey(node: TomlValueRef; key: string): bool

hasValidationLayer:

vulkan_wrappers: 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

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:

core: type Image

ImageArray:

core: type ImageArray

ImageByteOrder:

xlib: proc ImageByteOrder(dpy: PDisplay): cint

ImageObject:

core: object ImageObject

InactiveState:

xutil: const InactiveState

INAME:

xi: const INAME

IncludeInferiors:

x: const IncludeInferiors

IndexBuffer:

core: BufferType.IndexBuffer

IndexBufferMapped:

core: BufferType.IndexBufferMapped

INFLIGHTFRAMES:

core: const INFLIGHTFRAMES

initBackgroundLoader:

initDescriptorSet:

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

initEngine:

semicongine: proc initEngine(appName: string)

initMixer:

mixer_module: proc initMixer(): Mixer

initRenderData:

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

initTextBuffer:

text: proc initTextBuffer[MaxGlyphs: static int](font: Font[MaxGlyphs]; bufferSize: int; renderdata: var RenderData; baseScale = 1.0'f32): TextBuffer[MaxGlyphs]

initVulkan:

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

InProximity:

xi: const InProximity

Input:

core: object Input

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:

core: 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:

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:

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:

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:

KeyPressMask:

x: const KeyPressMask

KeyRelease:

x: const KeyRelease

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:

shaders: 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

core: proc lerp[T](a, b: T; value: SomeFloat): T

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:

audio: 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): TomlValueRef

LoaderResponse:

core: object LoaderResponse

LoaderThreadArgs:

core: type LoaderThreadArgs

loadExtension:

loadFont:

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

loadImage:

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

loadImageArray:

loadImageData:

loadJson:

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

loadMeshes:

gltf: 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:

loadVK_AMD_device_coherent_memory:

loadVK_AMD_display_native_hdr:

loadVK_AMD_gcn_shader:

loadVK_AMD_gpu_shader_half_float:

loadVK_AMD_gpu_shader_int16:

loadVK_AMD_memory_overallocation_behavior:

loadVK_AMD_mixed_attachment_samples:

loadVK_AMD_negative_viewport_height:

loadVK_AMD_pipeline_compiler_control:

loadVK_AMD_rasterization_order:

loadVK_AMD_shader_ballot:

loadVK_AMD_shader_core_properties:

loadVK_AMD_shader_core_properties2:

loadVK_AMD_shader_early_and_late_fragment_tests:

loadVK_AMD_shader_explicit_vertex_parameter:

loadVK_AMD_shader_fragment_mask:

loadVK_AMD_shader_image_load_store_lod:

loadVK_AMD_shader_info:

loadVK_AMD_shader_trinary_minmax:

loadVK_AMD_texture_gather_bias_lod:

loadVK_ARM_shader_core_builtins:

loadVK_ARM_shader_core_properties:

loadVK_EXT_acquire_drm_display:

loadVK_EXT_astc_decode_mode:

loadVK_EXT_attachment_feedback_loop_layout:

loadVK_EXT_blend_operation_advanced:

loadVK_EXT_border_color_swizzle:

loadVK_EXT_buffer_device_address:

loadVK_EXT_calibrated_timestamps:

loadVK_EXT_color_write_enable:

loadVK_EXT_conditional_rendering:

loadVK_EXT_conservative_rasterization:

loadVK_EXT_custom_border_color:

loadVK_EXT_debug_report:

loadVK_EXT_debug_utils:

loadVK_EXT_depth_clamp_zero_one:

loadVK_EXT_depth_clip_control:

loadVK_EXT_depth_clip_enable:

loadVK_EXT_depth_range_unrestricted:

loadVK_EXT_descriptor_buffer:

loadVK_EXT_device_address_binding_report:

loadVK_EXT_device_fault:

loadVK_EXT_device_memory_report:

loadVK_EXT_direct_mode_display:

loadVK_EXT_discard_rectangles:

loadVK_EXT_display_control:

loadVK_EXT_display_surface_counter:

loadVK_EXT_extended_dynamic_state3:

loadVK_EXT_external_memory_dma_buf:

loadVK_EXT_external_memory_host:

loadVK_EXT_filter_cubic:

loadVK_EXT_fragment_density_map:

loadVK_EXT_fragment_density_map2:

loadVK_EXT_fragment_shader_interlock:

loadVK_EXT_graphics_pipeline_library:

loadVK_EXT_hdr_metadata:

loadVK_EXT_headless_surface:

loadVK_EXT_image_2d_view_of_3d:

loadVK_EXT_image_compression_control:

loadVK_EXT_image_compression_control_swapchain:

loadVK_EXT_image_drm_format_modifier:

loadVK_EXT_image_sliced_view_of_3d:

loadVK_EXT_image_view_min_lod:

loadVK_EXT_index_type_uint8:

loadVK_EXT_legacy_dithering:

loadVK_EXT_line_rasterization:

loadVK_EXT_load_store_op_none:

loadVK_EXT_memory_budget:

loadVK_EXT_memory_priority:

loadVK_EXT_mesh_shader:

loadVK_EXT_multi_draw:

loadVK_EXT_multisampled_render_to_single_sampled:

loadVK_EXT_mutable_descriptor_type:

loadVK_EXT_non_seamless_cube_map:

loadVK_EXT_opacity_micromap:

loadVK_EXT_pageable_device_local_memory:

loadVK_EXT_pci_bus_info:

loadVK_EXT_physical_device_drm:

loadVK_EXT_pipeline_library_group_handles:

loadVK_EXT_pipeline_properties:

loadVK_EXT_pipeline_protected_access:

loadVK_EXT_pipeline_robustness:

loadVK_EXT_post_depth_coverage:

loadVK_EXT_primitives_generated_query:

loadVK_EXT_primitive_topology_list_restart:

loadVK_EXT_provoking_vertex:

loadVK_EXT_queue_family_foreign:

loadVK_EXT_rasterization_order_attachment_access:

loadVK_EXT_rgba10x6_formats:

loadVK_EXT_robustness2:

loadVK_EXT_sample_locations:

loadVK_EXT_shader_atomic_float:

loadVK_EXT_shader_atomic_float2:

loadVK_EXT_shader_image_atomic_int64:

loadVK_EXT_shader_module_identifier:

loadVK_EXT_shader_stencil_export:

loadVK_EXT_shader_subgroup_ballot:

loadVK_EXT_shader_subgroup_vote:

loadVK_EXT_subpass_merge_feedback:

loadVK_EXT_surface_maintenance1:

loadVK_EXT_swapchain_colorspace:

loadVK_EXT_swapchain_maintenance1:

loadVK_EXT_transform_feedback:

loadVK_EXT_validation_cache:

loadVK_EXT_validation_features:

loadVK_EXT_validation_flags:

loadVK_EXT_vertex_attribute_divisor:

loadVK_EXT_vertex_input_dynamic_state:

loadVK_EXT_ycbcr_image_arrays:

loadVK_GOOGLE_decorate_string:

loadVK_GOOGLE_display_timing:

loadVK_GOOGLE_hlsl_functionality1:

loadVK_GOOGLE_surfaceless_query:

loadVK_GOOGLE_user_type:

loadVK_HUAWEI_cluster_culling_shader:

loadVK_HUAWEI_invocation_mask:

loadVK_HUAWEI_subpass_shading:

loadVK_IMG_filter_cubic:

loadVK_IMG_format_pvrtc:

loadVK_INTEL_performance_query:

loadVK_INTEL_shader_integer_functions2:

loadVK_KHR_acceleration_structure:

loadVK_KHR_deferred_host_operations:

loadVK_KHR_display:

loadVK_KHR_display_swapchain:

loadVK_KHR_external_fence_fd:

loadVK_KHR_external_memory_fd:

loadVK_KHR_external_semaphore_fd:

loadVK_KHR_fragment_shader_barycentric:

loadVK_KHR_fragment_shading_rate:

loadVK_KHR_get_display_properties2:

loadVK_KHR_get_surface_capabilities2:

loadVK_KHR_global_priority:

loadVK_KHR_incremental_present:

loadVK_KHR_performance_query:

loadVK_KHR_pipeline_executable_properties:

loadVK_KHR_pipeline_library:

loadVK_KHR_portability_enumeration:

loadVK_KHR_present_id:

loadVK_KHR_present_wait:

loadVK_KHR_push_descriptor:

loadVK_KHR_ray_query:

loadVK_KHR_ray_tracing_maintenance1:

loadVK_KHR_ray_tracing_pipeline:

loadVK_KHR_shader_clock:

loadVK_KHR_shader_subgroup_uniform_control_flow:

loadVK_KHR_shared_presentable_image:

loadVK_KHR_surface:

loadVK_KHR_surface_protected_capabilities:

loadVK_KHR_swapchain:

loadVK_KHR_swapchain_mutable_format:

loadVK_KHR_workgroup_memory_explicit_layout:

loadVK_KHR_xlib_surface:

core: proc loadVK_KHR_xlib_surface(instance: VkInstance)

loadVK_LUNARG_direct_driver_loading:

loadVK_NV_clip_space_w_scaling:

loadVK_NV_compute_shader_derivatives:

loadVK_NV_cooperative_matrix:

loadVK_NV_copy_memory_indirect:

loadVK_NV_corner_sampled_image:

loadVK_NV_coverage_reduction_mode:

loadVK_NV_dedicated_allocation:

loadVK_NV_dedicated_allocation_image_aliasing:

loadVK_NV_device_diagnostic_checkpoints:

loadVK_NV_device_diagnostics_config:

loadVK_NV_device_generated_commands:

loadVK_NV_external_memory:

loadVK_NV_external_memory_capabilities:

loadVK_NV_external_memory_rdma:

loadVK_NV_fill_rectangle:

loadVK_NV_fragment_coverage_to_color:

loadVK_NV_fragment_shading_rate_enums:

loadVK_NV_framebuffer_mixed_samples:

loadVK_NV_geometry_shader_passthrough:

loadVK_NV_glsl_shader:

loadVK_NV_inherited_viewport_scissor:

loadVK_NV_linear_color_attachment:

loadVK_NV_memory_decompression:

loadVK_NV_mesh_shader:

loadVK_NV_optical_flow:

loadVK_NV_present_barrier:

loadVK_NV_ray_tracing:

loadVK_NV_ray_tracing_invocation_reorder:

loadVK_NV_ray_tracing_motion_blur:

loadVK_NV_representative_fragment_test:

loadVK_NV_sample_mask_override_coverage:

loadVK_NV_scissor_exclusive:

loadVK_NV_shader_image_footprint:

loadVK_NV_shader_sm_builtins:

loadVK_NV_shader_subgroup_partitioned:

loadVK_NV_shading_rate_image:

loadVK_NV_viewport_array2:

loadVK_NV_viewport_swizzle:

loadVK_NVX_binary_import:

loadVK_NVX_image_view_handle:

loadVK_NVX_multiview_per_view_attributes:

loadVK_QCOM_fragment_density_map_offset:

loadVK_QCOM_image_processing:

loadVK_QCOM_multiview_per_view_render_areas:

loadVK_QCOM_multiview_per_view_viewports:

loadVK_QCOM_render_pass_shader_resolve:

loadVK_QCOM_render_pass_store_ops:

loadVK_QCOM_render_pass_transform:

loadVK_QCOM_rotated_copy_commands:

loadVK_QCOM_tile_properties:

loadVK_SEC_amigo_profiling:

loadVK_VALVE_descriptor_set_host_mapping:

loadVK_VERSION_1_0:

loadVK_VERSION_1_1:

loadVK_VERSION_1_2:

loadVK_VERSION_1_3:

loadVulkan:

LockMapIndex:

x: const LockMapIndex

LockMask:

x: const LockMask

lockMouse:

input: proc lockMouse(value: bool)

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

MaxCmapsOfScreen:

xlib: proc MaxCmapsOfScreen(s: PScreen): cint

MAX_DESCRIPTORSETS:

core: const MAX_DESCRIPTORSETS

maxFramebufferSampleCount:

rendering: proc maxFramebufferSampleCount(maxSamples = VK_SAMPLE_COUNT_8_BIT): VkSampleCountFlagBits

MemoryBlock:

core: object MemoryBlock

MEMORY_BLOCK_ALLOCATION_SIZE:

core: const MEMORY_BLOCK_ALLOCATION_SIZE

MinCmapsOfScreen:

xlib: proc MinCmapsOfScreen(s: PScreen): cint

MinimizedWindow:

Mixer:

core: object 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:

mouseIsDown:

input: proc mouseIsDown(button: MouseButton): bool

mouseMove:

input: proc mouseMove(): Vec2i

mousePosition:

input: proc mousePosition(): Vec2f

mousePositionPixel:

input: proc mousePositionPixel(): Vec2i

MousePressed:

mousePressedButtons:

input: proc mousePressedButtons(): set[MouseButton]

MouseReleased:

mouseReleasedButtons:

input: proc mouseReleasedButtons(): set[MouseButton]

mouseWasPressed:

mouseWasReleased:

MouseWheel:

mouseWheel:

input: proc mouseWheel(): float32

mprintf:

sqlite3: proc mprintf(para1: cstring): cstring

MSBFirst:

x: const MSBFirst

MTLBuffer_id:

MTLCommandQueue_id:

MTLDevice_id:

MTLSharedEvent_id:

MTLTexture_id:

nativeFree:

core: proc nativeFree(p: pointer)

NativeSoundDevice:

core: object NativeSoundDevice

NativeWindow:

core: object NativeWindow

Neg:

parsetoml: Sign.Neg

NewKeyboard:

xi: const NewKeyboard

NewPointer:

xi: const NewPointer

newTArray:

parsetoml: proc newTArray(): TomlValueRef

newTBool:

parsetoml: proc newTBool(b: bool): TomlValueRef

newTFloat:

parsetoml: proc newTFloat(n: float): TomlValueRef

newTInt:

parsetoml: proc newTInt(n: int64): TomlValueRef

newTNull:

parsetoml: proc newTNull(): TomlValueRef

newTString:

parsetoml: proc newTString(s: string): TomlValueRef

newTTable:

parsetoml: proc newTTable(): TomlValueRef

NextRequest:

xlib: proc NextRequest(dpy: PDisplay): culong

NimBool2VkBool:

nLayers:

core: template nLayers(image: Image): untyped

NoEventMask:

x: const NoEventMask

NoExpose:

x: const NoExpose

noExtensionEvent:

xi: const noExtensionEvent

Nonconvex:

x: const Nonconvex

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:

core: enum OpenMode

OpenSoundDevice:

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

parseFile:

parseStream:

parsetoml: proc parseStream(inputStream: streams.Stream; fileName: string = ""): TomlValueRef

parseString:

parsetoml: proc parseString(tomlStr: string; fileName: string = ""): TomlValueRef

parseToml:

parsetoml: macro parseToml(x: untyped): untyped

PAspect:

xutil: const PAspect

Pass:

core: template Pass()

PassFlat:

core: template PassFlat()

PAtom:

x: type PAtom

pause:

PBaseSize:

xutil: const PBaseSize

PBool:

xlib: type PBool

PByte:

xkb: type PByte

Pcint:

xlib: type Pcint

PCMFormat:

core: 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:

PFN_vkDebugReportCallbackEXT:

PFN_vkDebugUtilsMessengerCallbackEXT:

PFN_vkDeviceMemoryReportCallbackEXT:

PFN_vkFaultCallbackFunction:

PFN_vkFreeFunction:

PFN_vkGetInstanceProcAddrLUNARG:

PFN_vkInternalAllocationNotification:

PFN_vkInternalFreeNotification:

PFN_vkReallocationFunction:

PFN_vkVoidFunction:

PFont:

x: type PFont

PGC:

xlib: type PGC

PGContext:

x: type PGContext

Pipeline:

core: object Pipeline

PixelType:

core: 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:

Playback:

core: object Playback

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

Pos:

parsetoml: Sign.Pos

position:

text: proc position(textbuffer: var TextBuffer; textHandle: TextHandle; position: Vec3f)

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:

core: template PushConstant()

PUSH_CONSTANT_SIZE:

core: const PUSH_CONSTANT_SIZE

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:

R:

core: const R

r:

core: template r[T: TVec](v: T): untyped

r=:

core: template r=[T: TVec; S](v: T; a: S): untyped

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:

ReadDbEffect:

db_common: object ReadDbEffect

ReadglTF:

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

readVorbis:

recreateSwapchain:

RectangleIn:

xutil: const RectangleIn

RectangleOut:

xutil: const RectangleOut

RectanglePart:

xutil: const RectanglePart

refresh:

text: proc refresh(textbuffer: var TextBuffer; flush = false)

Region:

xutil: type Region

Relative:

xi: const Relative

ReleaseByFreeingColormap:

xutil: const ReleaseByFreeingColormap

ReloadSettings:

settings: proc ReloadSettings()

render:

RenderData:

core: type RenderData

RenderPass:

core: type RenderPass

renderTextBuffer:

text: proc renderTextBuffer(commandBuffer: VkCommandBuffer; pipeline: Pipeline; textbuffer: TextBuffer)

renderWithPushConstant:

ReparentNotify:

x: const ReparentNotify

ReplayKeyboard:

x: const ReplayKeyboard

ReplayPointer:

x: const ReplayPointer

ReplayThisDevice:

xi: const ReplayThisDevice

ResizeRedirectMask:

x: const ResizeRedirectMask

ResizeRequest:

x: const ResizeRequest

RESOURCEROOT:

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:

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:

core: 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:

swapchain: proc setupSwapchain(renderPass: RenderPass; vSync: bool; tripleBuffering: bool)

ShaderOutput:

core: template ShaderOutput()

ShiftMapIndex:

x: const ShiftMapIndex

ShiftMask:

x: const ShiftMask

showSystemCursor:

Shutdown:

steam: var Shutdown

Sign:

parsetoml: enum Sign

simpleGetOrDefault:

parsetoml: template simpleGetOrDefault{ `{}`(node, [key]) }(node: TomlValueRef; key: string): TomlValueRef

sineSoundData:

Size:

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

size:

snd_pcm_close:

snd_pcm_hw_params:

snd_pcm_hw_params_any:

snd_pcm_hw_params_free:

snd_pcm_hw_params_malloc:

snd_pcm_hw_params_p:

core: type snd_pcm_hw_params_p

snd_pcm_hw_params_set_access:

snd_pcm_hw_params_set_buffer_size:

snd_pcm_hw_params_set_channels:

snd_pcm_hw_params_set_format:

snd_pcm_hw_params_set_rate:

snd_pcm_open:

snd_pcm_p:

core: type snd_pcm_p

snd_pcm_recover:

snd_pcm_sframes_t:

core: type snd_pcm_sframes_t

snd_pcm_uframes_t:

core: type snd_pcm_uframes_t

snd_pcm_writei:

snprintf:

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

SoundData:

core: 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

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

SteamUserStatsRef:

core: type SteamUserStatsRef

step:

sqlite3: proc step(para1: PStmt): int32

StippleShape:

x: const StippleShape

stop:

StorageBuffer:

core: BufferType.StorageBuffer

StorageBufferMapped:

core: BufferType.StorageBufferMapped

StorageType:

core: enum StorageType

store:

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

StreamMode:

core: enum StreamMode

StringFeedbackClass:

xi: const StringFeedbackClass

StructureNotifyMask:

x: const StructureNotifyMask

SubstructureNotifyMask:

x: const SubstructureNotifyMask

SubstructureRedirectMask:

x: const SubstructureRedirectMask

Success:

x: const Success

sum:

SupportedGPUType:

core: type SupportedGPUType

SURFACE_FORMAT:

core: const SURFACE_FORMAT

svkAllocateMemory:

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

svkCmdBindDescriptorSet:

vulkan_wrappers: proc svkCmdBindDescriptorSet(commandBuffer: VkCommandBuffer; descriptorSet: VkDescriptorSet; index: DescriptorSetIndex; layout: VkPipelineLayout)

svkCmdBindDescriptorSets:

vulkan_wrappers: proc svkCmdBindDescriptorSets(commandBuffer: VkCommandBuffer; descriptorSets: openArray[VkDescriptorSet]; layout: VkPipelineLayout)

svkCreate2DImage:

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

svkCreate2DImageView:

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

svkCreateBuffer:

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

svkCreateFence:

vulkan_wrappers: proc svkCreateFence(signaled = false): VkFence

svkCreateFramebuffer:

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

svkCreateRenderPass:

vulkan_wrappers: proc svkCreateRenderPass(attachments: openArray[VkAttachmentDescription]; colorAttachments: openArray[VkAttachmentReference]; depthAttachments: openArray[VkAttachmentReference]; resolveAttachments: openArray[VkAttachmentReference]; dependencies: openArray[VkSubpassDependency]): VkRenderPass

svkCreateSemaphore:

vulkan_wrappers: proc svkCreateSemaphore(): VkSemaphore

svkGetBufferMemoryRequirements:

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

svkGetDeviceQueue:

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

svkGetImageMemoryRequirements:

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

svkGetPhysicalDeviceProperties:

vulkan_wrappers: proc svkGetPhysicalDeviceProperties(): VkPhysicalDeviceProperties

svkGetPhysicalDeviceSurfacePresentModesKHR:

vulkan_wrappers: proc svkGetPhysicalDeviceSurfacePresentModesKHR(): seq[VkPresentModeKHR]

svkGetPhysicalDeviceSurfaceSupportKHR:

vulkan_wrappers: proc svkGetPhysicalDeviceSurfaceSupportKHR(pDevice: VkPhysicalDevice; surface: VkSurfaceKHR; queueFamily: uint32): bool

svkResetFences:

vulkan_wrappers: proc svkResetFences(fence: VkFence)

Swapchain:

core: type Swapchain

SyncAll:

xi: const SyncAll

SyncBoth:

x: const SyncBoth

SyncKeyboard:

x: const SyncKeyboard

SyncPointer:

x: const SyncPointer

SyncThisDevice:

xi: const SyncThisDevice

SystemStorage:

core: 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:

core: object Text

text:

TextAlignment:

core: enum TextAlignment

textDimension:

TextHandle:

core: object TextHandle

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

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

toEnums:

toJson:

TomlDate:

parsetoml: object TomlDate

TomlDateTime:

parsetoml: object TomlDateTime

TomlError:

parsetoml: object TomlError

TomlTable:

parsetoml: type TomlTable

TomlTableRef:

parsetoml: type TomlTableRef

TomlTime:

parsetoml: object TomlTime

TomlValue:

parsetoml: object TomlValue

TomlValueKind:

parsetoml: enum TomlValueKind

TomlValueRef:

parsetoml: type TomlValueRef

Top:

core: VerticalAlignment.Top

TopIf:

x: const TopIf

total_changes:

sqlite3: proc total_changes(para1: PSqlite3): int32

toTomlString:

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

Track:

core: object Track

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:

core: BufferType.UniformBuffer

UniformBufferMapped:

core: 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:

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

updateGlyphData:

updateGPUBuffer:

memory: proc updateGPUBuffer(gpuData: GPUData; frame: int; count = 0'u64; flush = false)

updateInputs:

input: proc updateInputs(): bool

updateSoundBuffer:

upload:

font: proc upload(font: Font; renderdata: var RenderData)

uploadImages:

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

user_data:

sqlite3: proc user_data(para1: Pcontext): pointer

UserStorage:

core: 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

Vec1i8:

core: type Vec1i8

vec1i8:

Vec1u:

core: type Vec1u

Vec1u8:

core: type Vec1u8

vec1u8:

vec2:

Vec2f:

core: type Vec2f

Vec2i:

core: type Vec2i

vec2i:

Vec2i8:

core: type Vec2i8

vec2i8:

Vec2u:

core: type Vec2u

Vec2u8:

core: type Vec2u8

vec3:

Vec3f:

core: type Vec3f

Vec3i:

core: type Vec3i

vec3i:

Vec3i8:

core: type Vec3i8

vec3i8:

Vec3u:

core: type Vec3u

Vec3u8:

core: type Vec3u8

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:

core: template VertexAttribute()

VertexBuffer:

core: BufferType.VertexBuffer

VertexBufferMapped:

core: BufferType.VertexBufferMapped

VerticalAlignment:

core: enum 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:

VisualIDMask:

xutil: const VisualIDMask

VisualNoMask:

xutil: const VisualNoMask

VisualRedMaskMask:

xutil: const VisualRedMaskMask

VisualScreenMask:

xutil: const VisualScreenMask

VkAabbPositionsKHR:

VkAabbPositionsNV:

VkAccelerationStructureBuildGeometryInfoKHR:

VkAccelerationStructureBuildRangeInfoKHR:

VkAccelerationStructureBuildSizesInfoKHR:

VkAccelerationStructureBuildTypeKHR:

VkAccelerationStructureCaptureDescriptorDataInfoEXT:

VkAccelerationStructureCompatibilityKHR:

VkAccelerationStructureCreateFlagBitsKHR:

VkAccelerationStructureCreateFlagsKHR:

VkAccelerationStructureCreateInfoKHR:

VkAccelerationStructureCreateInfoNV:

VkAccelerationStructureDeviceAddressInfoKHR:

VkAccelerationStructureGeometryAabbsDataKHR:

VkAccelerationStructureGeometryDataKHR:

VkAccelerationStructureGeometryInstancesDataKHR:

VkAccelerationStructureGeometryKHR:

VkAccelerationStructureGeometryMotionTrianglesDataNV:

VkAccelerationStructureGeometryTrianglesDataKHR:

VkAccelerationStructureInfoNV:

VkAccelerationStructureInstanceKHR:

VkAccelerationStructureInstanceNV:

VkAccelerationStructureKHR:

VkAccelerationStructureMatrixMotionInstanceNV:

VkAccelerationStructureMemoryRequirementsInfoNV:

VkAccelerationStructureMemoryRequirementsTypeNV:

VkAccelerationStructureMotionInfoFlagsNV:

VkAccelerationStructureMotionInfoNV:

VkAccelerationStructureMotionInstanceDataNV:

VkAccelerationStructureMotionInstanceFlagsNV:

VkAccelerationStructureMotionInstanceNV:

VkAccelerationStructureMotionInstanceTypeNV:

VkAccelerationStructureNV:

VkAccelerationStructureSRTMotionInstanceNV:

VkAccelerationStructureTrianglesOpacityMicromapEXT:

VkAccelerationStructureTypeKHR:

VkAccelerationStructureTypeNV:

VkAccelerationStructureVersionInfoKHR:

VK_ACCESS_2_NONE:

VkAccessFlagBits:

VkAccessFlagBits2:

VkAccessFlagBits2KHR:

VkAccessFlags:

VkAccessFlags2:

VkAccessFlags2KHR:

vkAcquireDrmDisplayEXT:

vkAcquireNextImage2KHR:

VkAcquireNextImageInfoKHR:

vkAcquireNextImageKHR:

vkAcquirePerformanceConfigurationINTEL:

VkAcquireProfilingLockFlagsKHR:

VkAcquireProfilingLockInfoKHR:

vkAcquireProfilingLockKHR:

vkAllocateCommandBuffers:

vkAllocateDescriptorSets:

vkAllocateMemory:

VkAllocationCallbacks:

VkAmigoProfilingSubmitInfoSEC:

VkAndroidSurfaceCreateFlagsKHR:

VkApplicationInfo:

VkApplicationParametersEXT:

VkAttachmentDescription:

VkAttachmentDescription2:

VkAttachmentDescription2KHR:

VkAttachmentDescriptionFlagBits:

VkAttachmentDescriptionFlags:

VkAttachmentDescriptionStencilLayout:

VkAttachmentDescriptionStencilLayoutKHR:

VkAttachmentLoadOp:

VkAttachmentReference:

VkAttachmentReference2:

VkAttachmentReference2KHR:

VkAttachmentReferenceStencilLayout:

VkAttachmentReferenceStencilLayoutKHR:

VkAttachmentSampleCountInfoAMD:

VkAttachmentSampleCountInfoNV:

VkAttachmentSampleLocationsEXT:

VkAttachmentStoreOp:

VK_ATTACHMENT_UNUSED:

VkBaseInStructure:

VkBaseOutStructure:

vkBeginCommandBuffer:

VkBindAccelerationStructureMemoryInfoNV:

vkBindAccelerationStructureMemoryNV:

vkBindBufferMemory:

vkBindBufferMemory2:

VkBindBufferMemoryDeviceGroupInfo:

VkBindBufferMemoryDeviceGroupInfoKHR:

VkBindBufferMemoryInfo:

VkBindBufferMemoryInfoKHR:

vkBindImageMemory:

vkBindImageMemory2:

VkBindImageMemoryDeviceGroupInfo:

VkBindImageMemoryDeviceGroupInfoKHR:

VkBindImageMemoryInfo:

VkBindImageMemoryInfoKHR:

VkBindImageMemorySwapchainInfoKHR:

VkBindImagePlaneMemoryInfo:

VkBindImagePlaneMemoryInfoKHR:

VkBindIndexBufferIndirectCommandNV:

vkBindOpticalFlowSessionImageNV:

VkBindShaderGroupIndirectCommandNV:

VkBindSparseInfo:

VkBindVertexBufferIndirectCommandNV:

VkBlendFactor:

VkBlendOp:

VkBlendOverlapEXT:

VkBlitImageInfo2:

VkBlitImageInfo2KHR:

VkBool32:

VkBorderColor:

VkBuffer:

VkBufferCaptureDescriptorDataInfoEXT:

VkBufferCollectionFUCHSIA:

VkBufferCopy:

VkBufferCopy2:

VkBufferCopy2KHR:

VkBufferCreateFlagBits:

VkBufferCreateFlags:

VkBufferCreateInfo:

VkBufferDeviceAddressCreateInfoEXT:

VkBufferDeviceAddressInfo:

VkBufferDeviceAddressInfoEXT:

VkBufferDeviceAddressInfoKHR:

VkBufferImageCopy:

VkBufferImageCopy2:

VkBufferImageCopy2KHR:

VkBufferMemoryBarrier:

VkBufferMemoryBarrier2:

VkBufferMemoryBarrier2KHR:

VkBufferMemoryRequirementsInfo2:

VkBufferMemoryRequirementsInfo2KHR:

VkBufferOpaqueCaptureAddressCreateInfo:

VkBufferOpaqueCaptureAddressCreateInfoKHR:

VkBufferUsageFlagBits:

VkBufferUsageFlags:

VkBufferView:

VkBufferViewCreateFlags:

VkBufferViewCreateInfo:

VkBuildAccelerationStructureFlagBitsKHR:

VkBuildAccelerationStructureFlagBitsNV:

VkBuildAccelerationStructureFlagsKHR:

VkBuildAccelerationStructureFlagsNV:

VkBuildAccelerationStructureModeKHR:

vkBuildAccelerationStructuresKHR:

VkBuildMicromapFlagBitsEXT:

VkBuildMicromapFlagsEXT:

VkBuildMicromapModeEXT:

vkBuildMicromapsEXT:

VkCalibratedTimestampInfoEXT:

VkCheckpointData2NV:

VkCheckpointDataNV:

VkChromaLocation:

VkChromaLocationKHR:

VkClearAttachment:

VkClearColorValue:

VkClearDepthStencilValue:

VkClearRect:

VkClearValue:

vkCmdBeginConditionalRenderingEXT:

vkCmdBeginDebugUtilsLabelEXT:

vkCmdBeginQuery:

vkCmdBeginQueryIndexedEXT:

vkCmdBeginRendering:

vkCmdBeginRenderPass:

vkCmdBeginRenderPass2:

vkCmdBeginTransformFeedbackEXT:

vkCmdBindDescriptorBufferEmbeddedSamplersEXT:

vkCmdBindDescriptorBuffersEXT:

vkCmdBindDescriptorSets:

vkCmdBindIndexBuffer:

vkCmdBindInvocationMaskHUAWEI:

vkCmdBindPipeline:

vkCmdBindPipelineShaderGroupNV:

vkCmdBindShadingRateImageNV:

vkCmdBindTransformFeedbackBuffersEXT:

vkCmdBindVertexBuffers:

vkCmdBindVertexBuffers2:

vkCmdBlitImage:

vkCmdBlitImage2:

vkCmdBuildAccelerationStructureNV:

vkCmdBuildAccelerationStructuresIndirectKHR:

vkCmdBuildAccelerationStructuresKHR:

vkCmdBuildMicromapsEXT:

vkCmdClearAttachments:

vkCmdClearColorImage:

vkCmdClearDepthStencilImage:

vkCmdCopyAccelerationStructureKHR:

vkCmdCopyAccelerationStructureNV:

vkCmdCopyAccelerationStructureToMemoryKHR:

vkCmdCopyBuffer:

vkCmdCopyBuffer2:

vkCmdCopyBufferToImage:

vkCmdCopyBufferToImage2:

vkCmdCopyImage:

vkCmdCopyImage2:

vkCmdCopyImageToBuffer:

vkCmdCopyImageToBuffer2:

vkCmdCopyMemoryIndirectNV:

vkCmdCopyMemoryToAccelerationStructureKHR:

vkCmdCopyMemoryToImageIndirectNV:

vkCmdCopyMemoryToMicromapEXT:

vkCmdCopyMicromapEXT:

vkCmdCopyMicromapToMemoryEXT:

vkCmdCopyQueryPoolResults:

vkCmdCuLaunchKernelNVX:

vkCmdDecompressMemoryIndirectCountNV:

vkCmdDecompressMemoryNV:

vkCmdDispatch:

vkCmdDispatchBase:

vkCmdDispatchIndirect:

vkCmdDraw:

vkCmdDrawClusterHUAWEI:

vkCmdDrawClusterIndirectHUAWEI:

vkCmdDrawIndexed:

vkCmdDrawIndexedIndirect:

vkCmdDrawIndexedIndirectCount:

vkCmdDrawIndirect:

vkCmdDrawIndirectByteCountEXT:

vkCmdDrawIndirectCount:

vkCmdDrawMeshTasksEXT:

vkCmdDrawMeshTasksIndirectCountEXT:

vkCmdDrawMeshTasksIndirectCountNV:

vkCmdDrawMeshTasksIndirectEXT:

vkCmdDrawMeshTasksIndirectNV:

vkCmdDrawMeshTasksNV:

vkCmdDrawMultiEXT:

vkCmdDrawMultiIndexedEXT:

vkCmdEndConditionalRenderingEXT:

vkCmdEndDebugUtilsLabelEXT:

vkCmdEndQuery:

vkCmdEndQueryIndexedEXT:

vkCmdEndRendering:

vkCmdEndRenderPass:

vkCmdEndRenderPass2:

vkCmdEndTransformFeedbackEXT:

vkCmdExecuteCommands:

vkCmdExecuteGeneratedCommandsNV:

vkCmdFillBuffer:

vkCmdInsertDebugUtilsLabelEXT:

vkCmdNextSubpass:

vkCmdNextSubpass2:

vkCmdOpticalFlowExecuteNV:

vkCmdPipelineBarrier:

vkCmdPipelineBarrier2:

vkCmdPreprocessGeneratedCommandsNV:

vkCmdPushConstants:

vkCmdPushDescriptorSetKHR:

vkCmdPushDescriptorSetWithTemplateKHR:

vkCmdResetEvent:

vkCmdResetEvent2:

vkCmdResetQueryPool:

vkCmdResolveImage:

vkCmdResolveImage2:

vkCmdSetAlphaToCoverageEnableEXT:

vkCmdSetAlphaToOneEnableEXT:

vkCmdSetBlendConstants:

vkCmdSetCheckpointNV:

vkCmdSetCoarseSampleOrderNV:

vkCmdSetColorBlendAdvancedEXT:

vkCmdSetColorBlendEnableEXT:

vkCmdSetColorBlendEquationEXT:

vkCmdSetColorWriteEnableEXT:

vkCmdSetColorWriteMaskEXT:

vkCmdSetConservativeRasterizationModeEXT:

vkCmdSetCoverageModulationModeNV:

vkCmdSetCoverageModulationTableEnableNV:

vkCmdSetCoverageModulationTableNV:

vkCmdSetCoverageReductionModeNV:

vkCmdSetCoverageToColorEnableNV:

vkCmdSetCoverageToColorLocationNV:

vkCmdSetCullMode:

vkCmdSetDepthBias:

vkCmdSetDepthBiasEnable:

vkCmdSetDepthBounds:

vkCmdSetDepthBoundsTestEnable:

vkCmdSetDepthClampEnableEXT:

vkCmdSetDepthClipEnableEXT:

vkCmdSetDepthClipNegativeOneToOneEXT:

vkCmdSetDepthCompareOp:

vkCmdSetDepthTestEnable:

vkCmdSetDepthWriteEnable:

vkCmdSetDescriptorBufferOffsetsEXT:

vkCmdSetDeviceMask:

vkCmdSetDiscardRectangleEnableEXT:

vkCmdSetDiscardRectangleEXT:

vkCmdSetDiscardRectangleModeEXT:

vkCmdSetEvent:

vkCmdSetEvent2:

vkCmdSetExclusiveScissorEnableNV:

vkCmdSetExclusiveScissorNV:

vkCmdSetExtraPrimitiveOverestimationSizeEXT:

vkCmdSetFragmentShadingRateEnumNV:

vkCmdSetFragmentShadingRateKHR:

vkCmdSetFrontFace:

vkCmdSetLineRasterizationModeEXT:

vkCmdSetLineStippleEnableEXT:

vkCmdSetLineStippleEXT:

vkCmdSetLineWidth:

vkCmdSetLogicOpEnableEXT:

vkCmdSetPerformanceMarkerINTEL:

vkCmdSetPerformanceOverrideINTEL:

vkCmdSetPerformanceStreamMarkerINTEL:

vkCmdSetPolygonModeEXT:

vkCmdSetPrimitiveRestartEnable:

vkCmdSetPrimitiveTopology:

vkCmdSetProvokingVertexModeEXT:

vkCmdSetRasterizationSamplesEXT:

vkCmdSetRasterizationStreamEXT:

vkCmdSetRasterizerDiscardEnable:

vkCmdSetRayTracingPipelineStackSizeKHR:

vkCmdSetRepresentativeFragmentTestEnableNV:

vkCmdSetSampleLocationsEnableEXT:

vkCmdSetSampleLocationsEXT:

vkCmdSetSampleMaskEXT:

vkCmdSetScissor:

vkCmdSetScissorWithCount:

vkCmdSetShadingRateImageEnableNV:

vkCmdSetStencilCompareMask:

vkCmdSetStencilOp:

vkCmdSetStencilReference:

vkCmdSetStencilTestEnable:

vkCmdSetStencilWriteMask:

vkCmdSetTessellationDomainOriginEXT:

vkCmdSetVertexInputEXT:

vkCmdSetViewport:

vkCmdSetViewportShadingRatePaletteNV:

vkCmdSetViewportSwizzleNV:

vkCmdSetViewportWithCount:

vkCmdSetViewportWScalingEnableNV:

vkCmdSetViewportWScalingNV:

vkCmdSubpassShadingHUAWEI:

vkCmdTraceRaysIndirect2KHR:

vkCmdTraceRaysIndirectKHR:

vkCmdTraceRaysKHR:

vkCmdTraceRaysNV:

vkCmdUpdateBuffer:

vkCmdWaitEvents:

vkCmdWaitEvents2:

vkCmdWriteAccelerationStructuresPropertiesKHR:

vkCmdWriteAccelerationStructuresPropertiesNV:

vkCmdWriteBufferMarkerAMD:

vkCmdWriteMicromapsPropertiesEXT:

vkCmdWriteTimestamp:

vkCmdWriteTimestamp2:

VkCoarseSampleLocationNV:

VkCoarseSampleOrderCustomNV:

VkCoarseSampleOrderTypeNV:

VkColorBlendAdvancedEXT:

VkColorBlendEquationEXT:

VkColorComponentFlagBits:

VkColorComponentFlags:

VkColorSpaceKHR:

VkCommandBuffer:

VkCommandBufferAllocateInfo:

VkCommandBufferBeginInfo:

VkCommandBufferInheritanceConditionalRenderingInfoEXT:

VkCommandBufferInheritanceInfo:

VkCommandBufferInheritanceRenderingInfo:

VkCommandBufferInheritanceRenderingInfoKHR:

VkCommandBufferInheritanceRenderPassTransformInfoQCOM:

VkCommandBufferInheritanceViewportScissorInfoNV:

VkCommandBufferLevel:

VkCommandBufferResetFlagBits:

VkCommandBufferResetFlags:

VkCommandBufferSubmitInfo:

VkCommandBufferSubmitInfoKHR:

VkCommandBufferUsageFlagBits:

VkCommandBufferUsageFlags:

VkCommandPool:

VkCommandPoolCreateFlagBits:

VkCommandPoolCreateFlags:

VkCommandPoolCreateInfo:

VkCommandPoolMemoryConsumption:

VkCommandPoolMemoryReservationCreateInfo:

VkCommandPoolResetFlagBits:

VkCommandPoolResetFlags:

VkCommandPoolTrimFlags:

VkCommandPoolTrimFlagsKHR:

VkCompareOp:

vkCompileDeferredNV:

VkComponentMapping:

VkComponentSwizzle:

VkComponentTypeNV:

VkCompositeAlphaFlagBitsKHR:

VkCompositeAlphaFlagsKHR:

VkComputePipelineCreateInfo:

VkConditionalRenderingBeginInfoEXT:

VkConditionalRenderingFlagBitsEXT:

VkConditionalRenderingFlagsEXT:

VkConformanceVersion:

VkConformanceVersionKHR:

VkConservativeRasterizationModeEXT:

VkCooperativeMatrixPropertiesNV:

VkCopyAccelerationStructureInfoKHR:

vkCopyAccelerationStructureKHR:

VkCopyAccelerationStructureModeKHR:

VkCopyAccelerationStructureModeNV:

VkCopyAccelerationStructureToMemoryInfoKHR:

vkCopyAccelerationStructureToMemoryKHR:

VkCopyBufferInfo2:

VkCopyBufferInfo2KHR:

VkCopyBufferToImageInfo2:

VkCopyBufferToImageInfo2KHR:

VkCopyCommandTransformInfoQCOM:

VkCopyDescriptorSet:

VkCopyImageInfo2:

VkCopyImageInfo2KHR:

VkCopyImageToBufferInfo2:

VkCopyImageToBufferInfo2KHR:

VkCopyMemoryIndirectCommandNV:

VkCopyMemoryToAccelerationStructureInfoKHR:

vkCopyMemoryToAccelerationStructureKHR:

VkCopyMemoryToImageIndirectCommandNV:

vkCopyMemoryToMicromapEXT:

VkCopyMemoryToMicromapInfoEXT:

vkCopyMicromapEXT:

VkCopyMicromapInfoEXT:

VkCopyMicromapModeEXT:

vkCopyMicromapToMemoryEXT:

VkCopyMicromapToMemoryInfoEXT:

VkCoverageModulationModeNV:

VkCoverageReductionModeNV:

vkCreateAccelerationStructureKHR:

vkCreateAccelerationStructureNV:

vkCreateBuffer:

vkCreateBufferView:

vkCreateCommandPool:

vkCreateComputePipelines:

vkCreateCuFunctionNVX:

vkCreateCuModuleNVX:

vkCreateDebugReportCallbackEXT:

vkCreateDebugUtilsMessengerEXT:

vkCreateDeferredOperationKHR:

vkCreateDescriptorPool:

vkCreateDescriptorSetLayout:

vkCreateDescriptorUpdateTemplate:

vkCreateDevice:

vkCreateDisplayModeKHR:

vkCreateDisplayPlaneSurfaceKHR:

vkCreateEvent:

vkCreateFence:

vkCreateFramebuffer:

vkCreateGraphicsPipelines:

vkCreateHeadlessSurfaceEXT:

vkCreateImage:

vkCreateImageView:

vkCreateIndirectCommandsLayoutNV:

vkCreateInstance:

vkCreateMicromapEXT:

vkCreateOpticalFlowSessionNV:

vkCreatePipelineCache:

vkCreatePipelineLayout:

vkCreatePrivateDataSlot:

vkCreateQueryPool:

vkCreateRayTracingPipelinesKHR:

vkCreateRayTracingPipelinesNV:

vkCreateRenderPass:

vkCreateRenderPass2:

vkCreateSampler:

vkCreateSamplerYcbcrConversion:

vkCreateSemaphore:

vkCreateShaderModule:

vkCreateSharedSwapchainsKHR:

vkCreateSwapchainKHR:

vkCreateValidationCacheEXT:

vkCreateXlibSurfaceKHR:

core: var vkCreateXlibSurfaceKHR

VkCuFunctionCreateInfoNVX:

VkCuFunctionNVX:

VkCuLaunchInfoNVX:

VkCullModeFlagBits:

VkCullModeFlags:

VK_CULL_MODE_FRONT_AND_BACK:

VK_CULL_MODE_NONE:

VkCuModuleCreateInfoNVX:

VkCuModuleNVX:

VkDebugMarkerMarkerInfoEXT:

VkDebugMarkerObjectNameInfoEXT:

VkDebugMarkerObjectTagInfoEXT:

VkDebugReportCallbackCreateInfoEXT:

VkDebugReportCallbackEXT:

VkDebugReportFlagBitsEXT:

VkDebugReportFlagsEXT:

vkDebugReportMessageEXT:

VkDebugReportObjectTypeEXT:

VkDebugUtilsLabelEXT:

VkDebugUtilsMessageSeverityFlagBitsEXT:

VkDebugUtilsMessageSeverityFlagsEXT:

VkDebugUtilsMessageTypeFlagBitsEXT:

VkDebugUtilsMessageTypeFlagsEXT:

VkDebugUtilsMessengerCallbackDataEXT:

VkDebugUtilsMessengerCallbackDataFlagsEXT:

VkDebugUtilsMessengerCreateFlagsEXT:

VkDebugUtilsMessengerCreateInfoEXT:

VkDebugUtilsMessengerEXT:

VkDebugUtilsObjectNameInfoEXT:

VkDebugUtilsObjectTagInfoEXT:

VkDecompressMemoryRegionNV:

VkDedicatedAllocationBufferCreateInfoNV:

VkDedicatedAllocationImageCreateInfoNV:

VkDedicatedAllocationMemoryAllocateInfoNV:

vkDeferredOperationJoinKHR:

VkDeferredOperationKHR:

VkDependencyFlagBits:

VkDependencyFlags:

VkDependencyInfo:

VkDependencyInfoKHR:

VkDescriptorAddressInfoEXT:

VkDescriptorBindingFlagBits:

VkDescriptorBindingFlagBitsEXT:

VkDescriptorBindingFlags:

VkDescriptorBindingFlagsEXT:

VkDescriptorBufferBindingInfoEXT:

VkDescriptorBufferBindingPushDescriptorBufferHandleEXT:

VkDescriptorBufferInfo:

VkDescriptorDataEXT:

VkDescriptorGetInfoEXT:

VkDescriptorImageInfo:

VkDescriptorPool:

VkDescriptorPoolCreateFlagBits:

VkDescriptorPoolCreateFlags:

VkDescriptorPoolCreateInfo:

VkDescriptorPoolInlineUniformBlockCreateInfo:

VkDescriptorPoolInlineUniformBlockCreateInfoEXT:

VkDescriptorPoolResetFlags:

VkDescriptorPoolSize:

VkDescriptorSet:

VkDescriptorSetAllocateInfo:

VkDescriptorSetBindingReferenceVALVE:

VkDescriptorSetLayout:

VkDescriptorSetLayoutBinding:

VkDescriptorSetLayoutBindingFlagsCreateInfo:

VkDescriptorSetLayoutBindingFlagsCreateInfoEXT:

VkDescriptorSetLayoutCreateFlagBits:

VkDescriptorSetLayoutCreateFlags:

VkDescriptorSetLayoutCreateInfo:

VkDescriptorSetLayoutHostMappingInfoVALVE:

VkDescriptorSetLayoutSupport:

VkDescriptorSetLayoutSupportKHR:

VkDescriptorSetVariableDescriptorCountAllocateInfo:

VkDescriptorSetVariableDescriptorCountAllocateInfoEXT:

VkDescriptorSetVariableDescriptorCountLayoutSupport:

VkDescriptorSetVariableDescriptorCountLayoutSupportEXT:

VkDescriptorType:

VkDescriptorUpdateTemplate:

VkDescriptorUpdateTemplateCreateFlags:

VkDescriptorUpdateTemplateCreateFlagsKHR:

VkDescriptorUpdateTemplateCreateInfo:

VkDescriptorUpdateTemplateCreateInfoKHR:

VkDescriptorUpdateTemplateEntry:

VkDescriptorUpdateTemplateEntryKHR:

VkDescriptorUpdateTemplateType:

VkDescriptorUpdateTemplateTypeKHR:

vkDestroyAccelerationStructureKHR:

vkDestroyAccelerationStructureNV:

vkDestroyBuffer:

vkDestroyBufferView:

vkDestroyCommandPool:

vkDestroyCuFunctionNVX:

vkDestroyCuModuleNVX:

vkDestroyDebugReportCallbackEXT:

vkDestroyDebugUtilsMessengerEXT:

vkDestroyDeferredOperationKHR:

vkDestroyDescriptorPool:

vkDestroyDescriptorSetLayout:

vkDestroyDescriptorUpdateTemplate:

vkDestroyDevice:

vkDestroyEvent:

vkDestroyFence:

vkDestroyFramebuffer:

vkDestroyImage:

vkDestroyImageView:

vkDestroyIndirectCommandsLayoutNV:

vkDestroyInstance:

vkDestroyMicromapEXT:

vkDestroyOpticalFlowSessionNV:

vkDestroyPipeline:

vkDestroyPipelineCache:

vkDestroyPipelineLayout:

vkDestroyPrivateDataSlot:

vkDestroyQueryPool:

vkDestroyRenderPass:

vkDestroySampler:

vkDestroySamplerYcbcrConversion:

vkDestroySemaphore:

vkDestroyShaderModule:

vkDestroySurfaceKHR:

vkDestroySwapchainKHR:

vkDestroyValidationCacheEXT:

VkDevice:

VkDeviceAddress:

VkDeviceAddressBindingCallbackDataEXT:

VkDeviceAddressBindingFlagBitsEXT:

VkDeviceAddressBindingFlagsEXT:

VkDeviceAddressBindingTypeEXT:

VkDeviceBufferMemoryRequirements:

VkDeviceBufferMemoryRequirementsKHR:

VkDeviceCreateFlags:

VkDeviceCreateInfo:

VkDeviceDeviceMemoryReportCreateInfoEXT:

VkDeviceDiagnosticsConfigCreateInfoNV:

VkDeviceDiagnosticsConfigFlagBitsNV:

VkDeviceDiagnosticsConfigFlagsNV:

VkDeviceEventInfoEXT:

VkDeviceEventTypeEXT:

VkDeviceFaultAddressInfoEXT:

VkDeviceFaultAddressTypeEXT:

VkDeviceFaultCountsEXT:

VkDeviceFaultInfoEXT:

VkDeviceFaultVendorBinaryHeaderVersionEXT:

VkDeviceFaultVendorBinaryHeaderVersionOneEXT:

VkDeviceFaultVendorInfoEXT:

VkDeviceGroupBindSparseInfo:

VkDeviceGroupBindSparseInfoKHR:

VkDeviceGroupCommandBufferBeginInfo:

VkDeviceGroupCommandBufferBeginInfoKHR:

VkDeviceGroupDeviceCreateInfo:

VkDeviceGroupDeviceCreateInfoKHR:

VkDeviceGroupPresentCapabilitiesKHR:

VkDeviceGroupPresentInfoKHR:

VkDeviceGroupPresentModeFlagBitsKHR:

VkDeviceGroupPresentModeFlagsKHR:

VkDeviceGroupRenderPassBeginInfo:

VkDeviceGroupRenderPassBeginInfoKHR:

VkDeviceGroupSubmitInfo:

VkDeviceGroupSubmitInfoKHR:

VkDeviceGroupSwapchainCreateInfoKHR:

VkDeviceImageMemoryRequirements:

VkDeviceImageMemoryRequirementsKHR:

VkDeviceMemory:

VkDeviceMemoryOpaqueCaptureAddressInfo:

VkDeviceMemoryOpaqueCaptureAddressInfoKHR:

VkDeviceMemoryOverallocationCreateInfoAMD:

VkDeviceMemoryReportCallbackDataEXT:

VkDeviceMemoryReportEventTypeEXT:

VkDeviceMemoryReportFlagsEXT:

VkDeviceObjectReservationCreateInfo:

VkDeviceOrHostAddressConstKHR:

VkDeviceOrHostAddressKHR:

VkDevicePrivateDataCreateInfo:

VkDevicePrivateDataCreateInfoEXT:

VkDeviceQueueCreateFlagBits:

VkDeviceQueueCreateFlags:

VkDeviceQueueCreateInfo:

VkDeviceQueueGlobalPriorityCreateInfoEXT:

VkDeviceQueueGlobalPriorityCreateInfoKHR:

VkDeviceQueueInfo2:

VkDeviceSize:

vkDeviceWaitIdle:

VkDirectDriverLoadingFlagsLUNARG:

VkDirectDriverLoadingInfoLUNARG:

VkDirectDriverLoadingListLUNARG:

VkDirectDriverLoadingModeLUNARG:

VkDirectFBSurfaceCreateFlagsEXT:

VkDiscardRectangleModeEXT:

VkDispatchIndirectCommand:

VkDisplayEventInfoEXT:

VkDisplayEventTypeEXT:

VkDisplayKHR:

VkDisplayModeCreateFlagsKHR:

VkDisplayModeCreateInfoKHR:

VkDisplayModeKHR:

VkDisplayModeParametersKHR:

VkDisplayModeProperties2KHR:

VkDisplayModePropertiesKHR:

VkDisplayNativeHdrSurfaceCapabilitiesAMD:

VkDisplayPlaneAlphaFlagBitsKHR:

VkDisplayPlaneAlphaFlagsKHR:

VkDisplayPlaneCapabilities2KHR:

VkDisplayPlaneCapabilitiesKHR:

VkDisplayPlaneInfo2KHR:

VkDisplayPlaneProperties2KHR:

VkDisplayPlanePropertiesKHR:

vkDisplayPowerControlEXT:

VkDisplayPowerInfoEXT:

VkDisplayPowerStateEXT:

VkDisplayPresentInfoKHR:

VkDisplayProperties2KHR:

VkDisplayPropertiesKHR:

VkDisplaySurfaceCreateFlagsKHR:

VkDisplaySurfaceCreateInfoKHR:

VkDrawIndexedIndirectCommand:

VkDrawIndirectCommand:

VkDrawMeshTasksIndirectCommandEXT:

VkDrawMeshTasksIndirectCommandNV:

VkDriverId:

VkDriverIdKHR:

VkDrmFormatModifierProperties2EXT:

VkDrmFormatModifierPropertiesEXT:

VkDrmFormatModifierPropertiesList2EXT:

VkDrmFormatModifierPropertiesListEXT:

VkDynamicState:

vkEndCommandBuffer:

vkEnumerateDeviceExtensionProperties:

vkEnumerateDeviceLayerProperties:

vkEnumerateInstanceExtensionProperties:

vkEnumerateInstanceLayerProperties:

vkEnumerateInstanceVersion:

vkEnumeratePhysicalDeviceGroups:

vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR:

vkEnumeratePhysicalDevices:

VkEvent:

VkEventCreateFlagBits:

VkEventCreateFlags:

VkEventCreateInfo:

VkExportFenceCreateInfo:

VkExportFenceCreateInfoKHR:

VkExportMemoryAllocateInfo:

VkExportMemoryAllocateInfoKHR:

VkExportMemoryAllocateInfoNV:

VkExportMetalObjectTypeFlagBitsEXT:

VkExportMetalObjectTypeFlagsEXT:

VkExportSemaphoreCreateInfo:

VkExportSemaphoreCreateInfoKHR:

VkExtensionProperties:

VkExtent2D:

VkExtent3D:

VkExternalBufferProperties:

VkExternalBufferPropertiesKHR:

VkExternalFenceFeatureFlagBits:

VkExternalFenceFeatureFlagBitsKHR:

VkExternalFenceFeatureFlags:

VkExternalFenceFeatureFlagsKHR:

VkExternalFenceHandleTypeFlagBits:

VkExternalFenceHandleTypeFlagBitsKHR:

VkExternalFenceHandleTypeFlags:

VkExternalFenceHandleTypeFlagsKHR:

VkExternalFenceProperties:

VkExternalFencePropertiesKHR:

VkExternalImageFormatProperties:

VkExternalImageFormatPropertiesKHR:

VkExternalImageFormatPropertiesNV:

VkExternalMemoryBufferCreateInfo:

VkExternalMemoryBufferCreateInfoKHR:

VkExternalMemoryFeatureFlagBits:

VkExternalMemoryFeatureFlagBitsKHR:

VkExternalMemoryFeatureFlagBitsNV:

VkExternalMemoryFeatureFlags:

VkExternalMemoryFeatureFlagsKHR:

VkExternalMemoryFeatureFlagsNV:

VkExternalMemoryHandleTypeFlagBits:

VkExternalMemoryHandleTypeFlagBitsKHR:

VkExternalMemoryHandleTypeFlagBitsNV:

VkExternalMemoryHandleTypeFlags:

VkExternalMemoryHandleTypeFlagsKHR:

VkExternalMemoryHandleTypeFlagsNV:

VkExternalMemoryImageCreateInfo:

VkExternalMemoryImageCreateInfoKHR:

VkExternalMemoryImageCreateInfoNV:

VkExternalMemoryProperties:

VkExternalMemoryPropertiesKHR:

VkExternalSemaphoreFeatureFlagBits:

VkExternalSemaphoreFeatureFlagBitsKHR:

VkExternalSemaphoreFeatureFlags:

VkExternalSemaphoreFeatureFlagsKHR:

VkExternalSemaphoreHandleTypeFlagBits:

VkExternalSemaphoreHandleTypeFlagBitsKHR:

VkExternalSemaphoreHandleTypeFlags:

VkExternalSemaphoreHandleTypeFlagsKHR:

VkExternalSemaphoreProperties:

VkExternalSemaphorePropertiesKHR:

VK_FALSE:

VkFaultCallbackInfo:

VkFaultData:

VkFaultLevel:

VkFaultQueryBehavior:

VkFaultType:

VkFence:

VkFenceCreateFlagBits:

VkFenceCreateFlags:

VkFenceCreateInfo:

VkFenceGetFdInfoKHR:

VkFenceImportFlagBits:

VkFenceImportFlagBitsKHR:

VkFenceImportFlags:

VkFenceImportFlagsKHR:

VkFilter:

VkFilterCubicImageViewImageFormatPropertiesEXT:

VkFlags:

VkFlags64:

vkFlushMappedMemoryRanges:

VkFormat:

VkFormatFeatureFlagBits:

VkFormatFeatureFlagBits2:

VkFormatFeatureFlagBits2KHR:

VkFormatFeatureFlags:

VkFormatFeatureFlags2:

VkFormatFeatureFlags2KHR:

VkFormatProperties:

VkFormatProperties2:

VkFormatProperties2KHR:

VkFormatProperties3:

VkFormatProperties3KHR:

VkFragmentShadingRateAttachmentInfoKHR:

VkFragmentShadingRateCombinerOpKHR:

VkFragmentShadingRateNV:

VkFragmentShadingRateTypeNV:

VkFramebuffer:

VkFramebufferAttachmentImageInfo:

VkFramebufferAttachmentImageInfoKHR:

VkFramebufferAttachmentsCreateInfo:

VkFramebufferAttachmentsCreateInfoKHR:

VkFramebufferCreateFlagBits:

VkFramebufferCreateFlags:

VkFramebufferCreateInfo:

VkFramebufferMixedSamplesCombinationNV:

vkFreeCommandBuffers:

vkFreeDescriptorSets:

vkFreeMemory:

VkFrontFace:

VkFullScreenExclusiveEXT:

VkGeneratedCommandsInfoNV:

VkGeneratedCommandsMemoryRequirementsInfoNV:

VkGeometryAABBNV:

VkGeometryDataNV:

VkGeometryFlagBitsKHR:

VkGeometryFlagBitsNV:

VkGeometryFlagsKHR:

VkGeometryFlagsNV:

VkGeometryInstanceFlagBitsKHR:

VkGeometryInstanceFlagBitsNV:

VkGeometryInstanceFlagsKHR:

VkGeometryInstanceFlagsNV:

VkGeometryNV:

VkGeometryTrianglesNV:

VkGeometryTypeKHR:

VkGeometryTypeNV:

vkGetAccelerationStructureBuildSizesKHR:

vkGetAccelerationStructureDeviceAddressKHR:

vkGetAccelerationStructureHandleNV:

vkGetAccelerationStructureMemoryRequirementsNV:

vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT:

vkGetBufferDeviceAddress:

vkGetBufferDeviceAddressEXT:

vkGetBufferMemoryRequirements:

vkGetBufferMemoryRequirements2:

vkGetBufferOpaqueCaptureAddress:

vkGetBufferOpaqueCaptureDescriptorDataEXT:

vkGetCalibratedTimestampsEXT:

vkGetDeferredOperationMaxConcurrencyKHR:

vkGetDeferredOperationResultKHR:

vkGetDescriptorEXT:

vkGetDescriptorSetHostMappingVALVE:

vkGetDescriptorSetLayoutBindingOffsetEXT:

vkGetDescriptorSetLayoutHostMappingInfoVALVE:

vkGetDescriptorSetLayoutSizeEXT:

vkGetDescriptorSetLayoutSupport:

vkGetDeviceAccelerationStructureCompatibilityKHR:

vkGetDeviceBufferMemoryRequirements:

vkGetDeviceFaultInfoEXT:

vkGetDeviceGroupPeerMemoryFeatures:

vkGetDeviceGroupPresentCapabilitiesKHR:

vkGetDeviceGroupSurfacePresentModesKHR:

vkGetDeviceImageMemoryRequirements:

vkGetDeviceImageSparseMemoryRequirements:

vkGetDeviceMemoryCommitment:

vkGetDeviceMemoryOpaqueCaptureAddress:

vkGetDeviceMicromapCompatibilityEXT:

vkGetDeviceProcAddr:

vkGetDeviceQueue:

vkGetDeviceQueue2:

vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI:

vkGetDisplayModeProperties2KHR:

vkGetDisplayModePropertiesKHR:

vkGetDisplayPlaneCapabilities2KHR:

vkGetDisplayPlaneCapabilitiesKHR:

vkGetDisplayPlaneSupportedDisplaysKHR:

vkGetDrmDisplayEXT:

vkGetDynamicRenderingTilePropertiesQCOM:

vkGetEventStatus:

vkGetFenceFdKHR:

vkGetFenceStatus:

vkGetFramebufferTilePropertiesQCOM:

vkGetGeneratedCommandsMemoryRequirementsNV:

vkGetImageDrmFormatModifierPropertiesEXT:

vkGetImageMemoryRequirements:

vkGetImageMemoryRequirements2:

vkGetImageOpaqueCaptureDescriptorDataEXT:

vkGetImageSparseMemoryRequirements:

vkGetImageSparseMemoryRequirements2:

vkGetImageSubresourceLayout:

vkGetImageSubresourceLayout2EXT:

vkGetImageViewAddressNVX:

vkGetImageViewHandleNVX:

vkGetImageViewOpaqueCaptureDescriptorDataEXT:

vkGetMemoryFdKHR:

vkGetMemoryFdPropertiesKHR:

vkGetMemoryHostPointerPropertiesEXT:

vkGetMemoryRemoteAddressNV:

vkGetMicromapBuildSizesEXT:

vkGetPastPresentationTimingGOOGLE:

vkGetPerformanceParameterINTEL:

vkGetPhysicalDeviceCalibrateableTimeDomainsEXT:

vkGetPhysicalDeviceCooperativeMatrixPropertiesNV:

vkGetPhysicalDeviceDisplayPlaneProperties2KHR:

vkGetPhysicalDeviceDisplayPlanePropertiesKHR:

vkGetPhysicalDeviceDisplayProperties2KHR:

vkGetPhysicalDeviceDisplayPropertiesKHR:

vkGetPhysicalDeviceExternalBufferProperties:

vkGetPhysicalDeviceExternalFenceProperties:

vkGetPhysicalDeviceExternalImageFormatPropertiesNV:

vkGetPhysicalDeviceExternalSemaphoreProperties:

vkGetPhysicalDeviceFeatures:

vkGetPhysicalDeviceFeatures2:

vkGetPhysicalDeviceFormatProperties:

vkGetPhysicalDeviceFormatProperties2:

vkGetPhysicalDeviceFragmentShadingRatesKHR:

vkGetPhysicalDeviceImageFormatProperties:

vkGetPhysicalDeviceImageFormatProperties2:

vkGetPhysicalDeviceMemoryProperties:

vkGetPhysicalDeviceMemoryProperties2:

vkGetPhysicalDeviceMultisamplePropertiesEXT:

vkGetPhysicalDeviceOpticalFlowImageFormatsNV:

vkGetPhysicalDevicePresentRectanglesKHR:

vkGetPhysicalDeviceProperties:

vkGetPhysicalDeviceProperties2:

vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR:

vkGetPhysicalDeviceQueueFamilyProperties:

vkGetPhysicalDeviceQueueFamilyProperties2:

vkGetPhysicalDeviceSparseImageFormatProperties:

vkGetPhysicalDeviceSparseImageFormatProperties2:

vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV:

vkGetPhysicalDeviceSurfaceCapabilities2EXT:

vkGetPhysicalDeviceSurfaceCapabilities2KHR:

vkGetPhysicalDeviceSurfaceCapabilitiesKHR:

vkGetPhysicalDeviceSurfaceFormats2KHR:

vkGetPhysicalDeviceSurfaceFormatsKHR:

vkGetPhysicalDeviceSurfacePresentModesKHR:

vkGetPhysicalDeviceSurfaceSupportKHR:

vkGetPhysicalDeviceToolProperties:

vkGetPhysicalDeviceXlibPresentationSupportKHR:

core: var vkGetPhysicalDeviceXlibPresentationSupportKHR

vkGetPipelineCacheData:

vkGetPipelineExecutableInternalRepresentationsKHR:

vkGetPipelineExecutablePropertiesKHR:

vkGetPipelineExecutableStatisticsKHR:

vkGetPipelinePropertiesEXT:

vkGetPrivateData:

vkGetQueryPoolResults:

vkGetQueueCheckpointDataNV:

vkGetRayTracingCaptureReplayShaderGroupHandlesKHR:

vkGetRayTracingShaderGroupHandlesKHR:

vkGetRayTracingShaderGroupHandlesNV:

vkGetRayTracingShaderGroupStackSizeKHR:

vkGetRefreshCycleDurationGOOGLE:

vkGetRenderAreaGranularity:

vkGetSamplerOpaqueCaptureDescriptorDataEXT:

vkGetSemaphoreCounterValue:

vkGetSemaphoreFdKHR:

vkGetShaderInfoAMD:

vkGetShaderModuleCreateInfoIdentifierEXT:

vkGetShaderModuleIdentifierEXT:

vkGetSwapchainCounterEXT:

vkGetSwapchainImagesKHR:

vkGetSwapchainStatusKHR:

vkGetValidationCacheDataEXT:

VkGraphicsPipelineCreateInfo:

VkGraphicsPipelineLibraryCreateInfoEXT:

VkGraphicsPipelineLibraryFlagBitsEXT:

VkGraphicsPipelineLibraryFlagsEXT:

VkGraphicsPipelineShaderGroupsCreateInfoNV:

VkGraphicsShaderGroupCreateInfoNV:

VkHandle:

VkHdrMetadataEXT:

VkHeadlessSurfaceCreateFlagsEXT:

VkHeadlessSurfaceCreateInfoEXT:

VkImage:

VkImageAspectFlagBits:

VkImageAspectFlags:

VkImageBlit:

VkImageBlit2:

VkImageBlit2KHR:

VkImageCaptureDescriptorDataInfoEXT:

VkImageCompressionControlEXT:

VK_IMAGE_COMPRESSION_DEFAULT_EXT:

VkImageCompressionFixedRateFlagBitsEXT:

VkImageCompressionFixedRateFlagsEXT:

VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT:

VkImageCompressionFlagBitsEXT:

VkImageCompressionFlagsEXT:

VkImageCompressionPropertiesEXT:

VkImageConstraintsInfoFlagBitsFUCHSIA:

VkImageConstraintsInfoFlagsFUCHSIA:

VkImageCopy:

VkImageCopy2:

VkImageCopy2KHR:

VkImageCreateFlagBits:

VkImageCreateFlags:

VkImageCreateInfo:

VkImageDrmFormatModifierExplicitCreateInfoEXT:

VkImageDrmFormatModifierListCreateInfoEXT:

VkImageDrmFormatModifierPropertiesEXT:

VkImageFormatConstraintsFlagsFUCHSIA:

VkImageFormatListCreateInfo:

VkImageFormatListCreateInfoKHR:

VkImageFormatProperties:

VkImageFormatProperties2:

VkImageFormatProperties2KHR:

VkImageLayout:

VkImageMemoryBarrier:

VkImageMemoryBarrier2:

VkImageMemoryBarrier2KHR:

VkImageMemoryRequirementsInfo2:

VkImageMemoryRequirementsInfo2KHR:

VkImagePipeSurfaceCreateFlagsFUCHSIA:

VkImagePlaneMemoryRequirementsInfo:

VkImagePlaneMemoryRequirementsInfoKHR:

VkImageResolve:

VkImageResolve2:

VkImageResolve2KHR:

VkImageSparseMemoryRequirementsInfo2:

VkImageSparseMemoryRequirementsInfo2KHR:

VkImageStencilUsageCreateInfo:

VkImageStencilUsageCreateInfoEXT:

VkImageSubresource:

VkImageSubresource2EXT:

VkImageSubresourceLayers:

VkImageSubresourceRange:

VkImageSwapchainCreateInfoKHR:

VkImageTiling:

VkImageType:

VkImageUsageFlagBits:

VkImageUsageFlags:

VkImageView:

VkImageViewAddressPropertiesNVX:

VkImageViewASTCDecodeModeEXT:

VkImageViewCaptureDescriptorDataInfoEXT:

VkImageViewCreateFlagBits:

VkImageViewCreateFlags:

VkImageViewCreateInfo:

VkImageViewHandleInfoNVX:

VkImageViewMinLodCreateInfoEXT:

VkImageViewSampleWeightCreateInfoQCOM:

VkImageViewSlicedCreateInfoEXT:

VkImageViewType:

VkImageViewUsageCreateInfo:

VkImageViewUsageCreateInfoKHR:

VkImportFenceFdInfoKHR:

vkImportFenceFdKHR:

VkImportMemoryFdInfoKHR:

VkImportMemoryHostPointerInfoEXT:

VkImportSemaphoreFdInfoKHR:

vkImportSemaphoreFdKHR:

VkIndexType:

VkIndirectCommandsLayoutCreateInfoNV:

VkIndirectCommandsLayoutNV:

VkIndirectCommandsLayoutTokenNV:

VkIndirectCommandsLayoutUsageFlagBitsNV:

VkIndirectCommandsLayoutUsageFlagsNV:

VkIndirectCommandsStreamNV:

VkIndirectCommandsTokenTypeNV:

VkIndirectStateFlagBitsNV:

VkIndirectStateFlagsNV:

VkInitializePerformanceApiInfoINTEL:

vkInitializePerformanceApiINTEL:

VkInputAttachmentAspectReference:

VkInputAttachmentAspectReferenceKHR:

VkInstance:

VkInstanceCreateFlagBits:

VkInstanceCreateFlags:

VkInstanceCreateInfo:

VkInternalAllocationType:

vkInvalidateMappedMemoryRanges:

VkIOSSurfaceCreateFlagsMVK:

VkLayerProperties:

VkLineRasterizationModeEXT:

VK_LOD_CLAMP_NONE:

VkLogicOp:

VK_LUID_SIZE:

VK_LUID_SIZE_KHR:

VkMacOSSurfaceCreateFlagsMVK:

VK_MAKE_API_VERSION:

vkMapMemory:

VkMappedMemoryRange:

VK_MAX_DESCRIPTION_SIZE:

VK_MAX_DEVICE_GROUP_SIZE:

VK_MAX_DEVICE_GROUP_SIZE_KHR:

VK_MAX_DRIVER_INFO_SIZE:

VK_MAX_DRIVER_INFO_SIZE_KHR:

VK_MAX_DRIVER_NAME_SIZE:

VK_MAX_DRIVER_NAME_SIZE_KHR:

VK_MAX_EXTENSION_NAME_SIZE:

VK_MAX_GLOBAL_PRIORITY_SIZE_EXT:

VK_MAX_GLOBAL_PRIORITY_SIZE_KHR:

VK_MAX_MEMORY_HEAPS:

VK_MAX_MEMORY_TYPES:

VK_MAX_PHYSICAL_DEVICE_NAME_SIZE:

VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT:

VkMemoryAllocateFlagBits:

VkMemoryAllocateFlagBitsKHR:

VkMemoryAllocateFlags:

VkMemoryAllocateFlagsInfo:

VkMemoryAllocateFlagsInfoKHR:

VkMemoryAllocateFlagsKHR:

VkMemoryAllocateInfo:

VkMemoryBarrier:

VkMemoryBarrier2:

VkMemoryBarrier2KHR:

VkMemoryDecompressionMethodFlagBitsNV:

VkMemoryDecompressionMethodFlagsNV:

VkMemoryDedicatedAllocateInfo:

VkMemoryDedicatedAllocateInfoKHR:

VkMemoryDedicatedRequirements:

VkMemoryDedicatedRequirementsKHR:

VkMemoryFdPropertiesKHR:

VkMemoryGetFdInfoKHR:

VkMemoryGetRemoteAddressInfoNV:

VkMemoryHeap:

VkMemoryHeapFlagBits:

VkMemoryHeapFlags:

VkMemoryHostPointerPropertiesEXT:

VkMemoryMapFlags:

VkMemoryOpaqueCaptureAddressAllocateInfo:

VkMemoryOpaqueCaptureAddressAllocateInfoKHR:

VkMemoryOverallocationBehaviorAMD:

VkMemoryPriorityAllocateInfoEXT:

VkMemoryPropertyFlagBits:

VkMemoryPropertyFlags:

VkMemoryRequirements:

VkMemoryRequirements2:

VkMemoryRequirements2KHR:

VkMemoryType:

vkMergePipelineCaches:

vkMergeValidationCachesEXT:

VkMetalSurfaceCreateFlagsEXT:

VkMicromapBuildInfoEXT:

VkMicromapBuildSizesInfoEXT:

VkMicromapCreateFlagBitsEXT:

VkMicromapCreateFlagsEXT:

VkMicromapCreateInfoEXT:

VkMicromapEXT:

VkMicromapTriangleEXT:

VkMicromapTypeEXT:

VkMicromapUsageEXT:

VkMicromapVersionInfoEXT:

VkMultiDrawIndexedInfoEXT:

VkMultiDrawInfoEXT:

VkMultisampledRenderToSingleSampledInfoEXT:

VkMultisamplePropertiesEXT:

VkMultiviewPerViewAttributesInfoNVX:

VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM:

VkMutableDescriptorTypeCreateInfoEXT:

VkMutableDescriptorTypeCreateInfoVALVE:

VkMutableDescriptorTypeListEXT:

VkMutableDescriptorTypeListVALVE:

VkNonDispatchableHandle:

VkObjectType:

VkOffset2D:

VkOffset3D:

VkOpacityMicromapFormatEXT:

VkOpacityMicromapSpecialIndexEXT:

VkOpaqueCaptureDescriptorDataCreateInfoEXT:

VkOpticalFlowExecuteFlagBitsNV:

VkOpticalFlowExecuteFlagsNV:

VkOpticalFlowExecuteInfoNV:

VkOpticalFlowGridSizeFlagBitsNV:

VkOpticalFlowGridSizeFlagsNV:

VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV:

VkOpticalFlowImageFormatInfoNV:

VkOpticalFlowImageFormatPropertiesNV:

VkOpticalFlowPerformanceLevelNV:

VkOpticalFlowSessionBindingPointNV:

VkOpticalFlowSessionCreateFlagBitsNV:

VkOpticalFlowSessionCreateFlagsNV:

VkOpticalFlowSessionCreateInfoNV:

VkOpticalFlowSessionCreatePrivateDataInfoNV:

VkOpticalFlowSessionNV:

VkOpticalFlowUsageFlagBitsNV:

VkOpticalFlowUsageFlagsNV:

VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV:

VkPastPresentationTimingGOOGLE:

VkPeerMemoryFeatureFlagBits:

VkPeerMemoryFeatureFlagBitsKHR:

VkPeerMemoryFeatureFlags:

VkPeerMemoryFeatureFlagsKHR:

VkPerformanceConfigurationAcquireInfoINTEL:

VkPerformanceConfigurationINTEL:

VkPerformanceConfigurationTypeINTEL:

VkPerformanceCounterDescriptionFlagBitsKHR:

VkPerformanceCounterDescriptionFlagsKHR:

VkPerformanceCounterDescriptionKHR:

VkPerformanceCounterKHR:

VkPerformanceCounterResultKHR:

VkPerformanceCounterScopeKHR:

VkPerformanceCounterStorageKHR:

VkPerformanceCounterUnitKHR:

VkPerformanceMarkerInfoINTEL:

VkPerformanceOverrideInfoINTEL:

VkPerformanceOverrideTypeINTEL:

VkPerformanceParameterTypeINTEL:

VkPerformanceQueryReservationInfoKHR:

VkPerformanceQuerySubmitInfoKHR:

VkPerformanceStreamMarkerInfoINTEL:

VkPerformanceValueDataINTEL:

VkPerformanceValueINTEL:

VkPerformanceValueTypeINTEL:

VkPhysicalDevice:

VkPhysicalDevice16BitStorageFeatures:

VkPhysicalDevice16BitStorageFeaturesKHR:

VkPhysicalDevice4444FormatsFeaturesEXT:

VkPhysicalDevice8BitStorageFeatures:

VkPhysicalDevice8BitStorageFeaturesKHR:

VkPhysicalDeviceAccelerationStructureFeaturesKHR:

VkPhysicalDeviceAccelerationStructurePropertiesKHR:

VkPhysicalDeviceAddressBindingReportFeaturesEXT:

VkPhysicalDeviceAmigoProfilingFeaturesSEC:

VkPhysicalDeviceASTCDecodeFeaturesEXT:

VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT:

VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT:

VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT:

VkPhysicalDeviceBorderColorSwizzleFeaturesEXT:

VkPhysicalDeviceBufferAddressFeaturesEXT:

VkPhysicalDeviceBufferDeviceAddressFeatures:

VkPhysicalDeviceBufferDeviceAddressFeaturesEXT:

VkPhysicalDeviceBufferDeviceAddressFeaturesKHR:

VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI:

VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI:

VkPhysicalDeviceCoherentMemoryFeaturesAMD:

VkPhysicalDeviceColorWriteEnableFeaturesEXT:

VkPhysicalDeviceComputeShaderDerivativesFeaturesNV:

VkPhysicalDeviceConditionalRenderingFeaturesEXT:

VkPhysicalDeviceConservativeRasterizationPropertiesEXT:

VkPhysicalDeviceCooperativeMatrixFeaturesNV:

VkPhysicalDeviceCooperativeMatrixPropertiesNV:

VkPhysicalDeviceCopyMemoryIndirectFeaturesNV:

VkPhysicalDeviceCopyMemoryIndirectPropertiesNV:

VkPhysicalDeviceCornerSampledImageFeaturesNV:

VkPhysicalDeviceCoverageReductionModeFeaturesNV:

VkPhysicalDeviceCustomBorderColorFeaturesEXT:

VkPhysicalDeviceCustomBorderColorPropertiesEXT:

VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV:

VkPhysicalDeviceDepthClampZeroOneFeaturesEXT:

VkPhysicalDeviceDepthClipControlFeaturesEXT:

VkPhysicalDeviceDepthClipEnableFeaturesEXT:

VkPhysicalDeviceDepthStencilResolveProperties:

VkPhysicalDeviceDepthStencilResolvePropertiesKHR:

VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT:

VkPhysicalDeviceDescriptorBufferFeaturesEXT:

VkPhysicalDeviceDescriptorBufferPropertiesEXT:

VkPhysicalDeviceDescriptorIndexingFeatures:

VkPhysicalDeviceDescriptorIndexingFeaturesEXT:

VkPhysicalDeviceDescriptorIndexingProperties:

VkPhysicalDeviceDescriptorIndexingPropertiesEXT:

VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE:

VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV:

VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV:

VkPhysicalDeviceDeviceMemoryReportFeaturesEXT:

VkPhysicalDeviceDiagnosticsConfigFeaturesNV:

VkPhysicalDeviceDiscardRectanglePropertiesEXT:

VkPhysicalDeviceDriverProperties:

VkPhysicalDeviceDriverPropertiesKHR:

VkPhysicalDeviceDrmPropertiesEXT:

VkPhysicalDeviceDynamicRenderingFeatures:

VkPhysicalDeviceDynamicRenderingFeaturesKHR:

VkPhysicalDeviceExclusiveScissorFeaturesNV:

VkPhysicalDeviceExtendedDynamicState2FeaturesEXT:

VkPhysicalDeviceExtendedDynamicState3FeaturesEXT:

VkPhysicalDeviceExtendedDynamicState3PropertiesEXT:

VkPhysicalDeviceExtendedDynamicStateFeaturesEXT:

VkPhysicalDeviceExternalBufferInfo:

VkPhysicalDeviceExternalBufferInfoKHR:

VkPhysicalDeviceExternalFenceInfo:

VkPhysicalDeviceExternalFenceInfoKHR:

VkPhysicalDeviceExternalImageFormatInfo:

VkPhysicalDeviceExternalImageFormatInfoKHR:

VkPhysicalDeviceExternalMemoryHostPropertiesEXT:

VkPhysicalDeviceExternalMemoryRDMAFeaturesNV:

VkPhysicalDeviceExternalSemaphoreInfo:

VkPhysicalDeviceExternalSemaphoreInfoKHR:

VkPhysicalDeviceFaultFeaturesEXT:

VkPhysicalDeviceFeatures:

VkPhysicalDeviceFeatures2:

VkPhysicalDeviceFeatures2KHR:

VkPhysicalDeviceFloat16Int8FeaturesKHR:

VkPhysicalDeviceFloatControlsProperties:

VkPhysicalDeviceFloatControlsPropertiesKHR:

VkPhysicalDeviceFragmentDensityMap2FeaturesEXT:

VkPhysicalDeviceFragmentDensityMap2PropertiesEXT:

VkPhysicalDeviceFragmentDensityMapFeaturesEXT:

VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM:

VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM:

VkPhysicalDeviceFragmentDensityMapPropertiesEXT:

VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR:

VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV:

VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR:

VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT:

VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV:

VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV:

VkPhysicalDeviceFragmentShadingRateFeaturesKHR:

VkPhysicalDeviceFragmentShadingRateKHR:

VkPhysicalDeviceFragmentShadingRatePropertiesKHR:

VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT:

VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR:

VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT:

VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT:

VkPhysicalDeviceGroupProperties:

VkPhysicalDeviceGroupPropertiesKHR:

VkPhysicalDeviceHostQueryResetFeatures:

VkPhysicalDeviceHostQueryResetFeaturesEXT:

VkPhysicalDeviceIDProperties:

VkPhysicalDeviceIDPropertiesKHR:

VkPhysicalDeviceImage2DViewOf3DFeaturesEXT:

VkPhysicalDeviceImageCompressionControlFeaturesEXT:

VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT:

VkPhysicalDeviceImageDrmFormatModifierInfoEXT:

VkPhysicalDeviceImageFormatInfo2:

VkPhysicalDeviceImageFormatInfo2KHR:

VkPhysicalDeviceImagelessFramebufferFeatures:

VkPhysicalDeviceImagelessFramebufferFeaturesKHR:

VkPhysicalDeviceImageProcessingFeaturesQCOM:

VkPhysicalDeviceImageProcessingPropertiesQCOM:

VkPhysicalDeviceImageRobustnessFeatures:

VkPhysicalDeviceImageRobustnessFeaturesEXT:

VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT:

VkPhysicalDeviceImageViewImageFormatInfoEXT:

VkPhysicalDeviceImageViewMinLodFeaturesEXT:

VkPhysicalDeviceIndexTypeUint8FeaturesEXT:

VkPhysicalDeviceInheritedViewportScissorFeaturesNV:

VkPhysicalDeviceInlineUniformBlockFeatures:

VkPhysicalDeviceInlineUniformBlockFeaturesEXT:

VkPhysicalDeviceInlineUniformBlockProperties:

VkPhysicalDeviceInlineUniformBlockPropertiesEXT:

VkPhysicalDeviceInvocationMaskFeaturesHUAWEI:

VkPhysicalDeviceLegacyDitheringFeaturesEXT:

VkPhysicalDeviceLimits:

VkPhysicalDeviceLinearColorAttachmentFeaturesNV:

VkPhysicalDeviceLineRasterizationFeaturesEXT:

VkPhysicalDeviceLineRasterizationPropertiesEXT:

VkPhysicalDeviceMaintenance3Properties:

VkPhysicalDeviceMaintenance3PropertiesKHR:

VkPhysicalDeviceMaintenance4Features:

VkPhysicalDeviceMaintenance4FeaturesKHR:

VkPhysicalDeviceMaintenance4Properties:

VkPhysicalDeviceMaintenance4PropertiesKHR:

VkPhysicalDeviceMemoryBudgetPropertiesEXT:

VkPhysicalDeviceMemoryDecompressionFeaturesNV:

VkPhysicalDeviceMemoryDecompressionPropertiesNV:

VkPhysicalDeviceMemoryPriorityFeaturesEXT:

VkPhysicalDeviceMemoryProperties:

VkPhysicalDeviceMemoryProperties2:

VkPhysicalDeviceMemoryProperties2KHR:

VkPhysicalDeviceMeshShaderFeaturesEXT:

VkPhysicalDeviceMeshShaderFeaturesNV:

VkPhysicalDeviceMeshShaderPropertiesEXT:

VkPhysicalDeviceMeshShaderPropertiesNV:

VkPhysicalDeviceMultiDrawFeaturesEXT:

VkPhysicalDeviceMultiDrawPropertiesEXT:

VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT:

VkPhysicalDeviceMultiviewFeatures:

VkPhysicalDeviceMultiviewFeaturesKHR:

VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX:

VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM:

VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM:

VkPhysicalDeviceMultiviewProperties:

VkPhysicalDeviceMultiviewPropertiesKHR:

VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT:

VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE:

VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT:

VkPhysicalDeviceOpacityMicromapFeaturesEXT:

VkPhysicalDeviceOpacityMicromapPropertiesEXT:

VkPhysicalDeviceOpticalFlowFeaturesNV:

VkPhysicalDeviceOpticalFlowPropertiesNV:

VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT:

VkPhysicalDevicePCIBusInfoPropertiesEXT:

VkPhysicalDevicePerformanceQueryFeaturesKHR:

VkPhysicalDevicePerformanceQueryPropertiesKHR:

VkPhysicalDevicePipelineCreationCacheControlFeatures:

VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT:

VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR:

VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT:

VkPhysicalDevicePipelinePropertiesFeaturesEXT:

VkPhysicalDevicePipelineProtectedAccessFeaturesEXT:

VkPhysicalDevicePipelineRobustnessFeaturesEXT:

VkPhysicalDevicePipelineRobustnessPropertiesEXT:

VkPhysicalDevicePointClippingProperties:

VkPhysicalDevicePointClippingPropertiesKHR:

VkPhysicalDevicePresentBarrierFeaturesNV:

VkPhysicalDevicePresentIdFeaturesKHR:

VkPhysicalDevicePresentWaitFeaturesKHR:

VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT:

VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT:

VkPhysicalDevicePrivateDataFeatures:

VkPhysicalDevicePrivateDataFeaturesEXT:

VkPhysicalDeviceProperties:

VkPhysicalDeviceProperties2:

VkPhysicalDeviceProperties2KHR:

VkPhysicalDeviceProtectedMemoryFeatures:

VkPhysicalDeviceProtectedMemoryProperties:

VkPhysicalDeviceProvokingVertexFeaturesEXT:

VkPhysicalDeviceProvokingVertexPropertiesEXT:

VkPhysicalDevicePushDescriptorPropertiesKHR:

VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM:

VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT:

VkPhysicalDeviceRayQueryFeaturesKHR:

VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV:

VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV:

VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR:

VkPhysicalDeviceRayTracingMotionBlurFeaturesNV:

VkPhysicalDeviceRayTracingPipelineFeaturesKHR:

VkPhysicalDeviceRayTracingPipelinePropertiesKHR:

VkPhysicalDeviceRayTracingPropertiesNV:

VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV:

VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT:

VkPhysicalDeviceRobustness2FeaturesEXT:

VkPhysicalDeviceRobustness2PropertiesEXT:

VkPhysicalDeviceSampleLocationsPropertiesEXT:

VkPhysicalDeviceSamplerFilterMinmaxProperties:

VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT:

VkPhysicalDeviceSamplerYcbcrConversionFeatures:

VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR:

VkPhysicalDeviceScalarBlockLayoutFeatures:

VkPhysicalDeviceScalarBlockLayoutFeaturesEXT:

VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures:

VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR:

VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT:

VkPhysicalDeviceShaderAtomicFloatFeaturesEXT:

VkPhysicalDeviceShaderAtomicInt64Features:

VkPhysicalDeviceShaderAtomicInt64FeaturesKHR:

VkPhysicalDeviceShaderClockFeaturesKHR:

VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM:

VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM:

VkPhysicalDeviceShaderCoreProperties2AMD:

VkPhysicalDeviceShaderCorePropertiesAMD:

VkPhysicalDeviceShaderCorePropertiesARM:

VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures:

VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT:

VkPhysicalDeviceShaderDrawParameterFeatures:

VkPhysicalDeviceShaderDrawParametersFeatures:

VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD:

VkPhysicalDeviceShaderFloat16Int8Features:

VkPhysicalDeviceShaderFloat16Int8FeaturesKHR:

VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT:

VkPhysicalDeviceShaderImageFootprintFeaturesNV:

VkPhysicalDeviceShaderIntegerDotProductFeatures:

VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR:

VkPhysicalDeviceShaderIntegerDotProductProperties:

VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR:

VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL:

VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT:

VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT:

VkPhysicalDeviceShaderSMBuiltinsFeaturesNV:

VkPhysicalDeviceShaderSMBuiltinsPropertiesNV:

VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures:

VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR:

VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR:

VkPhysicalDeviceShaderTerminateInvocationFeatures:

VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR:

VkPhysicalDeviceShadingRateImageFeaturesNV:

VkPhysicalDeviceShadingRateImagePropertiesNV:

VkPhysicalDeviceSparseImageFormatInfo2:

VkPhysicalDeviceSparseImageFormatInfo2KHR:

VkPhysicalDeviceSparseProperties:

VkPhysicalDeviceSubgroupProperties:

VkPhysicalDeviceSubgroupSizeControlFeatures:

VkPhysicalDeviceSubgroupSizeControlFeaturesEXT:

VkPhysicalDeviceSubgroupSizeControlProperties:

VkPhysicalDeviceSubgroupSizeControlPropertiesEXT:

VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT:

VkPhysicalDeviceSubpassShadingFeaturesHUAWEI:

VkPhysicalDeviceSubpassShadingPropertiesHUAWEI:

VkPhysicalDeviceSurfaceInfo2KHR:

VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT:

VkPhysicalDeviceSynchronization2Features:

VkPhysicalDeviceSynchronization2FeaturesKHR:

VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT:

VkPhysicalDeviceTexelBufferAlignmentProperties:

VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT:

VkPhysicalDeviceTextureCompressionASTCHDRFeatures:

VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT:

VkPhysicalDeviceTilePropertiesFeaturesQCOM:

VkPhysicalDeviceTimelineSemaphoreFeatures:

VkPhysicalDeviceTimelineSemaphoreFeaturesKHR:

VkPhysicalDeviceTimelineSemaphoreProperties:

VkPhysicalDeviceTimelineSemaphorePropertiesKHR:

VkPhysicalDeviceToolProperties:

VkPhysicalDeviceToolPropertiesEXT:

VkPhysicalDeviceTransformFeedbackFeaturesEXT:

VkPhysicalDeviceTransformFeedbackPropertiesEXT:

VkPhysicalDeviceType:

VkPhysicalDeviceUniformBufferStandardLayoutFeatures:

VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR:

VkPhysicalDeviceVariablePointerFeatures:

VkPhysicalDeviceVariablePointerFeaturesKHR:

VkPhysicalDeviceVariablePointersFeatures:

VkPhysicalDeviceVariablePointersFeaturesKHR:

VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT:

VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT:

VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT:

VkPhysicalDeviceVulkan11Features:

VkPhysicalDeviceVulkan11Properties:

VkPhysicalDeviceVulkan12Features:

VkPhysicalDeviceVulkan12Properties:

VkPhysicalDeviceVulkan13Features:

VkPhysicalDeviceVulkan13Properties:

VkPhysicalDeviceVulkanMemoryModelFeatures:

VkPhysicalDeviceVulkanMemoryModelFeaturesKHR:

VkPhysicalDeviceVulkanSC10Features:

VkPhysicalDeviceVulkanSC10Properties:

VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR:

VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT:

VkPhysicalDeviceYcbcrImageArraysFeaturesEXT:

VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures:

VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR:

VkPipeline:

VkPipelineBindPoint:

VkPipelineCache:

VkPipelineCacheCreateFlagBits:

VkPipelineCacheCreateFlags:

VkPipelineCacheCreateInfo:

VkPipelineCacheHeaderVersion:

VkPipelineCacheHeaderVersionOne:

VkPipelineCacheHeaderVersionSafetyCriticalOne:

VkPipelineCacheSafetyCriticalIndexEntry:

VkPipelineCacheStageValidationIndexEntry:

VkPipelineCacheValidationVersion:

VkPipelineColorBlendAdvancedStateCreateInfoEXT:

VkPipelineColorBlendAttachmentState:

VkPipelineColorBlendStateCreateFlagBits:

VkPipelineColorBlendStateCreateFlags:

VkPipelineColorBlendStateCreateInfo:

VkPipelineColorWriteCreateInfoEXT:

VkPipelineCompilerControlCreateInfoAMD:

VkPipelineCompilerControlFlagsAMD:

VkPipelineCoverageModulationStateCreateFlagsNV:

VkPipelineCoverageModulationStateCreateInfoNV:

VkPipelineCoverageReductionStateCreateFlagsNV:

VkPipelineCoverageReductionStateCreateInfoNV:

VkPipelineCoverageToColorStateCreateFlagsNV:

VkPipelineCoverageToColorStateCreateInfoNV:

VkPipelineCreateFlagBits:

VkPipelineCreateFlags:

VkPipelineCreationFeedback:

VkPipelineCreationFeedbackCreateInfo:

VkPipelineCreationFeedbackCreateInfoEXT:

VkPipelineCreationFeedbackEXT:

VkPipelineCreationFeedbackFlagBits:

VkPipelineCreationFeedbackFlagBitsEXT:

VkPipelineCreationFeedbackFlags:

VkPipelineCreationFeedbackFlagsEXT:

VkPipelineDepthStencilStateCreateFlagBits:

VkPipelineDepthStencilStateCreateFlags:

VkPipelineDepthStencilStateCreateInfo:

VkPipelineDiscardRectangleStateCreateFlagsEXT:

VkPipelineDiscardRectangleStateCreateInfoEXT:

VkPipelineDynamicStateCreateFlags:

VkPipelineDynamicStateCreateInfo:

VkPipelineExecutableInfoKHR:

VkPipelineExecutableInternalRepresentationKHR:

VkPipelineExecutablePropertiesKHR:

VkPipelineExecutableStatisticFormatKHR:

VkPipelineExecutableStatisticKHR:

VkPipelineExecutableStatisticValueKHR:

VkPipelineFragmentShadingRateEnumStateCreateInfoNV:

VkPipelineFragmentShadingRateStateCreateInfoKHR:

VkPipelineInfoEXT:

VkPipelineInfoKHR:

VkPipelineInputAssemblyStateCreateFlags:

VkPipelineInputAssemblyStateCreateInfo:

VkPipelineLayout:

VkPipelineLayoutCreateFlagBits:

VkPipelineLayoutCreateFlags:

VkPipelineLayoutCreateInfo:

VkPipelineLibraryCreateInfoKHR:

VkPipelineMatchControl:

VkPipelineMultisampleStateCreateFlags:

VkPipelineMultisampleStateCreateInfo:

VkPipelineOfflineCreateInfo:

VkPipelinePoolSize:

VkPipelinePropertiesIdentifierEXT:

VkPipelineRasterizationConservativeStateCreateFlagsEXT:

VkPipelineRasterizationConservativeStateCreateInfoEXT:

VkPipelineRasterizationDepthClipStateCreateFlagsEXT:

VkPipelineRasterizationDepthClipStateCreateInfoEXT:

VkPipelineRasterizationLineStateCreateInfoEXT:

VkPipelineRasterizationProvokingVertexStateCreateInfoEXT:

VkPipelineRasterizationStateCreateFlags:

VkPipelineRasterizationStateCreateInfo:

VkPipelineRasterizationStateRasterizationOrderAMD:

VkPipelineRasterizationStateStreamCreateFlagsEXT:

VkPipelineRasterizationStateStreamCreateInfoEXT:

VkPipelineRenderingCreateInfo:

VkPipelineRenderingCreateInfoKHR:

VkPipelineRepresentativeFragmentTestStateCreateInfoNV:

VkPipelineRobustnessBufferBehaviorEXT:

VkPipelineRobustnessCreateInfoEXT:

VkPipelineRobustnessImageBehaviorEXT:

VkPipelineSampleLocationsStateCreateInfoEXT:

VkPipelineShaderStageCreateFlagBits:

VkPipelineShaderStageCreateFlags:

VkPipelineShaderStageCreateInfo:

VkPipelineShaderStageModuleIdentifierCreateInfoEXT:

VkPipelineShaderStageRequiredSubgroupSizeCreateInfo:

VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT:

VK_PIPELINE_STAGE_2_NONE:

VkPipelineStageFlagBits:

VkPipelineStageFlagBits2:

VkPipelineStageFlagBits2KHR:

VkPipelineStageFlags:

VkPipelineStageFlags2:

VkPipelineStageFlags2KHR:

VkPipelineTessellationDomainOriginStateCreateInfo:

VkPipelineTessellationDomainOriginStateCreateInfoKHR:

VkPipelineTessellationStateCreateFlags:

VkPipelineTessellationStateCreateInfo:

VkPipelineVertexInputDivisorStateCreateInfoEXT:

VkPipelineVertexInputStateCreateFlags:

VkPipelineVertexInputStateCreateInfo:

VkPipelineViewportCoarseSampleOrderStateCreateInfoNV:

VkPipelineViewportDepthClipControlCreateInfoEXT:

VkPipelineViewportExclusiveScissorStateCreateInfoNV:

VkPipelineViewportShadingRateImageStateCreateInfoNV:

VkPipelineViewportStateCreateFlags:

VkPipelineViewportStateCreateInfo:

VkPipelineViewportSwizzleStateCreateFlagsNV:

VkPipelineViewportSwizzleStateCreateInfoNV:

VkPipelineViewportWScalingStateCreateInfoNV:

VkPointClippingBehavior:

VkPointClippingBehaviorKHR:

VkPolygonMode:

VkPresentGravityFlagBitsEXT:

VkPresentGravityFlagsEXT:

VkPresentIdKHR:

VkPresentInfoKHR:

VkPresentModeKHR:

VkPresentRegionKHR:

VkPresentRegionsKHR:

VkPresentScalingFlagBitsEXT:

VkPresentScalingFlagsEXT:

VkPresentTimeGOOGLE:

VkPresentTimesInfoGOOGLE:

VkPrimitiveTopology:

VkPrivateDataSlot:

VkPrivateDataSlotCreateFlagBits:

VkPrivateDataSlotCreateFlagBitsEXT:

VkPrivateDataSlotCreateFlags:

VkPrivateDataSlotCreateFlagsEXT:

VkPrivateDataSlotCreateInfo:

VkPrivateDataSlotCreateInfoEXT:

VkProtectedSubmitInfo:

VkProvokingVertexModeEXT:

VkPushConstantRange:

VkQueryControlFlagBits:

VkQueryControlFlags:

VkQueryPipelineStatisticFlagBits:

VkQueryPipelineStatisticFlags:

VkQueryPool:

VkQueryPoolCreateFlags:

VkQueryPoolCreateInfo:

VkQueryPoolCreateInfoINTEL:

VkQueryPoolPerformanceCreateInfoKHR:

VkQueryPoolPerformanceQueryCreateInfoINTEL:

VkQueryPoolSamplingModeINTEL:

VkQueryResultFlagBits:

VkQueryResultFlags:

VkQueryResultStatusKHR:

VkQueryType:

VkQueue:

vkQueueBeginDebugUtilsLabelEXT:

vkQueueBindSparse:

vkQueueEndDebugUtilsLabelEXT:

VkQueueFamilyCheckpointProperties2NV:

VkQueueFamilyCheckpointPropertiesNV:

VK_QUEUE_FAMILY_EXTERNAL:

VK_QUEUE_FAMILY_EXTERNAL_KHR:

VK_QUEUE_FAMILY_FOREIGN_EXT:

VkQueueFamilyGlobalPriorityPropertiesEXT:

VkQueueFamilyGlobalPriorityPropertiesKHR:

VK_QUEUE_FAMILY_IGNORED:

VkQueueFamilyProperties:

VkQueueFamilyProperties2:

VkQueueFamilyProperties2KHR:

VkQueueFlagBits:

VkQueueFlags:

VkQueueGlobalPriorityEXT:

VkQueueGlobalPriorityKHR:

vkQueueInsertDebugUtilsLabelEXT:

vkQueuePresentKHR:

vkQueueSetPerformanceConfigurationINTEL:

vkQueueSubmit:

vkQueueSubmit2:

vkQueueWaitIdle:

VkRasterizationOrderAMD:

VkRayTracingInvocationReorderModeNV:

VkRayTracingPipelineCreateInfoKHR:

VkRayTracingPipelineCreateInfoNV:

VkRayTracingPipelineInterfaceCreateInfoKHR:

VkRayTracingShaderGroupCreateInfoKHR:

VkRayTracingShaderGroupCreateInfoNV:

VkRayTracingShaderGroupTypeKHR:

VkRayTracingShaderGroupTypeNV:

VkRect2D:

VkRectLayerKHR:

VkRefreshCycleDurationGOOGLE:

VkRefreshObjectFlagsKHR:

VkRefreshObjectKHR:

VkRefreshObjectListKHR:

vkRegisterDeviceEventEXT:

vkRegisterDisplayEventEXT:

vkReleaseDisplayEXT:

vkReleasePerformanceConfigurationINTEL:

vkReleaseProfilingLockKHR:

vkReleaseSwapchainImagesEXT:

VkReleaseSwapchainImagesInfoEXT:

VK_REMAINING_3D_SLICES_EXT:

VK_REMAINING_ARRAY_LAYERS:

VK_REMAINING_MIP_LEVELS:

VkRemoteAddressNV:

VkRenderingAttachmentInfo:

VkRenderingAttachmentInfoKHR:

VkRenderingFlagBits:

VkRenderingFlagBitsKHR:

VkRenderingFlags:

VkRenderingFlagsKHR:

VkRenderingFragmentDensityMapAttachmentInfoEXT:

VkRenderingFragmentShadingRateAttachmentInfoKHR:

VkRenderingInfo:

VkRenderingInfoKHR:

VkRenderPass:

VkRenderPassAttachmentBeginInfo:

VkRenderPassAttachmentBeginInfoKHR:

VkRenderPassBeginInfo:

VkRenderPassCreateFlagBits:

VkRenderPassCreateFlags:

VkRenderPassCreateInfo:

VkRenderPassCreateInfo2:

VkRenderPassCreateInfo2KHR:

VkRenderPassCreationControlEXT:

VkRenderPassCreationFeedbackCreateInfoEXT:

VkRenderPassCreationFeedbackInfoEXT:

VkRenderPassFragmentDensityMapCreateInfoEXT:

VkRenderPassInputAttachmentAspectCreateInfo:

VkRenderPassInputAttachmentAspectCreateInfoKHR:

VkRenderPassMultiviewCreateInfo:

VkRenderPassMultiviewCreateInfoKHR:

VkRenderPassSampleLocationsBeginInfoEXT:

VkRenderPassSubpassFeedbackCreateInfoEXT:

VkRenderPassSubpassFeedbackInfoEXT:

VkRenderPassTransformBeginInfoQCOM:

vkResetCommandBuffer:

vkResetCommandPool:

vkResetDescriptorPool:

vkResetEvent:

vkResetFences:

vkResetQueryPool:

VkResolveImageInfo2:

VkResolveImageInfo2KHR:

VkResolveModeFlagBits:

VkResolveModeFlagBitsKHR:

VkResolveModeFlags:

VkResolveModeFlagsKHR:

VK_RESOLVE_MODE_NONE:

VkResult:

VkSampleCountFlagBits:

VkSampleCountFlags:

VkSampleLocationEXT:

VkSampleLocationsInfoEXT:

VkSampleMask:

VkSampler:

VkSamplerAddressMode:

VkSamplerBorderColorComponentMappingCreateInfoEXT:

VkSamplerCaptureDescriptorDataInfoEXT:

VkSamplerCreateFlagBits:

VkSamplerCreateFlags:

VkSamplerCreateInfo:

VkSamplerCustomBorderColorCreateInfoEXT:

VkSamplerMipmapMode:

VkSamplerReductionMode:

VkSamplerReductionModeCreateInfo:

VkSamplerReductionModeCreateInfoEXT:

VkSamplerReductionModeEXT:

VkSamplerYcbcrConversion:

VkSamplerYcbcrConversionCreateInfo:

VkSamplerYcbcrConversionCreateInfoKHR:

VkSamplerYcbcrConversionImageFormatProperties:

VkSamplerYcbcrConversionImageFormatPropertiesKHR:

VkSamplerYcbcrConversionInfo:

VkSamplerYcbcrConversionInfoKHR:

VkSamplerYcbcrModelConversion:

VkSamplerYcbcrModelConversionKHR:

VkSamplerYcbcrRange:

VkSamplerYcbcrRangeKHR:

VkSciSyncClientTypeNV:

VkSciSyncPrimitiveTypeNV:

VkScopeNV:

VkScreenSurfaceCreateFlagsQNX:

VkSemaphore:

VkSemaphoreCreateFlags:

VkSemaphoreCreateInfo:

VkSemaphoreGetFdInfoKHR:

VkSemaphoreImportFlagBits:

VkSemaphoreImportFlagBitsKHR:

VkSemaphoreImportFlags:

VkSemaphoreImportFlagsKHR:

VkSemaphoreSciSyncPoolNV:

VkSemaphoreSignalInfo:

VkSemaphoreSignalInfoKHR:

VkSemaphoreSubmitInfo:

VkSemaphoreSubmitInfoKHR:

VkSemaphoreType:

VkSemaphoreTypeCreateInfo:

VkSemaphoreTypeCreateInfoKHR:

VkSemaphoreTypeKHR:

VkSemaphoreWaitFlagBits:

VkSemaphoreWaitFlagBitsKHR:

VkSemaphoreWaitFlags:

VkSemaphoreWaitFlagsKHR:

VkSemaphoreWaitInfo:

VkSemaphoreWaitInfoKHR:

vkSetDebugUtilsObjectNameEXT:

vkSetDebugUtilsObjectTagEXT:

vkSetDeviceMemoryPriorityEXT:

vkSetEvent:

vkSetHdrMetadataEXT:

vkSetLocalDimmingAMD:

vkSetPrivateData:

VkSetStateFlagsIndirectCommandNV:

VkShaderCorePropertiesFlagsAMD:

VkShaderFloatControlsIndependence:

VkShaderFloatControlsIndependenceKHR:

VkShaderGroupShaderKHR:

VkShaderInfoTypeAMD:

VkShaderModule:

VkShaderModuleCreateFlags:

VkShaderModuleCreateInfo:

VkShaderModuleIdentifierEXT:

VkShaderModuleValidationCacheCreateInfoEXT:

VkShaderResourceUsageAMD:

VK_SHADER_STAGE_ALL:

VK_SHADER_STAGE_ALL_GRAPHICS:

VkShaderStageFlagBits:

VkShaderStageFlags:

VkShaderStatisticsInfoAMD:

VK_SHADER_UNUSED_KHR:

VK_SHADER_UNUSED_NV:

VkShadingRatePaletteEntryNV:

VkShadingRatePaletteNV:

VkSharedPresentSurfaceCapabilitiesKHR:

VkSharingMode:

vkSignalSemaphore:

VkSparseBufferMemoryBindInfo:

VkSparseImageFormatFlagBits:

VkSparseImageFormatFlags:

VkSparseImageFormatProperties:

VkSparseImageFormatProperties2:

VkSparseImageFormatProperties2KHR:

VkSparseImageMemoryBind:

VkSparseImageMemoryBindInfo:

VkSparseImageMemoryRequirements:

VkSparseImageMemoryRequirements2:

VkSparseImageMemoryRequirements2KHR:

VkSparseImageOpaqueMemoryBindInfo:

VkSparseMemoryBind:

VkSparseMemoryBindFlagBits:

VkSparseMemoryBindFlags:

VkSpecializationInfo:

VkSpecializationMapEntry:

VkSRTDataNV:

VkStencilFaceFlagBits:

VkStencilFaceFlags:

VK_STENCIL_FACE_FRONT_AND_BACK:

VkStencilOp:

VkStencilOpState:

VkStreamDescriptorSurfaceCreateFlagsGGP:

VkStridedDeviceAddressRegionKHR:

VkStructureType:

VkSubgroupFeatureFlagBits:

VkSubgroupFeatureFlags:

vkSubmitDebugUtilsMessageEXT:

VkSubmitFlagBits:

VkSubmitFlagBitsKHR:

VkSubmitFlags:

VkSubmitFlagsKHR:

VkSubmitInfo:

VkSubmitInfo2:

VkSubmitInfo2KHR:

VkSubpassBeginInfo:

VkSubpassBeginInfoKHR:

VkSubpassContents:

VkSubpassDependency:

VkSubpassDependency2:

VkSubpassDependency2KHR:

VkSubpassDescription:

VkSubpassDescription2:

VkSubpassDescription2KHR:

VkSubpassDescriptionDepthStencilResolve:

VkSubpassDescriptionDepthStencilResolveKHR:

VkSubpassDescriptionFlagBits:

VkSubpassDescriptionFlags:

VkSubpassEndInfo:

VkSubpassEndInfoKHR:

VK_SUBPASS_EXTERNAL:

VkSubpassFragmentDensityMapOffsetEndInfoQCOM:

VkSubpassMergeStatusEXT:

VkSubpassResolvePerformanceQueryEXT:

VkSubpassSampleLocationsEXT:

VkSubpassShadingPipelineCreateInfoHUAWEI:

VkSubresourceLayout:

VkSubresourceLayout2EXT:

VkSurfaceCapabilities2EXT:

VkSurfaceCapabilities2KHR:

VkSurfaceCapabilitiesKHR:

VkSurfaceCapabilitiesPresentBarrierNV:

VkSurfaceCounterFlagBitsEXT:

VkSurfaceCounterFlagsEXT:

VkSurfaceFormat2KHR:

VkSurfaceFormatKHR:

VkSurfaceKHR:

VkSurfacePresentModeCompatibilityEXT:

VkSurfacePresentModeEXT:

VkSurfacePresentScalingCapabilitiesEXT:

VkSurfaceProtectedCapabilitiesKHR:

VkSurfaceTransformFlagBitsKHR:

VkSurfaceTransformFlagsKHR:

VkSwapchainCounterCreateInfoEXT:

VkSwapchainCreateFlagBitsKHR:

VkSwapchainCreateFlagsKHR:

VkSwapchainCreateInfoKHR:

VkSwapchainDisplayNativeHdrCreateInfoAMD:

VkSwapchainImageUsageFlagBitsANDROID:

VkSwapchainImageUsageFlagsANDROID:

VkSwapchainKHR:

VkSwapchainPresentBarrierCreateInfoNV:

VkSwapchainPresentFenceInfoEXT:

VkSwapchainPresentModeInfoEXT:

VkSwapchainPresentModesCreateInfoEXT:

VkSwapchainPresentScalingCreateInfoEXT:

VkSystemAllocationScope:

VkTessellationDomainOrigin:

VkTessellationDomainOriginKHR:

VkTextureLODGatherFormatPropertiesAMD:

VkTilePropertiesQCOM:

VkTimeDomainEXT:

VkTimelineSemaphoreSubmitInfo:

VkTimelineSemaphoreSubmitInfoKHR:

VkToolPurposeFlagBits:

VkToolPurposeFlagBitsEXT:

VkToolPurposeFlags:

VkToolPurposeFlagsEXT:

VkTraceRaysIndirectCommand2KHR:

VkTraceRaysIndirectCommandKHR:

VkTransformMatrixKHR:

VkTransformMatrixNV:

vkTrimCommandPool:

VK_TRUE:

vkUninitializePerformanceApiINTEL:

vkUnmapMemory:

vkUpdateDescriptorSets:

vkUpdateDescriptorSetWithTemplate:

VK_UUID_SIZE:

VkValidationCacheCreateFlagsEXT:

VkValidationCacheCreateInfoEXT:

VkValidationCacheEXT:

VkValidationCacheHeaderVersionEXT:

VkValidationCheckEXT:

VkValidationFeatureDisableEXT:

VkValidationFeatureEnableEXT:

VkValidationFeaturesEXT:

VkValidationFlagsEXT:

VkVendorId:

VkVertexInputAttributeDescription:

VkVertexInputAttributeDescription2EXT:

VkVertexInputBindingDescription:

VkVertexInputBindingDescription2EXT:

VkVertexInputBindingDivisorDescriptionEXT:

VkVertexInputRate:

VkVideoBeginCodingFlagsKHR:

VkVideoCapabilityFlagBitsKHR:

VkVideoCapabilityFlagsKHR:

VkVideoChromaSubsamplingFlagBitsKHR:

VkVideoChromaSubsamplingFlagsKHR:

VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR:

VkVideoCodecOperationFlagBitsKHR:

VkVideoCodecOperationFlagsKHR:

VK_VIDEO_CODEC_OPERATION_NONE_KHR:

VkVideoCodingControlFlagBitsKHR:

VkVideoCodingControlFlagsKHR:

VkVideoComponentBitDepthFlagBitsKHR:

VkVideoComponentBitDepthFlagsKHR:

VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR:

VkVideoDecodeCapabilityFlagBitsKHR:

VkVideoDecodeCapabilityFlagsKHR:

VkVideoDecodeFlagsKHR:

VkVideoDecodeH264PictureLayoutFlagBitsKHR:

VkVideoDecodeH264PictureLayoutFlagsKHR:

VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR:

VK_VIDEO_DECODE_USAGE_DEFAULT_KHR:

VkVideoDecodeUsageFlagBitsKHR:

VkVideoDecodeUsageFlagsKHR:

VkVideoEncodeCapabilityFlagBitsKHR:

VkVideoEncodeCapabilityFlagsKHR:

VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR:

VkVideoEncodeContentFlagBitsKHR:

VkVideoEncodeContentFlagsKHR:

VkVideoEncodeFlagsKHR:

VkVideoEncodeH264CapabilityFlagBitsEXT:

VkVideoEncodeH264CapabilityFlagsEXT:

VkVideoEncodeH264InputModeFlagBitsEXT:

VkVideoEncodeH264InputModeFlagsEXT:

VkVideoEncodeH264OutputModeFlagBitsEXT:

VkVideoEncodeH264OutputModeFlagsEXT:

VkVideoEncodeH264RateControlStructureEXT:

VkVideoEncodeH265CapabilityFlagBitsEXT:

VkVideoEncodeH265CapabilityFlagsEXT:

VkVideoEncodeH265CtbSizeFlagBitsEXT:

VkVideoEncodeH265CtbSizeFlagsEXT:

VkVideoEncodeH265InputModeFlagBitsEXT:

VkVideoEncodeH265InputModeFlagsEXT:

VkVideoEncodeH265OutputModeFlagBitsEXT:

VkVideoEncodeH265OutputModeFlagsEXT:

VkVideoEncodeH265RateControlStructureEXT:

VkVideoEncodeH265TransformBlockSizeFlagBitsEXT:

VkVideoEncodeH265TransformBlockSizeFlagsEXT:

VkVideoEncodeRateControlFlagsKHR:

VkVideoEncodeRateControlModeFlagBitsKHR:

VkVideoEncodeRateControlModeFlagsKHR:

VkVideoEncodeTuningModeKHR:

VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR:

VkVideoEncodeUsageFlagBitsKHR:

VkVideoEncodeUsageFlagsKHR:

VkVideoEndCodingFlagsKHR:

VkVideoSessionCreateFlagBitsKHR:

VkVideoSessionCreateFlagsKHR:

VkVideoSessionKHR:

VkVideoSessionParametersCreateFlagsKHR:

VkVideoSessionParametersKHR:

VkViewport:

VkViewportCoordinateSwizzleNV:

VkViewportSwizzleNV:

VkViewportWScalingNV:

VkViSurfaceCreateFlagsNN:

vkWaitForFences:

vkWaitForPresentKHR:

vkWaitSemaphores:

VkWaylandSurfaceCreateFlagsKHR:

VK_WHOLE_SIZE:

VkWin32SurfaceCreateFlagsKHR:

vkWriteAccelerationStructuresPropertiesKHR:

VkWriteDescriptorSet:

VkWriteDescriptorSetAccelerationStructureKHR:

VkWriteDescriptorSetAccelerationStructureNV:

VkWriteDescriptorSetInlineUniformBlock:

VkWriteDescriptorSetInlineUniformBlockEXT:

vkWriteMicromapsPropertiesEXT:

VkXcbSurfaceCreateFlagsKHR:

VkXlibSurfaceCreateFlagsKHR:

VkXlibSurfaceCreateInfoKHR:

core: object VkXlibSurfaceCreateInfoKHR

VkXYColorEXT:

vulkanLib:

VulkanObject:

core: object VulkanObject

w:

core: template w[T: TVec](v: T): untyped

w=:

core: template w=[T: TVec; S](v: T; a: S): untyped

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

width:

WidthMMOfScreen:

xlib: proc WidthMMOfScreen(s: PScreen): cint

WidthOfScreen:

xlib: proc WidthOfScreen(s: PScreen): cint

WidthValue:

xutil: const WidthValue

WindingRule:

x: const WindingRule

Window:

WindowGroupHint:

xutil: const WindowGroupHint

windowIsMinimized:

input: proc windowIsMinimized(): auto

windowWasResized:

input: proc windowWasResized(): auto

WithdrawnState:

xutil: const WithdrawnState

withNextFrame:

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

withPipeline:

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

withRenderPass:

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

withSingleUseCommandBuffer:

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

withStagingBuffer:

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

WriteDbEffect:

db_common: object WriteDbEffect

WriteSoundData:

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: template x[T: TVec](v: T): untyped

x=:

core: template x=[T: TVec; S](v: T; a: S): untyped

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: template y[T: TVec](v: T): untyped

y=:

core: template y=[T: TVec; S](v: T; a: S): untyped

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: template z[T: TVec](v: T): untyped

z=:

core: template z=[T: TVec; S](v: T; a: S): untyped

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)