p
/
haven
1
0
Fork 0
Code Issues 1 Pull Requests Releases Wiki Activity
haven/nexgb/xf86vidmode/xf86vidmode.go

2361 lines
53 KiB
Go
Raw Normal View History

a huge commit. splitting extensions into their own sub-packages.
2012-05-10 23:01:42 +02:00
package xf86vidmode
/*
This file was generated by xf86vidmode.xml on May 10 2012 4:20:28pm EDT.
This file is automatically generated. Edit at your peril!
*/
import (
"github.com/BurntSushi/xgb"
"github.com/BurntSushi/xgb/xproto"
)
// Init must be called before using the XFree86-VidModeExtension extension.
func Init(c *xgb.Conn) error {
reply, err := xproto.QueryExtension(c, 24, "XFree86-VidModeExtension").Reply()
switch {
case err != nil:
return err
case !reply.Present:
return xgb.Errorf("No extension named XFree86-VidModeExtension could be found on on the server.")
}
xgb.ExtLock.Lock()
c.Extensions["XFree86-VidModeExtension"] = reply.MajorOpcode
for evNum, fun := range xgb.NewExtEventFuncs["XFree86-VidModeExtension"] {
xgb.NewEventFuncs[int(reply.FirstEvent)+evNum] = fun
}
for errNum, fun := range xgb.NewExtErrorFuncs["XFree86-VidModeExtension"] {
xgb.NewErrorFuncs[int(reply.FirstError)+errNum] = fun
}
xgb.ExtLock.Unlock()
return nil
}
func init() {
xgb.NewExtEventFuncs["XFree86-VidModeExtension"] = make(map[int]xgb.NewEventFun)
xgb.NewExtErrorFuncs["XFree86-VidModeExtension"] = make(map[int]xgb.NewErrorFun)
}
// Skipping definition for base type 'Card8'
// Skipping definition for base type 'Int16'
// Skipping definition for base type 'Int32'
// Skipping definition for base type 'Void'
// Skipping definition for base type 'Byte'
// Skipping definition for base type 'Int8'
// Skipping definition for base type 'Card16'
// Skipping definition for base type 'Char'
// Skipping definition for base type 'Card32'
// Skipping definition for base type 'Double'
// Skipping definition for base type 'Bool'
// Skipping definition for base type 'Float'
const (
ModeFlagPositiveHsync = 1
ModeFlagNegativeHsync = 2
ModeFlagPositiveVsync = 4
ModeFlagNegativeVsync = 8
ModeFlagInterlace = 16
ModeFlagCompositeSync = 32
ModeFlagPositiveCsync = 64
ModeFlagNegativeCsync = 128
ModeFlagHSkew = 256
ModeFlagBroadcast = 512
ModeFlagPixmux = 1024
ModeFlagDoubleClock = 2048
ModeFlagHalfClock = 4096
)
const (
ClockFlagProgramable = 1
)
const (
PermissionRead = 1
PermissionWrite = 2
)
type Syncrange uint32
type Dotclock uint32
// 'ModeInfo' struct definition
// Size: 48
type ModeInfo struct {
Dotclock Dotclock
Hdisplay uint16
Hsyncstart uint16
Hsyncend uint16
Htotal uint16
Hskew uint32
Vdisplay uint16
Vsyncstart uint16
Vsyncend uint16
Vtotal uint16
// padding: 4 bytes
Flags uint32
// padding: 12 bytes
Privsize uint32
}
// Struct read ModeInfo
func ModeInfoRead(buf []byte, v *ModeInfo) int {
b := 0
v.Dotclock = Dotclock(xgb.Get32(buf[b:]))
b += 4
v.Hdisplay = xgb.Get16(buf[b:])
b += 2
v.Hsyncstart = xgb.Get16(buf[b:])
b += 2
v.Hsyncend = xgb.Get16(buf[b:])
b += 2
v.Htotal = xgb.Get16(buf[b:])
b += 2
v.Hskew = xgb.Get32(buf[b:])
b += 4
v.Vdisplay = xgb.Get16(buf[b:])
b += 2
v.Vsyncstart = xgb.Get16(buf[b:])
b += 2
v.Vsyncend = xgb.Get16(buf[b:])
b += 2
v.Vtotal = xgb.Get16(buf[b:])
b += 2
b += 4 // padding
v.Flags = xgb.Get32(buf[b:])
b += 4
b += 12 // padding
v.Privsize = xgb.Get32(buf[b:])
b += 4
return b
}
// Struct list read ModeInfo
func ModeInfoReadList(buf []byte, dest []ModeInfo) int {
b := 0
for i := 0; i < len(dest); i++ {
dest[i] = ModeInfo{}
b += ModeInfoRead(buf[b:], &dest[i])
}
return xgb.Pad(b)
}
// Struct write ModeInfo
func (v ModeInfo) Bytes() []byte {
buf := make([]byte, 48)
b := 0
xgb.Put32(buf[b:], uint32(v.Dotclock))
b += 4
xgb.Put16(buf[b:], v.Hdisplay)
b += 2
xgb.Put16(buf[b:], v.Hsyncstart)
b += 2
xgb.Put16(buf[b:], v.Hsyncend)
b += 2
xgb.Put16(buf[b:], v.Htotal)
b += 2
xgb.Put32(buf[b:], v.Hskew)
b += 4
xgb.Put16(buf[b:], v.Vdisplay)
b += 2
xgb.Put16(buf[b:], v.Vsyncstart)
b += 2
xgb.Put16(buf[b:], v.Vsyncend)
b += 2
xgb.Put16(buf[b:], v.Vtotal)
b += 2
b += 4 // padding
xgb.Put32(buf[b:], v.Flags)
b += 4
b += 12 // padding
xgb.Put32(buf[b:], v.Privsize)
b += 4
return buf
}
// Write struct list ModeInfo
func ModeInfoListBytes(buf []byte, list []ModeInfo) int {
b := 0
var structBytes []byte
for _, item := range list {
structBytes = item.Bytes()
copy(buf[b:], structBytes)
b += xgb.Pad(len(structBytes))
}
return b
}
// Error definition BadClock (0)
// Size: 32
const BadBadClock = 0
type BadClockError struct {
Sequence uint16
NiceName string
}
// Error read BadClock
func BadClockErrorNew(buf []byte) xgb.Error {
v := BadClockError{}
v.NiceName = "BadClock"
b := 1 // skip error determinant
b += 1 // don't read error number
v.Sequence = xgb.Get16(buf[b:])
b += 2
return v
}
func (err BadClockError) ImplementsError() {}
func (err BadClockError) SequenceId() uint16 {
return err.Sequence
}
func (err BadClockError) BadId() uint32 {
return 0
}
func (err BadClockError) Error() string {
fieldVals := make([]string, 0, 0)
fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", err.Sequence))
return "BadBadClock {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}
func init() {
xgb.NewExtErrorFuncs["XFree86-VidModeExtension"][0] = BadClockErrorNew
}
// Error definition BadHTimings (1)
// Size: 32
const BadBadHTimings = 1
type BadHTimingsError struct {
Sequence uint16
NiceName string
}
// Error read BadHTimings
func BadHTimingsErrorNew(buf []byte) xgb.Error {
v := BadHTimingsError{}
v.NiceName = "BadHTimings"
b := 1 // skip error determinant
b += 1 // don't read error number
v.Sequence = xgb.Get16(buf[b:])
b += 2
return v
}
func (err BadHTimingsError) ImplementsError() {}
func (err BadHTimingsError) SequenceId() uint16 {
return err.Sequence
}
func (err BadHTimingsError) BadId() uint32 {
return 0
}
func (err BadHTimingsError) Error() string {
fieldVals := make([]string, 0, 0)
fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", err.Sequence))
return "BadBadHTimings {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}
func init() {
xgb.NewExtErrorFuncs["XFree86-VidModeExtension"][1] = BadHTimingsErrorNew
}
// Error definition BadVTimings (2)
// Size: 32
const BadBadVTimings = 2
type BadVTimingsError struct {
Sequence uint16
NiceName string
}
// Error read BadVTimings
func BadVTimingsErrorNew(buf []byte) xgb.Error {
v := BadVTimingsError{}
v.NiceName = "BadVTimings"
b := 1 // skip error determinant
b += 1 // don't read error number
v.Sequence = xgb.Get16(buf[b:])
b += 2
return v
}
func (err BadVTimingsError) ImplementsError() {}
func (err BadVTimingsError) SequenceId() uint16 {
return err.Sequence
}
func (err BadVTimingsError) BadId() uint32 {
return 0
}
func (err BadVTimingsError) Error() string {
fieldVals := make([]string, 0, 0)
fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", err.Sequence))
return "BadBadVTimings {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}
func init() {
xgb.NewExtErrorFuncs["XFree86-VidModeExtension"][2] = BadVTimingsErrorNew
}
// Error definition ModeUnsuitable (3)
// Size: 32
const BadModeUnsuitable = 3
type ModeUnsuitableError struct {
Sequence uint16
NiceName string
}
// Error read ModeUnsuitable
func ModeUnsuitableErrorNew(buf []byte) xgb.Error {
v := ModeUnsuitableError{}
v.NiceName = "ModeUnsuitable"
b := 1 // skip error determinant
b += 1 // don't read error number
v.Sequence = xgb.Get16(buf[b:])
b += 2
return v
}
func (err ModeUnsuitableError) ImplementsError() {}
func (err ModeUnsuitableError) SequenceId() uint16 {
return err.Sequence
}
func (err ModeUnsuitableError) BadId() uint32 {
return 0
}
func (err ModeUnsuitableError) Error() string {
fieldVals := make([]string, 0, 0)
fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", err.Sequence))
return "BadModeUnsuitable {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}
func init() {
xgb.NewExtErrorFuncs["XFree86-VidModeExtension"][3] = ModeUnsuitableErrorNew
}
// Error definition ExtensionDisabled (4)
// Size: 32
const BadExtensionDisabled = 4
type ExtensionDisabledError struct {
Sequence uint16
NiceName string
}
// Error read ExtensionDisabled
func ExtensionDisabledErrorNew(buf []byte) xgb.Error {
v := ExtensionDisabledError{}
v.NiceName = "ExtensionDisabled"
b := 1 // skip error determinant
b += 1 // don't read error number
v.Sequence = xgb.Get16(buf[b:])
b += 2
return v
}
func (err ExtensionDisabledError) ImplementsError() {}
func (err ExtensionDisabledError) SequenceId() uint16 {
return err.Sequence
}
func (err ExtensionDisabledError) BadId() uint32 {
return 0
}
func (err ExtensionDisabledError) Error() string {
fieldVals := make([]string, 0, 0)
fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", err.Sequence))
return "BadExtensionDisabled {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}
func init() {
xgb.NewExtErrorFuncs["XFree86-VidModeExtension"][4] = ExtensionDisabledErrorNew
}
// Error definition ClientNotLocal (5)
// Size: 32
const BadClientNotLocal = 5
type ClientNotLocalError struct {
Sequence uint16
NiceName string
}
// Error read ClientNotLocal
func ClientNotLocalErrorNew(buf []byte) xgb.Error {
v := ClientNotLocalError{}
v.NiceName = "ClientNotLocal"
b := 1 // skip error determinant
b += 1 // don't read error number
v.Sequence = xgb.Get16(buf[b:])
b += 2
return v
}
func (err ClientNotLocalError) ImplementsError() {}
func (err ClientNotLocalError) SequenceId() uint16 {
return err.Sequence
}
func (err ClientNotLocalError) BadId() uint32 {
return 0
}
func (err ClientNotLocalError) Error() string {
fieldVals := make([]string, 0, 0)
fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", err.Sequence))
return "BadClientNotLocal {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}
func init() {
xgb.NewExtErrorFuncs["XFree86-VidModeExtension"][5] = ClientNotLocalErrorNew
}
// Error definition ZoomLocked (6)
// Size: 32
const BadZoomLocked = 6
type ZoomLockedError struct {
Sequence uint16
NiceName string
}
// Error read ZoomLocked
func ZoomLockedErrorNew(buf []byte) xgb.Error {
v := ZoomLockedError{}
v.NiceName = "ZoomLocked"
b := 1 // skip error determinant
b += 1 // don't read error number
v.Sequence = xgb.Get16(buf[b:])
b += 2
return v
}
func (err ZoomLockedError) ImplementsError() {}
func (err ZoomLockedError) SequenceId() uint16 {
return err.Sequence
}
func (err ZoomLockedError) BadId() uint32 {
return 0
}
func (err ZoomLockedError) Error() string {
fieldVals := make([]string, 0, 0)
fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", err.Sequence))
return "BadZoomLocked {" + xgb.StringsJoin(fieldVals, ", ") + "}"
}
func init() {
xgb.NewExtErrorFuncs["XFree86-VidModeExtension"][6] = ZoomLockedErrorNew
}
// Request QueryVersion
// size: 4
type QueryVersionCookie struct {
*xgb.Cookie
}
func QueryVersion(c *xgb.Conn) QueryVersionCookie {
cookie := c.NewCookie(true, true)
c.NewRequest(queryVersionRequest(c), cookie)
return QueryVersionCookie{cookie}
}
func QueryVersionUnchecked(c *xgb.Conn) QueryVersionCookie {
cookie := c.NewCookie(false, true)
c.NewRequest(queryVersionRequest(c), cookie)
return QueryVersionCookie{cookie}
}
// Request reply for QueryVersion
// size: 12
type QueryVersionReply struct {
Sequence uint16
Length uint32
// padding: 1 bytes
MajorVersion uint16
MinorVersion uint16
}
// Waits and reads reply data from request QueryVersion
func (cook QueryVersionCookie) Reply() (*QueryVersionReply, error) {
buf, err := cook.Cookie.Reply()
if err != nil {
return nil, err
}
if buf == nil {
return nil, nil
}
return queryVersionReply(buf), nil
}
// Read reply into structure from buffer for QueryVersion
func queryVersionReply(buf []byte) *QueryVersionReply {
v := new(QueryVersionReply)
b := 1 // skip reply determinant
b += 1 // padding
v.Sequence = xgb.Get16(buf[b:])
b += 2
v.Length = xgb.Get32(buf[b:]) // 4-byte units
b += 4
v.MajorVersion = xgb.Get16(buf[b:])
b += 2
v.MinorVersion = xgb.Get16(buf[b:])
b += 2
return v
}
// Write request to wire for QueryVersion
func queryVersionRequest(c *xgb.Conn) []byte {
size := 4
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 0 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
return buf
}
// Request GetModeLine
// size: 8
type GetModeLineCookie struct {
*xgb.Cookie
}
func GetModeLine(c *xgb.Conn, Screen uint16) GetModeLineCookie {
cookie := c.NewCookie(true, true)
c.NewRequest(getModeLineRequest(c, Screen), cookie)
return GetModeLineCookie{cookie}
}
func GetModeLineUnchecked(c *xgb.Conn, Screen uint16) GetModeLineCookie {
cookie := c.NewCookie(false, true)
c.NewRequest(getModeLineRequest(c, Screen), cookie)
return GetModeLineCookie{cookie}
}
// Request reply for GetModeLine
// size: (52 + xgb.Pad((int(Privsize) * 1)))
type GetModeLineReply struct {
Sequence uint16
Length uint32
// padding: 1 bytes
Dotclock Dotclock
Hdisplay uint16
Hsyncstart uint16
Hsyncend uint16
Htotal uint16
Hskew uint16
Vdisplay uint16
Vsyncstart uint16
Vsyncend uint16
Vtotal uint16
// padding: 2 bytes
Flags uint32
// padding: 12 bytes
Privsize uint32
Private []byte // size: xgb.Pad((int(Privsize) * 1))
}
// Waits and reads reply data from request GetModeLine
func (cook GetModeLineCookie) Reply() (*GetModeLineReply, error) {
buf, err := cook.Cookie.Reply()
if err != nil {
return nil, err
}
if buf == nil {
return nil, nil
}
return getModeLineReply(buf), nil
}
// Read reply into structure from buffer for GetModeLine
func getModeLineReply(buf []byte) *GetModeLineReply {
v := new(GetModeLineReply)
b := 1 // skip reply determinant
b += 1 // padding
v.Sequence = xgb.Get16(buf[b:])
b += 2
v.Length = xgb.Get32(buf[b:]) // 4-byte units
b += 4
v.Dotclock = Dotclock(xgb.Get32(buf[b:]))
b += 4
v.Hdisplay = xgb.Get16(buf[b:])
b += 2
v.Hsyncstart = xgb.Get16(buf[b:])
b += 2
v.Hsyncend = xgb.Get16(buf[b:])
b += 2
v.Htotal = xgb.Get16(buf[b:])
b += 2
v.Hskew = xgb.Get16(buf[b:])
b += 2
v.Vdisplay = xgb.Get16(buf[b:])
b += 2
v.Vsyncstart = xgb.Get16(buf[b:])
b += 2
v.Vsyncend = xgb.Get16(buf[b:])
b += 2
v.Vtotal = xgb.Get16(buf[b:])
b += 2
b += 2 // padding
v.Flags = xgb.Get32(buf[b:])
b += 4
b += 12 // padding
v.Privsize = xgb.Get32(buf[b:])
b += 4
v.Private = make([]byte, v.Privsize)
copy(v.Private[:v.Privsize], buf[b:])
b += xgb.Pad(int(v.Privsize))
return v
}
// Write request to wire for GetModeLine
func getModeLineRequest(c *xgb.Conn, Screen uint16) []byte {
size := 8
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 1 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put16(buf[b:], Screen)
b += 2
b += 2 // padding
return buf
}
// Request ModModeLine
// size: xgb.Pad((48 + xgb.Pad((int(Privsize) * 1))))
type ModModeLineCookie struct {
*xgb.Cookie
}
// Write request to wire for ModModeLine
func ModModeLine(c *xgb.Conn, Screen uint32, Hdisplay uint16, Hsyncstart uint16, Hsyncend uint16, Htotal uint16, Hskew uint16, Vdisplay uint16, Vsyncstart uint16, Vsyncend uint16, Vtotal uint16, Flags uint32, Privsize uint32, Private []byte) ModModeLineCookie {
cookie := c.NewCookie(false, false)
c.NewRequest(modModeLineRequest(c, Screen, Hdisplay, Hsyncstart, Hsyncend, Htotal, Hskew, Vdisplay, Vsyncstart, Vsyncend, Vtotal, Flags, Privsize, Private), cookie)
return ModModeLineCookie{cookie}
}
func ModModeLineChecked(c *xgb.Conn, Screen uint32, Hdisplay uint16, Hsyncstart uint16, Hsyncend uint16, Htotal uint16, Hskew uint16, Vdisplay uint16, Vsyncstart uint16, Vsyncend uint16, Vtotal uint16, Flags uint32, Privsize uint32, Private []byte) ModModeLineCookie {
cookie := c.NewCookie(true, false)
c.NewRequest(modModeLineRequest(c, Screen, Hdisplay, Hsyncstart, Hsyncend, Htotal, Hskew, Vdisplay, Vsyncstart, Vsyncend, Vtotal, Flags, Privsize, Private), cookie)
return ModModeLineCookie{cookie}
}
func (cook ModModeLineCookie) Check() error {
return cook.Cookie.Check()
}
// Write request to wire for ModModeLine
func modModeLineRequest(c *xgb.Conn, Screen uint32, Hdisplay uint16, Hsyncstart uint16, Hsyncend uint16, Htotal uint16, Hskew uint16, Vdisplay uint16, Vsyncstart uint16, Vsyncend uint16, Vtotal uint16, Flags uint32, Privsize uint32, Private []byte) []byte {
size := xgb.Pad((48 + xgb.Pad((int(Privsize) * 1))))
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 2 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put32(buf[b:], Screen)
b += 4
xgb.Put16(buf[b:], Hdisplay)
b += 2
xgb.Put16(buf[b:], Hsyncstart)
b += 2
xgb.Put16(buf[b:], Hsyncend)
b += 2
xgb.Put16(buf[b:], Htotal)
b += 2
xgb.Put16(buf[b:], Hskew)
b += 2
xgb.Put16(buf[b:], Vdisplay)
b += 2
xgb.Put16(buf[b:], Vsyncstart)
b += 2
xgb.Put16(buf[b:], Vsyncend)
b += 2
xgb.Put16(buf[b:], Vtotal)
b += 2
b += 2 // padding
xgb.Put32(buf[b:], Flags)
b += 4
b += 12 // padding
xgb.Put32(buf[b:], Privsize)
b += 4
copy(buf[b:], Private[:Privsize])
b += xgb.Pad(int(Privsize))
return buf
}
// Request SwitchMode
// size: 8
type SwitchModeCookie struct {
*xgb.Cookie
}
// Write request to wire for SwitchMode
func SwitchMode(c *xgb.Conn, Screen uint16, Zoom uint16) SwitchModeCookie {
cookie := c.NewCookie(false, false)
c.NewRequest(switchModeRequest(c, Screen, Zoom), cookie)
return SwitchModeCookie{cookie}
}
func SwitchModeChecked(c *xgb.Conn, Screen uint16, Zoom uint16) SwitchModeCookie {
cookie := c.NewCookie(true, false)
c.NewRequest(switchModeRequest(c, Screen, Zoom), cookie)
return SwitchModeCookie{cookie}
}
func (cook SwitchModeCookie) Check() error {
return cook.Cookie.Check()
}
// Write request to wire for SwitchMode
func switchModeRequest(c *xgb.Conn, Screen uint16, Zoom uint16) []byte {
size := 8
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 3 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put16(buf[b:], Screen)
b += 2
xgb.Put16(buf[b:], Zoom)
b += 2
return buf
}
// Request GetMonitor
// size: 8
type GetMonitorCookie struct {
*xgb.Cookie
}
func GetMonitor(c *xgb.Conn, Screen uint16) GetMonitorCookie {
cookie := c.NewCookie(true, true)
c.NewRequest(getMonitorRequest(c, Screen), cookie)
return GetMonitorCookie{cookie}
}
func GetMonitorUnchecked(c *xgb.Conn, Screen uint16) GetMonitorCookie {
cookie := c.NewCookie(false, true)
c.NewRequest(getMonitorRequest(c, Screen), cookie)
return GetMonitorCookie{cookie}
}
// Request reply for GetMonitor
// size: (((((32 + xgb.Pad((int(NumHsync) * 4))) + xgb.Pad((int(NumVsync) * 4))) + xgb.Pad((int(VendorLength) * 1))) + xgb.Pad(((((int(VendorLength) + 3) & -4) - int(VendorLength)) * 1))) + xgb.Pad((int(ModelLength) * 1)))
type GetMonitorReply struct {
Sequence uint16
Length uint32
// padding: 1 bytes
VendorLength byte
ModelLength byte
NumHsync byte
NumVsync byte
// padding: 20 bytes
Hsync []Syncrange // size: xgb.Pad((int(NumHsync) * 4))
Vsync []Syncrange // size: xgb.Pad((int(NumVsync) * 4))
Vendor string // size: xgb.Pad((int(VendorLength) * 1))
AlignmentPad []byte // size: xgb.Pad(((((int(VendorLength) + 3) & -4) - int(VendorLength)) * 1))
Model string // size: xgb.Pad((int(ModelLength) * 1))
}
// Waits and reads reply data from request GetMonitor
func (cook GetMonitorCookie) Reply() (*GetMonitorReply, error) {
buf, err := cook.Cookie.Reply()
if err != nil {
return nil, err
}
if buf == nil {
return nil, nil
}
return getMonitorReply(buf), nil
}
// Read reply into structure from buffer for GetMonitor
func getMonitorReply(buf []byte) *GetMonitorReply {
v := new(GetMonitorReply)
b := 1 // skip reply determinant
b += 1 // padding
v.Sequence = xgb.Get16(buf[b:])
b += 2
v.Length = xgb.Get32(buf[b:]) // 4-byte units
b += 4
v.VendorLength = buf[b]
b += 1
v.ModelLength = buf[b]
b += 1
v.NumHsync = buf[b]
b += 1
v.NumVsync = buf[b]
b += 1
b += 20 // padding
v.Hsync = make([]Syncrange, v.NumHsync)
for i := 0; i < int(v.NumHsync); i++ {
v.Hsync[i] = Syncrange(xgb.Get32(buf[b:]))
b += 4
}
b = xgb.Pad(b)
v.Vsync = make([]Syncrange, v.NumVsync)
for i := 0; i < int(v.NumVsync); i++ {
v.Vsync[i] = Syncrange(xgb.Get32(buf[b:]))
b += 4
}
b = xgb.Pad(b)
{
byteString := make([]byte, v.VendorLength)
copy(byteString[:v.VendorLength], buf[b:])
v.Vendor = string(byteString)
b += xgb.Pad(int(v.VendorLength))
}
v.AlignmentPad = make([]byte, (((int(v.VendorLength) + 3) & -4) - int(v.VendorLength)))
copy(v.AlignmentPad[:(((int(v.VendorLength)+3)&-4)-int(v.VendorLength))], buf[b:])
b += xgb.Pad(int((((int(v.VendorLength) + 3) & -4) - int(v.VendorLength))))
{
byteString := make([]byte, v.ModelLength)
copy(byteString[:v.ModelLength], buf[b:])
v.Model = string(byteString)
b += xgb.Pad(int(v.ModelLength))
}
return v
}
// Write request to wire for GetMonitor
func getMonitorRequest(c *xgb.Conn, Screen uint16) []byte {
size := 8
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 4 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put16(buf[b:], Screen)
b += 2
b += 2 // padding
return buf
}
// Request LockModeSwitch
// size: 8
type LockModeSwitchCookie struct {
*xgb.Cookie
}
// Write request to wire for LockModeSwitch
func LockModeSwitch(c *xgb.Conn, Screen uint16, Lock uint16) LockModeSwitchCookie {
cookie := c.NewCookie(false, false)
c.NewRequest(lockModeSwitchRequest(c, Screen, Lock), cookie)
return LockModeSwitchCookie{cookie}
}
func LockModeSwitchChecked(c *xgb.Conn, Screen uint16, Lock uint16) LockModeSwitchCookie {
cookie := c.NewCookie(true, false)
c.NewRequest(lockModeSwitchRequest(c, Screen, Lock), cookie)
return LockModeSwitchCookie{cookie}
}
func (cook LockModeSwitchCookie) Check() error {
return cook.Cookie.Check()
}
// Write request to wire for LockModeSwitch
func lockModeSwitchRequest(c *xgb.Conn, Screen uint16, Lock uint16) []byte {
size := 8
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 5 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put16(buf[b:], Screen)
b += 2
xgb.Put16(buf[b:], Lock)
b += 2
return buf
}
// Request GetAllModeLines
// size: 8
type GetAllModeLinesCookie struct {
*xgb.Cookie
}
func GetAllModeLines(c *xgb.Conn, Screen uint16) GetAllModeLinesCookie {
cookie := c.NewCookie(true, true)
c.NewRequest(getAllModeLinesRequest(c, Screen), cookie)
return GetAllModeLinesCookie{cookie}
}
func GetAllModeLinesUnchecked(c *xgb.Conn, Screen uint16) GetAllModeLinesCookie {
cookie := c.NewCookie(false, true)
c.NewRequest(getAllModeLinesRequest(c, Screen), cookie)
return GetAllModeLinesCookie{cookie}
}
// Request reply for GetAllModeLines
// size: (32 + xgb.Pad((int(Modecount) * 48)))
type GetAllModeLinesReply struct {
Sequence uint16
Length uint32
// padding: 1 bytes
Modecount uint32
// padding: 20 bytes
Modeinfo []ModeInfo // size: xgb.Pad((int(Modecount) * 48))
}
// Waits and reads reply data from request GetAllModeLines
func (cook GetAllModeLinesCookie) Reply() (*GetAllModeLinesReply, error) {
buf, err := cook.Cookie.Reply()
if err != nil {
return nil, err
}
if buf == nil {
return nil, nil
}
return getAllModeLinesReply(buf), nil
}
// Read reply into structure from buffer for GetAllModeLines
func getAllModeLinesReply(buf []byte) *GetAllModeLinesReply {
v := new(GetAllModeLinesReply)
b := 1 // skip reply determinant
b += 1 // padding
v.Sequence = xgb.Get16(buf[b:])
b += 2
v.Length = xgb.Get32(buf[b:]) // 4-byte units
b += 4
v.Modecount = xgb.Get32(buf[b:])
b += 4
b += 20 // padding
v.Modeinfo = make([]ModeInfo, v.Modecount)
b += ModeInfoReadList(buf[b:], v.Modeinfo)
return v
}
// Write request to wire for GetAllModeLines
func getAllModeLinesRequest(c *xgb.Conn, Screen uint16) []byte {
size := 8
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 6 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put16(buf[b:], Screen)
b += 2
b += 2 // padding
return buf
}
// Request AddModeLine
// size: xgb.Pad((92 + xgb.Pad((int(Privsize) * 1))))
type AddModeLineCookie struct {
*xgb.Cookie
}
// Write request to wire for AddModeLine
func AddModeLine(c *xgb.Conn, Screen uint32, Dotclock Dotclock, Hdisplay uint16, Hsyncstart uint16, Hsyncend uint16, Htotal uint16, Hskew uint16, Vdisplay uint16, Vsyncstart uint16, Vsyncend uint16, Vtotal uint16, Flags uint32, Privsize uint32, AfterDotclock Dotclock, AfterHdisplay uint16, AfterHsyncstart uint16, AfterHsyncend uint16, AfterHtotal uint16, AfterHskew uint16, AfterVdisplay uint16, AfterVsyncstart uint16, AfterVsyncend uint16, AfterVtotal uint16, AfterFlags uint32, Private []byte) AddModeLineCookie {
cookie := c.NewCookie(false, false)
c.NewRequest(addModeLineRequest(c, Screen, Dotclock, Hdisplay, Hsyncstart, Hsyncend, Htotal, Hskew, Vdisplay, Vsyncstart, Vsyncend, Vtotal, Flags, Privsize, AfterDotclock, AfterHdisplay, AfterHsyncstart, AfterHsyncend, AfterHtotal, AfterHskew, AfterVdisplay, AfterVsyncstart, AfterVsyncend, AfterVtotal, AfterFlags, Private), cookie)
return AddModeLineCookie{cookie}
}
func AddModeLineChecked(c *xgb.Conn, Screen uint32, Dotclock Dotclock, Hdisplay uint16, Hsyncstart uint16, Hsyncend uint16, Htotal uint16, Hskew uint16, Vdisplay uint16, Vsyncstart uint16, Vsyncend uint16, Vtotal uint16, Flags uint32, Privsize uint32, AfterDotclock Dotclock, AfterHdisplay uint16, AfterHsyncstart uint16, AfterHsyncend uint16, AfterHtotal uint16, AfterHskew uint16, AfterVdisplay uint16, AfterVsyncstart uint16, AfterVsyncend uint16, AfterVtotal uint16, AfterFlags uint32, Private []byte) AddModeLineCookie {
cookie := c.NewCookie(true, false)
c.NewRequest(addModeLineRequest(c, Screen, Dotclock, Hdisplay, Hsyncstart, Hsyncend, Htotal, Hskew, Vdisplay, Vsyncstart, Vsyncend, Vtotal, Flags, Privsize, AfterDotclock, AfterHdisplay, AfterHsyncstart, AfterHsyncend, AfterHtotal, AfterHskew, AfterVdisplay, AfterVsyncstart, AfterVsyncend, AfterVtotal, AfterFlags, Private), cookie)
return AddModeLineCookie{cookie}
}
func (cook AddModeLineCookie) Check() error {
return cook.Cookie.Check()
}
// Write request to wire for AddModeLine
func addModeLineRequest(c *xgb.Conn, Screen uint32, Dotclock Dotclock, Hdisplay uint16, Hsyncstart uint16, Hsyncend uint16, Htotal uint16, Hskew uint16, Vdisplay uint16, Vsyncstart uint16, Vsyncend uint16, Vtotal uint16, Flags uint32, Privsize uint32, AfterDotclock Dotclock, AfterHdisplay uint16, AfterHsyncstart uint16, AfterHsyncend uint16, AfterHtotal uint16, AfterHskew uint16, AfterVdisplay uint16, AfterVsyncstart uint16, AfterVsyncend uint16, AfterVtotal uint16, AfterFlags uint32, Private []byte) []byte {
size := xgb.Pad((92 + xgb.Pad((int(Privsize) * 1))))
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 7 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put32(buf[b:], Screen)
b += 4
xgb.Put32(buf[b:], uint32(Dotclock))
b += 4
xgb.Put16(buf[b:], Hdisplay)
b += 2
xgb.Put16(buf[b:], Hsyncstart)
b += 2
xgb.Put16(buf[b:], Hsyncend)
b += 2
xgb.Put16(buf[b:], Htotal)
b += 2
xgb.Put16(buf[b:], Hskew)
b += 2
xgb.Put16(buf[b:], Vdisplay)
b += 2
xgb.Put16(buf[b:], Vsyncstart)
b += 2
xgb.Put16(buf[b:], Vsyncend)
b += 2
xgb.Put16(buf[b:], Vtotal)
b += 2
b += 2 // padding
xgb.Put32(buf[b:], Flags)
b += 4
b += 12 // padding
xgb.Put32(buf[b:], Privsize)
b += 4
xgb.Put32(buf[b:], uint32(AfterDotclock))
b += 4
xgb.Put16(buf[b:], AfterHdisplay)
b += 2
xgb.Put16(buf[b:], AfterHsyncstart)
b += 2
xgb.Put16(buf[b:], AfterHsyncend)
b += 2
xgb.Put16(buf[b:], AfterHtotal)
b += 2
xgb.Put16(buf[b:], AfterHskew)
b += 2
xgb.Put16(buf[b:], AfterVdisplay)
b += 2
xgb.Put16(buf[b:], AfterVsyncstart)
b += 2
xgb.Put16(buf[b:], AfterVsyncend)
b += 2
xgb.Put16(buf[b:], AfterVtotal)
b += 2
b += 2 // padding
xgb.Put32(buf[b:], AfterFlags)
b += 4
b += 12 // padding
copy(buf[b:], Private[:Privsize])
b += xgb.Pad(int(Privsize))
return buf
}
// Request DeleteModeLine
// size: xgb.Pad((52 + xgb.Pad((int(Privsize) * 1))))
type DeleteModeLineCookie struct {
*xgb.Cookie
}
// Write request to wire for DeleteModeLine
func DeleteModeLine(c *xgb.Conn, Screen uint32, Dotclock Dotclock, Hdisplay uint16, Hsyncstart uint16, Hsyncend uint16, Htotal uint16, Hskew uint16, Vdisplay uint16, Vsyncstart uint16, Vsyncend uint16, Vtotal uint16, Flags uint32, Privsize uint32, Private []byte) DeleteModeLineCookie {
cookie := c.NewCookie(false, false)
c.NewRequest(deleteModeLineRequest(c, Screen, Dotclock, Hdisplay, Hsyncstart, Hsyncend, Htotal, Hskew, Vdisplay, Vsyncstart, Vsyncend, Vtotal, Flags, Privsize, Private), cookie)
return DeleteModeLineCookie{cookie}
}
func DeleteModeLineChecked(c *xgb.Conn, Screen uint32, Dotclock Dotclock, Hdisplay uint16, Hsyncstart uint16, Hsyncend uint16, Htotal uint16, Hskew uint16, Vdisplay uint16, Vsyncstart uint16, Vsyncend uint16, Vtotal uint16, Flags uint32, Privsize uint32, Private []byte) DeleteModeLineCookie {
cookie := c.NewCookie(true, false)
c.NewRequest(deleteModeLineRequest(c, Screen, Dotclock, Hdisplay, Hsyncstart, Hsyncend, Htotal, Hskew, Vdisplay, Vsyncstart, Vsyncend, Vtotal, Flags, Privsize, Private), cookie)
return DeleteModeLineCookie{cookie}
}
func (cook DeleteModeLineCookie) Check() error {
return cook.Cookie.Check()
}
// Write request to wire for DeleteModeLine
func deleteModeLineRequest(c *xgb.Conn, Screen uint32, Dotclock Dotclock, Hdisplay uint16, Hsyncstart uint16, Hsyncend uint16, Htotal uint16, Hskew uint16, Vdisplay uint16, Vsyncstart uint16, Vsyncend uint16, Vtotal uint16, Flags uint32, Privsize uint32, Private []byte) []byte {
size := xgb.Pad((52 + xgb.Pad((int(Privsize) * 1))))
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 8 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put32(buf[b:], Screen)
b += 4
xgb.Put32(buf[b:], uint32(Dotclock))
b += 4
xgb.Put16(buf[b:], Hdisplay)
b += 2
xgb.Put16(buf[b:], Hsyncstart)
b += 2
xgb.Put16(buf[b:], Hsyncend)
b += 2
xgb.Put16(buf[b:], Htotal)
b += 2
xgb.Put16(buf[b:], Hskew)
b += 2
xgb.Put16(buf[b:], Vdisplay)
b += 2
xgb.Put16(buf[b:], Vsyncstart)
b += 2
xgb.Put16(buf[b:], Vsyncend)
b += 2
xgb.Put16(buf[b:], Vtotal)
b += 2
b += 2 // padding
xgb.Put32(buf[b:], Flags)
b += 4
b += 12 // padding
xgb.Put32(buf[b:], Privsize)
b += 4
copy(buf[b:], Private[:Privsize])
b += xgb.Pad(int(Privsize))
return buf
}
// Request ValidateModeLine
// size: xgb.Pad((52 + xgb.Pad((int(Privsize) * 1))))
type ValidateModeLineCookie struct {
*xgb.Cookie
}
func ValidateModeLine(c *xgb.Conn, Screen uint32, Dotclock Dotclock, Hdisplay uint16, Hsyncstart uint16, Hsyncend uint16, Htotal uint16, Hskew uint16, Vdisplay uint16, Vsyncstart uint16, Vsyncend uint16, Vtotal uint16, Flags uint32, Privsize uint32, Private []byte) ValidateModeLineCookie {
cookie := c.NewCookie(true, true)
c.NewRequest(validateModeLineRequest(c, Screen, Dotclock, Hdisplay, Hsyncstart, Hsyncend, Htotal, Hskew, Vdisplay, Vsyncstart, Vsyncend, Vtotal, Flags, Privsize, Private), cookie)
return ValidateModeLineCookie{cookie}
}
func ValidateModeLineUnchecked(c *xgb.Conn, Screen uint32, Dotclock Dotclock, Hdisplay uint16, Hsyncstart uint16, Hsyncend uint16, Htotal uint16, Hskew uint16, Vdisplay uint16, Vsyncstart uint16, Vsyncend uint16, Vtotal uint16, Flags uint32, Privsize uint32, Private []byte) ValidateModeLineCookie {
cookie := c.NewCookie(false, true)
c.NewRequest(validateModeLineRequest(c, Screen, Dotclock, Hdisplay, Hsyncstart, Hsyncend, Htotal, Hskew, Vdisplay, Vsyncstart, Vsyncend, Vtotal, Flags, Privsize, Private), cookie)
return ValidateModeLineCookie{cookie}
}
// Request reply for ValidateModeLine
// size: 32
type ValidateModeLineReply struct {
Sequence uint16
Length uint32
// padding: 1 bytes
Status uint32
// padding: 20 bytes
}
// Waits and reads reply data from request ValidateModeLine
func (cook ValidateModeLineCookie) Reply() (*ValidateModeLineReply, error) {
buf, err := cook.Cookie.Reply()
if err != nil {
return nil, err
}
if buf == nil {
return nil, nil
}
return validateModeLineReply(buf), nil
}
// Read reply into structure from buffer for ValidateModeLine
func validateModeLineReply(buf []byte) *ValidateModeLineReply {
v := new(ValidateModeLineReply)
b := 1 // skip reply determinant
b += 1 // padding
v.Sequence = xgb.Get16(buf[b:])
b += 2
v.Length = xgb.Get32(buf[b:]) // 4-byte units
b += 4
v.Status = xgb.Get32(buf[b:])
b += 4
b += 20 // padding
return v
}
// Write request to wire for ValidateModeLine
func validateModeLineRequest(c *xgb.Conn, Screen uint32, Dotclock Dotclock, Hdisplay uint16, Hsyncstart uint16, Hsyncend uint16, Htotal uint16, Hskew uint16, Vdisplay uint16, Vsyncstart uint16, Vsyncend uint16, Vtotal uint16, Flags uint32, Privsize uint32, Private []byte) []byte {
size := xgb.Pad((52 + xgb.Pad((int(Privsize) * 1))))
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 9 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put32(buf[b:], Screen)
b += 4
xgb.Put32(buf[b:], uint32(Dotclock))
b += 4
xgb.Put16(buf[b:], Hdisplay)
b += 2
xgb.Put16(buf[b:], Hsyncstart)
b += 2
xgb.Put16(buf[b:], Hsyncend)
b += 2
xgb.Put16(buf[b:], Htotal)
b += 2
xgb.Put16(buf[b:], Hskew)
b += 2
xgb.Put16(buf[b:], Vdisplay)
b += 2
xgb.Put16(buf[b:], Vsyncstart)
b += 2
xgb.Put16(buf[b:], Vsyncend)
b += 2
xgb.Put16(buf[b:], Vtotal)
b += 2
b += 2 // padding
xgb.Put32(buf[b:], Flags)
b += 4
b += 12 // padding
xgb.Put32(buf[b:], Privsize)
b += 4
copy(buf[b:], Private[:Privsize])
b += xgb.Pad(int(Privsize))
return buf
}
// Request SwitchToMode
// size: xgb.Pad((52 + xgb.Pad((int(Privsize) * 1))))
type SwitchToModeCookie struct {
*xgb.Cookie
}
// Write request to wire for SwitchToMode
func SwitchToMode(c *xgb.Conn, Screen uint32, Dotclock Dotclock, Hdisplay uint16, Hsyncstart uint16, Hsyncend uint16, Htotal uint16, Hskew uint16, Vdisplay uint16, Vsyncstart uint16, Vsyncend uint16, Vtotal uint16, Flags uint32, Privsize uint32, Private []byte) SwitchToModeCookie {
cookie := c.NewCookie(false, false)
c.NewRequest(switchToModeRequest(c, Screen, Dotclock, Hdisplay, Hsyncstart, Hsyncend, Htotal, Hskew, Vdisplay, Vsyncstart, Vsyncend, Vtotal, Flags, Privsize, Private), cookie)
return SwitchToModeCookie{cookie}
}
func SwitchToModeChecked(c *xgb.Conn, Screen uint32, Dotclock Dotclock, Hdisplay uint16, Hsyncstart uint16, Hsyncend uint16, Htotal uint16, Hskew uint16, Vdisplay uint16, Vsyncstart uint16, Vsyncend uint16, Vtotal uint16, Flags uint32, Privsize uint32, Private []byte) SwitchToModeCookie {
cookie := c.NewCookie(true, false)
c.NewRequest(switchToModeRequest(c, Screen, Dotclock, Hdisplay, Hsyncstart, Hsyncend, Htotal, Hskew, Vdisplay, Vsyncstart, Vsyncend, Vtotal, Flags, Privsize, Private), cookie)
return SwitchToModeCookie{cookie}
}
func (cook SwitchToModeCookie) Check() error {
return cook.Cookie.Check()
}
// Write request to wire for SwitchToMode
func switchToModeRequest(c *xgb.Conn, Screen uint32, Dotclock Dotclock, Hdisplay uint16, Hsyncstart uint16, Hsyncend uint16, Htotal uint16, Hskew uint16, Vdisplay uint16, Vsyncstart uint16, Vsyncend uint16, Vtotal uint16, Flags uint32, Privsize uint32, Private []byte) []byte {
size := xgb.Pad((52 + xgb.Pad((int(Privsize) * 1))))
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 10 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put32(buf[b:], Screen)
b += 4
xgb.Put32(buf[b:], uint32(Dotclock))
b += 4
xgb.Put16(buf[b:], Hdisplay)
b += 2
xgb.Put16(buf[b:], Hsyncstart)
b += 2
xgb.Put16(buf[b:], Hsyncend)
b += 2
xgb.Put16(buf[b:], Htotal)
b += 2
xgb.Put16(buf[b:], Hskew)
b += 2
xgb.Put16(buf[b:], Vdisplay)
b += 2
xgb.Put16(buf[b:], Vsyncstart)
b += 2
xgb.Put16(buf[b:], Vsyncend)
b += 2
xgb.Put16(buf[b:], Vtotal)
b += 2
b += 2 // padding
xgb.Put32(buf[b:], Flags)
b += 4
b += 12 // padding
xgb.Put32(buf[b:], Privsize)
b += 4
copy(buf[b:], Private[:Privsize])
b += xgb.Pad(int(Privsize))
return buf
}
// Request GetViewPort
// size: 8
type GetViewPortCookie struct {
*xgb.Cookie
}
func GetViewPort(c *xgb.Conn, Screen uint16) GetViewPortCookie {
cookie := c.NewCookie(true, true)
c.NewRequest(getViewPortRequest(c, Screen), cookie)
return GetViewPortCookie{cookie}
}
func GetViewPortUnchecked(c *xgb.Conn, Screen uint16) GetViewPortCookie {
cookie := c.NewCookie(false, true)
c.NewRequest(getViewPortRequest(c, Screen), cookie)
return GetViewPortCookie{cookie}
}
// Request reply for GetViewPort
// size: 32
type GetViewPortReply struct {
Sequence uint16
Length uint32
// padding: 1 bytes
X uint32
Y uint32
// padding: 16 bytes
}
// Waits and reads reply data from request GetViewPort
func (cook GetViewPortCookie) Reply() (*GetViewPortReply, error) {
buf, err := cook.Cookie.Reply()
if err != nil {
return nil, err
}
if buf == nil {
return nil, nil
}
return getViewPortReply(buf), nil
}
// Read reply into structure from buffer for GetViewPort
func getViewPortReply(buf []byte) *GetViewPortReply {
v := new(GetViewPortReply)
b := 1 // skip reply determinant
b += 1 // padding
v.Sequence = xgb.Get16(buf[b:])
b += 2
v.Length = xgb.Get32(buf[b:]) // 4-byte units
b += 4
v.X = xgb.Get32(buf[b:])
b += 4
v.Y = xgb.Get32(buf[b:])
b += 4
b += 16 // padding
return v
}
// Write request to wire for GetViewPort
func getViewPortRequest(c *xgb.Conn, Screen uint16) []byte {
size := 8
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 11 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put16(buf[b:], Screen)
b += 2
b += 2 // padding
return buf
}
// Request SetViewPort
// size: 16
type SetViewPortCookie struct {
*xgb.Cookie
}
// Write request to wire for SetViewPort
func SetViewPort(c *xgb.Conn, Screen uint16, X uint32, Y uint32) SetViewPortCookie {
cookie := c.NewCookie(false, false)
c.NewRequest(setViewPortRequest(c, Screen, X, Y), cookie)
return SetViewPortCookie{cookie}
}
func SetViewPortChecked(c *xgb.Conn, Screen uint16, X uint32, Y uint32) SetViewPortCookie {
cookie := c.NewCookie(true, false)
c.NewRequest(setViewPortRequest(c, Screen, X, Y), cookie)
return SetViewPortCookie{cookie}
}
func (cook SetViewPortCookie) Check() error {
return cook.Cookie.Check()
}
// Write request to wire for SetViewPort
func setViewPortRequest(c *xgb.Conn, Screen uint16, X uint32, Y uint32) []byte {
size := 16
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 12 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put16(buf[b:], Screen)
b += 2
b += 2 // padding
xgb.Put32(buf[b:], X)
b += 4
xgb.Put32(buf[b:], Y)
b += 4
return buf
}
// Request GetDotClocks
// size: 8
type GetDotClocksCookie struct {
*xgb.Cookie
}
func GetDotClocks(c *xgb.Conn, Screen uint16) GetDotClocksCookie {
cookie := c.NewCookie(true, true)
c.NewRequest(getDotClocksRequest(c, Screen), cookie)
return GetDotClocksCookie{cookie}
}
func GetDotClocksUnchecked(c *xgb.Conn, Screen uint16) GetDotClocksCookie {
cookie := c.NewCookie(false, true)
c.NewRequest(getDotClocksRequest(c, Screen), cookie)
return GetDotClocksCookie{cookie}
}
// Request reply for GetDotClocks
// size: (32 + xgb.Pad((((1 - (int(Flags) & 1)) * int(Clocks)) * 4)))
type GetDotClocksReply struct {
Sequence uint16
Length uint32
// padding: 1 bytes
Flags uint32
Clocks uint32
Maxclocks uint32
// padding: 12 bytes
Clock []uint32 // size: xgb.Pad((((1 - (int(Flags) & 1)) * int(Clocks)) * 4))
}
// Waits and reads reply data from request GetDotClocks
func (cook GetDotClocksCookie) Reply() (*GetDotClocksReply, error) {
buf, err := cook.Cookie.Reply()
if err != nil {
return nil, err
}
if buf == nil {
return nil, nil
}
return getDotClocksReply(buf), nil
}
// Read reply into structure from buffer for GetDotClocks
func getDotClocksReply(buf []byte) *GetDotClocksReply {
v := new(GetDotClocksReply)
b := 1 // skip reply determinant
b += 1 // padding
v.Sequence = xgb.Get16(buf[b:])
b += 2
v.Length = xgb.Get32(buf[b:]) // 4-byte units
b += 4
v.Flags = xgb.Get32(buf[b:])
b += 4
v.Clocks = xgb.Get32(buf[b:])
b += 4
v.Maxclocks = xgb.Get32(buf[b:])
b += 4
b += 12 // padding
v.Clock = make([]uint32, ((1 - (int(v.Flags) & 1)) * int(v.Clocks)))
for i := 0; i < int(((1 - (int(v.Flags) & 1)) * int(v.Clocks))); i++ {
v.Clock[i] = xgb.Get32(buf[b:])
b += 4
}
b = xgb.Pad(b)
return v
}
// Write request to wire for GetDotClocks
func getDotClocksRequest(c *xgb.Conn, Screen uint16) []byte {
size := 8
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 13 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put16(buf[b:], Screen)
b += 2
b += 2 // padding
return buf
}
// Request SetClientVersion
// size: 8
type SetClientVersionCookie struct {
*xgb.Cookie
}
// Write request to wire for SetClientVersion
func SetClientVersion(c *xgb.Conn, Major uint16, Minor uint16) SetClientVersionCookie {
cookie := c.NewCookie(false, false)
c.NewRequest(setClientVersionRequest(c, Major, Minor), cookie)
return SetClientVersionCookie{cookie}
}
func SetClientVersionChecked(c *xgb.Conn, Major uint16, Minor uint16) SetClientVersionCookie {
cookie := c.NewCookie(true, false)
c.NewRequest(setClientVersionRequest(c, Major, Minor), cookie)
return SetClientVersionCookie{cookie}
}
func (cook SetClientVersionCookie) Check() error {
return cook.Cookie.Check()
}
// Write request to wire for SetClientVersion
func setClientVersionRequest(c *xgb.Conn, Major uint16, Minor uint16) []byte {
size := 8
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 14 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put16(buf[b:], Major)
b += 2
xgb.Put16(buf[b:], Minor)
b += 2
return buf
}
// Request SetGamma
// size: 32
type SetGammaCookie struct {
*xgb.Cookie
}
// Write request to wire for SetGamma
func SetGamma(c *xgb.Conn, Screen uint16, Red uint32, Green uint32, Blue uint32) SetGammaCookie {
cookie := c.NewCookie(false, false)
c.NewRequest(setGammaRequest(c, Screen, Red, Green, Blue), cookie)
return SetGammaCookie{cookie}
}
func SetGammaChecked(c *xgb.Conn, Screen uint16, Red uint32, Green uint32, Blue uint32) SetGammaCookie {
cookie := c.NewCookie(true, false)
c.NewRequest(setGammaRequest(c, Screen, Red, Green, Blue), cookie)
return SetGammaCookie{cookie}
}
func (cook SetGammaCookie) Check() error {
return cook.Cookie.Check()
}
// Write request to wire for SetGamma
func setGammaRequest(c *xgb.Conn, Screen uint16, Red uint32, Green uint32, Blue uint32) []byte {
size := 32
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 15 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put16(buf[b:], Screen)
b += 2
b += 2 // padding
xgb.Put32(buf[b:], Red)
b += 4
xgb.Put32(buf[b:], Green)
b += 4
xgb.Put32(buf[b:], Blue)
b += 4
b += 12 // padding
return buf
}
// Request GetGamma
// size: 32
type GetGammaCookie struct {
*xgb.Cookie
}
func GetGamma(c *xgb.Conn, Screen uint16) GetGammaCookie {
cookie := c.NewCookie(true, true)
c.NewRequest(getGammaRequest(c, Screen), cookie)
return GetGammaCookie{cookie}
}
func GetGammaUnchecked(c *xgb.Conn, Screen uint16) GetGammaCookie {
cookie := c.NewCookie(false, true)
c.NewRequest(getGammaRequest(c, Screen), cookie)
return GetGammaCookie{cookie}
}
// Request reply for GetGamma
// size: 32
type GetGammaReply struct {
Sequence uint16
Length uint32
// padding: 1 bytes
Red uint32
Green uint32
Blue uint32
// padding: 12 bytes
}
// Waits and reads reply data from request GetGamma
func (cook GetGammaCookie) Reply() (*GetGammaReply, error) {
buf, err := cook.Cookie.Reply()
if err != nil {
return nil, err
}
if buf == nil {
return nil, nil
}
return getGammaReply(buf), nil
}
// Read reply into structure from buffer for GetGamma
func getGammaReply(buf []byte) *GetGammaReply {
v := new(GetGammaReply)
b := 1 // skip reply determinant
b += 1 // padding
v.Sequence = xgb.Get16(buf[b:])
b += 2
v.Length = xgb.Get32(buf[b:]) // 4-byte units
b += 4
v.Red = xgb.Get32(buf[b:])
b += 4
v.Green = xgb.Get32(buf[b:])
b += 4
v.Blue = xgb.Get32(buf[b:])
b += 4
b += 12 // padding
return v
}
// Write request to wire for GetGamma
func getGammaRequest(c *xgb.Conn, Screen uint16) []byte {
size := 32
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 16 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put16(buf[b:], Screen)
b += 2
b += 26 // padding
return buf
}
// Request GetGammaRamp
// size: 8
type GetGammaRampCookie struct {
*xgb.Cookie
}
func GetGammaRamp(c *xgb.Conn, Screen uint16, Size uint16) GetGammaRampCookie {
cookie := c.NewCookie(true, true)
c.NewRequest(getGammaRampRequest(c, Screen, Size), cookie)
return GetGammaRampCookie{cookie}
}
func GetGammaRampUnchecked(c *xgb.Conn, Screen uint16, Size uint16) GetGammaRampCookie {
cookie := c.NewCookie(false, true)
c.NewRequest(getGammaRampRequest(c, Screen, Size), cookie)
return GetGammaRampCookie{cookie}
}
// Request reply for GetGammaRamp
// size: (((32 + xgb.Pad((((int(Size) + 1) & -2) * 2))) + xgb.Pad((((int(Size) + 1) & -2) * 2))) + xgb.Pad((((int(Size) + 1) & -2) * 2)))
type GetGammaRampReply struct {
Sequence uint16
Length uint32
// padding: 1 bytes
Size uint16
// padding: 22 bytes
Red []uint16 // size: xgb.Pad((((int(Size) + 1) & -2) * 2))
Green []uint16 // size: xgb.Pad((((int(Size) + 1) & -2) * 2))
Blue []uint16 // size: xgb.Pad((((int(Size) + 1) & -2) * 2))
}
// Waits and reads reply data from request GetGammaRamp
func (cook GetGammaRampCookie) Reply() (*GetGammaRampReply, error) {
buf, err := cook.Cookie.Reply()
if err != nil {
return nil, err
}
if buf == nil {
return nil, nil
}
return getGammaRampReply(buf), nil
}
// Read reply into structure from buffer for GetGammaRamp
func getGammaRampReply(buf []byte) *GetGammaRampReply {
v := new(GetGammaRampReply)
b := 1 // skip reply determinant
b += 1 // padding
v.Sequence = xgb.Get16(buf[b:])
b += 2
v.Length = xgb.Get32(buf[b:]) // 4-byte units
b += 4
v.Size = xgb.Get16(buf[b:])
b += 2
b += 22 // padding
v.Red = make([]uint16, ((int(v.Size) + 1) & -2))
for i := 0; i < int(((int(v.Size) + 1) & -2)); i++ {
v.Red[i] = xgb.Get16(buf[b:])
b += 2
}
b = xgb.Pad(b)
v.Green = make([]uint16, ((int(v.Size) + 1) & -2))
for i := 0; i < int(((int(v.Size) + 1) & -2)); i++ {
v.Green[i] = xgb.Get16(buf[b:])
b += 2
}
b = xgb.Pad(b)
v.Blue = make([]uint16, ((int(v.Size) + 1) & -2))
for i := 0; i < int(((int(v.Size) + 1) & -2)); i++ {
v.Blue[i] = xgb.Get16(buf[b:])
b += 2
}
b = xgb.Pad(b)
return v
}
// Write request to wire for GetGammaRamp
func getGammaRampRequest(c *xgb.Conn, Screen uint16, Size uint16) []byte {
size := 8
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 17 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put16(buf[b:], Screen)
b += 2
xgb.Put16(buf[b:], Size)
b += 2
return buf
}
// Request SetGammaRamp
// size: xgb.Pad((((8 + xgb.Pad((((int(Size) + 1) & -2) * 2))) + xgb.Pad((((int(Size) + 1) & -2) * 2))) + xgb.Pad((((int(Size) + 1) & -2) * 2))))
type SetGammaRampCookie struct {
*xgb.Cookie
}
// Write request to wire for SetGammaRamp
func SetGammaRamp(c *xgb.Conn, Screen uint16, Size uint16, Red []uint16, Green []uint16, Blue []uint16) SetGammaRampCookie {
cookie := c.NewCookie(false, false)
c.NewRequest(setGammaRampRequest(c, Screen, Size, Red, Green, Blue), cookie)
return SetGammaRampCookie{cookie}
}
func SetGammaRampChecked(c *xgb.Conn, Screen uint16, Size uint16, Red []uint16, Green []uint16, Blue []uint16) SetGammaRampCookie {
cookie := c.NewCookie(true, false)
c.NewRequest(setGammaRampRequest(c, Screen, Size, Red, Green, Blue), cookie)
return SetGammaRampCookie{cookie}
}
func (cook SetGammaRampCookie) Check() error {
return cook.Cookie.Check()
}
// Write request to wire for SetGammaRamp
func setGammaRampRequest(c *xgb.Conn, Screen uint16, Size uint16, Red []uint16, Green []uint16, Blue []uint16) []byte {
size := xgb.Pad((((8 + xgb.Pad((((int(Size) + 1) & -2) * 2))) + xgb.Pad((((int(Size) + 1) & -2) * 2))) + xgb.Pad((((int(Size) + 1) & -2) * 2))))
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 18 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put16(buf[b:], Screen)
b += 2
xgb.Put16(buf[b:], Size)
b += 2
for i := 0; i < int(((int(Size) + 1) & -2)); i++ {
xgb.Put16(buf[b:], Red[i])
b += 2
}
b = xgb.Pad(b)
for i := 0; i < int(((int(Size) + 1) & -2)); i++ {
xgb.Put16(buf[b:], Green[i])
b += 2
}
b = xgb.Pad(b)
for i := 0; i < int(((int(Size) + 1) & -2)); i++ {
xgb.Put16(buf[b:], Blue[i])
b += 2
}
b = xgb.Pad(b)
return buf
}
// Request GetGammaRampSize
// size: 8
type GetGammaRampSizeCookie struct {
*xgb.Cookie
}
func GetGammaRampSize(c *xgb.Conn, Screen uint16) GetGammaRampSizeCookie {
cookie := c.NewCookie(true, true)
c.NewRequest(getGammaRampSizeRequest(c, Screen), cookie)
return GetGammaRampSizeCookie{cookie}
}
func GetGammaRampSizeUnchecked(c *xgb.Conn, Screen uint16) GetGammaRampSizeCookie {
cookie := c.NewCookie(false, true)
c.NewRequest(getGammaRampSizeRequest(c, Screen), cookie)
return GetGammaRampSizeCookie{cookie}
}
// Request reply for GetGammaRampSize
// size: 32
type GetGammaRampSizeReply struct {
Sequence uint16
Length uint32
// padding: 1 bytes
Size uint16
// padding: 22 bytes
}
// Waits and reads reply data from request GetGammaRampSize
func (cook GetGammaRampSizeCookie) Reply() (*GetGammaRampSizeReply, error) {
buf, err := cook.Cookie.Reply()
if err != nil {
return nil, err
}
if buf == nil {
return nil, nil
}
return getGammaRampSizeReply(buf), nil
}
// Read reply into structure from buffer for GetGammaRampSize
func getGammaRampSizeReply(buf []byte) *GetGammaRampSizeReply {
v := new(GetGammaRampSizeReply)
b := 1 // skip reply determinant
b += 1 // padding
v.Sequence = xgb.Get16(buf[b:])
b += 2
v.Length = xgb.Get32(buf[b:]) // 4-byte units
b += 4
v.Size = xgb.Get16(buf[b:])
b += 2
b += 22 // padding
return v
}
// Write request to wire for GetGammaRampSize
func getGammaRampSizeRequest(c *xgb.Conn, Screen uint16) []byte {
size := 8
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 19 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put16(buf[b:], Screen)
b += 2
b += 2 // padding
return buf
}
// Request GetPermissions
// size: 8
type GetPermissionsCookie struct {
*xgb.Cookie
}
func GetPermissions(c *xgb.Conn, Screen uint16) GetPermissionsCookie {
cookie := c.NewCookie(true, true)
c.NewRequest(getPermissionsRequest(c, Screen), cookie)
return GetPermissionsCookie{cookie}
}
func GetPermissionsUnchecked(c *xgb.Conn, Screen uint16) GetPermissionsCookie {
cookie := c.NewCookie(false, true)
c.NewRequest(getPermissionsRequest(c, Screen), cookie)
return GetPermissionsCookie{cookie}
}
// Request reply for GetPermissions
// size: 32
type GetPermissionsReply struct {
Sequence uint16
Length uint32
// padding: 1 bytes
Permissions uint32
// padding: 20 bytes
}
// Waits and reads reply data from request GetPermissions
func (cook GetPermissionsCookie) Reply() (*GetPermissionsReply, error) {
buf, err := cook.Cookie.Reply()
if err != nil {
return nil, err
}
if buf == nil {
return nil, nil
}
return getPermissionsReply(buf), nil
}
// Read reply into structure from buffer for GetPermissions
func getPermissionsReply(buf []byte) *GetPermissionsReply {
v := new(GetPermissionsReply)
b := 1 // skip reply determinant
b += 1 // padding
v.Sequence = xgb.Get16(buf[b:])
b += 2
v.Length = xgb.Get32(buf[b:]) // 4-byte units
b += 4
v.Permissions = xgb.Get32(buf[b:])
b += 4
b += 20 // padding
return v
}
// Write request to wire for GetPermissions
func getPermissionsRequest(c *xgb.Conn, Screen uint16) []byte {
size := 8
b := 0
buf := make([]byte, size)
buf[b] = c.Extensions["XFREE86-VIDMODEEXTENSION"]
b += 1
buf[b] = 20 // request opcode
b += 1
xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
b += 2
xgb.Put16(buf[b:], Screen)
b += 2
b += 2 // padding
return buf
}