656 lines
14 KiB
Go
656 lines
14 KiB
Go
package xgb
|
|
|
|
/*
|
|
This file was generated by xinerama.xml on May 10 2012 12:39:34pm EDT.
|
|
This file is automatically generated. Edit at your peril!
|
|
*/
|
|
|
|
// Imports are not necessary for XGB because everything is
|
|
// in one package. They are still listed here for reference.
|
|
// import "xproto"
|
|
|
|
// XineramaInit must be called before using the XINERAMA extension.
|
|
func (c *Conn) XineramaInit() error {
|
|
reply, err := c.QueryExtension(8, "XINERAMA").Reply()
|
|
switch {
|
|
case err != nil:
|
|
return err
|
|
case !reply.Present:
|
|
return errorf("No extension named XINERAMA could be found on on the server.")
|
|
}
|
|
|
|
c.extLock.Lock()
|
|
c.extensions["XINERAMA"] = reply.MajorOpcode
|
|
for evNum, fun := range newExtEventFuncs["XINERAMA"] {
|
|
newEventFuncs[int(reply.FirstEvent)+evNum] = fun
|
|
}
|
|
for errNum, fun := range newExtErrorFuncs["XINERAMA"] {
|
|
newErrorFuncs[int(reply.FirstError)+errNum] = fun
|
|
}
|
|
c.extLock.Unlock()
|
|
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["XINERAMA"] = make(map[int]newEventFun)
|
|
newExtErrorFuncs["XINERAMA"] = make(map[int]newErrorFun)
|
|
}
|
|
|
|
// 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'
|
|
|
|
// 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'
|
|
|
|
// 'XineramaScreenInfo' struct definition
|
|
// Size: 8
|
|
type XineramaScreenInfo struct {
|
|
XOrg int16
|
|
YOrg int16
|
|
Width uint16
|
|
Height uint16
|
|
}
|
|
|
|
// Struct read XineramaScreenInfo
|
|
func ReadXineramaScreenInfo(buf []byte, v *XineramaScreenInfo) int {
|
|
b := 0
|
|
|
|
v.XOrg = int16(Get16(buf[b:]))
|
|
b += 2
|
|
|
|
v.YOrg = int16(Get16(buf[b:]))
|
|
b += 2
|
|
|
|
v.Width = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Height = Get16(buf[b:])
|
|
b += 2
|
|
|
|
return b
|
|
}
|
|
|
|
// Struct list read XineramaScreenInfo
|
|
func ReadXineramaScreenInfoList(buf []byte, dest []XineramaScreenInfo) int {
|
|
b := 0
|
|
for i := 0; i < len(dest); i++ {
|
|
dest[i] = XineramaScreenInfo{}
|
|
b += ReadXineramaScreenInfo(buf[b:], &dest[i])
|
|
}
|
|
return pad(b)
|
|
}
|
|
|
|
// Struct write XineramaScreenInfo
|
|
func (v XineramaScreenInfo) Bytes() []byte {
|
|
buf := make([]byte, 8)
|
|
b := 0
|
|
|
|
Put16(buf[b:], uint16(v.XOrg))
|
|
b += 2
|
|
|
|
Put16(buf[b:], uint16(v.YOrg))
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.Width)
|
|
b += 2
|
|
|
|
Put16(buf[b:], v.Height)
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Write struct list XineramaScreenInfo
|
|
func XineramaScreenInfoListBytes(buf []byte, list []XineramaScreenInfo) int {
|
|
b := 0
|
|
var structBytes []byte
|
|
for _, item := range list {
|
|
structBytes = item.Bytes()
|
|
copy(buf[b:], structBytes)
|
|
b += pad(len(structBytes))
|
|
}
|
|
return b
|
|
}
|
|
|
|
// Request XineramaQueryVersion
|
|
// size: 8
|
|
type XineramaQueryVersionCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XineramaQueryVersion(Major byte, Minor byte) XineramaQueryVersionCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xineramaQueryVersionRequest(Major, Minor), cookie)
|
|
return XineramaQueryVersionCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XineramaQueryVersionUnchecked(Major byte, Minor byte) XineramaQueryVersionCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xineramaQueryVersionRequest(Major, Minor), cookie)
|
|
return XineramaQueryVersionCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XineramaQueryVersion
|
|
// size: 12
|
|
type XineramaQueryVersionReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
Major uint16
|
|
Minor uint16
|
|
}
|
|
|
|
// Waits and reads reply data from request XineramaQueryVersion
|
|
func (cook XineramaQueryVersionCookie) Reply() (*XineramaQueryVersionReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xineramaQueryVersionReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XineramaQueryVersion
|
|
func xineramaQueryVersionReply(buf []byte) *XineramaQueryVersionReply {
|
|
v := new(XineramaQueryVersionReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.Major = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Minor = Get16(buf[b:])
|
|
b += 2
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XineramaQueryVersionCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XineramaQueryVersion
|
|
func (c *Conn) xineramaQueryVersionRequest(Major byte, Minor byte) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINERAMA"]
|
|
b += 1
|
|
|
|
buf[b] = 0 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
buf[b] = Major
|
|
b += 1
|
|
|
|
buf[b] = Minor
|
|
b += 1
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XineramaGetState
|
|
// size: 8
|
|
type XineramaGetStateCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XineramaGetState(Window Window) XineramaGetStateCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xineramaGetStateRequest(Window), cookie)
|
|
return XineramaGetStateCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XineramaGetStateUnchecked(Window Window) XineramaGetStateCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xineramaGetStateRequest(Window), cookie)
|
|
return XineramaGetStateCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XineramaGetState
|
|
// size: 12
|
|
type XineramaGetStateReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
State byte
|
|
Window Window
|
|
}
|
|
|
|
// Waits and reads reply data from request XineramaGetState
|
|
func (cook XineramaGetStateCookie) Reply() (*XineramaGetStateReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xineramaGetStateReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XineramaGetState
|
|
func xineramaGetStateReply(buf []byte) *XineramaGetStateReply {
|
|
v := new(XineramaGetStateReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
v.State = buf[b]
|
|
b += 1
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.Window = Window(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XineramaGetStateCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XineramaGetState
|
|
func (c *Conn) xineramaGetStateRequest(Window Window) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINERAMA"]
|
|
b += 1
|
|
|
|
buf[b] = 1 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(Window))
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XineramaGetScreenCount
|
|
// size: 8
|
|
type XineramaGetScreenCountCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XineramaGetScreenCount(Window Window) XineramaGetScreenCountCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xineramaGetScreenCountRequest(Window), cookie)
|
|
return XineramaGetScreenCountCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XineramaGetScreenCountUnchecked(Window Window) XineramaGetScreenCountCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xineramaGetScreenCountRequest(Window), cookie)
|
|
return XineramaGetScreenCountCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XineramaGetScreenCount
|
|
// size: 12
|
|
type XineramaGetScreenCountReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
ScreenCount byte
|
|
Window Window
|
|
}
|
|
|
|
// Waits and reads reply data from request XineramaGetScreenCount
|
|
func (cook XineramaGetScreenCountCookie) Reply() (*XineramaGetScreenCountReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xineramaGetScreenCountReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XineramaGetScreenCount
|
|
func xineramaGetScreenCountReply(buf []byte) *XineramaGetScreenCountReply {
|
|
v := new(XineramaGetScreenCountReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
v.ScreenCount = buf[b]
|
|
b += 1
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.Window = Window(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XineramaGetScreenCountCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XineramaGetScreenCount
|
|
func (c *Conn) xineramaGetScreenCountRequest(Window Window) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINERAMA"]
|
|
b += 1
|
|
|
|
buf[b] = 2 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(Window))
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XineramaGetScreenSize
|
|
// size: 12
|
|
type XineramaGetScreenSizeCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XineramaGetScreenSize(Window Window, Screen uint32) XineramaGetScreenSizeCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xineramaGetScreenSizeRequest(Window, Screen), cookie)
|
|
return XineramaGetScreenSizeCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XineramaGetScreenSizeUnchecked(Window Window, Screen uint32) XineramaGetScreenSizeCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xineramaGetScreenSizeRequest(Window, Screen), cookie)
|
|
return XineramaGetScreenSizeCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XineramaGetScreenSize
|
|
// size: 24
|
|
type XineramaGetScreenSizeReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
Width uint32
|
|
Height uint32
|
|
Window Window
|
|
Screen uint32
|
|
}
|
|
|
|
// Waits and reads reply data from request XineramaGetScreenSize
|
|
func (cook XineramaGetScreenSizeCookie) Reply() (*XineramaGetScreenSizeReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xineramaGetScreenSizeReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XineramaGetScreenSize
|
|
func xineramaGetScreenSizeReply(buf []byte) *XineramaGetScreenSizeReply {
|
|
v := new(XineramaGetScreenSizeReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.Width = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.Height = Get32(buf[b:])
|
|
b += 4
|
|
|
|
v.Window = Window(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.Screen = Get32(buf[b:])
|
|
b += 4
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XineramaGetScreenSizeCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XineramaGetScreenSize
|
|
func (c *Conn) xineramaGetScreenSizeRequest(Window Window, Screen uint32) []byte {
|
|
size := 12
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINERAMA"]
|
|
b += 1
|
|
|
|
buf[b] = 3 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(Window))
|
|
b += 4
|
|
|
|
Put32(buf[b:], Screen)
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XineramaIsActive
|
|
// size: 4
|
|
type XineramaIsActiveCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XineramaIsActive() XineramaIsActiveCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xineramaIsActiveRequest(), cookie)
|
|
return XineramaIsActiveCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XineramaIsActiveUnchecked() XineramaIsActiveCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xineramaIsActiveRequest(), cookie)
|
|
return XineramaIsActiveCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XineramaIsActive
|
|
// size: 12
|
|
type XineramaIsActiveReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
State uint32
|
|
}
|
|
|
|
// Waits and reads reply data from request XineramaIsActive
|
|
func (cook XineramaIsActiveCookie) Reply() (*XineramaIsActiveReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xineramaIsActiveReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XineramaIsActive
|
|
func xineramaIsActiveReply(buf []byte) *XineramaIsActiveReply {
|
|
v := new(XineramaIsActiveReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.State = Get32(buf[b:])
|
|
b += 4
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XineramaIsActiveCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XineramaIsActive
|
|
func (c *Conn) xineramaIsActiveRequest() []byte {
|
|
size := 4
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINERAMA"]
|
|
b += 1
|
|
|
|
buf[b] = 4 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request XineramaQueryScreens
|
|
// size: 4
|
|
type XineramaQueryScreensCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) XineramaQueryScreens() XineramaQueryScreensCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.xineramaQueryScreensRequest(), cookie)
|
|
return XineramaQueryScreensCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) XineramaQueryScreensUnchecked() XineramaQueryScreensCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.xineramaQueryScreensRequest(), cookie)
|
|
return XineramaQueryScreensCookie{cookie}
|
|
}
|
|
|
|
// Request reply for XineramaQueryScreens
|
|
// size: (32 + pad((int(Number) * 8)))
|
|
type XineramaQueryScreensReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
// padding: 1 bytes
|
|
Number uint32
|
|
// padding: 20 bytes
|
|
ScreenInfo []XineramaScreenInfo // size: pad((int(Number) * 8))
|
|
}
|
|
|
|
// Waits and reads reply data from request XineramaQueryScreens
|
|
func (cook XineramaQueryScreensCookie) Reply() (*XineramaQueryScreensReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return xineramaQueryScreensReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for XineramaQueryScreens
|
|
func xineramaQueryScreensReply(buf []byte) *XineramaQueryScreensReply {
|
|
v := new(XineramaQueryScreensReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.Number = Get32(buf[b:])
|
|
b += 4
|
|
|
|
b += 20 // padding
|
|
|
|
v.ScreenInfo = make([]XineramaScreenInfo, v.Number)
|
|
b += ReadXineramaScreenInfoList(buf[b:], v.ScreenInfo)
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook XineramaQueryScreensCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for XineramaQueryScreens
|
|
func (c *Conn) xineramaQueryScreensRequest() []byte {
|
|
size := 4
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["XINERAMA"]
|
|
b += 1
|
|
|
|
buf[b] = 5 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
return buf
|
|
}
|