xinerama.go

Documentation: github.com/jezek/xgb/xinerama

     1  // Package xinerama is the X client API for the XINERAMA extension.
     2  package xinerama
     3  
     4  // This file is automatically generated from xinerama.xml. Edit at your peril!
     5  
     6  import (
     7  	"github.com/jezek/xgb"
     8  
     9  	"github.com/jezek/xgb/xproto"
    10  )
    11  
    12  // Init must be called before using the XINERAMA extension.
    13  func Init(c *xgb.Conn) error {
    14  	reply, err := xproto.QueryExtension(c, 8, "XINERAMA").Reply()
    15  	switch {
    16  	case err != nil:
    17  		return err
    18  	case !reply.Present:
    19  		return xgb.Errorf("No extension named XINERAMA could be found on on the server.")
    20  	}
    21  
    22  	c.ExtLock.Lock()
    23  	c.Extensions["XINERAMA"] = reply.MajorOpcode
    24  	c.ExtLock.Unlock()
    25  	for evNum, fun := range xgb.NewExtEventFuncs["XINERAMA"] {
    26  		xgb.NewEventFuncs[int(reply.FirstEvent)+evNum] = fun
    27  	}
    28  	for errNum, fun := range xgb.NewExtErrorFuncs["XINERAMA"] {
    29  		xgb.NewErrorFuncs[int(reply.FirstError)+errNum] = fun
    30  	}
    31  	return nil
    32  }
    33  
    34  func init() {
    35  	xgb.NewExtEventFuncs["XINERAMA"] = make(map[int]xgb.NewEventFun)
    36  	xgb.NewExtErrorFuncs["XINERAMA"] = make(map[int]xgb.NewErrorFun)
    37  }
    38  
    39  type ScreenInfo struct {
    40  	XOrg   int16
    41  	YOrg   int16
    42  	Width  uint16
    43  	Height uint16
    44  }
    45  
    46  // ScreenInfoRead reads a byte slice into a ScreenInfo value.
    47  func ScreenInfoRead(buf []byte, v *ScreenInfo) int {
    48  	b := 0
    49  
    50  	v.XOrg = int16(xgb.Get16(buf[b:]))
    51  	b += 2
    52  
    53  	v.YOrg = int16(xgb.Get16(buf[b:]))
    54  	b += 2
    55  
    56  	v.Width = xgb.Get16(buf[b:])
    57  	b += 2
    58  
    59  	v.Height = xgb.Get16(buf[b:])
    60  	b += 2
    61  
    62  	return b
    63  }
    64  
    65  // ScreenInfoReadList reads a byte slice into a list of ScreenInfo values.
    66  func ScreenInfoReadList(buf []byte, dest []ScreenInfo) int {
    67  	b := 0
    68  	for i := 0; i < len(dest); i++ {
    69  		dest[i] = ScreenInfo{}
    70  		b += ScreenInfoRead(buf[b:], &dest[i])
    71  	}
    72  	return xgb.Pad(b)
    73  }
    74  
    75  // Bytes writes a ScreenInfo value to a byte slice.
    76  func (v ScreenInfo) Bytes() []byte {
    77  	buf := make([]byte, 8)
    78  	b := 0
    79  
    80  	xgb.Put16(buf[b:], uint16(v.XOrg))
    81  	b += 2
    82  
    83  	xgb.Put16(buf[b:], uint16(v.YOrg))
    84  	b += 2
    85  
    86  	xgb.Put16(buf[b:], v.Width)
    87  	b += 2
    88  
    89  	xgb.Put16(buf[b:], v.Height)
    90  	b += 2
    91  
    92  	return buf[:b]
    93  }
    94  
    95  // ScreenInfoListBytes writes a list of ScreenInfo values to a byte slice.
    96  func ScreenInfoListBytes(buf []byte, list []ScreenInfo) int {
    97  	b := 0
    98  	var structBytes []byte
    99  	for _, item := range list {
   100  		structBytes = item.Bytes()
   101  		copy(buf[b:], structBytes)
   102  		b += len(structBytes)
   103  	}
   104  	return xgb.Pad(b)
   105  }
   106  
   107  // Skipping definition for base type 'Bool'
   108  
   109  // Skipping definition for base type 'Byte'
   110  
   111  // Skipping definition for base type 'Card8'
   112  
   113  // Skipping definition for base type 'Char'
   114  
   115  // Skipping definition for base type 'Void'
   116  
   117  // Skipping definition for base type 'Double'
   118  
   119  // Skipping definition for base type 'Float'
   120  
   121  // Skipping definition for base type 'Int16'
   122  
   123  // Skipping definition for base type 'Int32'
   124  
   125  // Skipping definition for base type 'Int8'
   126  
   127  // Skipping definition for base type 'Card16'
   128  
   129  // Skipping definition for base type 'Card32'
   130  
   131  // GetScreenCountCookie is a cookie used only for GetScreenCount requests.
   132  type GetScreenCountCookie struct {
   133  	*xgb.Cookie
   134  }
   135  
   136  // GetScreenCount sends a checked request.
   137  // If an error occurs, it will be returned with the reply by calling GetScreenCountCookie.Reply()
   138  func GetScreenCount(c *xgb.Conn, Window xproto.Window) GetScreenCountCookie {
   139  	c.ExtLock.RLock()
   140  	defer c.ExtLock.RUnlock()
   141  	if _, ok := c.Extensions["XINERAMA"]; !ok {
   142  		panic("Cannot issue request 'GetScreenCount' using the uninitialized extension 'XINERAMA'. xinerama.Init(connObj) must be called first.")
   143  	}
   144  	cookie := c.NewCookie(true, true)
   145  	c.NewRequest(getScreenCountRequest(c, Window), cookie)
   146  	return GetScreenCountCookie{cookie}
   147  }
   148  
   149  // GetScreenCountUnchecked sends an unchecked request.
   150  // If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
   151  func GetScreenCountUnchecked(c *xgb.Conn, Window xproto.Window) GetScreenCountCookie {
   152  	c.ExtLock.RLock()
   153  	defer c.ExtLock.RUnlock()
   154  	if _, ok := c.Extensions["XINERAMA"]; !ok {
   155  		panic("Cannot issue request 'GetScreenCount' using the uninitialized extension 'XINERAMA'. xinerama.Init(connObj) must be called first.")
   156  	}
   157  	cookie := c.NewCookie(false, true)
   158  	c.NewRequest(getScreenCountRequest(c, Window), cookie)
   159  	return GetScreenCountCookie{cookie}
   160  }
   161  
   162  // GetScreenCountReply represents the data returned from a GetScreenCount request.
   163  type GetScreenCountReply struct {
   164  	Sequence    uint16 // sequence number of the request for this reply
   165  	Length      uint32 // number of bytes in this reply
   166  	ScreenCount byte
   167  	Window      xproto.Window
   168  }
   169  
   170  // Reply blocks and returns the reply data for a GetScreenCount request.
   171  func (cook GetScreenCountCookie) Reply() (*GetScreenCountReply, error) {
   172  	buf, err := cook.Cookie.Reply()
   173  	if err != nil {
   174  		return nil, err
   175  	}
   176  	if buf == nil {
   177  		return nil, nil
   178  	}
   179  	return getScreenCountReply(buf), nil
   180  }
   181  
   182  // getScreenCountReply reads a byte slice into a GetScreenCountReply value.
   183  func getScreenCountReply(buf []byte) *GetScreenCountReply {
   184  	v := new(GetScreenCountReply)
   185  	b := 1 // skip reply determinant
   186  
   187  	v.ScreenCount = buf[b]
   188  	b += 1
   189  
   190  	v.Sequence = xgb.Get16(buf[b:])
   191  	b += 2
   192  
   193  	v.Length = xgb.Get32(buf[b:]) // 4-byte units
   194  	b += 4
   195  
   196  	v.Window = xproto.Window(xgb.Get32(buf[b:]))
   197  	b += 4
   198  
   199  	return v
   200  }
   201  
   202  // Write request to wire for GetScreenCount
   203  // getScreenCountRequest writes a GetScreenCount request to a byte slice.
   204  func getScreenCountRequest(c *xgb.Conn, Window xproto.Window) []byte {
   205  	size := 8
   206  	b := 0
   207  	buf := make([]byte, size)
   208  
   209  	c.ExtLock.RLock()
   210  	buf[b] = c.Extensions["XINERAMA"]
   211  	c.ExtLock.RUnlock()
   212  	b += 1
   213  
   214  	buf[b] = 2 // request opcode
   215  	b += 1
   216  
   217  	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
   218  	b += 2
   219  
   220  	xgb.Put32(buf[b:], uint32(Window))
   221  	b += 4
   222  
   223  	return buf
   224  }
   225  
   226  // GetScreenSizeCookie is a cookie used only for GetScreenSize requests.
   227  type GetScreenSizeCookie struct {
   228  	*xgb.Cookie
   229  }
   230  
   231  // GetScreenSize sends a checked request.
   232  // If an error occurs, it will be returned with the reply by calling GetScreenSizeCookie.Reply()
   233  func GetScreenSize(c *xgb.Conn, Window xproto.Window, Screen uint32) GetScreenSizeCookie {
   234  	c.ExtLock.RLock()
   235  	defer c.ExtLock.RUnlock()
   236  	if _, ok := c.Extensions["XINERAMA"]; !ok {
   237  		panic("Cannot issue request 'GetScreenSize' using the uninitialized extension 'XINERAMA'. xinerama.Init(connObj) must be called first.")
   238  	}
   239  	cookie := c.NewCookie(true, true)
   240  	c.NewRequest(getScreenSizeRequest(c, Window, Screen), cookie)
   241  	return GetScreenSizeCookie{cookie}
   242  }
   243  
   244  // GetScreenSizeUnchecked sends an unchecked request.
   245  // If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
   246  func GetScreenSizeUnchecked(c *xgb.Conn, Window xproto.Window, Screen uint32) GetScreenSizeCookie {
   247  	c.ExtLock.RLock()
   248  	defer c.ExtLock.RUnlock()
   249  	if _, ok := c.Extensions["XINERAMA"]; !ok {
   250  		panic("Cannot issue request 'GetScreenSize' using the uninitialized extension 'XINERAMA'. xinerama.Init(connObj) must be called first.")
   251  	}
   252  	cookie := c.NewCookie(false, true)
   253  	c.NewRequest(getScreenSizeRequest(c, Window, Screen), cookie)
   254  	return GetScreenSizeCookie{cookie}
   255  }
   256  
   257  // GetScreenSizeReply represents the data returned from a GetScreenSize request.
   258  type GetScreenSizeReply struct {
   259  	Sequence uint16 // sequence number of the request for this reply
   260  	Length   uint32 // number of bytes in this reply
   261  	// padding: 1 bytes
   262  	Width  uint32
   263  	Height uint32
   264  	Window xproto.Window
   265  	Screen uint32
   266  }
   267  
   268  // Reply blocks and returns the reply data for a GetScreenSize request.
   269  func (cook GetScreenSizeCookie) Reply() (*GetScreenSizeReply, error) {
   270  	buf, err := cook.Cookie.Reply()
   271  	if err != nil {
   272  		return nil, err
   273  	}
   274  	if buf == nil {
   275  		return nil, nil
   276  	}
   277  	return getScreenSizeReply(buf), nil
   278  }
   279  
   280  // getScreenSizeReply reads a byte slice into a GetScreenSizeReply value.
   281  func getScreenSizeReply(buf []byte) *GetScreenSizeReply {
   282  	v := new(GetScreenSizeReply)
   283  	b := 1 // skip reply determinant
   284  
   285  	b += 1 // padding
   286  
   287  	v.Sequence = xgb.Get16(buf[b:])
   288  	b += 2
   289  
   290  	v.Length = xgb.Get32(buf[b:]) // 4-byte units
   291  	b += 4
   292  
   293  	v.Width = xgb.Get32(buf[b:])
   294  	b += 4
   295  
   296  	v.Height = xgb.Get32(buf[b:])
   297  	b += 4
   298  
   299  	v.Window = xproto.Window(xgb.Get32(buf[b:]))
   300  	b += 4
   301  
   302  	v.Screen = xgb.Get32(buf[b:])
   303  	b += 4
   304  
   305  	return v
   306  }
   307  
   308  // Write request to wire for GetScreenSize
   309  // getScreenSizeRequest writes a GetScreenSize request to a byte slice.
   310  func getScreenSizeRequest(c *xgb.Conn, Window xproto.Window, Screen uint32) []byte {
   311  	size := 12
   312  	b := 0
   313  	buf := make([]byte, size)
   314  
   315  	c.ExtLock.RLock()
   316  	buf[b] = c.Extensions["XINERAMA"]
   317  	c.ExtLock.RUnlock()
   318  	b += 1
   319  
   320  	buf[b] = 3 // request opcode
   321  	b += 1
   322  
   323  	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
   324  	b += 2
   325  
   326  	xgb.Put32(buf[b:], uint32(Window))
   327  	b += 4
   328  
   329  	xgb.Put32(buf[b:], Screen)
   330  	b += 4
   331  
   332  	return buf
   333  }
   334  
   335  // GetStateCookie is a cookie used only for GetState requests.
   336  type GetStateCookie struct {
   337  	*xgb.Cookie
   338  }
   339  
   340  // GetState sends a checked request.
   341  // If an error occurs, it will be returned with the reply by calling GetStateCookie.Reply()
   342  func GetState(c *xgb.Conn, Window xproto.Window) GetStateCookie {
   343  	c.ExtLock.RLock()
   344  	defer c.ExtLock.RUnlock()
   345  	if _, ok := c.Extensions["XINERAMA"]; !ok {
   346  		panic("Cannot issue request 'GetState' using the uninitialized extension 'XINERAMA'. xinerama.Init(connObj) must be called first.")
   347  	}
   348  	cookie := c.NewCookie(true, true)
   349  	c.NewRequest(getStateRequest(c, Window), cookie)
   350  	return GetStateCookie{cookie}
   351  }
   352  
   353  // GetStateUnchecked sends an unchecked request.
   354  // If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
   355  func GetStateUnchecked(c *xgb.Conn, Window xproto.Window) GetStateCookie {
   356  	c.ExtLock.RLock()
   357  	defer c.ExtLock.RUnlock()
   358  	if _, ok := c.Extensions["XINERAMA"]; !ok {
   359  		panic("Cannot issue request 'GetState' using the uninitialized extension 'XINERAMA'. xinerama.Init(connObj) must be called first.")
   360  	}
   361  	cookie := c.NewCookie(false, true)
   362  	c.NewRequest(getStateRequest(c, Window), cookie)
   363  	return GetStateCookie{cookie}
   364  }
   365  
   366  // GetStateReply represents the data returned from a GetState request.
   367  type GetStateReply struct {
   368  	Sequence uint16 // sequence number of the request for this reply
   369  	Length   uint32 // number of bytes in this reply
   370  	State    byte
   371  	Window   xproto.Window
   372  }
   373  
   374  // Reply blocks and returns the reply data for a GetState request.
   375  func (cook GetStateCookie) Reply() (*GetStateReply, error) {
   376  	buf, err := cook.Cookie.Reply()
   377  	if err != nil {
   378  		return nil, err
   379  	}
   380  	if buf == nil {
   381  		return nil, nil
   382  	}
   383  	return getStateReply(buf), nil
   384  }
   385  
   386  // getStateReply reads a byte slice into a GetStateReply value.
   387  func getStateReply(buf []byte) *GetStateReply {
   388  	v := new(GetStateReply)
   389  	b := 1 // skip reply determinant
   390  
   391  	v.State = buf[b]
   392  	b += 1
   393  
   394  	v.Sequence = xgb.Get16(buf[b:])
   395  	b += 2
   396  
   397  	v.Length = xgb.Get32(buf[b:]) // 4-byte units
   398  	b += 4
   399  
   400  	v.Window = xproto.Window(xgb.Get32(buf[b:]))
   401  	b += 4
   402  
   403  	return v
   404  }
   405  
   406  // Write request to wire for GetState
   407  // getStateRequest writes a GetState request to a byte slice.
   408  func getStateRequest(c *xgb.Conn, Window xproto.Window) []byte {
   409  	size := 8
   410  	b := 0
   411  	buf := make([]byte, size)
   412  
   413  	c.ExtLock.RLock()
   414  	buf[b] = c.Extensions["XINERAMA"]
   415  	c.ExtLock.RUnlock()
   416  	b += 1
   417  
   418  	buf[b] = 1 // request opcode
   419  	b += 1
   420  
   421  	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
   422  	b += 2
   423  
   424  	xgb.Put32(buf[b:], uint32(Window))
   425  	b += 4
   426  
   427  	return buf
   428  }
   429  
   430  // IsActiveCookie is a cookie used only for IsActive requests.
   431  type IsActiveCookie struct {
   432  	*xgb.Cookie
   433  }
   434  
   435  // IsActive sends a checked request.
   436  // If an error occurs, it will be returned with the reply by calling IsActiveCookie.Reply()
   437  func IsActive(c *xgb.Conn) IsActiveCookie {
   438  	c.ExtLock.RLock()
   439  	defer c.ExtLock.RUnlock()
   440  	if _, ok := c.Extensions["XINERAMA"]; !ok {
   441  		panic("Cannot issue request 'IsActive' using the uninitialized extension 'XINERAMA'. xinerama.Init(connObj) must be called first.")
   442  	}
   443  	cookie := c.NewCookie(true, true)
   444  	c.NewRequest(isActiveRequest(c), cookie)
   445  	return IsActiveCookie{cookie}
   446  }
   447  
   448  // IsActiveUnchecked sends an unchecked request.
   449  // If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
   450  func IsActiveUnchecked(c *xgb.Conn) IsActiveCookie {
   451  	c.ExtLock.RLock()
   452  	defer c.ExtLock.RUnlock()
   453  	if _, ok := c.Extensions["XINERAMA"]; !ok {
   454  		panic("Cannot issue request 'IsActive' using the uninitialized extension 'XINERAMA'. xinerama.Init(connObj) must be called first.")
   455  	}
   456  	cookie := c.NewCookie(false, true)
   457  	c.NewRequest(isActiveRequest(c), cookie)
   458  	return IsActiveCookie{cookie}
   459  }
   460  
   461  // IsActiveReply represents the data returned from a IsActive request.
   462  type IsActiveReply struct {
   463  	Sequence uint16 // sequence number of the request for this reply
   464  	Length   uint32 // number of bytes in this reply
   465  	// padding: 1 bytes
   466  	State uint32
   467  }
   468  
   469  // Reply blocks and returns the reply data for a IsActive request.
   470  func (cook IsActiveCookie) Reply() (*IsActiveReply, error) {
   471  	buf, err := cook.Cookie.Reply()
   472  	if err != nil {
   473  		return nil, err
   474  	}
   475  	if buf == nil {
   476  		return nil, nil
   477  	}
   478  	return isActiveReply(buf), nil
   479  }
   480  
   481  // isActiveReply reads a byte slice into a IsActiveReply value.
   482  func isActiveReply(buf []byte) *IsActiveReply {
   483  	v := new(IsActiveReply)
   484  	b := 1 // skip reply determinant
   485  
   486  	b += 1 // padding
   487  
   488  	v.Sequence = xgb.Get16(buf[b:])
   489  	b += 2
   490  
   491  	v.Length = xgb.Get32(buf[b:]) // 4-byte units
   492  	b += 4
   493  
   494  	v.State = xgb.Get32(buf[b:])
   495  	b += 4
   496  
   497  	return v
   498  }
   499  
   500  // Write request to wire for IsActive
   501  // isActiveRequest writes a IsActive request to a byte slice.
   502  func isActiveRequest(c *xgb.Conn) []byte {
   503  	size := 4
   504  	b := 0
   505  	buf := make([]byte, size)
   506  
   507  	c.ExtLock.RLock()
   508  	buf[b] = c.Extensions["XINERAMA"]
   509  	c.ExtLock.RUnlock()
   510  	b += 1
   511  
   512  	buf[b] = 4 // request opcode
   513  	b += 1
   514  
   515  	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
   516  	b += 2
   517  
   518  	return buf
   519  }
   520  
   521  // QueryScreensCookie is a cookie used only for QueryScreens requests.
   522  type QueryScreensCookie struct {
   523  	*xgb.Cookie
   524  }
   525  
   526  // QueryScreens sends a checked request.
   527  // If an error occurs, it will be returned with the reply by calling QueryScreensCookie.Reply()
   528  func QueryScreens(c *xgb.Conn) QueryScreensCookie {
   529  	c.ExtLock.RLock()
   530  	defer c.ExtLock.RUnlock()
   531  	if _, ok := c.Extensions["XINERAMA"]; !ok {
   532  		panic("Cannot issue request 'QueryScreens' using the uninitialized extension 'XINERAMA'. xinerama.Init(connObj) must be called first.")
   533  	}
   534  	cookie := c.NewCookie(true, true)
   535  	c.NewRequest(queryScreensRequest(c), cookie)
   536  	return QueryScreensCookie{cookie}
   537  }
   538  
   539  // QueryScreensUnchecked sends an unchecked request.
   540  // If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
   541  func QueryScreensUnchecked(c *xgb.Conn) QueryScreensCookie {
   542  	c.ExtLock.RLock()
   543  	defer c.ExtLock.RUnlock()
   544  	if _, ok := c.Extensions["XINERAMA"]; !ok {
   545  		panic("Cannot issue request 'QueryScreens' using the uninitialized extension 'XINERAMA'. xinerama.Init(connObj) must be called first.")
   546  	}
   547  	cookie := c.NewCookie(false, true)
   548  	c.NewRequest(queryScreensRequest(c), cookie)
   549  	return QueryScreensCookie{cookie}
   550  }
   551  
   552  // QueryScreensReply represents the data returned from a QueryScreens request.
   553  type QueryScreensReply struct {
   554  	Sequence uint16 // sequence number of the request for this reply
   555  	Length   uint32 // number of bytes in this reply
   556  	// padding: 1 bytes
   557  	Number uint32
   558  	// padding: 20 bytes
   559  	ScreenInfo []ScreenInfo // size: xgb.Pad((int(Number) * 8))
   560  }
   561  
   562  // Reply blocks and returns the reply data for a QueryScreens request.
   563  func (cook QueryScreensCookie) Reply() (*QueryScreensReply, error) {
   564  	buf, err := cook.Cookie.Reply()
   565  	if err != nil {
   566  		return nil, err
   567  	}
   568  	if buf == nil {
   569  		return nil, nil
   570  	}
   571  	return queryScreensReply(buf), nil
   572  }
   573  
   574  // queryScreensReply reads a byte slice into a QueryScreensReply value.
   575  func queryScreensReply(buf []byte) *QueryScreensReply {
   576  	v := new(QueryScreensReply)
   577  	b := 1 // skip reply determinant
   578  
   579  	b += 1 // padding
   580  
   581  	v.Sequence = xgb.Get16(buf[b:])
   582  	b += 2
   583  
   584  	v.Length = xgb.Get32(buf[b:]) // 4-byte units
   585  	b += 4
   586  
   587  	v.Number = xgb.Get32(buf[b:])
   588  	b += 4
   589  
   590  	b += 20 // padding
   591  
   592  	v.ScreenInfo = make([]ScreenInfo, v.Number)
   593  	b += ScreenInfoReadList(buf[b:], v.ScreenInfo)
   594  
   595  	return v
   596  }
   597  
   598  // Write request to wire for QueryScreens
   599  // queryScreensRequest writes a QueryScreens request to a byte slice.
   600  func queryScreensRequest(c *xgb.Conn) []byte {
   601  	size := 4
   602  	b := 0
   603  	buf := make([]byte, size)
   604  
   605  	c.ExtLock.RLock()
   606  	buf[b] = c.Extensions["XINERAMA"]
   607  	c.ExtLock.RUnlock()
   608  	b += 1
   609  
   610  	buf[b] = 5 // request opcode
   611  	b += 1
   612  
   613  	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
   614  	b += 2
   615  
   616  	return buf
   617  }
   618  
   619  // QueryVersionCookie is a cookie used only for QueryVersion requests.
   620  type QueryVersionCookie struct {
   621  	*xgb.Cookie
   622  }
   623  
   624  // QueryVersion sends a checked request.
   625  // If an error occurs, it will be returned with the reply by calling QueryVersionCookie.Reply()
   626  func QueryVersion(c *xgb.Conn, Major byte, Minor byte) QueryVersionCookie {
   627  	c.ExtLock.RLock()
   628  	defer c.ExtLock.RUnlock()
   629  	if _, ok := c.Extensions["XINERAMA"]; !ok {
   630  		panic("Cannot issue request 'QueryVersion' using the uninitialized extension 'XINERAMA'. xinerama.Init(connObj) must be called first.")
   631  	}
   632  	cookie := c.NewCookie(true, true)
   633  	c.NewRequest(queryVersionRequest(c, Major, Minor), cookie)
   634  	return QueryVersionCookie{cookie}
   635  }
   636  
   637  // QueryVersionUnchecked sends an unchecked request.
   638  // If an error occurs, it can only be retrieved using xgb.WaitForEvent or xgb.PollForEvent.
   639  func QueryVersionUnchecked(c *xgb.Conn, Major byte, Minor byte) QueryVersionCookie {
   640  	c.ExtLock.RLock()
   641  	defer c.ExtLock.RUnlock()
   642  	if _, ok := c.Extensions["XINERAMA"]; !ok {
   643  		panic("Cannot issue request 'QueryVersion' using the uninitialized extension 'XINERAMA'. xinerama.Init(connObj) must be called first.")
   644  	}
   645  	cookie := c.NewCookie(false, true)
   646  	c.NewRequest(queryVersionRequest(c, Major, Minor), cookie)
   647  	return QueryVersionCookie{cookie}
   648  }
   649  
   650  // QueryVersionReply represents the data returned from a QueryVersion request.
   651  type QueryVersionReply struct {
   652  	Sequence uint16 // sequence number of the request for this reply
   653  	Length   uint32 // number of bytes in this reply
   654  	// padding: 1 bytes
   655  	Major uint16
   656  	Minor uint16
   657  }
   658  
   659  // Reply blocks and returns the reply data for a QueryVersion request.
   660  func (cook QueryVersionCookie) Reply() (*QueryVersionReply, error) {
   661  	buf, err := cook.Cookie.Reply()
   662  	if err != nil {
   663  		return nil, err
   664  	}
   665  	if buf == nil {
   666  		return nil, nil
   667  	}
   668  	return queryVersionReply(buf), nil
   669  }
   670  
   671  // queryVersionReply reads a byte slice into a QueryVersionReply value.
   672  func queryVersionReply(buf []byte) *QueryVersionReply {
   673  	v := new(QueryVersionReply)
   674  	b := 1 // skip reply determinant
   675  
   676  	b += 1 // padding
   677  
   678  	v.Sequence = xgb.Get16(buf[b:])
   679  	b += 2
   680  
   681  	v.Length = xgb.Get32(buf[b:]) // 4-byte units
   682  	b += 4
   683  
   684  	v.Major = xgb.Get16(buf[b:])
   685  	b += 2
   686  
   687  	v.Minor = xgb.Get16(buf[b:])
   688  	b += 2
   689  
   690  	return v
   691  }
   692  
   693  // Write request to wire for QueryVersion
   694  // queryVersionRequest writes a QueryVersion request to a byte slice.
   695  func queryVersionRequest(c *xgb.Conn, Major byte, Minor byte) []byte {
   696  	size := 8
   697  	b := 0
   698  	buf := make([]byte, size)
   699  
   700  	c.ExtLock.RLock()
   701  	buf[b] = c.Extensions["XINERAMA"]
   702  	c.ExtLock.RUnlock()
   703  	b += 1
   704  
   705  	buf[b] = 0 // request opcode
   706  	b += 1
   707  
   708  	xgb.Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
   709  	b += 2
   710  
   711  	buf[b] = Major
   712  	b += 1
   713  
   714  	buf[b] = Minor
   715  	b += 1
   716  
   717  	return buf
   718  }
   719
View as plain text