aboutsummaryrefslogtreecommitdiff
path: root/nexgb/xselinux
diff options
context:
space:
mode:
authorPřemysl Janouch <p@janouch.name>2018-09-08 16:54:17 +0200
committerPřemysl Janouch <p@janouch.name>2018-09-08 16:54:17 +0200
commit3173202cc1e08762c6e156a8fffd23269a5ddb2b (patch)
tree95c4a06f8384d41b15e9c22afac0a387de79dc51 /nexgb/xselinux
parent632b3ae494d45755525644fe5d04475c95aae364 (diff)
parent3906399e7c2a40fbaf355de572cf50a314083f64 (diff)
downloadhaven-3173202cc1e08762c6e156a8fffd23269a5ddb2b.tar.gz
haven-3173202cc1e08762c6e156a8fffd23269a5ddb2b.tar.xz
haven-3173202cc1e08762c6e156a8fffd23269a5ddb2b.zip
Merge aarzilli/xgb, branch xcb1.12 as nexgb
History has been linearized and rewritten to stay under the new subdirectory. I want to make changes incompatible to BurntSushi/xgb. The history begs for being thrown away entirely because of its quality and because it doesn't cover the Google period but it is still useful for copyright tracking.
Diffstat (limited to 'nexgb/xselinux')
-rw-r--r--nexgb/xselinux/xselinux.go2267
1 files changed, 2267 insertions, 0 deletions
diff --git a/nexgb/xselinux/xselinux.go b/nexgb/xselinux/xselinux.go
new file mode 100644
index 0000000..c237857
--- /dev/null
+++ b/nexgb/xselinux/xselinux.go
@@ -0,0 +1,2267 @@
+// Package xselinux is the X client API for the SELinux extension.
+package xselinux
+
+// This file is automatically generated from xselinux.xml. Edit at your peril!
+
+import (
+ "github.com/BurntSushi/xgb"
+
+ "github.com/BurntSushi/xgb/xproto"
+)
+
+// Init must be called before using the SELinux extension.
+func Init(c *xgb.Conn) error {
+ reply, err := xproto.QueryExtension(c, 7, "SELinux").Reply()
+ switch {
+ case err != nil:
+ return err
+ case !reply.Present:
+ return xgb.Errorf("No extension named SELinux could be found on on the server.")
+ }
+
+ c.ExtLock.Lock()
+ c.Extensions["SELinux"] = reply.MajorOpcode
+ c.ExtLock.Unlock()
+ for evNum, fun := range xgb.NewExtEventFuncs["SELinux"] {
+ xgb.NewEventFuncs[int(reply.FirstEvent)+evNum] = fun
+ }
+ for errNum, fun := range xgb.NewExtErrorFuncs["SELinux"] {
+ xgb.NewErrorFuncs[int(reply.FirstError)+errNum] = fun
+ }
+ return nil
+}
+
+func init() {
+ xgb.NewExtEventFuncs["SELinux"] = make(map[int]xgb.NewEventFun)
+ xgb.NewExtErrorFuncs["SELinux"] = make(map[int]xgb.NewErrorFun)
+}
+
+type ListItem struct {
+ Name xproto.Atom
+ ObjectContextLen uint32
+ DataContextLen uint32
+ ObjectContext string // size: xgb.Pad((int(ObjectContextLen) * 1))
+ // alignment gap to multiple of 4
+ DataContext string // size: xgb.Pad((int(DataContextLen) * 1))
+ // alignment gap to multiple of 4
+}
+
+// ListItemRead reads a byte slice into a ListItem value.
+func ListItemRead(buf []byte, v *ListItem) int {
+ b := 0
+
+ v.Name = xproto.Atom(xgb.Get32(buf[b:]))
+ b += 4
+
+ v.ObjectContextLen = xgb.Get32(buf[b:])
+ b += 4
+
+ v.DataContextLen = xgb.Get32(buf[b:])
+ b += 4
+
+ {
+ byteString := make([]byte, v.ObjectContextLen)
+ copy(byteString[:v.ObjectContextLen], buf[b:])
+ v.ObjectContext = string(byteString)
+ b += int(v.ObjectContextLen)
+ }
+
+ b = (b + 3) & ^3 // alignment gap
+
+ {
+ byteString := make([]byte, v.DataContextLen)
+ copy(byteString[:v.DataContextLen], buf[b:])
+ v.DataContext = string(byteString)
+ b += int(v.DataContextLen)
+ }
+
+ b = (b + 3) & ^3 // alignment gap
+
+ return b
+}
+
+// ListItemReadList reads a byte slice into a list of ListItem values.
+func ListItemReadList(buf []byte, dest []ListItem) int {
+ b := 0
+ for i := 0; i < len(dest); i++ {
+ dest[i] = ListItem{}
+ b += ListItemRead(buf[b:], &dest[i])
+ }
+ return xgb.Pad(b)
+}
+
+// Bytes writes a ListItem value to a byte slice.
+func (v ListItem) Bytes() []byte {
+ buf := make([]byte, ((((12 + xgb.Pad((int(v.ObjectContextLen) * 1))) + 4) + xgb.Pad((int(v.DataContextLen) * 1))) + 4))
+ b := 0
+
+ xgb.Put32(buf[b:], uint32(v.Name))
+ b += 4
+
+ xgb.Put32(buf[b:], v.ObjectContextLen)
+ b += 4
+
+ xgb.Put32(buf[b:], v.DataContextLen)
+ b += 4
+
+ copy(buf[b:], v.ObjectContext[:v.ObjectContextLen])
+ b += int(v.ObjectContextLen)
+
+ b = (b + 3) & ^3 // alignment gap
+
+ copy(buf[b:], v.DataContext[:v.DataContextLen])
+ b += int(v.DataContextLen)
+
+ b = (b + 3) & ^3 // alignment gap
+
+ return buf[:b]
+}
+
+// ListItemListBytes writes a list of ListItem values to a byte slice.
+func ListItemListBytes(buf []byte, list []ListItem) int {
+ b := 0
+ var structBytes []byte
+ for _, item := range list {
+ structBytes = item.Bytes()
+ copy(buf[b:], structBytes)
+ b += len(structBytes)
+ }
+ return xgb.Pad(b)
+}
+
+// ListItemListSize computes the size (bytes) of a list of ListItem values.
+func ListItemListSize(list []ListItem) int {
+ size := 0
+ for _, item := range list {
+ size += ((((12 + xgb.Pad((int(item.ObjectContextLen) * 1))) + 4) + xgb.Pad((int(item.DataContextLen) * 1))) + 4)
+ }
+ return size
+}
+
+// Skipping definition for base type 'Bool'
+
+// Skipping definition for base type 'Byte'
+
+// Skipping definition for base type 'Card8'
+
+// Skipping definition for base type 'Char'
+
+// Skipping definition for base type 'Void'
+
+// Skipping definition for base type 'Double'
+
+// Skipping definition for base type 'Float'
+
+// Skipping definition for base type 'Int16'
+
+// Skipping definition for base type 'Int32'
+
+// Skipping definition for base type 'Int8'
+
+// Skipping definition for base type 'Card16'
+
+// Skipping definition for base type 'Card32'
+
+// GetClientContextCookie is a cookie used only for GetClientContext requests.
+type GetClientContextCookie struct {
+ *xgb.Cookie
+}
+
+// GetClientContext sends a checked request.
+// If an error occurs, it will be returned with the reply by calling GetClientContextCookie.Reply()
+func GetClientContext(c *xgb.Conn, Resource uint32) GetClientContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetClientContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, true)
+ c.NewRequest(getClientContextRequest(c, Resource), cookie)
+ return GetClientContextCookie{cookie}
+}
+
+// GetClientContextUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func GetClientContextUnchecked(c *xgb.Conn, Resource uint32) GetClientContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetClientContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, true)
+ c.NewRequest(getClientContextRequest(c, Resource), cookie)
+ return GetClientContextCookie{cookie}
+}
+
+// GetClientContextReply represents the data returned from a GetClientContext request.
+type GetClientContextReply struct {
+ Sequence uint16 // sequence number of the request for this reply
+ Length uint32 // number of bytes in this reply
+ // padding: 1 bytes
+ ContextLen uint32
+ // padding: 20 bytes
+ Context string // size: xgb.Pad((int(ContextLen) * 1))
+}
+
+// Reply blocks and returns the reply data for a GetClientContext request.
+func (cook GetClientContextCookie) Reply() (*GetClientContextReply, error) {
+ buf, err := cook.Cookie.Reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return getClientContextReply(buf), nil
+}
+
+// getClientContextReply reads a byte slice into a GetClientContextReply value.
+func getClientContextReply(buf []byte) *GetClientContextReply {
+ v := new(GetClientContextReply)
+ 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.ContextLen = xgb.Get32(buf[b:])
+ b += 4
+
+ b += 20 // padding
+
+ {
+ byteString := make([]byte, v.ContextLen)
+ copy(byteString[:v.ContextLen], buf[b:])
+ v.Context = string(byteString)
+ b += int(v.ContextLen)
+ }
+
+ return v
+}
+
+// Write request to wire for GetClientContext
+// getClientContextRequest writes a GetClientContext request to a byte slice.
+func getClientContextRequest(c *xgb.Conn, Resource uint32) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 22 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ xgb.Put32(buf[b:], Resource)
+ b += 4
+
+ return buf
+}
+
+// GetDeviceContextCookie is a cookie used only for GetDeviceContext requests.
+type GetDeviceContextCookie struct {
+ *xgb.Cookie
+}
+
+// GetDeviceContext sends a checked request.
+// If an error occurs, it will be returned with the reply by calling GetDeviceContextCookie.Reply()
+func GetDeviceContext(c *xgb.Conn, Device uint32) GetDeviceContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetDeviceContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, true)
+ c.NewRequest(getDeviceContextRequest(c, Device), cookie)
+ return GetDeviceContextCookie{cookie}
+}
+
+// GetDeviceContextUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func GetDeviceContextUnchecked(c *xgb.Conn, Device uint32) GetDeviceContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetDeviceContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, true)
+ c.NewRequest(getDeviceContextRequest(c, Device), cookie)
+ return GetDeviceContextCookie{cookie}
+}
+
+// GetDeviceContextReply represents the data returned from a GetDeviceContext request.
+type GetDeviceContextReply struct {
+ Sequence uint16 // sequence number of the request for this reply
+ Length uint32 // number of bytes in this reply
+ // padding: 1 bytes
+ ContextLen uint32
+ // padding: 20 bytes
+ Context string // size: xgb.Pad((int(ContextLen) * 1))
+}
+
+// Reply blocks and returns the reply data for a GetDeviceContext request.
+func (cook GetDeviceContextCookie) Reply() (*GetDeviceContextReply, error) {
+ buf, err := cook.Cookie.Reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return getDeviceContextReply(buf), nil
+}
+
+// getDeviceContextReply reads a byte slice into a GetDeviceContextReply value.
+func getDeviceContextReply(buf []byte) *GetDeviceContextReply {
+ v := new(GetDeviceContextReply)
+ 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.ContextLen = xgb.Get32(buf[b:])
+ b += 4
+
+ b += 20 // padding
+
+ {
+ byteString := make([]byte, v.ContextLen)
+ copy(byteString[:v.ContextLen], buf[b:])
+ v.Context = string(byteString)
+ b += int(v.ContextLen)
+ }
+
+ return v
+}
+
+// Write request to wire for GetDeviceContext
+// getDeviceContextRequest writes a GetDeviceContext request to a byte slice.
+func getDeviceContextRequest(c *xgb.Conn, Device uint32) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ 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:], Device)
+ b += 4
+
+ return buf
+}
+
+// GetDeviceCreateContextCookie is a cookie used only for GetDeviceCreateContext requests.
+type GetDeviceCreateContextCookie struct {
+ *xgb.Cookie
+}
+
+// GetDeviceCreateContext sends a checked request.
+// If an error occurs, it will be returned with the reply by calling GetDeviceCreateContextCookie.Reply()
+func GetDeviceCreateContext(c *xgb.Conn) GetDeviceCreateContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetDeviceCreateContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, true)
+ c.NewRequest(getDeviceCreateContextRequest(c), cookie)
+ return GetDeviceCreateContextCookie{cookie}
+}
+
+// GetDeviceCreateContextUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func GetDeviceCreateContextUnchecked(c *xgb.Conn) GetDeviceCreateContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetDeviceCreateContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, true)
+ c.NewRequest(getDeviceCreateContextRequest(c), cookie)
+ return GetDeviceCreateContextCookie{cookie}
+}
+
+// GetDeviceCreateContextReply represents the data returned from a GetDeviceCreateContext request.
+type GetDeviceCreateContextReply struct {
+ Sequence uint16 // sequence number of the request for this reply
+ Length uint32 // number of bytes in this reply
+ // padding: 1 bytes
+ ContextLen uint32
+ // padding: 20 bytes
+ Context string // size: xgb.Pad((int(ContextLen) * 1))
+}
+
+// Reply blocks and returns the reply data for a GetDeviceCreateContext request.
+func (cook GetDeviceCreateContextCookie) Reply() (*GetDeviceCreateContextReply, error) {
+ buf, err := cook.Cookie.Reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return getDeviceCreateContextReply(buf), nil
+}
+
+// getDeviceCreateContextReply reads a byte slice into a GetDeviceCreateContextReply value.
+func getDeviceCreateContextReply(buf []byte) *GetDeviceCreateContextReply {
+ v := new(GetDeviceCreateContextReply)
+ 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.ContextLen = xgb.Get32(buf[b:])
+ b += 4
+
+ b += 20 // padding
+
+ {
+ byteString := make([]byte, v.ContextLen)
+ copy(byteString[:v.ContextLen], buf[b:])
+ v.Context = string(byteString)
+ b += int(v.ContextLen)
+ }
+
+ return v
+}
+
+// Write request to wire for GetDeviceCreateContext
+// getDeviceCreateContextRequest writes a GetDeviceCreateContext request to a byte slice.
+func getDeviceCreateContextRequest(c *xgb.Conn) []byte {
+ size := 4
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 2 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ return buf
+}
+
+// GetPropertyContextCookie is a cookie used only for GetPropertyContext requests.
+type GetPropertyContextCookie struct {
+ *xgb.Cookie
+}
+
+// GetPropertyContext sends a checked request.
+// If an error occurs, it will be returned with the reply by calling GetPropertyContextCookie.Reply()
+func GetPropertyContext(c *xgb.Conn, Window xproto.Window, Property xproto.Atom) GetPropertyContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetPropertyContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, true)
+ c.NewRequest(getPropertyContextRequest(c, Window, Property), cookie)
+ return GetPropertyContextCookie{cookie}
+}
+
+// GetPropertyContextUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func GetPropertyContextUnchecked(c *xgb.Conn, Window xproto.Window, Property xproto.Atom) GetPropertyContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetPropertyContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, true)
+ c.NewRequest(getPropertyContextRequest(c, Window, Property), cookie)
+ return GetPropertyContextCookie{cookie}
+}
+
+// GetPropertyContextReply represents the data returned from a GetPropertyContext request.
+type GetPropertyContextReply struct {
+ Sequence uint16 // sequence number of the request for this reply
+ Length uint32 // number of bytes in this reply
+ // padding: 1 bytes
+ ContextLen uint32
+ // padding: 20 bytes
+ Context string // size: xgb.Pad((int(ContextLen) * 1))
+}
+
+// Reply blocks and returns the reply data for a GetPropertyContext request.
+func (cook GetPropertyContextCookie) Reply() (*GetPropertyContextReply, error) {
+ buf, err := cook.Cookie.Reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return getPropertyContextReply(buf), nil
+}
+
+// getPropertyContextReply reads a byte slice into a GetPropertyContextReply value.
+func getPropertyContextReply(buf []byte) *GetPropertyContextReply {
+ v := new(GetPropertyContextReply)
+ 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.ContextLen = xgb.Get32(buf[b:])
+ b += 4
+
+ b += 20 // padding
+
+ {
+ byteString := make([]byte, v.ContextLen)
+ copy(byteString[:v.ContextLen], buf[b:])
+ v.Context = string(byteString)
+ b += int(v.ContextLen)
+ }
+
+ return v
+}
+
+// Write request to wire for GetPropertyContext
+// getPropertyContextRequest writes a GetPropertyContext request to a byte slice.
+func getPropertyContextRequest(c *xgb.Conn, Window xproto.Window, Property xproto.Atom) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 12 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ xgb.Put32(buf[b:], uint32(Window))
+ b += 4
+
+ xgb.Put32(buf[b:], uint32(Property))
+ b += 4
+
+ return buf
+}
+
+// GetPropertyCreateContextCookie is a cookie used only for GetPropertyCreateContext requests.
+type GetPropertyCreateContextCookie struct {
+ *xgb.Cookie
+}
+
+// GetPropertyCreateContext sends a checked request.
+// If an error occurs, it will be returned with the reply by calling GetPropertyCreateContextCookie.Reply()
+func GetPropertyCreateContext(c *xgb.Conn) GetPropertyCreateContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetPropertyCreateContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, true)
+ c.NewRequest(getPropertyCreateContextRequest(c), cookie)
+ return GetPropertyCreateContextCookie{cookie}
+}
+
+// GetPropertyCreateContextUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func GetPropertyCreateContextUnchecked(c *xgb.Conn) GetPropertyCreateContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetPropertyCreateContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, true)
+ c.NewRequest(getPropertyCreateContextRequest(c), cookie)
+ return GetPropertyCreateContextCookie{cookie}
+}
+
+// GetPropertyCreateContextReply represents the data returned from a GetPropertyCreateContext request.
+type GetPropertyCreateContextReply struct {
+ Sequence uint16 // sequence number of the request for this reply
+ Length uint32 // number of bytes in this reply
+ // padding: 1 bytes
+ ContextLen uint32
+ // padding: 20 bytes
+ Context string // size: xgb.Pad((int(ContextLen) * 1))
+}
+
+// Reply blocks and returns the reply data for a GetPropertyCreateContext request.
+func (cook GetPropertyCreateContextCookie) Reply() (*GetPropertyCreateContextReply, error) {
+ buf, err := cook.Cookie.Reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return getPropertyCreateContextReply(buf), nil
+}
+
+// getPropertyCreateContextReply reads a byte slice into a GetPropertyCreateContextReply value.
+func getPropertyCreateContextReply(buf []byte) *GetPropertyCreateContextReply {
+ v := new(GetPropertyCreateContextReply)
+ 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.ContextLen = xgb.Get32(buf[b:])
+ b += 4
+
+ b += 20 // padding
+
+ {
+ byteString := make([]byte, v.ContextLen)
+ copy(byteString[:v.ContextLen], buf[b:])
+ v.Context = string(byteString)
+ b += int(v.ContextLen)
+ }
+
+ return v
+}
+
+// Write request to wire for GetPropertyCreateContext
+// getPropertyCreateContextRequest writes a GetPropertyCreateContext request to a byte slice.
+func getPropertyCreateContextRequest(c *xgb.Conn) []byte {
+ size := 4
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 9 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ return buf
+}
+
+// GetPropertyDataContextCookie is a cookie used only for GetPropertyDataContext requests.
+type GetPropertyDataContextCookie struct {
+ *xgb.Cookie
+}
+
+// GetPropertyDataContext sends a checked request.
+// If an error occurs, it will be returned with the reply by calling GetPropertyDataContextCookie.Reply()
+func GetPropertyDataContext(c *xgb.Conn, Window xproto.Window, Property xproto.Atom) GetPropertyDataContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetPropertyDataContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, true)
+ c.NewRequest(getPropertyDataContextRequest(c, Window, Property), cookie)
+ return GetPropertyDataContextCookie{cookie}
+}
+
+// GetPropertyDataContextUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func GetPropertyDataContextUnchecked(c *xgb.Conn, Window xproto.Window, Property xproto.Atom) GetPropertyDataContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetPropertyDataContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, true)
+ c.NewRequest(getPropertyDataContextRequest(c, Window, Property), cookie)
+ return GetPropertyDataContextCookie{cookie}
+}
+
+// GetPropertyDataContextReply represents the data returned from a GetPropertyDataContext request.
+type GetPropertyDataContextReply struct {
+ Sequence uint16 // sequence number of the request for this reply
+ Length uint32 // number of bytes in this reply
+ // padding: 1 bytes
+ ContextLen uint32
+ // padding: 20 bytes
+ Context string // size: xgb.Pad((int(ContextLen) * 1))
+}
+
+// Reply blocks and returns the reply data for a GetPropertyDataContext request.
+func (cook GetPropertyDataContextCookie) Reply() (*GetPropertyDataContextReply, error) {
+ buf, err := cook.Cookie.Reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return getPropertyDataContextReply(buf), nil
+}
+
+// getPropertyDataContextReply reads a byte slice into a GetPropertyDataContextReply value.
+func getPropertyDataContextReply(buf []byte) *GetPropertyDataContextReply {
+ v := new(GetPropertyDataContextReply)
+ 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.ContextLen = xgb.Get32(buf[b:])
+ b += 4
+
+ b += 20 // padding
+
+ {
+ byteString := make([]byte, v.ContextLen)
+ copy(byteString[:v.ContextLen], buf[b:])
+ v.Context = string(byteString)
+ b += int(v.ContextLen)
+ }
+
+ return v
+}
+
+// Write request to wire for GetPropertyDataContext
+// getPropertyDataContextRequest writes a GetPropertyDataContext request to a byte slice.
+func getPropertyDataContextRequest(c *xgb.Conn, Window xproto.Window, Property xproto.Atom) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 13 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ xgb.Put32(buf[b:], uint32(Window))
+ b += 4
+
+ xgb.Put32(buf[b:], uint32(Property))
+ b += 4
+
+ return buf
+}
+
+// GetPropertyUseContextCookie is a cookie used only for GetPropertyUseContext requests.
+type GetPropertyUseContextCookie struct {
+ *xgb.Cookie
+}
+
+// GetPropertyUseContext sends a checked request.
+// If an error occurs, it will be returned with the reply by calling GetPropertyUseContextCookie.Reply()
+func GetPropertyUseContext(c *xgb.Conn) GetPropertyUseContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetPropertyUseContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, true)
+ c.NewRequest(getPropertyUseContextRequest(c), cookie)
+ return GetPropertyUseContextCookie{cookie}
+}
+
+// GetPropertyUseContextUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func GetPropertyUseContextUnchecked(c *xgb.Conn) GetPropertyUseContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetPropertyUseContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, true)
+ c.NewRequest(getPropertyUseContextRequest(c), cookie)
+ return GetPropertyUseContextCookie{cookie}
+}
+
+// GetPropertyUseContextReply represents the data returned from a GetPropertyUseContext request.
+type GetPropertyUseContextReply struct {
+ Sequence uint16 // sequence number of the request for this reply
+ Length uint32 // number of bytes in this reply
+ // padding: 1 bytes
+ ContextLen uint32
+ // padding: 20 bytes
+ Context string // size: xgb.Pad((int(ContextLen) * 1))
+}
+
+// Reply blocks and returns the reply data for a GetPropertyUseContext request.
+func (cook GetPropertyUseContextCookie) Reply() (*GetPropertyUseContextReply, error) {
+ buf, err := cook.Cookie.Reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return getPropertyUseContextReply(buf), nil
+}
+
+// getPropertyUseContextReply reads a byte slice into a GetPropertyUseContextReply value.
+func getPropertyUseContextReply(buf []byte) *GetPropertyUseContextReply {
+ v := new(GetPropertyUseContextReply)
+ 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.ContextLen = xgb.Get32(buf[b:])
+ b += 4
+
+ b += 20 // padding
+
+ {
+ byteString := make([]byte, v.ContextLen)
+ copy(byteString[:v.ContextLen], buf[b:])
+ v.Context = string(byteString)
+ b += int(v.ContextLen)
+ }
+
+ return v
+}
+
+// Write request to wire for GetPropertyUseContext
+// getPropertyUseContextRequest writes a GetPropertyUseContext request to a byte slice.
+func getPropertyUseContextRequest(c *xgb.Conn) []byte {
+ size := 4
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 11 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ return buf
+}
+
+// GetSelectionContextCookie is a cookie used only for GetSelectionContext requests.
+type GetSelectionContextCookie struct {
+ *xgb.Cookie
+}
+
+// GetSelectionContext sends a checked request.
+// If an error occurs, it will be returned with the reply by calling GetSelectionContextCookie.Reply()
+func GetSelectionContext(c *xgb.Conn, Selection xproto.Atom) GetSelectionContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetSelectionContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, true)
+ c.NewRequest(getSelectionContextRequest(c, Selection), cookie)
+ return GetSelectionContextCookie{cookie}
+}
+
+// GetSelectionContextUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func GetSelectionContextUnchecked(c *xgb.Conn, Selection xproto.Atom) GetSelectionContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetSelectionContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, true)
+ c.NewRequest(getSelectionContextRequest(c, Selection), cookie)
+ return GetSelectionContextCookie{cookie}
+}
+
+// GetSelectionContextReply represents the data returned from a GetSelectionContext request.
+type GetSelectionContextReply struct {
+ Sequence uint16 // sequence number of the request for this reply
+ Length uint32 // number of bytes in this reply
+ // padding: 1 bytes
+ ContextLen uint32
+ // padding: 20 bytes
+ Context string // size: xgb.Pad((int(ContextLen) * 1))
+}
+
+// Reply blocks and returns the reply data for a GetSelectionContext request.
+func (cook GetSelectionContextCookie) Reply() (*GetSelectionContextReply, error) {
+ buf, err := cook.Cookie.Reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return getSelectionContextReply(buf), nil
+}
+
+// getSelectionContextReply reads a byte slice into a GetSelectionContextReply value.
+func getSelectionContextReply(buf []byte) *GetSelectionContextReply {
+ v := new(GetSelectionContextReply)
+ 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.ContextLen = xgb.Get32(buf[b:])
+ b += 4
+
+ b += 20 // padding
+
+ {
+ byteString := make([]byte, v.ContextLen)
+ copy(byteString[:v.ContextLen], buf[b:])
+ v.Context = string(byteString)
+ b += int(v.ContextLen)
+ }
+
+ return v
+}
+
+// Write request to wire for GetSelectionContext
+// getSelectionContextRequest writes a GetSelectionContext request to a byte slice.
+func getSelectionContextRequest(c *xgb.Conn, Selection xproto.Atom) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 19 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ xgb.Put32(buf[b:], uint32(Selection))
+ b += 4
+
+ return buf
+}
+
+// GetSelectionCreateContextCookie is a cookie used only for GetSelectionCreateContext requests.
+type GetSelectionCreateContextCookie struct {
+ *xgb.Cookie
+}
+
+// GetSelectionCreateContext sends a checked request.
+// If an error occurs, it will be returned with the reply by calling GetSelectionCreateContextCookie.Reply()
+func GetSelectionCreateContext(c *xgb.Conn) GetSelectionCreateContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetSelectionCreateContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, true)
+ c.NewRequest(getSelectionCreateContextRequest(c), cookie)
+ return GetSelectionCreateContextCookie{cookie}
+}
+
+// GetSelectionCreateContextUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func GetSelectionCreateContextUnchecked(c *xgb.Conn) GetSelectionCreateContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetSelectionCreateContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, true)
+ c.NewRequest(getSelectionCreateContextRequest(c), cookie)
+ return GetSelectionCreateContextCookie{cookie}
+}
+
+// GetSelectionCreateContextReply represents the data returned from a GetSelectionCreateContext request.
+type GetSelectionCreateContextReply struct {
+ Sequence uint16 // sequence number of the request for this reply
+ Length uint32 // number of bytes in this reply
+ // padding: 1 bytes
+ ContextLen uint32
+ // padding: 20 bytes
+ Context string // size: xgb.Pad((int(ContextLen) * 1))
+}
+
+// Reply blocks and returns the reply data for a GetSelectionCreateContext request.
+func (cook GetSelectionCreateContextCookie) Reply() (*GetSelectionCreateContextReply, error) {
+ buf, err := cook.Cookie.Reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return getSelectionCreateContextReply(buf), nil
+}
+
+// getSelectionCreateContextReply reads a byte slice into a GetSelectionCreateContextReply value.
+func getSelectionCreateContextReply(buf []byte) *GetSelectionCreateContextReply {
+ v := new(GetSelectionCreateContextReply)
+ 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.ContextLen = xgb.Get32(buf[b:])
+ b += 4
+
+ b += 20 // padding
+
+ {
+ byteString := make([]byte, v.ContextLen)
+ copy(byteString[:v.ContextLen], buf[b:])
+ v.Context = string(byteString)
+ b += int(v.ContextLen)
+ }
+
+ return v
+}
+
+// Write request to wire for GetSelectionCreateContext
+// getSelectionCreateContextRequest writes a GetSelectionCreateContext request to a byte slice.
+func getSelectionCreateContextRequest(c *xgb.Conn) []byte {
+ size := 4
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 16 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ return buf
+}
+
+// GetSelectionDataContextCookie is a cookie used only for GetSelectionDataContext requests.
+type GetSelectionDataContextCookie struct {
+ *xgb.Cookie
+}
+
+// GetSelectionDataContext sends a checked request.
+// If an error occurs, it will be returned with the reply by calling GetSelectionDataContextCookie.Reply()
+func GetSelectionDataContext(c *xgb.Conn, Selection xproto.Atom) GetSelectionDataContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetSelectionDataContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, true)
+ c.NewRequest(getSelectionDataContextRequest(c, Selection), cookie)
+ return GetSelectionDataContextCookie{cookie}
+}
+
+// GetSelectionDataContextUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func GetSelectionDataContextUnchecked(c *xgb.Conn, Selection xproto.Atom) GetSelectionDataContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetSelectionDataContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, true)
+ c.NewRequest(getSelectionDataContextRequest(c, Selection), cookie)
+ return GetSelectionDataContextCookie{cookie}
+}
+
+// GetSelectionDataContextReply represents the data returned from a GetSelectionDataContext request.
+type GetSelectionDataContextReply struct {
+ Sequence uint16 // sequence number of the request for this reply
+ Length uint32 // number of bytes in this reply
+ // padding: 1 bytes
+ ContextLen uint32
+ // padding: 20 bytes
+ Context string // size: xgb.Pad((int(ContextLen) * 1))
+}
+
+// Reply blocks and returns the reply data for a GetSelectionDataContext request.
+func (cook GetSelectionDataContextCookie) Reply() (*GetSelectionDataContextReply, error) {
+ buf, err := cook.Cookie.Reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return getSelectionDataContextReply(buf), nil
+}
+
+// getSelectionDataContextReply reads a byte slice into a GetSelectionDataContextReply value.
+func getSelectionDataContextReply(buf []byte) *GetSelectionDataContextReply {
+ v := new(GetSelectionDataContextReply)
+ 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.ContextLen = xgb.Get32(buf[b:])
+ b += 4
+
+ b += 20 // padding
+
+ {
+ byteString := make([]byte, v.ContextLen)
+ copy(byteString[:v.ContextLen], buf[b:])
+ v.Context = string(byteString)
+ b += int(v.ContextLen)
+ }
+
+ return v
+}
+
+// Write request to wire for GetSelectionDataContext
+// getSelectionDataContextRequest writes a GetSelectionDataContext request to a byte slice.
+func getSelectionDataContextRequest(c *xgb.Conn, Selection xproto.Atom) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 20 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ xgb.Put32(buf[b:], uint32(Selection))
+ b += 4
+
+ return buf
+}
+
+// GetSelectionUseContextCookie is a cookie used only for GetSelectionUseContext requests.
+type GetSelectionUseContextCookie struct {
+ *xgb.Cookie
+}
+
+// GetSelectionUseContext sends a checked request.
+// If an error occurs, it will be returned with the reply by calling GetSelectionUseContextCookie.Reply()
+func GetSelectionUseContext(c *xgb.Conn) GetSelectionUseContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetSelectionUseContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, true)
+ c.NewRequest(getSelectionUseContextRequest(c), cookie)
+ return GetSelectionUseContextCookie{cookie}
+}
+
+// GetSelectionUseContextUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func GetSelectionUseContextUnchecked(c *xgb.Conn) GetSelectionUseContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetSelectionUseContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, true)
+ c.NewRequest(getSelectionUseContextRequest(c), cookie)
+ return GetSelectionUseContextCookie{cookie}
+}
+
+// GetSelectionUseContextReply represents the data returned from a GetSelectionUseContext request.
+type GetSelectionUseContextReply struct {
+ Sequence uint16 // sequence number of the request for this reply
+ Length uint32 // number of bytes in this reply
+ // padding: 1 bytes
+ ContextLen uint32
+ // padding: 20 bytes
+ Context string // size: xgb.Pad((int(ContextLen) * 1))
+}
+
+// Reply blocks and returns the reply data for a GetSelectionUseContext request.
+func (cook GetSelectionUseContextCookie) Reply() (*GetSelectionUseContextReply, error) {
+ buf, err := cook.Cookie.Reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return getSelectionUseContextReply(buf), nil
+}
+
+// getSelectionUseContextReply reads a byte slice into a GetSelectionUseContextReply value.
+func getSelectionUseContextReply(buf []byte) *GetSelectionUseContextReply {
+ v := new(GetSelectionUseContextReply)
+ 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.ContextLen = xgb.Get32(buf[b:])
+ b += 4
+
+ b += 20 // padding
+
+ {
+ byteString := make([]byte, v.ContextLen)
+ copy(byteString[:v.ContextLen], buf[b:])
+ v.Context = string(byteString)
+ b += int(v.ContextLen)
+ }
+
+ return v
+}
+
+// Write request to wire for GetSelectionUseContext
+// getSelectionUseContextRequest writes a GetSelectionUseContext request to a byte slice.
+func getSelectionUseContextRequest(c *xgb.Conn) []byte {
+ size := 4
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 18 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ return buf
+}
+
+// GetWindowContextCookie is a cookie used only for GetWindowContext requests.
+type GetWindowContextCookie struct {
+ *xgb.Cookie
+}
+
+// GetWindowContext sends a checked request.
+// If an error occurs, it will be returned with the reply by calling GetWindowContextCookie.Reply()
+func GetWindowContext(c *xgb.Conn, Window xproto.Window) GetWindowContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetWindowContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, true)
+ c.NewRequest(getWindowContextRequest(c, Window), cookie)
+ return GetWindowContextCookie{cookie}
+}
+
+// GetWindowContextUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func GetWindowContextUnchecked(c *xgb.Conn, Window xproto.Window) GetWindowContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetWindowContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, true)
+ c.NewRequest(getWindowContextRequest(c, Window), cookie)
+ return GetWindowContextCookie{cookie}
+}
+
+// GetWindowContextReply represents the data returned from a GetWindowContext request.
+type GetWindowContextReply struct {
+ Sequence uint16 // sequence number of the request for this reply
+ Length uint32 // number of bytes in this reply
+ // padding: 1 bytes
+ ContextLen uint32
+ // padding: 20 bytes
+ Context string // size: xgb.Pad((int(ContextLen) * 1))
+}
+
+// Reply blocks and returns the reply data for a GetWindowContext request.
+func (cook GetWindowContextCookie) Reply() (*GetWindowContextReply, error) {
+ buf, err := cook.Cookie.Reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return getWindowContextReply(buf), nil
+}
+
+// getWindowContextReply reads a byte slice into a GetWindowContextReply value.
+func getWindowContextReply(buf []byte) *GetWindowContextReply {
+ v := new(GetWindowContextReply)
+ 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.ContextLen = xgb.Get32(buf[b:])
+ b += 4
+
+ b += 20 // padding
+
+ {
+ byteString := make([]byte, v.ContextLen)
+ copy(byteString[:v.ContextLen], buf[b:])
+ v.Context = string(byteString)
+ b += int(v.ContextLen)
+ }
+
+ return v
+}
+
+// Write request to wire for GetWindowContext
+// getWindowContextRequest writes a GetWindowContext request to a byte slice.
+func getWindowContextRequest(c *xgb.Conn, Window xproto.Window) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ 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(Window))
+ b += 4
+
+ return buf
+}
+
+// GetWindowCreateContextCookie is a cookie used only for GetWindowCreateContext requests.
+type GetWindowCreateContextCookie struct {
+ *xgb.Cookie
+}
+
+// GetWindowCreateContext sends a checked request.
+// If an error occurs, it will be returned with the reply by calling GetWindowCreateContextCookie.Reply()
+func GetWindowCreateContext(c *xgb.Conn) GetWindowCreateContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetWindowCreateContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, true)
+ c.NewRequest(getWindowCreateContextRequest(c), cookie)
+ return GetWindowCreateContextCookie{cookie}
+}
+
+// GetWindowCreateContextUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func GetWindowCreateContextUnchecked(c *xgb.Conn) GetWindowCreateContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'GetWindowCreateContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, true)
+ c.NewRequest(getWindowCreateContextRequest(c), cookie)
+ return GetWindowCreateContextCookie{cookie}
+}
+
+// GetWindowCreateContextReply represents the data returned from a GetWindowCreateContext request.
+type GetWindowCreateContextReply struct {
+ Sequence uint16 // sequence number of the request for this reply
+ Length uint32 // number of bytes in this reply
+ // padding: 1 bytes
+ ContextLen uint32
+ // padding: 20 bytes
+ Context string // size: xgb.Pad((int(ContextLen) * 1))
+}
+
+// Reply blocks and returns the reply data for a GetWindowCreateContext request.
+func (cook GetWindowCreateContextCookie) Reply() (*GetWindowCreateContextReply, error) {
+ buf, err := cook.Cookie.Reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return getWindowCreateContextReply(buf), nil
+}
+
+// getWindowCreateContextReply reads a byte slice into a GetWindowCreateContextReply value.
+func getWindowCreateContextReply(buf []byte) *GetWindowCreateContextReply {
+ v := new(GetWindowCreateContextReply)
+ 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.ContextLen = xgb.Get32(buf[b:])
+ b += 4
+
+ b += 20 // padding
+
+ {
+ byteString := make([]byte, v.ContextLen)
+ copy(byteString[:v.ContextLen], buf[b:])
+ v.Context = string(byteString)
+ b += int(v.ContextLen)
+ }
+
+ return v
+}
+
+// Write request to wire for GetWindowCreateContext
+// getWindowCreateContextRequest writes a GetWindowCreateContext request to a byte slice.
+func getWindowCreateContextRequest(c *xgb.Conn) []byte {
+ size := 4
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ 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
+
+ return buf
+}
+
+// ListPropertiesCookie is a cookie used only for ListProperties requests.
+type ListPropertiesCookie struct {
+ *xgb.Cookie
+}
+
+// ListProperties sends a checked request.
+// If an error occurs, it will be returned with the reply by calling ListPropertiesCookie.Reply()
+func ListProperties(c *xgb.Conn, Window xproto.Window) ListPropertiesCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'ListProperties' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, true)
+ c.NewRequest(listPropertiesRequest(c, Window), cookie)
+ return ListPropertiesCookie{cookie}
+}
+
+// ListPropertiesUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func ListPropertiesUnchecked(c *xgb.Conn, Window xproto.Window) ListPropertiesCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'ListProperties' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, true)
+ c.NewRequest(listPropertiesRequest(c, Window), cookie)
+ return ListPropertiesCookie{cookie}
+}
+
+// ListPropertiesReply represents the data returned from a ListProperties request.
+type ListPropertiesReply struct {
+ Sequence uint16 // sequence number of the request for this reply
+ Length uint32 // number of bytes in this reply
+ // padding: 1 bytes
+ PropertiesLen uint32
+ // padding: 20 bytes
+ Properties []ListItem // size: ListItemListSize(Properties)
+}
+
+// Reply blocks and returns the reply data for a ListProperties request.
+func (cook ListPropertiesCookie) Reply() (*ListPropertiesReply, error) {
+ buf, err := cook.Cookie.Reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return listPropertiesReply(buf), nil
+}
+
+// listPropertiesReply reads a byte slice into a ListPropertiesReply value.
+func listPropertiesReply(buf []byte) *ListPropertiesReply {
+ v := new(ListPropertiesReply)
+ 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.PropertiesLen = xgb.Get32(buf[b:])
+ b += 4
+
+ b += 20 // padding
+
+ v.Properties = make([]ListItem, v.PropertiesLen)
+ b += ListItemReadList(buf[b:], v.Properties)
+
+ return v
+}
+
+// Write request to wire for ListProperties
+// listPropertiesRequest writes a ListProperties request to a byte slice.
+func listPropertiesRequest(c *xgb.Conn, Window xproto.Window) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 14 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ xgb.Put32(buf[b:], uint32(Window))
+ b += 4
+
+ return buf
+}
+
+// ListSelectionsCookie is a cookie used only for ListSelections requests.
+type ListSelectionsCookie struct {
+ *xgb.Cookie
+}
+
+// ListSelections sends a checked request.
+// If an error occurs, it will be returned with the reply by calling ListSelectionsCookie.Reply()
+func ListSelections(c *xgb.Conn) ListSelectionsCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'ListSelections' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, true)
+ c.NewRequest(listSelectionsRequest(c), cookie)
+ return ListSelectionsCookie{cookie}
+}
+
+// ListSelectionsUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func ListSelectionsUnchecked(c *xgb.Conn) ListSelectionsCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'ListSelections' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, true)
+ c.NewRequest(listSelectionsRequest(c), cookie)
+ return ListSelectionsCookie{cookie}
+}
+
+// ListSelectionsReply represents the data returned from a ListSelections request.
+type ListSelectionsReply struct {
+ Sequence uint16 // sequence number of the request for this reply
+ Length uint32 // number of bytes in this reply
+ // padding: 1 bytes
+ SelectionsLen uint32
+ // padding: 20 bytes
+ Selections []ListItem // size: ListItemListSize(Selections)
+}
+
+// Reply blocks and returns the reply data for a ListSelections request.
+func (cook ListSelectionsCookie) Reply() (*ListSelectionsReply, error) {
+ buf, err := cook.Cookie.Reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return listSelectionsReply(buf), nil
+}
+
+// listSelectionsReply reads a byte slice into a ListSelectionsReply value.
+func listSelectionsReply(buf []byte) *ListSelectionsReply {
+ v := new(ListSelectionsReply)
+ 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.SelectionsLen = xgb.Get32(buf[b:])
+ b += 4
+
+ b += 20 // padding
+
+ v.Selections = make([]ListItem, v.SelectionsLen)
+ b += ListItemReadList(buf[b:], v.Selections)
+
+ return v
+}
+
+// Write request to wire for ListSelections
+// listSelectionsRequest writes a ListSelections request to a byte slice.
+func listSelectionsRequest(c *xgb.Conn) []byte {
+ size := 4
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 21 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ return buf
+}
+
+// QueryVersionCookie is a cookie used only for QueryVersion requests.
+type QueryVersionCookie struct {
+ *xgb.Cookie
+}
+
+// QueryVersion sends a checked request.
+// If an error occurs, it will be returned with the reply by calling QueryVersionCookie.Reply()
+func QueryVersion(c *xgb.Conn, ClientMajor byte, ClientMinor byte) QueryVersionCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'QueryVersion' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, true)
+ c.NewRequest(queryVersionRequest(c, ClientMajor, ClientMinor), cookie)
+ return QueryVersionCookie{cookie}
+}
+
+// QueryVersionUnchecked sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func QueryVersionUnchecked(c *xgb.Conn, ClientMajor byte, ClientMinor byte) QueryVersionCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'QueryVersion' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, true)
+ c.NewRequest(queryVersionRequest(c, ClientMajor, ClientMinor), cookie)
+ return QueryVersionCookie{cookie}
+}
+
+// QueryVersionReply represents the data returned from a QueryVersion request.
+type QueryVersionReply struct {
+ Sequence uint16 // sequence number of the request for this reply
+ Length uint32 // number of bytes in this reply
+ // padding: 1 bytes
+ ServerMajor uint16
+ ServerMinor uint16
+}
+
+// Reply blocks and returns the reply data for a QueryVersion request.
+func (cook QueryVersionCookie) Reply() (*QueryVersionReply, error) {
+ buf, err := cook.Cookie.Reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return queryVersionReply(buf), nil
+}
+
+// queryVersionReply reads a byte slice into a QueryVersionReply value.
+func queryVersionReply(buf []byte) *QueryVersionReply {
+ v := new(QueryVersionReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = xgb.Get16(buf[b:])
+ b += 2
+
+ v.Length = xgb.Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.ServerMajor = xgb.Get16(buf[b:])
+ b += 2
+
+ v.ServerMinor = xgb.Get16(buf[b:])
+ b += 2
+
+ return v
+}
+
+// Write request to wire for QueryVersion
+// queryVersionRequest writes a QueryVersion request to a byte slice.
+func queryVersionRequest(c *xgb.Conn, ClientMajor byte, ClientMinor byte) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 0 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ buf[b] = ClientMajor
+ b += 1
+
+ buf[b] = ClientMinor
+ b += 1
+
+ return buf
+}
+
+// SetDeviceContextCookie is a cookie used only for SetDeviceContext requests.
+type SetDeviceContextCookie struct {
+ *xgb.Cookie
+}
+
+// SetDeviceContext sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func SetDeviceContext(c *xgb.Conn, Device uint32, ContextLen uint32, Context string) SetDeviceContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'SetDeviceContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, false)
+ c.NewRequest(setDeviceContextRequest(c, Device, ContextLen, Context), cookie)
+ return SetDeviceContextCookie{cookie}
+}
+
+// SetDeviceContextChecked sends a checked request.
+// If an error occurs, it can be retrieved using SetDeviceContextCookie.Check()
+func SetDeviceContextChecked(c *xgb.Conn, Device uint32, ContextLen uint32, Context string) SetDeviceContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'SetDeviceContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, false)
+ c.NewRequest(setDeviceContextRequest(c, Device, ContextLen, Context), cookie)
+ return SetDeviceContextCookie{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 SetDeviceContextCookie) Check() error {
+ return cook.Cookie.Check()
+}
+
+// Write request to wire for SetDeviceContext
+// setDeviceContextRequest writes a SetDeviceContext request to a byte slice.
+func setDeviceContextRequest(c *xgb.Conn, Device uint32, ContextLen uint32, Context string) []byte {
+ size := xgb.Pad((12 + xgb.Pad((int(ContextLen) * 1))))
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 3 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ xgb.Put32(buf[b:], Device)
+ b += 4
+
+ xgb.Put32(buf[b:], ContextLen)
+ b += 4
+
+ copy(buf[b:], Context[:ContextLen])
+ b += int(ContextLen)
+
+ return buf
+}
+
+// SetDeviceCreateContextCookie is a cookie used only for SetDeviceCreateContext requests.
+type SetDeviceCreateContextCookie struct {
+ *xgb.Cookie
+}
+
+// SetDeviceCreateContext sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func SetDeviceCreateContext(c *xgb.Conn, ContextLen uint32, Context string) SetDeviceCreateContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'SetDeviceCreateContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, false)
+ c.NewRequest(setDeviceCreateContextRequest(c, ContextLen, Context), cookie)
+ return SetDeviceCreateContextCookie{cookie}
+}
+
+// SetDeviceCreateContextChecked sends a checked request.
+// If an error occurs, it can be retrieved using SetDeviceCreateContextCookie.Check()
+func SetDeviceCreateContextChecked(c *xgb.Conn, ContextLen uint32, Context string) SetDeviceCreateContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'SetDeviceCreateContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, false)
+ c.NewRequest(setDeviceCreateContextRequest(c, ContextLen, Context), cookie)
+ return SetDeviceCreateContextCookie{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 SetDeviceCreateContextCookie) Check() error {
+ return cook.Cookie.Check()
+}
+
+// Write request to wire for SetDeviceCreateContext
+// setDeviceCreateContextRequest writes a SetDeviceCreateContext request to a byte slice.
+func setDeviceCreateContextRequest(c *xgb.Conn, ContextLen uint32, Context string) []byte {
+ size := xgb.Pad((8 + xgb.Pad((int(ContextLen) * 1))))
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 1 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ xgb.Put32(buf[b:], ContextLen)
+ b += 4
+
+ copy(buf[b:], Context[:ContextLen])
+ b += int(ContextLen)
+
+ return buf
+}
+
+// SetPropertyCreateContextCookie is a cookie used only for SetPropertyCreateContext requests.
+type SetPropertyCreateContextCookie struct {
+ *xgb.Cookie
+}
+
+// SetPropertyCreateContext sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func SetPropertyCreateContext(c *xgb.Conn, ContextLen uint32, Context string) SetPropertyCreateContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'SetPropertyCreateContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, false)
+ c.NewRequest(setPropertyCreateContextRequest(c, ContextLen, Context), cookie)
+ return SetPropertyCreateContextCookie{cookie}
+}
+
+// SetPropertyCreateContextChecked sends a checked request.
+// If an error occurs, it can be retrieved using SetPropertyCreateContextCookie.Check()
+func SetPropertyCreateContextChecked(c *xgb.Conn, ContextLen uint32, Context string) SetPropertyCreateContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'SetPropertyCreateContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, false)
+ c.NewRequest(setPropertyCreateContextRequest(c, ContextLen, Context), cookie)
+ return SetPropertyCreateContextCookie{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 SetPropertyCreateContextCookie) Check() error {
+ return cook.Cookie.Check()
+}
+
+// Write request to wire for SetPropertyCreateContext
+// setPropertyCreateContextRequest writes a SetPropertyCreateContext request to a byte slice.
+func setPropertyCreateContextRequest(c *xgb.Conn, ContextLen uint32, Context string) []byte {
+ size := xgb.Pad((8 + xgb.Pad((int(ContextLen) * 1))))
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 8 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ xgb.Put32(buf[b:], ContextLen)
+ b += 4
+
+ copy(buf[b:], Context[:ContextLen])
+ b += int(ContextLen)
+
+ return buf
+}
+
+// SetPropertyUseContextCookie is a cookie used only for SetPropertyUseContext requests.
+type SetPropertyUseContextCookie struct {
+ *xgb.Cookie
+}
+
+// SetPropertyUseContext sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func SetPropertyUseContext(c *xgb.Conn, ContextLen uint32, Context string) SetPropertyUseContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'SetPropertyUseContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, false)
+ c.NewRequest(setPropertyUseContextRequest(c, ContextLen, Context), cookie)
+ return SetPropertyUseContextCookie{cookie}
+}
+
+// SetPropertyUseContextChecked sends a checked request.
+// If an error occurs, it can be retrieved using SetPropertyUseContextCookie.Check()
+func SetPropertyUseContextChecked(c *xgb.Conn, ContextLen uint32, Context string) SetPropertyUseContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'SetPropertyUseContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, false)
+ c.NewRequest(setPropertyUseContextRequest(c, ContextLen, Context), cookie)
+ return SetPropertyUseContextCookie{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 SetPropertyUseContextCookie) Check() error {
+ return cook.Cookie.Check()
+}
+
+// Write request to wire for SetPropertyUseContext
+// setPropertyUseContextRequest writes a SetPropertyUseContext request to a byte slice.
+func setPropertyUseContextRequest(c *xgb.Conn, ContextLen uint32, Context string) []byte {
+ size := xgb.Pad((8 + xgb.Pad((int(ContextLen) * 1))))
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 10 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ xgb.Put32(buf[b:], ContextLen)
+ b += 4
+
+ copy(buf[b:], Context[:ContextLen])
+ b += int(ContextLen)
+
+ return buf
+}
+
+// SetSelectionCreateContextCookie is a cookie used only for SetSelectionCreateContext requests.
+type SetSelectionCreateContextCookie struct {
+ *xgb.Cookie
+}
+
+// SetSelectionCreateContext sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func SetSelectionCreateContext(c *xgb.Conn, ContextLen uint32, Context string) SetSelectionCreateContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'SetSelectionCreateContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, false)
+ c.NewRequest(setSelectionCreateContextRequest(c, ContextLen, Context), cookie)
+ return SetSelectionCreateContextCookie{cookie}
+}
+
+// SetSelectionCreateContextChecked sends a checked request.
+// If an error occurs, it can be retrieved using SetSelectionCreateContextCookie.Check()
+func SetSelectionCreateContextChecked(c *xgb.Conn, ContextLen uint32, Context string) SetSelectionCreateContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'SetSelectionCreateContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, false)
+ c.NewRequest(setSelectionCreateContextRequest(c, ContextLen, Context), cookie)
+ return SetSelectionCreateContextCookie{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 SetSelectionCreateContextCookie) Check() error {
+ return cook.Cookie.Check()
+}
+
+// Write request to wire for SetSelectionCreateContext
+// setSelectionCreateContextRequest writes a SetSelectionCreateContext request to a byte slice.
+func setSelectionCreateContextRequest(c *xgb.Conn, ContextLen uint32, Context string) []byte {
+ size := xgb.Pad((8 + xgb.Pad((int(ContextLen) * 1))))
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 15 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ xgb.Put32(buf[b:], ContextLen)
+ b += 4
+
+ copy(buf[b:], Context[:ContextLen])
+ b += int(ContextLen)
+
+ return buf
+}
+
+// SetSelectionUseContextCookie is a cookie used only for SetSelectionUseContext requests.
+type SetSelectionUseContextCookie struct {
+ *xgb.Cookie
+}
+
+// SetSelectionUseContext sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func SetSelectionUseContext(c *xgb.Conn, ContextLen uint32, Context string) SetSelectionUseContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'SetSelectionUseContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, false)
+ c.NewRequest(setSelectionUseContextRequest(c, ContextLen, Context), cookie)
+ return SetSelectionUseContextCookie{cookie}
+}
+
+// SetSelectionUseContextChecked sends a checked request.
+// If an error occurs, it can be retrieved using SetSelectionUseContextCookie.Check()
+func SetSelectionUseContextChecked(c *xgb.Conn, ContextLen uint32, Context string) SetSelectionUseContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'SetSelectionUseContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, false)
+ c.NewRequest(setSelectionUseContextRequest(c, ContextLen, Context), cookie)
+ return SetSelectionUseContextCookie{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 SetSelectionUseContextCookie) Check() error {
+ return cook.Cookie.Check()
+}
+
+// Write request to wire for SetSelectionUseContext
+// setSelectionUseContextRequest writes a SetSelectionUseContext request to a byte slice.
+func setSelectionUseContextRequest(c *xgb.Conn, ContextLen uint32, Context string) []byte {
+ size := xgb.Pad((8 + xgb.Pad((int(ContextLen) * 1))))
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ b += 1
+
+ buf[b] = 17 // request opcode
+ b += 1
+
+ xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ xgb.Put32(buf[b:], ContextLen)
+ b += 4
+
+ copy(buf[b:], Context[:ContextLen])
+ b += int(ContextLen)
+
+ return buf
+}
+
+// SetWindowCreateContextCookie is a cookie used only for SetWindowCreateContext requests.
+type SetWindowCreateContextCookie struct {
+ *xgb.Cookie
+}
+
+// SetWindowCreateContext sends an unchecked request.
+// If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
+func SetWindowCreateContext(c *xgb.Conn, ContextLen uint32, Context string) SetWindowCreateContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'SetWindowCreateContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(false, false)
+ c.NewRequest(setWindowCreateContextRequest(c, ContextLen, Context), cookie)
+ return SetWindowCreateContextCookie{cookie}
+}
+
+// SetWindowCreateContextChecked sends a checked request.
+// If an error occurs, it can be retrieved using SetWindowCreateContextCookie.Check()
+func SetWindowCreateContextChecked(c *xgb.Conn, ContextLen uint32, Context string) SetWindowCreateContextCookie {
+ c.ExtLock.RLock()
+ defer c.ExtLock.RUnlock()
+ if _, ok := c.Extensions["SELinux"]; !ok {
+ panic("Cannot issue request 'SetWindowCreateContext' using the uninitialized extension 'SELinux'. xselinux.Init(connObj) must be called first.")
+ }
+ cookie := c.NewCookie(true, false)
+ c.NewRequest(setWindowCreateContextRequest(c, ContextLen, Context), cookie)
+ return SetWindowCreateContextCookie{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 SetWindowCreateContextCookie) Check() error {
+ return cook.Cookie.Check()
+}
+
+// Write request to wire for SetWindowCreateContext
+// setWindowCreateContextRequest writes a SetWindowCreateContext request to a byte slice.
+func setWindowCreateContextRequest(c *xgb.Conn, ContextLen uint32, Context string) []byte {
+ size := xgb.Pad((8 + xgb.Pad((int(ContextLen) * 1))))
+ b := 0
+ buf := make([]byte, size)
+
+ c.ExtLock.RLock()
+ buf[b] = c.Extensions["SELinux"]
+ c.ExtLock.RUnlock()
+ 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:], ContextLen)
+ b += 4
+
+ copy(buf[b:], Context[:ContextLen])
+ b += int(ContextLen)
+
+ return buf
+}