2362 lines
54 KiB
Go
2362 lines
54 KiB
Go
// Package xf86vidmode is the X client API for the XFree86-VidModeExtension extension.
|
|
package xf86vidmode
|
|
|
|
/*
|
|
This file was generated by xf86vidmode.xml on May 10 2012 8:04:32pm 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
|
|
}
|