diff options
| -rw-r--r-- | nexgb/glx/glx.go | 116 | ||||
| -rw-r--r-- | nexgb/randr/randr.go | 1427 | ||||
| -rw-r--r-- | nexgb/res/res.go | 533 | ||||
| -rw-r--r-- | nexgb/screensaver/screensaver.go | 37 | ||||
| -rw-r--r-- | nexgb/shm/shm.go | 164 | ||||
| -rw-r--r-- | nexgb/xfixes/xfixes.go | 164 | ||||
| -rw-r--r-- | nexgb/xproto/xproto.go | 58 |
7 files changed, 2454 insertions, 45 deletions
diff --git a/nexgb/glx/glx.go b/nexgb/glx/glx.go index 84d37b5..2db5798 100644 --- a/nexgb/glx/glx.go +++ b/nexgb/glx/glx.go @@ -495,6 +495,122 @@ func init() { type Bool32 uint32 +// BufferSwapComplete is the event number for a BufferSwapCompleteEvent. +const BufferSwapComplete = 1 + +type BufferSwapCompleteEvent struct { + Sequence uint16 + // padding: 1 bytes + EventType uint16 + // padding: 2 bytes + Drawable Drawable + UstHi uint32 + UstLo uint32 + MscHi uint32 + MscLo uint32 + Sbc uint32 +} + +// BufferSwapCompleteEventNew constructs a BufferSwapCompleteEvent value that implements xgb.Event from a byte slice. +func BufferSwapCompleteEventNew(buf []byte) xgb.Event { + v := BufferSwapCompleteEvent{} + b := 1 // don't read event number + + b += 1 // padding + + v.Sequence = xgb.Get16(buf[b:]) + b += 2 + + v.EventType = xgb.Get16(buf[b:]) + b += 2 + + b += 2 // padding + + v.Drawable = Drawable(xgb.Get32(buf[b:])) + b += 4 + + v.UstHi = xgb.Get32(buf[b:]) + b += 4 + + v.UstLo = xgb.Get32(buf[b:]) + b += 4 + + v.MscHi = xgb.Get32(buf[b:]) + b += 4 + + v.MscLo = xgb.Get32(buf[b:]) + b += 4 + + v.Sbc = xgb.Get32(buf[b:]) + b += 4 + + return v +} + +// Bytes writes a BufferSwapCompleteEvent value to a byte slice. +func (v BufferSwapCompleteEvent) Bytes() []byte { + buf := make([]byte, 32) + b := 0 + + // write event number + buf[b] = 1 + b += 1 + + b += 1 // padding + + b += 2 // skip sequence number + + xgb.Put16(buf[b:], v.EventType) + b += 2 + + b += 2 // padding + + xgb.Put32(buf[b:], uint32(v.Drawable)) + b += 4 + + xgb.Put32(buf[b:], v.UstHi) + b += 4 + + xgb.Put32(buf[b:], v.UstLo) + b += 4 + + xgb.Put32(buf[b:], v.MscHi) + b += 4 + + xgb.Put32(buf[b:], v.MscLo) + b += 4 + + xgb.Put32(buf[b:], v.Sbc) + b += 4 + + return buf +} + +// SequenceId returns the sequence id attached to the BufferSwapComplete event. +// Events without a sequence number (KeymapNotify) return 0. +// This is mostly used internally. +func (v BufferSwapCompleteEvent) SequenceId() uint16 { + return v.Sequence +} + +// String is a rudimentary string representation of BufferSwapCompleteEvent. +func (v BufferSwapCompleteEvent) String() string { + fieldVals := make([]string, 0, 9) + fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence)) + fieldVals = append(fieldVals, xgb.Sprintf("EventType: %d", v.EventType)) + fieldVals = append(fieldVals, xgb.Sprintf("Drawable: %d", v.Drawable)) + fieldVals = append(fieldVals, xgb.Sprintf("UstHi: %d", v.UstHi)) + fieldVals = append(fieldVals, xgb.Sprintf("UstLo: %d", v.UstLo)) + fieldVals = append(fieldVals, xgb.Sprintf("MscHi: %d", v.MscHi)) + fieldVals = append(fieldVals, xgb.Sprintf("MscLo: %d", v.MscLo)) + fieldVals = append(fieldVals, xgb.Sprintf("Sbc: %d", v.Sbc)) + return "BufferSwapComplete {" + xgb.StringsJoin(fieldVals, ", ") + "}" +} + +func init() { + xgb.NewExtEventFuncs["GLX"][1] = BufferSwapCompleteEventNew +} + type Context uint32 func NewContextId(c *xgb.Conn) (Context, error) { diff --git a/nexgb/randr/randr.go b/nexgb/randr/randr.go index 9eb8dc9..11e1230 100644 --- a/nexgb/randr/randr.go +++ b/nexgb/randr/randr.go @@ -176,6 +176,52 @@ func init() { xgb.NewExtErrorFuncs["RANDR"][0] = BadOutputErrorNew } +// BadBadProvider is the error number for a BadBadProvider. +const BadBadProvider = 3 + +type BadProviderError struct { + Sequence uint16 + NiceName string +} + +// BadProviderErrorNew constructs a BadProviderError value that implements xgb.Error from a byte slice. +func BadProviderErrorNew(buf []byte) xgb.Error { + v := BadProviderError{} + v.NiceName = "BadProvider" + + b := 1 // skip error determinant + b += 1 // don't read error number + + v.Sequence = xgb.Get16(buf[b:]) + b += 2 + + return v +} + +// SequenceId returns the sequence id attached to the BadBadProvider error. +// This is mostly used internally. +func (err BadProviderError) SequenceId() uint16 { + return err.Sequence +} + +// BadId returns the 'BadValue' number if one exists for the BadBadProvider error. If no bad value exists, 0 is returned. +func (err BadProviderError) BadId() uint32 { + return 0 +} + +// Error returns a rudimentary string representation of the BadBadProvider error. + +func (err BadProviderError) Error() string { + fieldVals := make([]string, 0, 0) + fieldVals = append(fieldVals, "NiceName: "+err.NiceName) + fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", err.Sequence)) + return "BadBadProvider {" + xgb.StringsJoin(fieldVals, ", ") + "}" +} + +func init() { + xgb.NewExtErrorFuncs["RANDR"][3] = BadProviderErrorNew +} + const ( ConnectionConnected = 0 ConnectionDisconnected = 1 @@ -459,9 +505,12 @@ func ModeInfoListBytes(buf []byte, list []ModeInfo) int { } const ( - NotifyCrtcChange = 0 - NotifyOutputChange = 1 - NotifyOutputProperty = 2 + NotifyCrtcChange = 0 + NotifyOutputChange = 1 + NotifyOutputProperty = 2 + NotifyProviderChange = 3 + NotifyProviderProperty = 4 + NotifyResourceChange = 5 ) // Notify is the event number for a NotifyEvent. @@ -539,10 +588,16 @@ func init() { // NotifyDataUnionCcNew(Cc CrtcChange) NotifyDataUnion // NotifyDataUnionOcNew(Oc OutputChange) NotifyDataUnion // NotifyDataUnionOpNew(Op OutputProperty) NotifyDataUnion +// NotifyDataUnionPcNew(Pc ProviderChange) NotifyDataUnion +// NotifyDataUnionPpNew(Pp ProviderProperty) NotifyDataUnion +// NotifyDataUnionRcNew(Rc ResourceChange) NotifyDataUnion type NotifyDataUnion struct { Cc CrtcChange Oc OutputChange Op OutputProperty + Pc ProviderChange + Pp ProviderProperty + Rc ResourceChange } // NotifyDataUnionCcNew constructs a new NotifyDataUnion union type with the Cc field. @@ -573,6 +628,18 @@ func NotifyDataUnionCcNew(Cc CrtcChange) NotifyDataUnion { v.Op = OutputProperty{} b += OutputPropertyRead(buf[b:], &v.Op) + b = 0 // always read the same bytes + v.Pc = ProviderChange{} + b += ProviderChangeRead(buf[b:], &v.Pc) + + b = 0 // always read the same bytes + v.Pp = ProviderProperty{} + b += ProviderPropertyRead(buf[b:], &v.Pp) + + b = 0 // always read the same bytes + v.Rc = ResourceChange{} + b += ResourceChangeRead(buf[b:], &v.Rc) + return v } @@ -604,6 +671,18 @@ func NotifyDataUnionOcNew(Oc OutputChange) NotifyDataUnion { v.Op = OutputProperty{} b += OutputPropertyRead(buf[b:], &v.Op) + b = 0 // always read the same bytes + v.Pc = ProviderChange{} + b += ProviderChangeRead(buf[b:], &v.Pc) + + b = 0 // always read the same bytes + v.Pp = ProviderProperty{} + b += ProviderPropertyRead(buf[b:], &v.Pp) + + b = 0 // always read the same bytes + v.Rc = ResourceChange{} + b += ResourceChangeRead(buf[b:], &v.Rc) + return v } @@ -635,6 +714,147 @@ func NotifyDataUnionOpNew(Op OutputProperty) NotifyDataUnion { v.Op = OutputProperty{} b += OutputPropertyRead(buf[b:], &v.Op) + b = 0 // always read the same bytes + v.Pc = ProviderChange{} + b += ProviderChangeRead(buf[b:], &v.Pc) + + b = 0 // always read the same bytes + v.Pp = ProviderProperty{} + b += ProviderPropertyRead(buf[b:], &v.Pp) + + b = 0 // always read the same bytes + v.Rc = ResourceChange{} + b += ResourceChangeRead(buf[b:], &v.Rc) + + return v +} + +// NotifyDataUnionPcNew constructs a new NotifyDataUnion union type with the Pc field. +func NotifyDataUnionPcNew(Pc ProviderChange) NotifyDataUnion { + var b int + buf := make([]byte, 28) + + { + structBytes := Pc.Bytes() + copy(buf[b:], structBytes) + b += xgb.Pad(len(structBytes)) + } + + // Create the Union type + v := NotifyDataUnion{} + + // Now copy buf into all fields + + b = 0 // always read the same bytes + v.Cc = CrtcChange{} + b += CrtcChangeRead(buf[b:], &v.Cc) + + b = 0 // always read the same bytes + v.Oc = OutputChange{} + b += OutputChangeRead(buf[b:], &v.Oc) + + b = 0 // always read the same bytes + v.Op = OutputProperty{} + b += OutputPropertyRead(buf[b:], &v.Op) + + b = 0 // always read the same bytes + v.Pc = ProviderChange{} + b += ProviderChangeRead(buf[b:], &v.Pc) + + b = 0 // always read the same bytes + v.Pp = ProviderProperty{} + b += ProviderPropertyRead(buf[b:], &v.Pp) + + b = 0 // always read the same bytes + v.Rc = ResourceChange{} + b += ResourceChangeRead(buf[b:], &v.Rc) + + return v +} + +// NotifyDataUnionPpNew constructs a new NotifyDataUnion union type with the Pp field. +func NotifyDataUnionPpNew(Pp ProviderProperty) NotifyDataUnion { + var b int + buf := make([]byte, 28) + + { + structBytes := Pp.Bytes() + copy(buf[b:], structBytes) + b += xgb.Pad(len(structBytes)) + } + + // Create the Union type + v := NotifyDataUnion{} + + // Now copy buf into all fields + + b = 0 // always read the same bytes + v.Cc = CrtcChange{} + b += CrtcChangeRead(buf[b:], &v.Cc) + + b = 0 // always read the same bytes + v.Oc = OutputChange{} + b += OutputChangeRead(buf[b:], &v.Oc) + + b = 0 // always read the same bytes + v.Op = OutputProperty{} + b += OutputPropertyRead(buf[b:], &v.Op) + + b = 0 // always read the same bytes + v.Pc = ProviderChange{} + b += ProviderChangeRead(buf[b:], &v.Pc) + + b = 0 // always read the same bytes + v.Pp = ProviderProperty{} + b += ProviderPropertyRead(buf[b:], &v.Pp) + + b = 0 // always read the same bytes + v.Rc = ResourceChange{} + b += ResourceChangeRead(buf[b:], &v.Rc) + + return v +} + +// NotifyDataUnionRcNew constructs a new NotifyDataUnion union type with the Rc field. +func NotifyDataUnionRcNew(Rc ResourceChange) NotifyDataUnion { + var b int + buf := make([]byte, 28) + + { + structBytes := Rc.Bytes() + copy(buf[b:], structBytes) + b += xgb.Pad(len(structBytes)) + } + + // Create the Union type + v := NotifyDataUnion{} + + // Now copy buf into all fields + + b = 0 // always read the same bytes + v.Cc = CrtcChange{} + b += CrtcChangeRead(buf[b:], &v.Cc) + + b = 0 // always read the same bytes + v.Oc = OutputChange{} + b += OutputChangeRead(buf[b:], &v.Oc) + + b = 0 // always read the same bytes + v.Op = OutputProperty{} + b += OutputPropertyRead(buf[b:], &v.Op) + + b = 0 // always read the same bytes + v.Pc = ProviderChange{} + b += ProviderChangeRead(buf[b:], &v.Pc) + + b = 0 // always read the same bytes + v.Pp = ProviderProperty{} + b += ProviderPropertyRead(buf[b:], &v.Pp) + + b = 0 // always read the same bytes + v.Rc = ResourceChange{} + b += ResourceChangeRead(buf[b:], &v.Rc) + return v } @@ -654,6 +874,18 @@ func NotifyDataUnionRead(buf []byte, v *NotifyDataUnion) int { v.Op = OutputProperty{} b += OutputPropertyRead(buf[b:], &v.Op) + b = 0 // re-read the same bytes + v.Pc = ProviderChange{} + b += ProviderChangeRead(buf[b:], &v.Pc) + + b = 0 // re-read the same bytes + v.Pp = ProviderProperty{} + b += ProviderPropertyRead(buf[b:], &v.Pp) + + b = 0 // re-read the same bytes + v.Rc = ResourceChange{} + b += ResourceChangeRead(buf[b:], &v.Rc) + return 28 } @@ -682,7 +914,7 @@ func (v NotifyDataUnion) Bytes() []byte { return buf } -// NotifyDataUnionListBytes writes a list of %s(MISSING) values to a byte slice. +// NotifyDataUnionListBytes writes a list of NotifyDataUnion values to a byte slice. func NotifyDataUnionListBytes(buf []byte, list []NotifyDataUnion) int { b := 0 var unionBytes []byte @@ -695,10 +927,13 @@ func NotifyDataUnionListBytes(buf []byte, list []NotifyDataUnion) int { } const ( - NotifyMaskScreenChange = 1 - NotifyMaskCrtcChange = 2 - NotifyMaskOutputChange = 4 - NotifyMaskOutputProperty = 8 + NotifyMaskScreenChange = 1 + NotifyMaskCrtcChange = 2 + NotifyMaskOutputChange = 4 + NotifyMaskOutputProperty = 8 + NotifyMaskProviderChange = 16 + NotifyMaskProviderProperty = 32 + NotifyMaskResourceChange = 64 ) type Output uint32 @@ -894,6 +1129,169 @@ func OutputPropertyListBytes(buf []byte, list []OutputProperty) int { return xgb.Pad(b) } +type Provider uint32 + +func NewProviderId(c *xgb.Conn) (Provider, error) { + id, err := c.NewId() + if err != nil { + return 0, err + } + return Provider(id), nil +} + +const ( + ProviderCapabilitySourceOutput = 1 + ProviderCapabilitySinkOutput = 2 + ProviderCapabilitySourceOffload = 4 + ProviderCapabilitySinkOffload = 8 +) + +type ProviderChange struct { + Timestamp xproto.Timestamp + Window xproto.Window + Provider Provider + // padding: 16 bytes +} + +// ProviderChangeRead reads a byte slice into a ProviderChange value. +func ProviderChangeRead(buf []byte, v *ProviderChange) int { + b := 0 + + v.Timestamp = xproto.Timestamp(xgb.Get32(buf[b:])) + b += 4 + + v.Window = xproto.Window(xgb.Get32(buf[b:])) + b += 4 + + v.Provider = Provider(xgb.Get32(buf[b:])) + b += 4 + + b += 16 // padding + + return b +} + +// ProviderChangeReadList reads a byte slice into a list of ProviderChange values. +func ProviderChangeReadList(buf []byte, dest []ProviderChange) int { + b := 0 + for i := 0; i < len(dest); i++ { + dest[i] = ProviderChange{} + b += ProviderChangeRead(buf[b:], &dest[i]) + } + return xgb.Pad(b) +} + +// Bytes writes a ProviderChange value to a byte slice. +func (v ProviderChange) Bytes() []byte { + buf := make([]byte, 28) + b := 0 + + xgb.Put32(buf[b:], uint32(v.Timestamp)) + b += 4 + + xgb.Put32(buf[b:], uint32(v.Window)) + b += 4 + + xgb.Put32(buf[b:], uint32(v.Provider)) + b += 4 + + b += 16 // padding + + return buf +} + +// ProviderChangeListBytes writes a list of ProviderChange values to a byte slice. +func ProviderChangeListBytes(buf []byte, list []ProviderChange) int { + b := 0 + var structBytes []byte + for _, item := range list { + structBytes = item.Bytes() + copy(buf[b:], structBytes) + b += len(structBytes) + } + return xgb.Pad(b) +} + +type ProviderProperty struct { + Window xproto.Window + Provider Provider + Atom xproto.Atom + Timestamp xproto.Timestamp + State byte + // padding: 11 bytes +} + +// ProviderPropertyRead reads a byte slice into a ProviderProperty value. +func ProviderPropertyRead(buf []byte, v *ProviderProperty) int { + b := 0 + + v.Window = xproto.Window(xgb.Get32(buf[b:])) + b += 4 + + v.Provider = Provider(xgb.Get32(buf[b:])) + b += 4 + + v.Atom = xproto.Atom(xgb.Get32(buf[b:])) + b += 4 + + v.Timestamp = xproto.Timestamp(xgb.Get32(buf[b:])) + b += 4 + + v.State = buf[b] + b += 1 + + b += 11 // padding + + return b +} + +// ProviderPropertyReadList reads a byte slice into a list of ProviderProperty values. +func ProviderPropertyReadList(buf []byte, dest []ProviderProperty) int { + b := 0 + for i := 0; i < len(dest); i++ { + dest[i] = ProviderProperty{} + b += ProviderPropertyRead(buf[b:], &dest[i]) + } + return xgb.Pad(b) +} + +// Bytes writes a ProviderProperty value to a byte slice. +func (v ProviderProperty) Bytes() []byte { + buf := make([]byte, 28) + b := 0 + + xgb.Put32(buf[b:], uint32(v.Window)) + b += 4 + + xgb.Put32(buf[b:], uint32(v.Provider)) + b += 4 + + xgb.Put32(buf[b:], uint32(v.Atom)) + b += 4 + + xgb.Put32(buf[b:], uint32(v.Timestamp)) + b += 4 + + buf[b] = v.State + b += 1 + + b += 11 // padding + + return buf +} + +// ProviderPropertyListBytes writes a list of ProviderProperty values to a byte slice. +func ProviderPropertyListBytes(buf []byte, list []ProviderProperty) int { + b := 0 + var structBytes []byte + for _, item := range list { + structBytes = item.Bytes() + copy(buf[b:], structBytes) + b += len(structBytes) + } + return xgb.Pad(b) +} + type RefreshRates struct { NRates uint16 Rates []uint16 // size: xgb.Pad((int(NRates) * 2)) @@ -964,6 +1362,65 @@ func RefreshRatesListSize(list []RefreshRates) int { return size } +type ResourceChange struct { + Timestamp xproto.Timestamp + Window xproto.Window + // padding: 20 bytes +} + +// ResourceChangeRead reads a byte slice into a ResourceChange value. +func ResourceChangeRead(buf []byte, v *ResourceChange) int { + b := 0 + + v.Timestamp = xproto.Timestamp(xgb.Get32(buf[b:])) + b += 4 + + v.Window = xproto.Window(xgb.Get32(buf[b:])) + b += 4 + + b += 20 // padding + + return b +} + +// ResourceChangeReadList reads a byte slice into a list of ResourceChange values. +func ResourceChangeReadList(buf []byte, dest []ResourceChange) int { + b := 0 + for i := 0; i < len(dest); i++ { + dest[i] = ResourceChange{} + b += ResourceChangeRead(buf[b:], &dest[i]) + } + return xgb.Pad(b) +} + +// Bytes writes a ResourceChange value to a byte slice. +func (v ResourceChange) Bytes() []byte { + buf := make([]byte, 28) + b := 0 + + xgb.Put32(buf[b:], uint32(v.Timestamp)) + b += 4 + + xgb.Put32(buf[b:], uint32(v.Window)) + b += 4 + + b += 20 // padding + + return buf +} + +// ResourceChangeListBytes writes a list of ResourceChange values to a byte slice. +func ResourceChangeListBytes(buf []byte, list []ResourceChange) int { + b := 0 + var structBytes []byte + for _, item := range list { + structBytes = item.Bytes() + copy(buf[b:], structBytes) + b += len(structBytes) + } + return xgb.Pad(b) +} + const ( RotationRotate0 = 1 RotationRotate90 = 2 @@ -1186,6 +1643,13 @@ const ( SetConfigFailed = 3 ) +const ( + TransformUnit = 1 + TransformScaleUp = 2 + TransformScaleDown = 4 + TransformProjective = 8 +) + // Skipping definition for base type 'Bool' // Skipping definition for base type 'Byte' @@ -1343,6 +1807,81 @@ func changeOutputPropertyRequest(c *xgb.Conn, Output Output, Property xproto.Ato return buf } +// ChangeProviderPropertyCookie is a cookie used only for ChangeProviderProperty requests. +type ChangeProviderPropertyCookie struct { + *xgb.Cookie +} + +// ChangeProviderProperty sends an unchecked request. +// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent. +func ChangeProviderProperty(c *xgb.Conn, Provider Provider, Property xproto.Atom, Type xproto.Atom, Format byte, Mode byte, NumItems uint32, Data []byte) ChangeProviderPropertyCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'ChangeProviderProperty' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(false, false) + c.NewRequest(changeProviderPropertyRequest(c, Provider, Property, Type, Format, Mode, NumItems, Data), cookie) + return ChangeProviderPropertyCookie{cookie} +} + +// ChangeProviderPropertyChecked sends a checked request. +// If an error occurs, it can be retrieved using ChangeProviderPropertyCookie.Check() +func ChangeProviderPropertyChecked(c *xgb.Conn, Provider Provider, Property xproto.Atom, Type xproto.Atom, Format byte, Mode byte, NumItems uint32, Data []byte) ChangeProviderPropertyCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'ChangeProviderProperty' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(true, false) + c.NewRequest(changeProviderPropertyRequest(c, Provider, Property, Type, Format, Mode, NumItems, Data), cookie) + return ChangeProviderPropertyCookie{cookie} +} + +// Check returns an error if one occurred for checked requests that are not expecting a reply. +// This cannot be called for requests expecting a reply, nor for unchecked requests. +func (cook ChangeProviderPropertyCookie) Check() error { + return cook.Cookie.Check() +} + +// Write request to wire for ChangeProviderProperty +// changeProviderPropertyRequest writes a ChangeProviderProperty request to a byte slice. +func changeProviderPropertyRequest(c *xgb.Conn, Provider Provider, Property xproto.Atom, Type xproto.Atom, Format byte, Mode byte, NumItems uint32, Data []byte) []byte { + size := xgb.Pad((24 + xgb.Pad(((int(NumItems) * (int(Format) / 8)) * 1)))) + b := 0 + buf := make([]byte, size) + + buf[b] = c.Extensions["RANDR"] + b += 1 + + buf[b] = 39 // request opcode + b += 1 + + xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units + b += 2 + + xgb.Put32(buf[b:], uint32(Provider)) + b += 4 + + xgb.Put32(buf[b:], uint32(Property)) + b += 4 + + xgb.Put32(buf[b:], uint32(Type)) + b += 4 + + buf[b] = Format + b += 1 + + buf[b] = Mode + b += 1 + + b += 2 // padding + + xgb.Put32(buf[b:], NumItems) + b += 4 + + copy(buf[b:], Data[:(int(NumItems)*(int(Format)/8))]) + b += xgb.Pad(int((int(NumItems) * (int(Format) / 8)))) + + return buf +} + // ConfigureOutputPropertyCookie is a cookie used only for ConfigureOutputProperty requests. type ConfigureOutputPropertyCookie struct { *xgb.Cookie @@ -1423,6 +1962,86 @@ func configureOutputPropertyRequest(c *xgb.Conn, Output Output, Property xproto. return buf } +// ConfigureProviderPropertyCookie is a cookie used only for ConfigureProviderProperty requests. +type ConfigureProviderPropertyCookie struct { + *xgb.Cookie +} + +// ConfigureProviderProperty sends an unchecked request. +// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent. +func ConfigureProviderProperty(c *xgb.Conn, Provider Provider, Property xproto.Atom, Pending bool, Range bool, Values []int32) ConfigureProviderPropertyCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'ConfigureProviderProperty' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(false, false) + c.NewRequest(configureProviderPropertyRequest(c, Provider, Property, Pending, Range, Values), cookie) + return ConfigureProviderPropertyCookie{cookie} +} + +// ConfigureProviderPropertyChecked sends a checked request. +// If an error occurs, it can be retrieved using ConfigureProviderPropertyCookie.Check() +func ConfigureProviderPropertyChecked(c *xgb.Conn, Provider Provider, Property xproto.Atom, Pending bool, Range bool, Values []int32) ConfigureProviderPropertyCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'ConfigureProviderProperty' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(true, false) + c.NewRequest(configureProviderPropertyRequest(c, Provider, Property, Pending, Range, Values), cookie) + return ConfigureProviderPropertyCookie{cookie} +} + +// Check returns an error if one occurred for checked requests that are not expecting a reply. +// This cannot be called for requests expecting a reply, nor for unchecked requests. +func (cook ConfigureProviderPropertyCookie) Check() error { + return cook.Cookie.Check() +} + +// Write request to wire for ConfigureProviderProperty +// configureProviderPropertyRequest writes a ConfigureProviderProperty request to a byte slice. +func configureProviderPropertyRequest(c *xgb.Conn, Provider Provider, Property xproto.Atom, Pending bool, Range bool, Values []int32) []byte { + size := xgb.Pad((16 + xgb.Pad((len(Values) * 4)))) + b := 0 + buf := make([]byte, size) + + buf[b] = c.Extensions["RANDR"] + b += 1 + + buf[b] = 38 // request opcode + b += 1 + + xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units + b += 2 + + xgb.Put32(buf[b:], uint32(Provider)) + b += 4 + + xgb.Put32(buf[b:], uint32(Property)) + b += 4 + + if Pending { + buf[b] = 1 + } else { + buf[b] = 0 + } + b += 1 + + if Range { + buf[b] = 1 + } else { + buf[b] = 0 + } + b += 1 + + b += 2 // padding + + for i := 0; i < int(len(Values)); i++ { + xgb.Put32(buf[b:], uint32(Values[i])) + b += 4 + } + b = xgb.Pad(b) + + return buf +} + // CreateModeCookie is a cookie used only for CreateMode requests. type CreateModeCookie struct { *xgb.Cookie @@ -1639,6 +2258,64 @@ func deleteOutputPropertyRequest(c *xgb.Conn, Output Output, Property xproto.Ato return buf } +// DeleteProviderPropertyCookie is a cookie used only for DeleteProviderProperty requests. +type DeleteProviderPropertyCookie struct { + *xgb.Cookie +} + +// DeleteProviderProperty sends an unchecked request. +// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent. +func DeleteProviderProperty(c *xgb.Conn, Provider Provider, Property xproto.Atom) DeleteProviderPropertyCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'DeleteProviderProperty' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(false, false) + c.NewRequest(deleteProviderPropertyRequest(c, Provider, Property), cookie) + return DeleteProviderPropertyCookie{cookie} +} + +// DeleteProviderPropertyChecked sends a checked request. +// If an error occurs, it can be retrieved using DeleteProviderPropertyCookie.Check() +func DeleteProviderPropertyChecked(c *xgb.Conn, Provider Provider, Property xproto.Atom) DeleteProviderPropertyCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'DeleteProviderProperty' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(true, false) + c.NewRequest(deleteProviderPropertyRequest(c, Provider, Property), cookie) + return DeleteProviderPropertyCookie{cookie} +} + +// Check returns an error if one occurred for checked requests that are not expecting a reply. +// This cannot be called for requests expecting a reply, nor for unchecked requests. +func (cook DeleteProviderPropertyCookie) Check() error { + return cook.Cookie.Check() +} + +// Write request to wire for DeleteProviderProperty +// deleteProviderPropertyRequest writes a DeleteProviderProperty request to a byte slice. +func deleteProviderPropertyRequest(c *xgb.Conn, Provider Provider, Property xproto.Atom) []byte { + size := 12 + b := 0 + buf := make([]byte, size) + + buf[b] = c.Extensions["RANDR"] + b += 1 + + buf[b] = 40 // request opcode + b += 1 + + xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units + b += 2 + + xgb.Put32(buf[b:], uint32(Provider)) + b += 4 + + xgb.Put32(buf[b:], uint32(Property)) + b += 4 + + return buf +} + // DestroyModeCookie is a cookie used only for DestroyMode requests. type DestroyModeCookie struct { *xgb.Cookie @@ -2717,6 +3394,397 @@ func getPanningRequest(c *xgb.Conn, Crtc Crtc) []byte { return buf } +// GetProviderInfoCookie is a cookie used only for GetProviderInfo requests. +type GetProviderInfoCookie struct { + *xgb.Cookie +} + +// GetProviderInfo sends a checked request. +// If an error occurs, it will be returned with the reply by calling GetProviderInfoCookie.Reply() +func GetProviderInfo(c *xgb.Conn, Provider Provider, ConfigTimestamp xproto.Timestamp) GetProviderInfoCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'GetProviderInfo' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(true, true) + c.NewRequest(getProviderInfoRequest(c, Provider, ConfigTimestamp), cookie) + return GetProviderInfoCookie{cookie} +} + +// GetProviderInfoUnchecked sends an unchecked request. +// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent. +func GetProviderInfoUnchecked(c *xgb.Conn, Provider Provider, ConfigTimestamp xproto.Timestamp) GetProviderInfoCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'GetProviderInfo' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(false, true) + c.NewRequest(getProviderInfoRequest(c, Provider, ConfigTimestamp), cookie) + return GetProviderInfoCookie{cookie} +} + +// GetProviderInfoReply represents the data returned from a GetProviderInfo request. +type GetProviderInfoReply struct { + Sequence uint16 // sequence number of the request for this reply + Length uint32 // number of bytes in this reply + Status byte + Timestamp xproto.Timestamp + Capabilities uint32 + NumCrtcs uint16 + NumOutputs uint16 + NumAssociatedProviders uint16 + NameLen uint16 + // padding: 8 bytes + Crtcs []Crtc // size: xgb.Pad((int(NumCrtcs) * 4)) + Outputs []Output // size: xgb.Pad((int(NumOutputs) * 4)) + AssociatedProviders []Provider // size: xgb.Pad((int(NumAssociatedProviders) * 4)) + AssociatedCapability []uint32 // size: xgb.Pad((int(NumAssociatedProviders) * 4)) + Name string // size: xgb.Pad((int(NameLen) * 1)) +} + +// Reply blocks and returns the reply data for a GetProviderInfo request. +func (cook GetProviderInfoCookie) Reply() (*GetProviderInfoReply, error) { + buf, err := cook.Cookie.Reply() + if err != nil { + return nil, err + } + if buf == nil { + return nil, nil + } + return getProviderInfoReply(buf), nil +} + +// getProviderInfoReply reads a byte slice into a GetProviderInfoReply value. +func getProviderInfoReply(buf []byte) *GetProviderInfoReply { + v := new(GetProviderInfoReply) + b := 1 // skip reply determinant + + v.Status = buf[b] + b += 1 + + v.Sequence = xgb.Get16(buf[b:]) + b += 2 + + v.Length = xgb.Get32(buf[b:]) // 4-byte units + b += 4 + + v.Timestamp = xproto.Timestamp(xgb.Get32(buf[b:])) + b += 4 + + v.Capabilities = xgb.Get32(buf[b:]) + b += 4 + + v.NumCrtcs = xgb.Get16(buf[b:]) + b += 2 + + v.NumOutputs = xgb.Get16(buf[b:]) + b += 2 + + v.NumAssociatedProviders = xgb.Get16(buf[b:]) + b += 2 + + v.NameLen = xgb.Get16(buf[b:]) + b += 2 + + b += 8 // padding + + v.Crtcs = make([]Crtc, v.NumCrtcs) + for i := 0; i < int(v.NumCrtcs); i++ { + v.Crtcs[i] = Crtc(xgb.Get32(buf[b:])) + b += 4 + } + b = xgb.Pad(b) + + v.Outputs = make([]Output, v.NumOutputs) + for i := 0; i < int(v.NumOutputs); i++ { + v.Outputs[i] = Output(xgb.Get32(buf[b:])) + b += 4 + } + b = xgb.Pad(b) + + v.AssociatedProviders = make([]Provider, v.NumAssociatedProviders) + for i := 0; i < int(v.NumAssociatedProviders); i++ { + v.AssociatedProviders[i] = Provider(xgb.Get32(buf[b:])) + b += 4 + } + b = xgb.Pad(b) + + v.AssociatedCapability = make([]uint32, v.NumAssociatedProviders) + for i := 0; i < int(v.NumAssociatedProviders); i++ { + v.AssociatedCapability[i] = xgb.Get32(buf[b:]) + b += 4 + } + b = xgb.Pad(b) + + { + byteString := make([]byte, v.NameLen) + copy(byteString[:v.NameLen], buf[b:]) + v.Name = string(byteString) + b += xgb.Pad(int(v.NameLen)) + } + + return v +} + +// Write request to wire for GetProviderInfo +// getProviderInfoRequest writes a GetProviderInfo request to a byte slice. +func getProviderInfoRequest(c *xgb.Conn, Provider Provider, ConfigTimestamp xproto.Timestamp) []byte { + size := 12 + b := 0 + buf := make([]byte, size) + + buf[b] = c.Extensions["RANDR"] + b += 1 + + buf[b] = 33 // request opcode + b += 1 + + xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units + b += 2 + + xgb.Put32(buf[b:], uint32(Provider)) + b += 4 + + xgb.Put32(buf[b:], uint32(ConfigTimestamp)) + b += 4 + + return buf +} + +// GetProviderPropertyCookie is a cookie used only for GetProviderProperty requests. +type GetProviderPropertyCookie struct { + *xgb.Cookie +} + +// GetProviderProperty sends a checked request. +// If an error occurs, it will be returned with the reply by calling GetProviderPropertyCookie.Reply() +func GetProviderProperty(c *xgb.Conn, Provider Provider, Property xproto.Atom, Type xproto.Atom, LongOffset uint32, LongLength uint32, Delete bool, Pending bool) GetProviderPropertyCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'GetProviderProperty' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(true, true) + c.NewRequest(getProviderPropertyRequest(c, Provider, Property, Type, LongOffset, LongLength, Delete, Pending), cookie) + return GetProviderPropertyCookie{cookie} +} + +// GetProviderPropertyUnchecked sends an unchecked request. +// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent. +func GetProviderPropertyUnchecked(c *xgb.Conn, Provider Provider, Property xproto.Atom, Type xproto.Atom, LongOffset uint32, LongLength uint32, Delete bool, Pending bool) GetProviderPropertyCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'GetProviderProperty' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(false, true) + c.NewRequest(getProviderPropertyRequest(c, Provider, Property, Type, LongOffset, LongLength, Delete, Pending), cookie) + return GetProviderPropertyCookie{cookie} +} + +// GetProviderPropertyReply represents the data returned from a GetProviderProperty request. +type GetProviderPropertyReply struct { + Sequence uint16 // sequence number of the request for this reply + Length uint32 // number of bytes in this reply + Format byte + Type xproto.Atom + BytesAfter uint32 + NumItems uint32 + // padding: 12 bytes + Data []byte // size: xgb.Pad(((int(NumItems) * (int(Format) / 8)) * 1)) +} + +// Reply blocks and returns the reply data for a GetProviderProperty request. +func (cook GetProviderPropertyCookie) Reply() (*GetProviderPropertyReply, error) { + buf, err := cook.Cookie.Reply() + if err != nil { + return nil, err + } + if buf == nil { + return nil, nil + } + return getProviderPropertyReply(buf), nil +} + +// getProviderPropertyReply reads a byte slice into a GetProviderPropertyReply value. +func getProviderPropertyReply(buf []byte) *GetProviderPropertyReply { + v := new(GetProviderPropertyReply) + b := 1 // skip reply determinant + + v.Format = buf[b] + b += 1 + + v.Sequence = xgb.Get16(buf[b:]) + b += 2 + + v.Length = xgb.Get32(buf[b:]) // 4-byte units + b += 4 + + v.Type = xproto.Atom(xgb.Get32(buf[b:])) + b += 4 + + v.BytesAfter = xgb.Get32(buf[b:]) + b += 4 + + v.NumItems = xgb.Get32(buf[b:]) + b += 4 + + b += 12 // padding + + v.Data = make([]byte, (int(v.NumItems) * (int(v.Format) / 8))) + copy(v.Data[:(int(v.NumItems)*(int(v.Format)/8))], buf[b:]) + b += xgb.Pad(int((int(v.NumItems) * (int(v.Format) / 8)))) + + return v +} + +// Write request to wire for GetProviderProperty +// getProviderPropertyRequest writes a GetProviderProperty request to a byte slice. +func getProviderPropertyRequest(c *xgb.Conn, Provider Provider, Property xproto.Atom, Type xproto.Atom, LongOffset uint32, LongLength uint32, Delete bool, Pending bool) []byte { + size := 28 + b := 0 + buf := make([]byte, size) + + buf[b] = c.Extensions["RANDR"] + b += 1 + + buf[b] = 41 // request opcode + b += 1 + + xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units + b += 2 + + xgb.Put32(buf[b:], uint32(Provider)) + b += 4 + + xgb.Put32(buf[b:], uint32(Property)) + b += 4 + + xgb.Put32(buf[b:], uint32(Type)) + b += 4 + + xgb.Put32(buf[b:], LongOffset) + b += 4 + + xgb.Put32(buf[b:], LongLength) + b += 4 + + if Delete { + buf[b] = 1 + } else { + buf[b] = 0 + } + b += 1 + + if Pending { + buf[b] = 1 + } else { + buf[b] = 0 + } + b += 1 + + b += 2 // padding + + return buf +} + +// GetProvidersCookie is a cookie used only for GetProviders requests. +type GetProvidersCookie struct { + *xgb.Cookie +} + +// GetProviders sends a checked request. +// If an error occurs, it will be returned with the reply by calling GetProvidersCookie.Reply() +func GetProviders(c *xgb.Conn, Window xproto.Window) GetProvidersCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'GetProviders' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(true, true) + c.NewRequest(getProvidersRequest(c, Window), cookie) + return GetProvidersCookie{cookie} +} + +// GetProvidersUnchecked sends an unchecked request. +// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent. +func GetProvidersUnchecked(c *xgb.Conn, Window xproto.Window) GetProvidersCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'GetProviders' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(false, true) + c.NewRequest(getProvidersRequest(c, Window), cookie) + return GetProvidersCookie{cookie} +} + +// GetProvidersReply represents the data returned from a GetProviders request. +type GetProvidersReply struct { + Sequence uint16 // sequence number of the request for this reply + Length uint32 // number of bytes in this reply + // padding: 1 bytes + Timestamp xproto.Timestamp + NumProviders uint16 + // padding: 18 bytes + Providers []Provider // size: xgb.Pad((int(NumProviders) * 4)) +} + +// Reply blocks and returns the reply data for a GetProviders request. +func (cook GetProvidersCookie) Reply() (*GetProvidersReply, error) { + buf, err := cook.Cookie.Reply() + if err != nil { + return nil, err + } + if buf == nil { + return nil, nil + } + return getProvidersReply(buf), nil +} + +// getProvidersReply reads a byte slice into a GetProvidersReply value. +func getProvidersReply(buf []byte) *GetProvidersReply { + v := new(GetProvidersReply) + 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.Timestamp = xproto.Timestamp(xgb.Get32(buf[b:])) + b += 4 + + v.NumProviders = xgb.Get16(buf[b:]) + b += 2 + + b += 18 // padding + + v.Providers = make([]Provider, v.NumProviders) + for i := 0; i < int(v.NumProviders); i++ { + v.Providers[i] = Provider(xgb.Get32(buf[b:])) + b += 4 + } + b = xgb.Pad(b) + + return v +} + +// Write request to wire for GetProviders +// getProvidersRequest writes a GetProviders request to a byte slice. +func getProvidersRequest(c *xgb.Conn, Window xproto.Window) []byte { + size := 8 + b := 0 + buf := make([]byte, size) + + buf[b] = c.Extensions["RANDR"] + b += 1 + + buf[b] = 32 // request opcode + b += 1 + + xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units + b += 2 + + xgb.Put32(buf[b:], uint32(Window)) + b += 4 + + return buf +} + // GetScreenInfoCookie is a cookie used only for GetScreenInfo requests. type GetScreenInfoCookie struct { *xgb.Cookie @@ -3319,6 +4387,105 @@ func listOutputPropertiesRequest(c *xgb.Conn, Output Output) []byte { return buf } +// ListProviderPropertiesCookie is a cookie used only for ListProviderProperties requests. +type ListProviderPropertiesCookie struct { + *xgb.Cookie +} + +// ListProviderProperties sends a checked request. +// If an error occurs, it will be returned with the reply by calling ListProviderPropertiesCookie.Reply() +func ListProviderProperties(c *xgb.Conn, Provider Provider) ListProviderPropertiesCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'ListProviderProperties' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(true, true) + c.NewRequest(listProviderPropertiesRequest(c, Provider), cookie) + return ListProviderPropertiesCookie{cookie} +} + +// ListProviderPropertiesUnchecked sends an unchecked request. +// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent. +func ListProviderPropertiesUnchecked(c *xgb.Conn, Provider Provider) ListProviderPropertiesCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'ListProviderProperties' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(false, true) + c.NewRequest(listProviderPropertiesRequest(c, Provider), cookie) + return ListProviderPropertiesCookie{cookie} +} + +// ListProviderPropertiesReply represents the data returned from a ListProviderProperties request. +type ListProviderPropertiesReply struct { + Sequence uint16 // sequence number of the request for this reply + Length uint32 // number of bytes in this reply + // padding: 1 bytes + NumAtoms uint16 + // padding: 22 bytes + Atoms []xproto.Atom // size: xgb.Pad((int(NumAtoms) * 4)) +} + +// Reply blocks and returns the reply data for a ListProviderProperties request. +func (cook ListProviderPropertiesCookie) Reply() (*ListProviderPropertiesReply, error) { + buf, err := cook.Cookie.Reply() + if err != nil { + return nil, err + } + if buf == nil { + return nil, nil + } + return listProviderPropertiesReply(buf), nil +} + +// listProviderPropertiesReply reads a byte slice into a ListProviderPropertiesReply value. +func listProviderPropertiesReply(buf []byte) *ListProviderPropertiesReply { + v := new(ListProviderPropertiesReply) + 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.NumAtoms = xgb.Get16(buf[b:]) + b += 2 + + b += 22 // padding + + v.Atoms = make([]xproto.Atom, v.NumAtoms) + for i := 0; i < int(v.NumAtoms); i++ { + v.Atoms[i] = xproto.Atom(xgb.Get32(buf[b:])) + b += 4 + } + b = xgb.Pad(b) + + return v +} + +// Write request to wire for ListProviderProperties +// listProviderPropertiesRequest writes a ListProviderProperties request to a byte slice. +func listProviderPropertiesRequest(c *xgb.Conn, Provider Provider) []byte { + size := 8 + b := 0 + buf := make([]byte, size) + + buf[b] = c.Extensions["RANDR"] + b += 1 + + buf[b] = 36 // request opcode + b += 1 + + xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units + b += 2 + + xgb.Put32(buf[b:], uint32(Provider)) + b += 4 + + return buf +} + // QueryOutputPropertyCookie is a cookie used only for QueryOutputProperty requests. type QueryOutputPropertyCookie struct { *xgb.Cookie @@ -3441,6 +4608,128 @@ func queryOutputPropertyRequest(c *xgb.Conn, Output Output, Property xproto.Atom return buf } +// QueryProviderPropertyCookie is a cookie used only for QueryProviderProperty requests. +type QueryProviderPropertyCookie struct { + *xgb.Cookie +} + +// QueryProviderProperty sends a checked request. +// If an error occurs, it will be returned with the reply by calling QueryProviderPropertyCookie.Reply() +func QueryProviderProperty(c *xgb.Conn, Provider Provider, Property xproto.Atom) QueryProviderPropertyCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'QueryProviderProperty' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(true, true) + c.NewRequest(queryProviderPropertyRequest(c, Provider, Property), cookie) + return QueryProviderPropertyCookie{cookie} +} + +// QueryProviderPropertyUnchecked sends an unchecked request. +// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent. +func QueryProviderPropertyUnchecked(c *xgb.Conn, Provider Provider, Property xproto.Atom) QueryProviderPropertyCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'QueryProviderProperty' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(false, true) + c.NewRequest(queryProviderPropertyRequest(c, Provider, Property), cookie) + return QueryProviderPropertyCookie{cookie} +} + +// QueryProviderPropertyReply represents the data returned from a QueryProviderProperty request. +type QueryProviderPropertyReply struct { + Sequence uint16 // sequence number of the request for this reply + Length uint32 // number of bytes in this reply + // padding: 1 bytes + Pending bool + Range bool + Immutable bool + // padding: 21 bytes + ValidValues []int32 // size: xgb.Pad((int(Length) * 4)) +} + +// Reply blocks and returns the reply data for a QueryProviderProperty request. +func (cook QueryProviderPropertyCookie) Reply() (*QueryProviderPropertyReply, error) { + buf, err := cook.Cookie.Reply() + if err != nil { + return nil, err + } + if buf == nil { + return nil, nil + } + return queryProviderPropertyReply(buf), nil +} + +// queryProviderPropertyReply reads a byte slice into a QueryProviderPropertyReply value. +func queryProviderPropertyReply(buf []byte) *QueryProviderPropertyReply { + v := new(QueryProviderPropertyReply) + 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 + + if buf[b] == 1 { + v.Pending = true + } else { + v.Pending = false + } + b += 1 + + if buf[b] == 1 { + v.Range = true + } else { + v.Range = false + } + b += 1 + + if buf[b] == 1 { + v.Immutable = true + } else { + v.Immutable = false + } + b += 1 + + b += 21 // padding + + v.ValidValues = make([]int32, v.Length) + for i := 0; i < int(v.Length); i++ { + v.ValidValues[i] = int32(xgb.Get32(buf[b:])) + b += 4 + } + b = xgb.Pad(b) + + return v +} + +// Write request to wire for QueryProviderProperty +// queryProviderPropertyRequest writes a QueryProviderProperty request to a byte slice. +func queryProviderPropertyRequest(c *xgb.Conn, Provider Provider, Property xproto.Atom) []byte { + size := 12 + b := 0 + buf := make([]byte, size) + + buf[b] = c.Extensions["RANDR"] + b += 1 + + buf[b] = 37 // request opcode + b += 1 + + xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units + b += 2 + + xgb.Put32(buf[b:], uint32(Provider)) + b += 4 + + xgb.Put32(buf[b:], uint32(Property)) + b += 4 + + return buf +} + // QueryVersionCookie is a cookie used only for QueryVersion requests. type QueryVersionCookie struct { *xgb.Cookie @@ -4056,6 +5345,128 @@ func setPanningRequest(c *xgb.Conn, Crtc Crtc, Timestamp xproto.Timestamp, Left return buf } +// SetProviderOffloadSinkCookie is a cookie used only for SetProviderOffloadSink requests. +type SetProviderOffloadSinkCookie struct { + *xgb.Cookie +} + +// SetProviderOffloadSink sends an unchecked request. +// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent. +func SetProviderOffloadSink(c *xgb.Conn, Provider Provider, SinkProvider Provider, ConfigTimestamp xproto.Timestamp) SetProviderOffloadSinkCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'SetProviderOffloadSink' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(false, false) + c.NewRequest(setProviderOffloadSinkRequest(c, Provider, SinkProvider, ConfigTimestamp), cookie) + return SetProviderOffloadSinkCookie{cookie} +} + +// SetProviderOffloadSinkChecked sends a checked request. +// If an error occurs, it can be retrieved using SetProviderOffloadSinkCookie.Check() +func SetProviderOffloadSinkChecked(c *xgb.Conn, Provider Provider, SinkProvider Provider, ConfigTimestamp xproto.Timestamp) SetProviderOffloadSinkCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'SetProviderOffloadSink' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(true, false) + c.NewRequest(setProviderOffloadSinkRequest(c, Provider, SinkProvider, ConfigTimestamp), cookie) + return SetProviderOffloadSinkCookie{cookie} +} + +// Check returns an error if one occurred for checked requests that are not expecting a reply. +// This cannot be called for requests expecting a reply, nor for unchecked requests. +func (cook SetProviderOffloadSinkCookie) Check() error { + return cook.Cookie.Check() +} + +// Write request to wire for SetProviderOffloadSink +// setProviderOffloadSinkRequest writes a SetProviderOffloadSink request to a byte slice. +func setProviderOffloadSinkRequest(c *xgb.Conn, Provider Provider, SinkProvider Provider, ConfigTimestamp xproto.Timestamp) []byte { + size := 16 + b := 0 + buf := make([]byte, size) + + buf[b] = c.Extensions["RANDR"] + b += 1 + + buf[b] = 34 // request opcode + b += 1 + + xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units + b += 2 + + xgb.Put32(buf[b:], uint32(Provider)) + b += 4 + + xgb.Put32(buf[b:], uint32(SinkProvider)) + b += 4 + + xgb.Put32(buf[b:], uint32(ConfigTimestamp)) + b += 4 + + return buf +} + +// SetProviderOutputSourceCookie is a cookie used only for SetProviderOutputSource requests. +type SetProviderOutputSourceCookie struct { + *xgb.Cookie +} + +// SetProviderOutputSource sends an unchecked request. +// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent. +func SetProviderOutputSource(c *xgb.Conn, Provider Provider, SourceProvider Provider, ConfigTimestamp xproto.Timestamp) SetProviderOutputSourceCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'SetProviderOutputSource' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(false, false) + c.NewRequest(setProviderOutputSourceRequest(c, Provider, SourceProvider, ConfigTimestamp), cookie) + return SetProviderOutputSourceCookie{cookie} +} + +// SetProviderOutputSourceChecked sends a checked request. +// If an error occurs, it can be retrieved using SetProviderOutputSourceCookie.Check() +func SetProviderOutputSourceChecked(c *xgb.Conn, Provider Provider, SourceProvider Provider, ConfigTimestamp xproto.Timestamp) SetProviderOutputSourceCookie { + if _, ok := c.Extensions["RANDR"]; !ok { + panic("Cannot issue request 'SetProviderOutputSource' using the uninitialized extension 'RANDR'. randr.Init(connObj) must be called first.") + } + cookie := c.NewCookie(true, false) + c.NewRequest(setProviderOutputSourceRequest(c, Provider, SourceProvider, ConfigTimestamp), cookie) + return SetProviderOutputSourceCookie{cookie} +} + +// Check returns an error if one occurred for checked requests that are not expecting a reply. +// This cannot be called for requests expecting a reply, nor for unchecked requests. +func (cook SetProviderOutputSourceCookie) Check() error { + return cook.Cookie.Check() +} + +// Write request to wire for SetProviderOutputSource +// setProviderOutputSourceRequest writes a SetProviderOutputSource request to a byte slice. +func setProviderOutputSourceRequest(c *xgb.Conn, Provider Provider, SourceProvider Provider, ConfigTimestamp xproto.Timestamp) []byte { + size := 16 + b := 0 + buf := make([]byte, size) + + buf[b] = c.Extensions["RANDR"] + b += 1 + + buf[b] = 35 // request opcode + b += 1 + + xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units + b += 2 + + xgb.Put32(buf[b:], uint32(Provider)) + b += 4 + + xgb.Put32(buf[b:], uint32(SourceProvider)) + b += 4 + + xgb.Put32(buf[b:], uint32(ConfigTimestamp)) + b += 4 + + return buf +} + // SetScreenConfigCookie is a cookie used only for SetScreenConfig requests. type SetScreenConfigCookie struct { *xgb.Cookie diff --git a/nexgb/res/res.go b/nexgb/res/res.go index 20da54a..43480ec 100644 --- a/nexgb/res/res.go +++ b/nexgb/res/res.go @@ -91,6 +91,342 @@ func ClientListBytes(buf []byte, list []Client) int { return xgb.Pad(b) } +const ( + ClientIdMaskClientXID = 1 + ClientIdMaskLocalClientPID = 2 +) + +type ClientIdSpec struct { + Client uint32 + Mask uint32 +} + +// ClientIdSpecRead reads a byte slice into a ClientIdSpec value. +func ClientIdSpecRead(buf []byte, v *ClientIdSpec) int { + b := 0 + + v.Client = xgb.Get32(buf[b:]) + b += 4 + + v.Mask = xgb.Get32(buf[b:]) + b += 4 + + return b +} + +// ClientIdSpecReadList reads a byte slice into a list of ClientIdSpec values. +func ClientIdSpecReadList(buf []byte, dest []ClientIdSpec) int { + b := 0 + for i := 0; i < len(dest); i++ { + dest[i] = ClientIdSpec{} + b += ClientIdSpecRead(buf[b:], &dest[i]) + } + return xgb.Pad(b) +} + +// Bytes writes a ClientIdSpec value to a byte slice. +func (v ClientIdSpec) Bytes() []byte { + buf := make([]byte, 8) + b := 0 + + xgb.Put32(buf[b:], v.Client) + b += 4 + + xgb.Put32(buf[b:], v.Mask) + b += 4 + + return buf +} + +// ClientIdSpecListBytes writes a list of ClientIdSpec values to a byte slice. +func ClientIdSpecListBytes(buf []byte, list []ClientIdSpec) int { + b := 0 + var structBytes []byte + for _, item := range list { + structBytes = item.Bytes() + copy(buf[b:], structBytes) + b += len(structBytes) + } + return xgb.Pad(b) +} + +type ClientIdValue struct { + Spec ClientIdSpec + Length uint32 + Value []uint32 // size: xgb.Pad((int(Length) * 4)) +} + +// ClientIdValueRead reads a byte slice into a ClientIdValue value. +func ClientIdValueRead(buf []byte, v *ClientIdValue) int { + b := 0 + + v.Spec = ClientIdSpec{} + b += ClientIdSpecRead(buf[b:], &v.Spec) + + v.Length = xgb.Get32(buf[b:]) + b += 4 + + v.Value = make([]uint32, v.Length) + for i := 0; i < int(v.Length); i++ { + v.Value[i] = xgb.Get32(buf[b:]) + b += 4 + } + b = xgb.Pad(b) + + return b +} + +// ClientIdValueReadList reads a byte slice into a list of ClientIdValue values. +func ClientIdValueReadList(buf []byte, dest []ClientIdValue) int { + b := 0 + for i := 0; i < len(dest); i++ { + dest[i] = ClientIdValue{} + b += ClientIdValueRead(buf[b:], &dest[i]) + } + return xgb.Pad(b) +} + +// Bytes writes a ClientIdValue value to a byte slice. +func (v ClientIdValue) Bytes() []byte { + buf := make([]byte, (12 + xgb.Pad((int(v.Length) * 4)))) + b := 0 + + { + structBytes := v.Spec.Bytes() + copy(buf[b:], structBytes) + b += xgb.Pad(len(structBytes)) + } + + xgb.Put32(buf[b:], v.Length) + b += 4 + + for i := 0; i < int(v.Length); i++ { + xgb.Put32(buf[b:], v.Value[i]) + b += 4 + } + b = xgb.Pad(b) + + return buf +} + +// ClientIdValueListBytes writes a list of ClientIdValue values to a byte slice. +func ClientIdValueListBytes(buf []byte, list []ClientIdValue) int { + b := 0 + var structBytes []byte + for _, item := range list { + structBytes = item.Bytes() + copy(buf[b:], structBytes) + b += len(structBytes) + } + return xgb.Pad(b) +} + +// ClientIdValueListSize computes the size (bytes) of a list of ClientIdValue values. +func ClientIdValueListSize(list []ClientIdValue) int { + size := 0 + for _, item := range list { + size += (12 + xgb.Pad((int(item.Length) * 4))) + } + return size +} + +type ResourceIdSpec struct { + Resource uint32 + Type uint32 +} + +// ResourceIdSpecRead reads a byte slice into a ResourceIdSpec value. +func ResourceIdSpecRead(buf []byte, v *ResourceIdSpec) int { + b := 0 + + v.Resource = xgb.Get32(buf[b:]) + b += 4 + + v.Type = xgb.Get32(buf[b:]) + b += 4 + + return b +} + +// ResourceIdSpecReadList reads a byte slice into a list of ResourceIdSpec values. +func ResourceIdSpecReadList(buf []byte, dest []ResourceIdSpec) int { + b := 0 + for i := 0; i < len(dest); i++ { + dest[i] = ResourceIdSpec{} + b += ResourceIdSpecRead(buf[b:], &dest[i]) + } + return xgb.Pad(b) +} + +// Bytes writes a ResourceIdSpec value to a byte slice. +func (v ResourceIdSpec) Bytes() []byte { + buf := make([]byte, 8) + b := 0 + + xgb.Put32(buf[b:], v.Resource) + b += 4 + + xgb.Put32(buf[b:], v.Type) + b += 4 + + return buf +} + +// ResourceIdSpecListBytes writes a list of ResourceIdSpec values to a byte slice. +func ResourceIdSpecListBytes(buf []byte, list []ResourceIdSpec) int { + b := 0 + var structBytes []byte + for _, item := range list { + structBytes = item.Bytes() + copy(buf[b:], structBytes) + b += len(structBytes) + } + return xgb.Pad(b) +} + +type ResourceSizeSpec struct { + Spec ResourceIdSpec + Bytes uint32 + RefCount uint32 + UseCount uint32 +} + +// ResourceSizeSpecRead reads a byte slice into a ResourceSizeSpec value. +func ResourceSizeSpecRead(buf []byte, v *ResourceSizeSpec) int { + b := 0 + + v.Spec = ResourceIdSpec{} + b += ResourceIdSpecRead(buf[b:], &v.Spec) + + v.Bytes = xgb.Get32(buf[b:]) + b += 4 + + v.RefCount = xgb.Get32(buf[b:]) + b += 4 + + v.UseCount = xgb.Get32(buf[b:]) + b += 4 + + return b +} + +// ResourceSizeSpecReadList reads a byte slice into a list of ResourceSizeSpec values. +func ResourceSizeSpecReadList(buf []byte, dest []ResourceSizeSpec) int { + b := 0 + for i := 0; i < len(dest); i++ { + dest[i] = ResourceSizeSpec{} + b += ResourceSizeSpecRead(buf[b:], &dest[i]) + } + return xgb.Pad(b) +} + +// Bytes writes a ResourceSizeSpec value to a byte slice. +func (v ResourceSizeSpec) Bytes() []byte { + buf := make([]byte, 20) + b := 0 + + { + structBytes := v.Spec.Bytes() + copy(buf[b:], structBytes) + b += xgb.Pad(len(structBytes)) + } + + xgb.Put32(buf[b:], v.Bytes) + b += 4 + + xgb.Put32(buf[b:], v.RefCount) + b += 4 + + xgb.Put32(buf[b:], v.UseCount) + b += 4 + + return buf +} + +// ResourceSizeSpecListBytes writes a list of ResourceSizeSpec values to a byte slice. +func ResourceSizeSpecListBytes(buf []byte, list []ResourceSizeSpec) int { + b := 0 + var structBytes []byte + for _, item := range list { + structBytes = item.Bytes() + copy(buf[b:], structBytes) + b += len(structBytes) + } + return xgb.Pad(b) +} + +type ResourceSizeValue struct { + Size ResourceSizeSpec + NumCrossReferences uint32 + CrossReferences []ResourceSizeSpec // size: xgb.Pad((int(NumCrossReferences) * 20)) +} + +// ResourceSizeValueRead reads a byte slice into a ResourceSizeValue value. +func ResourceSizeValueRead(buf []byte, v *ResourceSizeValue) int { + b := 0 + + v.Size = ResourceSizeSpec{} + b += ResourceSizeSpecRead(buf[b:], &v.Size) + + v.NumCrossReferences = xgb.Get32(buf[b:]) + b += 4 + + v.CrossReferences = make([]ResourceSizeSpec, v.NumCrossReferences) + b += ResourceSizeSpecReadList(buf[b:], v.CrossReferences) + + return b +} + +// ResourceSizeValueReadList reads a byte slice into a list of ResourceSizeValue values. +func ResourceSizeValueReadList(buf []byte, dest []ResourceSizeValue) int { + b := 0 + for i := 0; i < len(dest); i++ { + dest[i] = ResourceSizeValue{} + b += ResourceSizeValueRead(buf[b:], &dest[i]) + } + return xgb.Pad(b) +} + +// Bytes writes a ResourceSizeValue value to a byte slice. +func (v ResourceSizeValue) Bytes() []byte { + buf := make([]byte, (24 + xgb.Pad((int(v.NumCrossReferences) * 20)))) + b := 0 + + { + structBytes := v.Size.Bytes() + copy(buf[b:], structBytes) + b += xgb.Pad(len(structBytes)) + } + + xgb.Put32(buf[b:], v.NumCrossReferences) + b += 4 + + b += ResourceSizeSpecListBytes(buf[b:], v.CrossReferences) + + return buf +} + +// ResourceSizeValueListBytes writes a list of ResourceSizeValue values to a byte slice. +func ResourceSizeValueListBytes(buf []byte, list []ResourceSizeValue) int { + b := 0 + var structBytes []byte + for _, item := range list { + structBytes = item.Bytes() + copy(buf[b:], structBytes) + b += len(structBytes) + } + return xgb.Pad(b) +} + +// ResourceSizeValueListSize computes the size (bytes) of a list of ResourceSizeValue values. +func ResourceSizeValueListSize(list []ResourceSizeValue) int { + size := 0 + for _, item := range list { + size += (24 + xgb.Pad((int(item.NumCrossReferences) * 20))) + } + return size +} + type Type struct { ResourceType xproto.Atom Count uint32 @@ -169,6 +505,103 @@ func TypeListBytes(buf []byte, list []Type) int { // Skipping definition for base type 'Card32' +// QueryClientIdsCookie is a cookie used only for QueryClientIds requests. +type QueryClientIdsCookie struct { + *xgb.Cookie +} + +// QueryClientIds sends a checked request. +// If an error occurs, it will be returned with the reply by calling QueryClientIdsCookie.Reply() +func QueryClientIds(c *xgb.Conn, NumSpecs uint32, Specs []ClientIdSpec) QueryClientIdsCookie { + if _, ok := c.Extensions["X-RESOURCE"]; !ok { + panic("Cannot issue request 'QueryClientIds' using the uninitialized extension 'X-Resource'. res.Init(connObj) must be called first.") + } + cookie := c.NewCookie(true, true) + c.NewRequest(queryClientIdsRequest(c, NumSpecs, Specs), cookie) + return QueryClientIdsCookie{cookie} +} + +// QueryClientIdsUnchecked sends an unchecked request. +// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent. +func QueryClientIdsUnchecked(c *xgb.Conn, NumSpecs uint32, Specs []ClientIdSpec) QueryClientIdsCookie { + if _, ok := c.Extensions["X-RESOURCE"]; !ok { + panic("Cannot issue request 'QueryClientIds' using the uninitialized extension 'X-Resource'. res.Init(connObj) must be called first.") + } + cookie := c.NewCookie(false, true) + c.NewRequest(queryClientIdsRequest(c, NumSpecs, Specs), cookie) + return QueryClientIdsCookie{cookie} +} + +// QueryClientIdsReply represents the data returned from a QueryClientIds request. +type QueryClientIdsReply struct { + Sequence uint16 // sequence number of the request for this reply + Length uint32 // number of bytes in this reply + // padding: 1 bytes + NumIds uint32 + // padding: 20 bytes + Ids []ClientIdValue // size: ClientIdValueListSize(Ids) +} + +// Reply blocks and returns the reply data for a QueryClientIds request. +func (cook QueryClientIdsCookie) Reply() (*QueryClientIdsReply, error) { + buf, err := cook.Cookie.Reply() + if err != nil { + return nil, err + } + if buf == nil { + return nil, nil + } + return queryClientIdsReply(buf), nil +} + +// queryClientIdsReply reads a byte slice into a QueryClientIdsReply value. +func queryClientIdsReply(buf []byte) *QueryClientIdsReply { + v := new(QueryClientIdsReply) + 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.NumIds = xgb.Get32(buf[b:]) + b += 4 + + b += 20 // padding + + v.Ids = make([]ClientIdValue, v.NumIds) + b += ClientIdValueReadList(buf[b:], v.Ids) + + return v +} + +// Write request to wire for QueryClientIds +// queryClientIdsRequest writes a QueryClientIds request to a byte slice. +func queryClientIdsRequest(c *xgb.Conn, NumSpecs uint32, Specs []ClientIdSpec) []byte { + size := xgb.Pad((8 + xgb.Pad((int(NumSpecs) * 8)))) + b := 0 + buf := make([]byte, size) + + buf[b] = c.Extensions["X-RESOURCE"] + 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.Put32(buf[b:], NumSpecs) + b += 4 + + b += ClientIdSpecListBytes(buf[b:], Specs) + + return buf +} + // QueryClientPixmapBytesCookie is a cookie used only for QueryClientPixmapBytes requests. type QueryClientPixmapBytesCookie struct { *xgb.Cookie @@ -448,6 +881,106 @@ func queryClientsRequest(c *xgb.Conn) []byte { return buf } +// QueryResourceBytesCookie is a cookie used only for QueryResourceBytes requests. +type QueryResourceBytesCookie struct { + *xgb.Cookie +} + +// QueryResourceBytes sends a checked request. +// If an error occurs, it will be returned with the reply by calling QueryResourceBytesCookie.Reply() +func QueryResourceBytes(c *xgb.Conn, Client uint32, NumSpecs uint32, Specs []ResourceIdSpec) QueryResourceBytesCookie { + if _, ok := c.Extensions["X-RESOURCE"]; !ok { + panic("Cannot issue request 'QueryResourceBytes' using the uninitialized extension 'X-Resource'. res.Init(connObj) must be called first.") + } + cookie := c.NewCookie(true, true) + c.NewRequest(queryResourceBytesRequest(c, Client, NumSpecs, Specs), cookie) + return QueryResourceBytesCookie{cookie} +} + +// QueryResourceBytesUnchecked sends an unchecked request. +// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent. +func QueryResourceBytesUnchecked(c *xgb.Conn, Client uint32, NumSpecs uint32, Specs []ResourceIdSpec) QueryResourceBytesCookie { + if _, ok := c.Extensions["X-RESOURCE"]; !ok { + panic("Cannot issue request 'QueryResourceBytes' using the uninitialized extension 'X-Resource'. res.Init(connObj) must be called first.") + } + cookie := c.NewCookie(false, true) + c.NewRequest(queryResourceBytesRequest(c, Client, NumSpecs, Specs), cookie) + return QueryResourceBytesCookie{cookie} +} + +// QueryResourceBytesReply represents the data returned from a QueryResourceBytes request. +type QueryResourceBytesReply struct { + Sequence uint16 // sequence number of the request for this reply + Length uint32 // number of bytes in this reply + // padding: 1 bytes + NumSizes uint32 + // padding: 20 bytes + Sizes []ResourceSizeValue // size: ResourceSizeValueListSize(Sizes) +} + +// Reply blocks and returns the reply data for a QueryResourceBytes request. +func (cook QueryResourceBytesCookie) Reply() (*QueryResourceBytesReply, error) { + buf, err := cook.Cookie.Reply() + if err != nil { + return nil, err + } + if buf == nil { + return nil, nil + } + return queryResourceBytesReply(buf), nil +} + +// queryResourceBytesReply reads a byte slice into a QueryResourceBytesReply value. +func queryResourceBytesReply(buf []byte) *QueryResourceBytesReply { + v := new(QueryResourceBytesReply) + 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.NumSizes = xgb.Get32(buf[b:]) + b += 4 + + b += 20 // padding + + v.Sizes = make([]ResourceSizeValue, v.NumSizes) + b += ResourceSizeValueReadList(buf[b:], v.Sizes) + + return v +} + +// Write request to wire for QueryResourceBytes +// queryResourceBytesRequest writes a QueryResourceBytes request to a byte slice. +func queryResourceBytesRequest(c *xgb.Conn, Client uint32, NumSpecs uint32, Specs []ResourceIdSpec) []byte { + size := xgb.Pad((12 + xgb.Pad((int(NumSpecs) * 8)))) + b := 0 + buf := make([]byte, size) + + buf[b] = c.Extensions["X-RESOURCE"] + 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.Put32(buf[b:], Client) + b += 4 + + xgb.Put32(buf[b:], NumSpecs) + b += 4 + + b += ResourceIdSpecListBytes(buf[b:], Specs) + + return buf +} + // QueryVersionCookie is a cookie used only for QueryVersion requests. type QueryVersionCookie struct { *xgb.Cookie diff --git a/nexgb/screensaver/screensaver.go b/nexgb/screensaver/screensaver.go index e552c6d..ea60367 100644 --- a/nexgb/screensaver/screensaver.go +++ b/nexgb/screensaver/screensaver.go @@ -53,15 +53,12 @@ const Notify = 0 type NotifyEvent struct { Sequence uint16 - Code byte State byte - // padding: 1 bytes - SequenceNumber uint16 - Time xproto.Timestamp - Root xproto.Window - Window xproto.Window - Kind byte - Forced bool + Time xproto.Timestamp + Root xproto.Window + Window xproto.Window + Kind byte + Forced bool // padding: 14 bytes } @@ -70,18 +67,10 @@ func NotifyEventNew(buf []byte) xgb.Event { v := NotifyEvent{} b := 1 // don't read event number - v.Code = buf[b] - b += 1 - - v.Sequence = xgb.Get16(buf[b:]) - b += 2 - v.State = buf[b] b += 1 - b += 1 // padding - - v.SequenceNumber = xgb.Get16(buf[b:]) + v.Sequence = xgb.Get16(buf[b:]) b += 2 v.Time = xproto.Timestamp(xgb.Get32(buf[b:])) @@ -117,18 +106,10 @@ func (v NotifyEvent) Bytes() []byte { buf[b] = 0 b += 1 - buf[b] = v.Code - b += 1 - - b += 2 // skip sequence number - buf[b] = v.State b += 1 - b += 1 // padding - - xgb.Put16(buf[b:], v.SequenceNumber) - b += 2 + b += 2 // skip sequence number xgb.Put32(buf[b:], uint32(v.Time)) b += 4 @@ -163,11 +144,9 @@ func (v NotifyEvent) SequenceId() uint16 { // String is a rudimentary string representation of NotifyEvent. func (v NotifyEvent) String() string { - fieldVals := make([]string, 0, 10) + fieldVals := make([]string, 0, 7) fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence)) - fieldVals = append(fieldVals, xgb.Sprintf("Code: %d", v.Code)) fieldVals = append(fieldVals, xgb.Sprintf("State: %d", v.State)) - fieldVals = append(fieldVals, xgb.Sprintf("SequenceNumber: %d", v.SequenceNumber)) fieldVals = append(fieldVals, xgb.Sprintf("Time: %d", v.Time)) fieldVals = append(fieldVals, xgb.Sprintf("Root: %d", v.Root)) fieldVals = append(fieldVals, xgb.Sprintf("Window: %d", v.Window)) diff --git a/nexgb/shm/shm.go b/nexgb/shm/shm.go index 3e086c4..e5841ca 100644 --- a/nexgb/shm/shm.go +++ b/nexgb/shm/shm.go @@ -276,6 +276,70 @@ func attachRequest(c *xgb.Conn, Shmseg Seg, Shmid uint32, ReadOnly bool) []byte return buf } +// AttachFdCookie is a cookie used only for AttachFd requests. +type AttachFdCookie struct { + *xgb.Cookie +} + +// AttachFd sends an unchecked request. +// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent. +func AttachFd(c *xgb.Conn, Shmseg Seg, ReadOnly bool) AttachFdCookie { + if _, ok := c.Extensions["MIT-SHM"]; !ok { + panic("Cannot issue request 'AttachFd' using the uninitialized extension 'MIT-SHM'. shm.Init(connObj) must be called first.") + } + cookie := c.NewCookie(false, false) + c.NewRequest(attachFdRequest(c, Shmseg, ReadOnly), cookie) + return AttachFdCookie{cookie} +} + +// AttachFdChecked sends a checked request. +// If an error occurs, it can be retrieved using AttachFdCookie.Check() +func AttachFdChecked(c *xgb.Conn, Shmseg Seg, ReadOnly bool) AttachFdCookie { + if _, ok := c.Extensions["MIT-SHM"]; !ok { + panic("Cannot issue request 'AttachFd' using the uninitialized extension 'MIT-SHM'. shm.Init(connObj) must be called first.") + } + cookie := c.NewCookie(true, false) + c.NewRequest(attachFdRequest(c, Shmseg, ReadOnly), cookie) + return AttachFdCookie{cookie} +} + +// Check returns an error if one occurred for checked requests that are not expecting a reply. +// This cannot be called for requests expecting a reply, nor for unchecked requests. +func (cook AttachFdCookie) Check() error { + return cook.Cookie.Check() +} + +// Write request to wire for AttachFd +// attachFdRequest writes a AttachFd request to a byte slice. +func attachFdRequest(c *xgb.Conn, Shmseg Seg, ReadOnly bool) []byte { + size := 12 + b := 0 + buf := make([]byte, size) + + buf[b] = c.Extensions["MIT-SHM"] + 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.Put32(buf[b:], uint32(Shmseg)) + b += 4 + + if ReadOnly { + buf[b] = 1 + } else { + buf[b] = 0 + } + b += 1 + + b += 3 // padding + + return buf +} + // CreatePixmapCookie is a cookie used only for CreatePixmap requests. type CreatePixmapCookie struct { *xgb.Cookie @@ -351,6 +415,106 @@ func createPixmapRequest(c *xgb.Conn, Pid xproto.Pixmap, Drawable xproto.Drawabl return buf } +// CreateSegmentCookie is a cookie used only for CreateSegment requests. +type CreateSegmentCookie struct { + *xgb.Cookie +} + +// CreateSegment sends a checked request. +// If an error occurs, it will be returned with the reply by calling CreateSegmentCookie.Reply() +func CreateSegment(c *xgb.Conn, Shmseg Seg, Size uint32, ReadOnly bool) CreateSegmentCookie { + if _, ok := c.Extensions["MIT-SHM"]; !ok { + panic("Cannot issue request 'CreateSegment' using the uninitialized extension 'MIT-SHM'. shm.Init(connObj) must be called first.") + } + cookie := c.NewCookie(true, true) + c.NewRequest(createSegmentRequest(c, Shmseg, Size, ReadOnly), cookie) + return CreateSegmentCookie{cookie} +} + +// CreateSegmentUnchecked sends an unchecked request. +// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent. +func CreateSegmentUnchecked(c *xgb.Conn, Shmseg Seg, Size uint32, ReadOnly bool) CreateSegmentCookie { + if _, ok := c.Extensions["MIT-SHM"]; !ok { + panic("Cannot issue request 'CreateSegment' using the uninitialized extension 'MIT-SHM'. shm.Init(connObj) must be called first.") + } + cookie := c.NewCookie(false, true) + c.NewRequest(createSegmentRequest(c, Shmseg, Size, ReadOnly), cookie) + return CreateSegmentCookie{cookie} +} + +// CreateSegmentReply represents the data returned from a CreateSegment request. +type CreateSegmentReply struct { + Sequence uint16 // sequence number of the request for this reply + Length uint32 // number of bytes in this reply + Nfd byte + // padding: 24 bytes +} + +// Reply blocks and returns the reply data for a CreateSegment request. +func (cook CreateSegmentCookie) Reply() (*CreateSegmentReply, error) { + buf, err := cook.Cookie.Reply() + if err != nil { + return nil, err + } + if buf == nil { + return nil, nil + } + return createSegmentReply(buf), nil +} + +// createSegmentReply reads a byte slice into a CreateSegmentReply value. +func createSegmentReply(buf []byte) *CreateSegmentReply { + v := new(CreateSegmentReply) + b := 1 // skip reply determinant + + v.Nfd = buf[b] + b += 1 + + v.Sequence = xgb.Get16(buf[b:]) + b += 2 + + v.Length = xgb.Get32(buf[b:]) // 4-byte units + b += 4 + + b += 24 // padding + + return v +} + +// Write request to wire for CreateSegment +// createSegmentRequest writes a CreateSegment request to a byte slice. +func createSegmentRequest(c *xgb.Conn, Shmseg Seg, Size uint32, ReadOnly bool) []byte { + size := 16 + b := 0 + buf := make([]byte, size) + + buf[b] = c.Extensions["MIT-SHM"] + 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:], uint32(Shmseg)) + b += 4 + + xgb.Put32(buf[b:], Size) + b += 4 + + if ReadOnly { + buf[b] = 1 + } else { + buf[b] = 0 + } + b += 1 + + b += 3 // padding + + return buf +} + // DetachCookie is a cookie used only for Detach requests. type DetachCookie struct { *xgb.Cookie diff --git a/nexgb/xfixes/xfixes.go b/nexgb/xfixes/xfixes.go index 94e96e1..0424585 100644 --- a/nexgb/xfixes/xfixes.go +++ b/nexgb/xfixes/xfixes.go @@ -85,6 +85,27 @@ func init() { xgb.NewExtErrorFuncs["XFIXES"][0] = BadRegionErrorNew } +type Barrier uint32 + +func NewBarrierId(c *xgb.Conn) (Barrier, error) { + id, err := c.NewId() + if err != nil { + return 0, err + } + return Barrier(id), nil +} + +const ( + BarrierDirectionsPositiveX = 1 + BarrierDirectionsPositiveY = 2 + BarrierDirectionsNegativeX = 4 + BarrierDirectionsNegativeY = 8 +) + +const ( + CursorNotifyDisplayCursor = 0 +) + // CursorNotify is the event number for a CursorNotifyEvent. const CursorNotify = 1 @@ -181,10 +202,6 @@ func init() { } const ( - CursorNotifyDisplayCursor = 0 -) - -const ( CursorNotifyMaskDisplayCursor = 1 ) @@ -601,6 +618,90 @@ func copyRegionRequest(c *xgb.Conn, Source Region, Destination Region) []byte { return buf } +// CreatePointerBarrierCookie is a cookie used only for CreatePointerBarrier requests. +type CreatePointerBarrierCookie struct { + *xgb.Cookie +} + +// CreatePointerBarrier sends an unchecked request. +// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent. +func CreatePointerBarrier(c *xgb.Conn, Barrier Barrier, Window xproto.Window, X1 uint16, Y1 uint16, X2 uint16, Y2 uint16, Directions uint32, NumDevices uint16, Devices []uint16) CreatePointerBarrierCookie { + if _, ok := c.Extensions["XFIXES"]; !ok { + panic("Cannot issue request 'CreatePointerBarrier' using the uninitialized extension 'XFIXES'. xfixes.Init(connObj) must be called first.") + } + cookie := c.NewCookie(false, false) + c.NewRequest(createPointerBarrierRequest(c, Barrier, Window, X1, Y1, X2, Y2, Directions, NumDevices, Devices), cookie) + return CreatePointerBarrierCookie{cookie} +} + +// CreatePointerBarrierChecked sends a checked request. +// If an error occurs, it can be retrieved using CreatePointerBarrierCookie.Check() +func CreatePointerBarrierChecked(c *xgb.Conn, Barrier Barrier, Window xproto.Window, X1 uint16, Y1 uint16, X2 uint16, Y2 uint16, Directions uint32, NumDevices uint16, Devices []uint16) CreatePointerBarrierCookie { + if _, ok := c.Extensions["XFIXES"]; !ok { + panic("Cannot issue request 'CreatePointerBarrier' using the uninitialized extension 'XFIXES'. xfixes.Init(connObj) must be called first.") + } + cookie := c.NewCookie(true, false) + c.NewRequest(createPointerBarrierRequest(c, Barrier, Window, X1, Y1, X2, Y2, Directions, NumDevices, Devices), cookie) + return CreatePointerBarrierCookie{cookie} +} + +// Check returns an error if one occurred for checked requests that are not expecting a reply. +// This cannot be called for requests expecting a reply, nor for unchecked requests. +func (cook CreatePointerBarrierCookie) Check() error { + return cook.Cookie.Check() +} + +// Write request to wire for CreatePointerBarrier +// createPointerBarrierRequest writes a CreatePointerBarrier request to a byte slice. +func createPointerBarrierRequest(c *xgb.Conn, Barrier Barrier, Window xproto.Window, X1 uint16, Y1 uint16, X2 uint16, Y2 uint16, Directions uint32, NumDevices uint16, Devices []uint16) []byte { + size := xgb.Pad((28 + xgb.Pad((int(NumDevices) * 2)))) + b := 0 + buf := make([]byte, size) + + buf[b] = c.Extensions["XFIXES"] + b += 1 + + buf[b] = 31 // request opcode + b += 1 + + xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units + b += 2 + + xgb.Put32(buf[b:], uint32(Barrier)) + b += 4 + + xgb.Put32(buf[b:], uint32(Window)) + b += 4 + + xgb.Put16(buf[b:], X1) + b += 2 + + xgb.Put16(buf[b:], Y1) + b += 2 + + xgb.Put16(buf[b:], X2) + b += 2 + + xgb.Put16(buf[b:], Y2) + b += 2 + + xgb.Put32(buf[b:], Directions) + b += 4 + + b += 2 // padding + + xgb.Put16(buf[b:], NumDevices) + b += 2 + + for i := 0; i < int(NumDevices); i++ { + xgb.Put16(buf[b:], Devices[i]) + b += 2 + } + b = xgb.Pad(b) + + return buf +} + // CreateRegionCookie is a cookie used only for CreateRegion requests. type CreateRegionCookie struct { *xgb.Cookie @@ -895,6 +996,61 @@ func createRegionFromWindowRequest(c *xgb.Conn, Region Region, Window xproto.Win return buf } +// DeletePointerBarrierCookie is a cookie used only for DeletePointerBarrier requests. +type DeletePointerBarrierCookie struct { + *xgb.Cookie +} + +// DeletePointerBarrier sends an unchecked request. +// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent. +func DeletePointerBarrier(c *xgb.Conn, Barrier Barrier) DeletePointerBarrierCookie { + if _, ok := c.Extensions["XFIXES"]; !ok { + panic("Cannot issue request 'DeletePointerBarrier' using the uninitialized extension 'XFIXES'. xfixes.Init(connObj) must be called first.") + } + cookie := c.NewCookie(false, false) + c.NewRequest(deletePointerBarrierRequest(c, Barrier), cookie) + return DeletePointerBarrierCookie{cookie} +} + +// DeletePointerBarrierChecked sends a checked request. +// If an error occurs, it can be retrieved using DeletePointerBarrierCookie.Check() +func DeletePointerBarrierChecked(c *xgb.Conn, Barrier Barrier) DeletePointerBarrierCookie { + if _, ok := c.Extensions["XFIXES"]; !ok { + panic("Cannot issue request 'DeletePointerBarrier' using the uninitialized extension 'XFIXES'. xfixes.Init(connObj) must be called first.") + } + cookie := c.NewCookie(true, false) + c.NewRequest(deletePointerBarrierRequest(c, Barrier), cookie) + return DeletePointerBarrierCookie{cookie} +} + +// Check returns an error if one occurred for checked requests that are not expecting a reply. +// This cannot be called for requests expecting a reply, nor for unchecked requests. +func (cook DeletePointerBarrierCookie) Check() error { + return cook.Cookie.Check() +} + +// Write request to wire for DeletePointerBarrier +// deletePointerBarrierRequest writes a DeletePointerBarrier request to a byte slice. +func deletePointerBarrierRequest(c *xgb.Conn, Barrier Barrier) []byte { + size := 8 + b := 0 + buf := make([]byte, size) + + buf[b] = c.Extensions["XFIXES"] + b += 1 + + buf[b] = 32 // request opcode + b += 1 + + xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units + b += 2 + + xgb.Put32(buf[b:], uint32(Barrier)) + b += 4 + + return buf +} + // DestroyRegionCookie is a cookie used only for DestroyRegion requests. type DestroyRegionCookie struct { *xgb.Cookie diff --git a/nexgb/xproto/xproto.go b/nexgb/xproto/xproto.go index 0de64fd..9b33030 100644 --- a/nexgb/xproto/xproto.go +++ b/nexgb/xproto/xproto.go @@ -2484,10 +2484,6 @@ func NewFontId(c *xgb.Conn) (Font, error) { return Font(id), nil } -const ( - FontNone = 0 -) - // BadFont is the error number for a BadFont. const BadFont = 7 @@ -2527,6 +2523,10 @@ func init() { } const ( + FontNone = 0 +) + +const ( FontDrawLeftToRight = 0 FontDrawRightToLeft = 1 ) @@ -2735,6 +2735,56 @@ func NewGcontextId(c *xgb.Conn) (Gcontext, error) { return Gcontext(id), nil } +// GeGeneric is the event number for a GeGenericEvent. +const GeGeneric = 35 + +type GeGenericEvent struct { + Sequence uint16 + // padding: 22 bytes +} + +// GeGenericEventNew constructs a GeGenericEvent value that implements xgb.Event from a byte slice. +func GeGenericEventNew(buf []byte) xgb.Event { + v := GeGenericEvent{} + b := 1 // don't read event number + + b += 22 // padding + + return v +} + +// Bytes writes a GeGenericEvent value to a byte slice. +func (v GeGenericEvent) Bytes() []byte { + buf := make([]byte, 32) + b := 0 + + // write event number + buf[b] = 35 + b += 1 + + b += 22 // padding + + return buf +} + +// SequenceId returns the sequence id attached to the GeGeneric event. +// Events without a sequence number (KeymapNotify) return 0. +// This is mostly used internally. +func (v GeGenericEvent) SequenceId() uint16 { + return v.Sequence +} + +// String is a rudimentary string representation of GeGenericEvent. +func (v GeGenericEvent) String() string { + fieldVals := make([]string, 0, 1) + fieldVals = append(fieldVals, xgb.Sprintf("Sequence: %d", v.Sequence)) + return "GeGeneric {" + xgb.StringsJoin(fieldVals, ", ") + "}" +} + +func init() { + xgb.NewEventFuncs[35] = GeGenericEventNew +} + const ( GetPropertyTypeAny = 0 ) |