| // This file was generated automatically from xproto.xml. |
| |
| package xgb |
| |
| import "os" |
| |
| type Char2b struct { |
| Byte1 byte; |
| Byte2 byte; |
| } |
| |
| func getChar2b(b []byte, v *Char2b) int { |
| v.Byte1 = b[0]; |
| v.Byte2 = b[1]; |
| return 2; |
| } |
| |
| func (c *Conn) sendChar2bList(list []Char2b, count int) { |
| b0 := make([]byte, 2*count); |
| for k := 0; k < count; k++ { |
| b := b0[k*2:]; |
| b[0] = list[k].Byte1; |
| b[1] = list[k].Byte2; |
| } |
| c.sendBytes(b0); |
| } |
| |
| type Point struct { |
| X int16; |
| Y int16; |
| } |
| |
| func getPoint(b []byte, v *Point) int { |
| v.X = int16(get16(b[0:])); |
| v.Y = int16(get16(b[2:])); |
| return 4; |
| } |
| |
| func (c *Conn) sendPointList(list []Point, count int) { |
| b0 := make([]byte, 4*count); |
| for k := 0; k < count; k++ { |
| b := b0[k*4:]; |
| put16(b[0:], uint16(list[k].X)); |
| put16(b[2:], uint16(list[k].Y)); |
| } |
| c.sendBytes(b0); |
| } |
| |
| type Rectangle struct { |
| X int16; |
| Y int16; |
| Width uint16; |
| Height uint16; |
| } |
| |
| func getRectangle(b []byte, v *Rectangle) int { |
| v.X = int16(get16(b[0:])); |
| v.Y = int16(get16(b[2:])); |
| v.Width = get16(b[4:]); |
| v.Height = get16(b[6:]); |
| return 8; |
| } |
| |
| func (c *Conn) sendRectangleList(list []Rectangle, count int) { |
| b0 := make([]byte, 8*count); |
| for k := 0; k < count; k++ { |
| b := b0[k*8:]; |
| put16(b[0:], uint16(list[k].X)); |
| put16(b[2:], uint16(list[k].Y)); |
| put16(b[4:], list[k].Width); |
| put16(b[6:], list[k].Height); |
| } |
| c.sendBytes(b0); |
| } |
| |
| type Arc struct { |
| X int16; |
| Y int16; |
| Width uint16; |
| Height uint16; |
| Angle1 int16; |
| Angle2 int16; |
| } |
| |
| func getArc(b []byte, v *Arc) int { |
| v.X = int16(get16(b[0:])); |
| v.Y = int16(get16(b[2:])); |
| v.Width = get16(b[4:]); |
| v.Height = get16(b[6:]); |
| v.Angle1 = int16(get16(b[8:])); |
| v.Angle2 = int16(get16(b[10:])); |
| return 12; |
| } |
| |
| func (c *Conn) sendArcList(list []Arc, count int) { |
| b0 := make([]byte, 12*count); |
| for k := 0; k < count; k++ { |
| b := b0[k*12:]; |
| put16(b[0:], uint16(list[k].X)); |
| put16(b[2:], uint16(list[k].Y)); |
| put16(b[4:], list[k].Width); |
| put16(b[6:], list[k].Height); |
| put16(b[8:], uint16(list[k].Angle1)); |
| put16(b[10:], uint16(list[k].Angle2)); |
| } |
| c.sendBytes(b0); |
| } |
| |
| type Format struct { |
| Depth byte; |
| BitsPerPixel byte; |
| ScanlinePad byte; |
| } |
| |
| func getFormat(b []byte, v *Format) int { |
| v.Depth = b[0]; |
| v.BitsPerPixel = b[1]; |
| v.ScanlinePad = b[2]; |
| return 8; |
| } |
| |
| const ( |
| VisualClassStaticGray = 0; |
| VisualClassGrayScale = 1; |
| VisualClassStaticColor = 2; |
| VisualClassPseudoColor = 3; |
| VisualClassTrueColor = 4; |
| VisualClassDirectColor = 5; |
| ) |
| |
| type VisualInfo struct { |
| VisualId Id; |
| Class byte; |
| BitsPerRgbValue byte; |
| ColormapEntries uint16; |
| RedMask uint32; |
| GreenMask uint32; |
| BlueMask uint32; |
| } |
| |
| func getVisualInfo(b []byte, v *VisualInfo) int { |
| v.VisualId = Id(get32(b[0:])); |
| v.Class = b[4]; |
| v.BitsPerRgbValue = b[5]; |
| v.ColormapEntries = get16(b[6:]); |
| v.RedMask = get32(b[8:]); |
| v.GreenMask = get32(b[12:]); |
| v.BlueMask = get32(b[16:]); |
| return 24; |
| } |
| |
| type DepthInfo struct { |
| Depth byte; |
| VisualsLen uint16; |
| Visuals []VisualInfo; |
| } |
| |
| func getDepthInfo(b []byte, v *DepthInfo) int { |
| v.Depth = b[0]; |
| v.VisualsLen = get16(b[2:]); |
| offset := 8; |
| v.Visuals = make([]VisualInfo, int(v.VisualsLen)); |
| for i := 0; i < int(v.VisualsLen); i++ { |
| offset += getVisualInfo(b[offset:], &v.Visuals[i]) |
| } |
| return offset; |
| } |
| |
| const ( |
| EventMaskNoEvent = 0; |
| EventMaskKeyPress = 1; |
| EventMaskKeyRelease = 2; |
| EventMaskButtonPress = 4; |
| EventMaskButtonRelease = 8; |
| EventMaskEnterWindow = 16; |
| EventMaskLeaveWindow = 32; |
| EventMaskPointerMotion = 64; |
| EventMaskPointerMotionHint = 128; |
| EventMaskButton1Motion = 256; |
| EventMaskButton2Motion = 512; |
| EventMaskButton3Motion = 1024; |
| EventMaskButton4Motion = 2048; |
| EventMaskButton5Motion = 4096; |
| EventMaskButtonMotion = 8192; |
| EventMaskKeymapState = 16384; |
| EventMaskExposure = 32768; |
| EventMaskVisibilityChange = 65536; |
| EventMaskStructureNotify = 131072; |
| EventMaskResizeRedirect = 262144; |
| EventMaskSubstructureNotify = 524288; |
| EventMaskSubstructureRedirect = 1048576; |
| EventMaskFocusChange = 2097152; |
| EventMaskPropertyChange = 4194304; |
| EventMaskColorMapChange = 8388608; |
| EventMaskOwnerGrabButton = 16777216; |
| ) |
| |
| const ( |
| BackingStoreNotUseful = 0; |
| BackingStoreWhenMapped = 1; |
| BackingStoreAlways = 2; |
| ) |
| |
| type ScreenInfo struct { |
| Root Id; |
| DefaultColormap Id; |
| WhitePixel uint32; |
| BlackPixel uint32; |
| CurrentInputMasks uint32; |
| WidthInPixels uint16; |
| HeightInPixels uint16; |
| WidthInMillimeters uint16; |
| HeightInMillimeters uint16; |
| MinInstalledMaps uint16; |
| MaxInstalledMaps uint16; |
| RootVisual Id; |
| BackingStores byte; |
| SaveUnders byte; |
| RootDepth byte; |
| AllowedDepthsLen byte; |
| AllowedDepths []DepthInfo; |
| } |
| |
| func getScreenInfo(b []byte, v *ScreenInfo) int { |
| v.Root = Id(get32(b[0:])); |
| v.DefaultColormap = Id(get32(b[4:])); |
| v.WhitePixel = get32(b[8:]); |
| v.BlackPixel = get32(b[12:]); |
| v.CurrentInputMasks = get32(b[16:]); |
| v.WidthInPixels = get16(b[20:]); |
| v.HeightInPixels = get16(b[22:]); |
| v.WidthInMillimeters = get16(b[24:]); |
| v.HeightInMillimeters = get16(b[26:]); |
| v.MinInstalledMaps = get16(b[28:]); |
| v.MaxInstalledMaps = get16(b[30:]); |
| v.RootVisual = Id(get32(b[32:])); |
| v.BackingStores = b[36]; |
| v.SaveUnders = b[37]; |
| v.RootDepth = b[38]; |
| v.AllowedDepthsLen = b[39]; |
| offset := 40; |
| v.AllowedDepths = make([]DepthInfo, int(v.AllowedDepthsLen)); |
| for i := 0; i < int(v.AllowedDepthsLen); i++ { |
| offset += getDepthInfo(b[offset:], &v.AllowedDepths[i]) |
| } |
| return offset; |
| } |
| |
| const ( |
| ImageOrderLSBFirst = 0; |
| ImageOrderMSBFirst = 1; |
| ) |
| |
| type SetupInfo struct { |
| Status byte; |
| ProtocolMajorVersion uint16; |
| ProtocolMinorVersion uint16; |
| Length uint16; |
| ReleaseNumber uint32; |
| ResourceIdBase uint32; |
| ResourceIdMask uint32; |
| MotionBufferSize uint32; |
| VendorLen uint16; |
| MaximumRequestLength uint16; |
| RootsLen byte; |
| PixmapFormatsLen byte; |
| ImageByteOrder byte; |
| BitmapFormatBitOrder byte; |
| BitmapFormatScanlineUnit byte; |
| BitmapFormatScanlinePad byte; |
| MinKeycode byte; |
| MaxKeycode byte; |
| Vendor []byte; |
| PixmapFormats []Format; |
| Roots []ScreenInfo; |
| } |
| |
| func getSetupInfo(b []byte, v *SetupInfo) int { |
| v.Status = b[0]; |
| v.ProtocolMajorVersion = get16(b[2:]); |
| v.ProtocolMinorVersion = get16(b[4:]); |
| v.Length = get16(b[6:]); |
| v.ReleaseNumber = get32(b[8:]); |
| v.ResourceIdBase = get32(b[12:]); |
| v.ResourceIdMask = get32(b[16:]); |
| v.MotionBufferSize = get32(b[20:]); |
| v.VendorLen = get16(b[24:]); |
| v.MaximumRequestLength = get16(b[26:]); |
| v.RootsLen = b[28]; |
| v.PixmapFormatsLen = b[29]; |
| v.ImageByteOrder = b[30]; |
| v.BitmapFormatBitOrder = b[31]; |
| v.BitmapFormatScanlineUnit = b[32]; |
| v.BitmapFormatScanlinePad = b[33]; |
| v.MinKeycode = b[34]; |
| v.MaxKeycode = b[35]; |
| offset := 40; |
| v.Vendor = make([]byte, int(v.VendorLen)); |
| copy(v.Vendor[0:len(v.Vendor)], b[offset:]); |
| offset += len(v.Vendor) * 1; |
| offset = pad(offset); |
| v.PixmapFormats = make([]Format, int(v.PixmapFormatsLen)); |
| for i := 0; i < int(v.PixmapFormatsLen); i++ { |
| offset += getFormat(b[offset:], &v.PixmapFormats[i]) |
| } |
| offset = pad(offset); |
| v.Roots = make([]ScreenInfo, int(v.RootsLen)); |
| for i := 0; i < int(v.RootsLen); i++ { |
| offset += getScreenInfo(b[offset:], &v.Roots[i]) |
| } |
| return offset; |
| } |
| |
| const ( |
| ModMaskShift = 1; |
| ModMaskLock = 2; |
| ModMaskControl = 4; |
| ModMask1 = 8; |
| ModMask2 = 16; |
| ModMask3 = 32; |
| ModMask4 = 64; |
| ModMask5 = 128; |
| ModMaskAny = 32768; |
| ) |
| |
| const ( |
| KeyButMaskShift = 1; |
| KeyButMaskLock = 2; |
| KeyButMaskControl = 4; |
| KeyButMaskMod1 = 8; |
| KeyButMaskMod2 = 16; |
| KeyButMaskMod3 = 32; |
| KeyButMaskMod4 = 64; |
| KeyButMaskMod5 = 128; |
| KeyButMaskButton1 = 256; |
| KeyButMaskButton2 = 512; |
| KeyButMaskButton3 = 1024; |
| KeyButMaskButton4 = 2048; |
| KeyButMaskButton5 = 4096; |
| ) |
| |
| const ( |
| WindowNone = 0; |
| ) |
| |
| const KeyPress = 2 |
| |
| type KeyPressEvent struct { |
| Detail byte; |
| Time Timestamp; |
| Root Id; |
| Event Id; |
| Child Id; |
| RootX int16; |
| RootY int16; |
| EventX int16; |
| EventY int16; |
| State uint16; |
| SameScreen byte; |
| } |
| |
| func getKeyPressEvent(b []byte) KeyPressEvent { |
| var v KeyPressEvent; |
| v.Detail = b[1]; |
| v.Time = Timestamp(get32(b[4:])); |
| v.Root = Id(get32(b[8:])); |
| v.Event = Id(get32(b[12:])); |
| v.Child = Id(get32(b[16:])); |
| v.RootX = int16(get16(b[20:])); |
| v.RootY = int16(get16(b[22:])); |
| v.EventX = int16(get16(b[24:])); |
| v.EventY = int16(get16(b[26:])); |
| v.State = get16(b[28:]); |
| v.SameScreen = b[30]; |
| return v; |
| } |
| |
| const KeyRelease = 3 |
| |
| type KeyReleaseEvent KeyPressEvent |
| |
| func getKeyReleaseEvent(b []byte) KeyReleaseEvent { |
| return (KeyReleaseEvent)(getKeyPressEvent(b)) |
| } |
| |
| const ( |
| ButtonMask1 = 256; |
| ButtonMask2 = 512; |
| ButtonMask3 = 1024; |
| ButtonMask4 = 2048; |
| ButtonMask5 = 4096; |
| ButtonMaskAny = 32768; |
| ) |
| |
| const ButtonPress = 4 |
| |
| type ButtonPressEvent struct { |
| Detail byte; |
| Time Timestamp; |
| Root Id; |
| Event Id; |
| Child Id; |
| RootX int16; |
| RootY int16; |
| EventX int16; |
| EventY int16; |
| State uint16; |
| SameScreen byte; |
| } |
| |
| func getButtonPressEvent(b []byte) ButtonPressEvent { |
| var v ButtonPressEvent; |
| v.Detail = b[1]; |
| v.Time = Timestamp(get32(b[4:])); |
| v.Root = Id(get32(b[8:])); |
| v.Event = Id(get32(b[12:])); |
| v.Child = Id(get32(b[16:])); |
| v.RootX = int16(get16(b[20:])); |
| v.RootY = int16(get16(b[22:])); |
| v.EventX = int16(get16(b[24:])); |
| v.EventY = int16(get16(b[26:])); |
| v.State = get16(b[28:]); |
| v.SameScreen = b[30]; |
| return v; |
| } |
| |
| const ButtonRelease = 5 |
| |
| type ButtonReleaseEvent ButtonPressEvent |
| |
| func getButtonReleaseEvent(b []byte) ButtonReleaseEvent { |
| return (ButtonReleaseEvent)(getButtonPressEvent(b)) |
| } |
| |
| const ( |
| MotionNormal = 0; |
| MotionHint = 1; |
| ) |
| |
| const MotionNotify = 6 |
| |
| type MotionNotifyEvent struct { |
| Detail byte; |
| Time Timestamp; |
| Root Id; |
| Event Id; |
| Child Id; |
| RootX int16; |
| RootY int16; |
| EventX int16; |
| EventY int16; |
| State uint16; |
| SameScreen byte; |
| } |
| |
| func getMotionNotifyEvent(b []byte) MotionNotifyEvent { |
| var v MotionNotifyEvent; |
| v.Detail = b[1]; |
| v.Time = Timestamp(get32(b[4:])); |
| v.Root = Id(get32(b[8:])); |
| v.Event = Id(get32(b[12:])); |
| v.Child = Id(get32(b[16:])); |
| v.RootX = int16(get16(b[20:])); |
| v.RootY = int16(get16(b[22:])); |
| v.EventX = int16(get16(b[24:])); |
| v.EventY = int16(get16(b[26:])); |
| v.State = get16(b[28:]); |
| v.SameScreen = b[30]; |
| return v; |
| } |
| |
| const ( |
| NotifyDetailAncestor = 0; |
| NotifyDetailVirtual = 1; |
| NotifyDetailInferior = 2; |
| NotifyDetailNonlinear = 3; |
| NotifyDetailNonlinearVirtual = 4; |
| NotifyDetailPointer = 5; |
| NotifyDetailPointerRoot = 6; |
| NotifyDetailNone = 7; |
| ) |
| |
| const ( |
| NotifyModeNormal = 0; |
| NotifyModeGrab = 1; |
| NotifyModeUngrab = 2; |
| NotifyModeWhileGrabbed = 3; |
| ) |
| |
| const EnterNotify = 7 |
| |
| type EnterNotifyEvent struct { |
| Detail byte; |
| Time Timestamp; |
| Root Id; |
| Event Id; |
| Child Id; |
| RootX int16; |
| RootY int16; |
| EventX int16; |
| EventY int16; |
| State uint16; |
| Mode byte; |
| SameScreenFocus byte; |
| } |
| |
| func getEnterNotifyEvent(b []byte) EnterNotifyEvent { |
| var v EnterNotifyEvent; |
| v.Detail = b[1]; |
| v.Time = Timestamp(get32(b[4:])); |
| v.Root = Id(get32(b[8:])); |
| v.Event = Id(get32(b[12:])); |
| v.Child = Id(get32(b[16:])); |
| v.RootX = int16(get16(b[20:])); |
| v.RootY = int16(get16(b[22:])); |
| v.EventX = int16(get16(b[24:])); |
| v.EventY = int16(get16(b[26:])); |
| v.State = get16(b[28:]); |
| v.Mode = b[30]; |
| v.SameScreenFocus = b[31]; |
| return v; |
| } |
| |
| const LeaveNotify = 8 |
| |
| type LeaveNotifyEvent EnterNotifyEvent |
| |
| func getLeaveNotifyEvent(b []byte) LeaveNotifyEvent { |
| return (LeaveNotifyEvent)(getEnterNotifyEvent(b)) |
| } |
| |
| const FocusIn = 9 |
| |
| type FocusInEvent struct { |
| Detail byte; |
| Event Id; |
| Mode byte; |
| } |
| |
| func getFocusInEvent(b []byte) FocusInEvent { |
| var v FocusInEvent; |
| v.Detail = b[1]; |
| v.Event = Id(get32(b[4:])); |
| v.Mode = b[8]; |
| return v; |
| } |
| |
| const FocusOut = 10 |
| |
| type FocusOutEvent FocusInEvent |
| |
| func getFocusOutEvent(b []byte) FocusOutEvent { return (FocusOutEvent)(getFocusInEvent(b)) } |
| |
| const KeymapNotify = 11 |
| |
| type KeymapNotifyEvent struct { |
| Keys [31]byte; |
| } |
| |
| func getKeymapNotifyEvent(b []byte) KeymapNotifyEvent { |
| var v KeymapNotifyEvent; |
| copy(v.Keys[0:31], b[1:]); |
| return v; |
| } |
| |
| const Expose = 12 |
| |
| type ExposeEvent struct { |
| Window Id; |
| X uint16; |
| Y uint16; |
| Width uint16; |
| Height uint16; |
| Count uint16; |
| } |
| |
| func getExposeEvent(b []byte) ExposeEvent { |
| var v ExposeEvent; |
| v.Window = Id(get32(b[4:])); |
| v.X = get16(b[8:]); |
| v.Y = get16(b[10:]); |
| v.Width = get16(b[12:]); |
| v.Height = get16(b[14:]); |
| v.Count = get16(b[16:]); |
| return v; |
| } |
| |
| const GraphicsExposure = 13 |
| |
| type GraphicsExposureEvent struct { |
| Drawable Id; |
| X uint16; |
| Y uint16; |
| Width uint16; |
| Height uint16; |
| MinorOpcode uint16; |
| Count uint16; |
| MajorOpcode byte; |
| } |
| |
| func getGraphicsExposureEvent(b []byte) GraphicsExposureEvent { |
| var v GraphicsExposureEvent; |
| v.Drawable = Id(get32(b[4:])); |
| v.X = get16(b[8:]); |
| v.Y = get16(b[10:]); |
| v.Width = get16(b[12:]); |
| v.Height = get16(b[14:]); |
| v.MinorOpcode = get16(b[16:]); |
| v.Count = get16(b[18:]); |
| v.MajorOpcode = b[20]; |
| return v; |
| } |
| |
| const NoExposure = 14 |
| |
| type NoExposureEvent struct { |
| Drawable Id; |
| MinorOpcode uint16; |
| MajorOpcode byte; |
| } |
| |
| func getNoExposureEvent(b []byte) NoExposureEvent { |
| var v NoExposureEvent; |
| v.Drawable = Id(get32(b[4:])); |
| v.MinorOpcode = get16(b[8:]); |
| v.MajorOpcode = b[10]; |
| return v; |
| } |
| |
| const ( |
| VisibilityUnobscured = 0; |
| VisibilityPartiallyObscured = 1; |
| VisibilityFullyObscured = 2; |
| ) |
| |
| const VisibilityNotify = 15 |
| |
| type VisibilityNotifyEvent struct { |
| Window Id; |
| State byte; |
| } |
| |
| func getVisibilityNotifyEvent(b []byte) VisibilityNotifyEvent { |
| var v VisibilityNotifyEvent; |
| v.Window = Id(get32(b[4:])); |
| v.State = b[8]; |
| return v; |
| } |
| |
| const CreateNotify = 16 |
| |
| type CreateNotifyEvent struct { |
| Parent Id; |
| Window Id; |
| X int16; |
| Y int16; |
| Width uint16; |
| Height uint16; |
| BorderWidth uint16; |
| OverrideRedirect byte; |
| } |
| |
| func getCreateNotifyEvent(b []byte) CreateNotifyEvent { |
| var v CreateNotifyEvent; |
| v.Parent = Id(get32(b[4:])); |
| v.Window = Id(get32(b[8:])); |
| v.X = int16(get16(b[12:])); |
| v.Y = int16(get16(b[14:])); |
| v.Width = get16(b[16:]); |
| v.Height = get16(b[18:]); |
| v.BorderWidth = get16(b[20:]); |
| v.OverrideRedirect = b[22]; |
| return v; |
| } |
| |
| const DestroyNotify = 17 |
| |
| type DestroyNotifyEvent struct { |
| Event Id; |
| Window Id; |
| } |
| |
| func getDestroyNotifyEvent(b []byte) DestroyNotifyEvent { |
| var v DestroyNotifyEvent; |
| v.Event = Id(get32(b[4:])); |
| v.Window = Id(get32(b[8:])); |
| return v; |
| } |
| |
| const UnmapNotify = 18 |
| |
| type UnmapNotifyEvent struct { |
| Event Id; |
| Window Id; |
| FromConfigure byte; |
| } |
| |
| func getUnmapNotifyEvent(b []byte) UnmapNotifyEvent { |
| var v UnmapNotifyEvent; |
| v.Event = Id(get32(b[4:])); |
| v.Window = Id(get32(b[8:])); |
| v.FromConfigure = b[12]; |
| return v; |
| } |
| |
| const MapNotify = 19 |
| |
| type MapNotifyEvent struct { |
| Event Id; |
| Window Id; |
| OverrideRedirect byte; |
| } |
| |
| func getMapNotifyEvent(b []byte) MapNotifyEvent { |
| var v MapNotifyEvent; |
| v.Event = Id(get32(b[4:])); |
| v.Window = Id(get32(b[8:])); |
| v.OverrideRedirect = b[12]; |
| return v; |
| } |
| |
| const MapRequest = 20 |
| |
| type MapRequestEvent struct { |
| Parent Id; |
| Window Id; |
| } |
| |
| func getMapRequestEvent(b []byte) MapRequestEvent { |
| var v MapRequestEvent; |
| v.Parent = Id(get32(b[4:])); |
| v.Window = Id(get32(b[8:])); |
| return v; |
| } |
| |
| const ReparentNotify = 21 |
| |
| type ReparentNotifyEvent struct { |
| Event Id; |
| Window Id; |
| Parent Id; |
| X int16; |
| Y int16; |
| OverrideRedirect byte; |
| } |
| |
| func getReparentNotifyEvent(b []byte) ReparentNotifyEvent { |
| var v ReparentNotifyEvent; |
| v.Event = Id(get32(b[4:])); |
| v.Window = Id(get32(b[8:])); |
| v.Parent = Id(get32(b[12:])); |
| v.X = int16(get16(b[16:])); |
| v.Y = int16(get16(b[18:])); |
| v.OverrideRedirect = b[20]; |
| return v; |
| } |
| |
| const ConfigureNotify = 22 |
| |
| type ConfigureNotifyEvent struct { |
| Event Id; |
| Window Id; |
| AboveSibling Id; |
| X int16; |
| Y int16; |
| Width uint16; |
| Height uint16; |
| BorderWidth uint16; |
| OverrideRedirect byte; |
| } |
| |
| func getConfigureNotifyEvent(b []byte) ConfigureNotifyEvent { |
| var v ConfigureNotifyEvent; |
| v.Event = Id(get32(b[4:])); |
| v.Window = Id(get32(b[8:])); |
| v.AboveSibling = Id(get32(b[12:])); |
| v.X = int16(get16(b[16:])); |
| v.Y = int16(get16(b[18:])); |
| v.Width = get16(b[20:]); |
| v.Height = get16(b[22:]); |
| v.BorderWidth = get16(b[24:]); |
| v.OverrideRedirect = b[26]; |
| return v; |
| } |
| |
| const ConfigureRequest = 23 |
| |
| type ConfigureRequestEvent struct { |
| StackMode byte; |
| Parent Id; |
| Window Id; |
| Sibling Id; |
| X int16; |
| Y int16; |
| Width uint16; |
| Height uint16; |
| BorderWidth uint16; |
| ValueMask uint16; |
| } |
| |
| func getConfigureRequestEvent(b []byte) ConfigureRequestEvent { |
| var v ConfigureRequestEvent; |
| v.StackMode = b[1]; |
| v.Parent = Id(get32(b[4:])); |
| v.Window = Id(get32(b[8:])); |
| v.Sibling = Id(get32(b[12:])); |
| v.X = int16(get16(b[16:])); |
| v.Y = int16(get16(b[18:])); |
| v.Width = get16(b[20:]); |
| v.Height = get16(b[22:]); |
| v.BorderWidth = get16(b[24:]); |
| v.ValueMask = get16(b[26:]); |
| return v; |
| } |
| |
| const GravityNotify = 24 |
| |
| type GravityNotifyEvent struct { |
| Event Id; |
| Window Id; |
| X int16; |
| Y int16; |
| } |
| |
| func getGravityNotifyEvent(b []byte) GravityNotifyEvent { |
| var v GravityNotifyEvent; |
| v.Event = Id(get32(b[4:])); |
| v.Window = Id(get32(b[8:])); |
| v.X = int16(get16(b[12:])); |
| v.Y = int16(get16(b[14:])); |
| return v; |
| } |
| |
| const ResizeRequest = 25 |
| |
| type ResizeRequestEvent struct { |
| Window Id; |
| Width uint16; |
| Height uint16; |
| } |
| |
| func getResizeRequestEvent(b []byte) ResizeRequestEvent { |
| var v ResizeRequestEvent; |
| v.Window = Id(get32(b[4:])); |
| v.Width = get16(b[8:]); |
| v.Height = get16(b[10:]); |
| return v; |
| } |
| |
| const ( |
| PlaceOnTop = 0; |
| PlaceOnBottom = 1; |
| ) |
| |
| const CirculateNotify = 26 |
| |
| type CirculateNotifyEvent struct { |
| Event Id; |
| Window Id; |
| Place byte; |
| } |
| |
| func getCirculateNotifyEvent(b []byte) CirculateNotifyEvent { |
| var v CirculateNotifyEvent; |
| v.Event = Id(get32(b[4:])); |
| v.Window = Id(get32(b[8:])); |
| v.Place = b[16]; |
| return v; |
| } |
| |
| const CirculateRequest = 27 |
| |
| type CirculateRequestEvent CirculateNotifyEvent |
| |
| func getCirculateRequestEvent(b []byte) CirculateRequestEvent { |
| return (CirculateRequestEvent)(getCirculateNotifyEvent(b)) |
| } |
| |
| const ( |
| PropertyNewValue = 0; |
| PropertyDelete = 1; |
| ) |
| |
| const PropertyNotify = 28 |
| |
| type PropertyNotifyEvent struct { |
| Window Id; |
| Atom Id; |
| Time Timestamp; |
| State byte; |
| } |
| |
| func getPropertyNotifyEvent(b []byte) PropertyNotifyEvent { |
| var v PropertyNotifyEvent; |
| v.Window = Id(get32(b[4:])); |
| v.Atom = Id(get32(b[8:])); |
| v.Time = Timestamp(get32(b[12:])); |
| v.State = b[16]; |
| return v; |
| } |
| |
| const SelectionClear = 29 |
| |
| type SelectionClearEvent struct { |
| Time Timestamp; |
| Owner Id; |
| Selection Id; |
| } |
| |
| func getSelectionClearEvent(b []byte) SelectionClearEvent { |
| var v SelectionClearEvent; |
| v.Time = Timestamp(get32(b[4:])); |
| v.Owner = Id(get32(b[8:])); |
| v.Selection = Id(get32(b[12:])); |
| return v; |
| } |
| |
| const ( |
| TimeCurrentTime = 0; |
| ) |
| |
| const ( |
| AtomNone = 0; |
| AtomAny = 0; |
| AtomPrimary = 1; |
| AtomSecondary = 2; |
| AtomArc = 3; |
| AtomAtom = 4; |
| AtomBitmap = 5; |
| AtomCardinal = 6; |
| AtomColormap = 7; |
| AtomCursor = 8; |
| AtomCutBuffer0 = 9; |
| AtomCutBuffer1 = 10; |
| AtomCutBuffer2 = 11; |
| AtomCutBuffer3 = 12; |
| AtomCutBuffer4 = 13; |
| AtomCutBuffer5 = 14; |
| AtomCutBuffer6 = 15; |
| AtomCutBuffer7 = 16; |
| AtomDrawable = 17; |
| AtomFont = 18; |
| AtomInteger = 19; |
| AtomPixmap = 20; |
| AtomPoint = 21; |
| AtomRectangle = 22; |
| AtomResourceManager = 23; |
| AtomRgbColorMap = 24; |
| AtomRgbBestMap = 25; |
| AtomRgbBlueMap = 26; |
| AtomRgbDefaultMap = 27; |
| AtomRgbGrayMap = 28; |
| AtomRgbGreenMap = 29; |
| AtomRgbRedMap = 30; |
| AtomString = 31; |
| AtomVisualid = 32; |
| AtomWindow = 33; |
| AtomWmCommand = 34; |
| AtomWmHints = 35; |
| AtomWmClientMachine = 36; |
| AtomWmIconName = 37; |
| AtomWmIconSize = 38; |
| AtomWmName = 39; |
| AtomWmNormalHints = 40; |
| AtomWmSizeHints = 41; |
| AtomWmZoomHints = 42; |
| AtomMinSpace = 43; |
| AtomNormSpace = 44; |
| AtomMaxSpace = 45; |
| AtomEndSpace = 46; |
| AtomSuperscriptX = 47; |
| AtomSuperscriptY = 48; |
| AtomSubscriptX = 49; |
| AtomSubscriptY = 50; |
| AtomUnderlinePosition = 51; |
| AtomUnderlineThickness = 52; |
| AtomStrikeoutAscent = 53; |
| AtomStrikeoutDescent = 54; |
| AtomItalicAngle = 55; |
| AtomXHeight = 56; |
| AtomQuadWidth = 57; |
| AtomWeight = 58; |
| AtomPointSize = 59; |
| AtomResolution = 60; |
| AtomCopyright = 61; |
| AtomNotice = 62; |
| AtomFontName = 63; |
| AtomFamilyName = 64; |
| AtomFullName = 65; |
| AtomCapHeight = 66; |
| AtomWmClass = 67; |
| AtomWmTransientFor = 68; |
| ) |
| |
| const SelectionRequest = 30 |
| |
| type SelectionRequestEvent struct { |
| Time Timestamp; |
| Owner Id; |
| Requestor Id; |
| Selection Id; |
| Target Id; |
| Property Id; |
| } |
| |
| func getSelectionRequestEvent(b []byte) SelectionRequestEvent { |
| var v SelectionRequestEvent; |
| v.Time = Timestamp(get32(b[4:])); |
| v.Owner = Id(get32(b[8:])); |
| v.Requestor = Id(get32(b[12:])); |
| v.Selection = Id(get32(b[16:])); |
| v.Target = Id(get32(b[20:])); |
| v.Property = Id(get32(b[24:])); |
| return v; |
| } |
| |
| const SelectionNotify = 31 |
| |
| type SelectionNotifyEvent struct { |
| Time Timestamp; |
| Requestor Id; |
| Selection Id; |
| Target Id; |
| Property Id; |
| } |
| |
| func getSelectionNotifyEvent(b []byte) SelectionNotifyEvent { |
| var v SelectionNotifyEvent; |
| v.Time = Timestamp(get32(b[4:])); |
| v.Requestor = Id(get32(b[8:])); |
| v.Selection = Id(get32(b[12:])); |
| v.Target = Id(get32(b[16:])); |
| v.Property = Id(get32(b[20:])); |
| return v; |
| } |
| |
| const ( |
| ColormapStateUninstalled = 0; |
| ColormapStateInstalled = 1; |
| ) |
| |
| const ( |
| ColormapNone = 0; |
| ) |
| |
| const ColormapNotify = 32 |
| |
| type ColormapNotifyEvent struct { |
| Window Id; |
| Colormap Id; |
| New byte; |
| State byte; |
| } |
| |
| func getColormapNotifyEvent(b []byte) ColormapNotifyEvent { |
| var v ColormapNotifyEvent; |
| v.Window = Id(get32(b[4:])); |
| v.Colormap = Id(get32(b[8:])); |
| v.New = b[12]; |
| v.State = b[13]; |
| return v; |
| } |
| |
| const ClientMessage = 33 |
| |
| type ClientMessageEvent struct { |
| Format byte; |
| Window Id; |
| Type Id; |
| Data ClientMessageData; |
| } |
| |
| func getClientMessageEvent(b []byte) ClientMessageEvent { |
| var v ClientMessageEvent; |
| v.Format = b[1]; |
| v.Window = Id(get32(b[4:])); |
| v.Type = Id(get32(b[8:])); |
| getClientMessageData(b[12:], &v.Data); |
| return v; |
| } |
| |
| const ( |
| MappingModifier = 0; |
| MappingKeyboard = 1; |
| MappingPointer = 2; |
| ) |
| |
| const MappingNotify = 34 |
| |
| type MappingNotifyEvent struct { |
| Request byte; |
| FirstKeycode byte; |
| Count byte; |
| } |
| |
| func getMappingNotifyEvent(b []byte) MappingNotifyEvent { |
| var v MappingNotifyEvent; |
| v.Request = b[4]; |
| v.FirstKeycode = b[5]; |
| v.Count = b[6]; |
| return v; |
| } |
| |
| const BadRequest = 1 |
| |
| const BadValue = 2 |
| |
| const BadWindow = 3 |
| |
| const BadPixmap = 4 |
| |
| const BadAtom = 5 |
| |
| const BadCursor = 6 |
| |
| const BadFont = 7 |
| |
| const BadMatch = 8 |
| |
| const BadDrawable = 9 |
| |
| const BadAccess = 10 |
| |
| const BadAlloc = 11 |
| |
| const BadColormap = 12 |
| |
| const BadGContext = 13 |
| |
| const BadIDChoice = 14 |
| |
| const BadName = 15 |
| |
| const BadLength = 16 |
| |
| const BadImplementation = 17 |
| |
| const ( |
| WindowClassCopyFromParent = 0; |
| WindowClassInputOutput = 1; |
| WindowClassInputOnly = 2; |
| ) |
| |
| const ( |
| CWBackPixmap = 1; |
| CWBackPixel = 2; |
| CWBorderPixmap = 4; |
| CWBorderPixel = 8; |
| CWBitGravity = 16; |
| CWWinGravity = 32; |
| CWBackingStore = 64; |
| CWBackingPlanes = 128; |
| CWBackingPixel = 256; |
| CWOverrideRedirect = 512; |
| CWSaveUnder = 1024; |
| CWEventMask = 2048; |
| CWDontPropagate = 4096; |
| CWColormap = 8192; |
| CWCursor = 16384; |
| ) |
| |
| const ( |
| BackPixmapNone = 0; |
| BackPixmapParentRelative = 1; |
| ) |
| |
| const ( |
| GravityBitForget = 0; |
| GravityWinUnmap = 0; |
| GravityNorthWest = 1; |
| GravityNorth = 2; |
| GravityNorthEast = 3; |
| GravityWest = 4; |
| GravityCenter = 5; |
| GravityEast = 6; |
| GravitySouthWest = 7; |
| GravitySouth = 8; |
| GravitySouthEast = 9; |
| GravityStatic = 10; |
| ) |
| |
| func (c *Conn) CreateWindow(Depth byte, Wid Id, Parent Id, X int16, Y int16, Width uint16, Height uint16, BorderWidth uint16, Class uint16, Visual Id, ValueMask uint32, ValueList []uint32) { |
| b := c.scratch[0:32]; |
| n := 32; |
| n += pad(popCount(int(ValueMask)) * 4); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 1; |
| b[1] = Depth; |
| put32(b[4:], uint32(Wid)); |
| put32(b[8:], uint32(Parent)); |
| put16(b[12:], uint16(X)); |
| put16(b[14:], uint16(Y)); |
| put16(b[16:], Width); |
| put16(b[18:], Height); |
| put16(b[20:], BorderWidth); |
| put16(b[22:], Class); |
| put32(b[24:], uint32(Visual)); |
| put32(b[28:], ValueMask); |
| c.sendRequest(b); |
| c.sendUInt32List(ValueList[0:popCount(int(ValueMask))]); |
| } |
| |
| func (c *Conn) ChangeWindowAttributes(Window Id, ValueMask uint32, ValueList []uint32) { |
| b := c.scratch[0:12]; |
| n := 12; |
| n += pad(popCount(int(ValueMask)) * 4); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 2; |
| put32(b[4:], uint32(Window)); |
| put32(b[8:], ValueMask); |
| c.sendRequest(b); |
| c.sendUInt32List(ValueList[0:popCount(int(ValueMask))]); |
| } |
| |
| const ( |
| MapStateUnmapped = 0; |
| MapStateUnviewable = 1; |
| MapStateViewable = 2; |
| ) |
| |
| func (c *Conn) GetWindowAttributesRequest(Window Id) Cookie { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 3; |
| put32(b[4:], uint32(Window)); |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetWindowAttributes(Window Id) (*GetWindowAttributesReply, os.Error) { |
| return c.GetWindowAttributesReply(c.GetWindowAttributesRequest(Window)) |
| } |
| |
| type GetWindowAttributesReply struct { |
| BackingStore byte; |
| Visual Id; |
| Class uint16; |
| BitGravity byte; |
| WinGravity byte; |
| BackingPlanes uint32; |
| BackingPixel uint32; |
| SaveUnder byte; |
| MapIsInstalled byte; |
| MapState byte; |
| OverrideRedirect byte; |
| Colormap Id; |
| AllEventMasks uint32; |
| YourEventMask uint32; |
| DoNotPropagateMask uint16; |
| } |
| |
| func (c *Conn) GetWindowAttributesReply(cookie Cookie) (*GetWindowAttributesReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(GetWindowAttributesReply); |
| v.BackingStore = b[1]; |
| v.Visual = Id(get32(b[8:])); |
| v.Class = get16(b[12:]); |
| v.BitGravity = b[14]; |
| v.WinGravity = b[15]; |
| v.BackingPlanes = get32(b[16:]); |
| v.BackingPixel = get32(b[20:]); |
| v.SaveUnder = b[24]; |
| v.MapIsInstalled = b[25]; |
| v.MapState = b[26]; |
| v.OverrideRedirect = b[27]; |
| v.Colormap = Id(get32(b[28:])); |
| v.AllEventMasks = get32(b[32:]); |
| v.YourEventMask = get32(b[36:]); |
| v.DoNotPropagateMask = get16(b[40:]); |
| return v, nil; |
| } |
| |
| func (c *Conn) DestroyWindow(Window Id) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 4; |
| put32(b[4:], uint32(Window)); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) DestroySubwindows(Window Id) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 5; |
| put32(b[4:], uint32(Window)); |
| c.sendRequest(b); |
| } |
| |
| const ( |
| SetModeInsert = 0; |
| SetModeDelete = 1; |
| ) |
| |
| func (c *Conn) ChangeSaveSet(Mode byte, Window Id) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 6; |
| b[1] = Mode; |
| put32(b[4:], uint32(Window)); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) ReparentWindow(Window Id, Parent Id, X int16, Y int16) { |
| b := c.scratch[0:16]; |
| put16(b[2:], 4); |
| b[0] = 7; |
| put32(b[4:], uint32(Window)); |
| put32(b[8:], uint32(Parent)); |
| put16(b[12:], uint16(X)); |
| put16(b[14:], uint16(Y)); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) MapWindow(Window Id) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 8; |
| put32(b[4:], uint32(Window)); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) MapSubwindows(Window Id) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 9; |
| put32(b[4:], uint32(Window)); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) UnmapWindow(Window Id) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 10; |
| put32(b[4:], uint32(Window)); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) UnmapSubwindows(Window Id) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 11; |
| put32(b[4:], uint32(Window)); |
| c.sendRequest(b); |
| } |
| |
| const ( |
| ConfigWindowX = 1; |
| ConfigWindowY = 2; |
| ConfigWindowWidth = 4; |
| ConfigWindowHeight = 8; |
| ConfigWindowBorderWidth = 16; |
| ConfigWindowSibling = 32; |
| ConfigWindowStackMode = 64; |
| ) |
| |
| const ( |
| StackModeAbove = 0; |
| StackModeBelow = 1; |
| StackModeTopIf = 2; |
| StackModeBottomIf = 3; |
| StackModeOpposite = 4; |
| ) |
| |
| func (c *Conn) ConfigureWindow(Window Id, ValueMask uint16, ValueList []uint32) { |
| b := c.scratch[0:12]; |
| n := 12; |
| n += pad(popCount(int(ValueMask)) * 4); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 12; |
| put32(b[4:], uint32(Window)); |
| put16(b[8:], ValueMask); |
| c.sendRequest(b); |
| c.sendUInt32List(ValueList[0:popCount(int(ValueMask))]); |
| } |
| |
| const ( |
| CirculateRaiseLowest = 0; |
| CirculateLowerHighest = 1; |
| ) |
| |
| func (c *Conn) CirculateWindow(Direction byte, Window Id) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 13; |
| b[1] = Direction; |
| put32(b[4:], uint32(Window)); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetGeometryRequest(Drawable Id) Cookie { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 14; |
| put32(b[4:], uint32(Drawable)); |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetGeometry(Drawable Id) (*GetGeometryReply, os.Error) { |
| return c.GetGeometryReply(c.GetGeometryRequest(Drawable)) |
| } |
| |
| type GetGeometryReply struct { |
| Depth byte; |
| Root Id; |
| X int16; |
| Y int16; |
| Width uint16; |
| Height uint16; |
| BorderWidth uint16; |
| } |
| |
| func (c *Conn) GetGeometryReply(cookie Cookie) (*GetGeometryReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(GetGeometryReply); |
| v.Depth = b[1]; |
| v.Root = Id(get32(b[8:])); |
| v.X = int16(get16(b[12:])); |
| v.Y = int16(get16(b[14:])); |
| v.Width = get16(b[16:]); |
| v.Height = get16(b[18:]); |
| v.BorderWidth = get16(b[20:]); |
| return v, nil; |
| } |
| |
| func (c *Conn) QueryTreeRequest(Window Id) Cookie { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 15; |
| put32(b[4:], uint32(Window)); |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) QueryTree(Window Id) (*QueryTreeReply, os.Error) { |
| return c.QueryTreeReply(c.QueryTreeRequest(Window)) |
| } |
| |
| type QueryTreeReply struct { |
| Root Id; |
| Parent Id; |
| ChildrenLen uint16; |
| Children []Id; |
| } |
| |
| func (c *Conn) QueryTreeReply(cookie Cookie) (*QueryTreeReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(QueryTreeReply); |
| v.Root = Id(get32(b[8:])); |
| v.Parent = Id(get32(b[12:])); |
| v.ChildrenLen = get16(b[16:]); |
| offset := 32; |
| v.Children = make([]Id, int(v.ChildrenLen)); |
| for i := 0; i < len(v.Children); i++ { |
| v.Children[i] = Id(get32(b[offset+i*4:])) |
| } |
| offset += len(v.Children) * 4; |
| return v, nil; |
| } |
| |
| func (c *Conn) InternAtomRequest(OnlyIfExists byte, Name string) Cookie { |
| b := c.scratch[0:8]; |
| n := 8; |
| n += pad(len(Name) * 1); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 16; |
| b[1] = OnlyIfExists; |
| put16(b[4:], uint16(len(Name))); |
| cookie := c.sendRequest(b); |
| c.sendString(Name); |
| return cookie; |
| } |
| |
| func (c *Conn) InternAtom(OnlyIfExists byte, Name string) (*InternAtomReply, os.Error) { |
| return c.InternAtomReply(c.InternAtomRequest(OnlyIfExists, Name)) |
| } |
| |
| type InternAtomReply struct { |
| Atom Id; |
| } |
| |
| func (c *Conn) InternAtomReply(cookie Cookie) (*InternAtomReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(InternAtomReply); |
| v.Atom = Id(get32(b[8:])); |
| return v, nil; |
| } |
| |
| func (c *Conn) GetAtomNameRequest(Atom Id) Cookie { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 17; |
| put32(b[4:], uint32(Atom)); |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetAtomName(Atom Id) (*GetAtomNameReply, os.Error) { |
| return c.GetAtomNameReply(c.GetAtomNameRequest(Atom)) |
| } |
| |
| type GetAtomNameReply struct { |
| NameLen uint16; |
| Name []byte; |
| } |
| |
| func (c *Conn) GetAtomNameReply(cookie Cookie) (*GetAtomNameReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(GetAtomNameReply); |
| v.NameLen = get16(b[8:]); |
| offset := 32; |
| v.Name = make([]byte, int(v.NameLen)); |
| copy(v.Name[0:len(v.Name)], b[offset:]); |
| offset += len(v.Name) * 1; |
| return v, nil; |
| } |
| |
| const ( |
| PropModeReplace = 0; |
| PropModePrepend = 1; |
| PropModeAppend = 2; |
| ) |
| |
| func (c *Conn) ChangeProperty(Mode byte, Window Id, Property Id, Type Id, Format byte, Data []byte) { |
| b := c.scratch[0:24]; |
| n := 24; |
| n += pad(((len(Data) * int(Format)) / 8) * 1); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 18; |
| b[1] = Mode; |
| put32(b[4:], uint32(Window)); |
| put32(b[8:], uint32(Property)); |
| put32(b[12:], uint32(Type)); |
| b[16] = Format; |
| put32(b[20:], uint32(len(Data))); |
| c.sendRequest(b); |
| c.sendBytes(Data[0:((len(Data) * int(Format)) / 8)]); |
| } |
| |
| func (c *Conn) DeleteProperty(Window Id, Property Id) { |
| b := c.scratch[0:12]; |
| put16(b[2:], 3); |
| b[0] = 19; |
| put32(b[4:], uint32(Window)); |
| put32(b[8:], uint32(Property)); |
| c.sendRequest(b); |
| } |
| |
| const ( |
| GetPropertyTypeAny = 0; |
| ) |
| |
| func (c *Conn) GetPropertyRequest(Delete byte, Window Id, Property Id, Type Id, LongOffset uint32, LongLength uint32) Cookie { |
| b := c.scratch[0:24]; |
| put16(b[2:], 6); |
| b[0] = 20; |
| b[1] = Delete; |
| put32(b[4:], uint32(Window)); |
| put32(b[8:], uint32(Property)); |
| put32(b[12:], uint32(Type)); |
| put32(b[16:], LongOffset); |
| put32(b[20:], LongLength); |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetProperty(Delete byte, Window Id, Property Id, Type Id, LongOffset uint32, LongLength uint32) (*GetPropertyReply, os.Error) { |
| return c.GetPropertyReply(c.GetPropertyRequest(Delete, Window, Property, Type, LongOffset, LongLength)) |
| } |
| |
| type GetPropertyReply struct { |
| Format byte; |
| Type Id; |
| BytesAfter uint32; |
| ValueLen uint32; |
| Value []byte; |
| } |
| |
| func (c *Conn) GetPropertyReply(cookie Cookie) (*GetPropertyReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(GetPropertyReply); |
| v.Format = b[1]; |
| v.Type = Id(get32(b[8:])); |
| v.BytesAfter = get32(b[12:]); |
| v.ValueLen = get32(b[16:]); |
| offset := 32; |
| v.Value = make([]byte, (int(v.ValueLen) * (int(v.Format) / 8))); |
| copy(v.Value[0:len(v.Value)], b[offset:]); |
| offset += len(v.Value) * 1; |
| return v, nil; |
| } |
| |
| func (c *Conn) ListPropertiesRequest(Window Id) Cookie { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 21; |
| put32(b[4:], uint32(Window)); |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) ListProperties(Window Id) (*ListPropertiesReply, os.Error) { |
| return c.ListPropertiesReply(c.ListPropertiesRequest(Window)) |
| } |
| |
| type ListPropertiesReply struct { |
| AtomsLen uint16; |
| Atoms []Id; |
| } |
| |
| func (c *Conn) ListPropertiesReply(cookie Cookie) (*ListPropertiesReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(ListPropertiesReply); |
| v.AtomsLen = get16(b[8:]); |
| offset := 32; |
| v.Atoms = make([]Id, int(v.AtomsLen)); |
| for i := 0; i < len(v.Atoms); i++ { |
| v.Atoms[i] = Id(get32(b[offset+i*4:])) |
| } |
| offset += len(v.Atoms) * 4; |
| return v, nil; |
| } |
| |
| func (c *Conn) SetSelectionOwner(Owner Id, Selection Id, Time Timestamp) { |
| b := c.scratch[0:16]; |
| put16(b[2:], 4); |
| b[0] = 22; |
| put32(b[4:], uint32(Owner)); |
| put32(b[8:], uint32(Selection)); |
| put32(b[12:], uint32(Time)); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetSelectionOwnerRequest(Selection Id) Cookie { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 23; |
| put32(b[4:], uint32(Selection)); |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetSelectionOwner(Selection Id) (*GetSelectionOwnerReply, os.Error) { |
| return c.GetSelectionOwnerReply(c.GetSelectionOwnerRequest(Selection)) |
| } |
| |
| type GetSelectionOwnerReply struct { |
| Owner Id; |
| } |
| |
| func (c *Conn) GetSelectionOwnerReply(cookie Cookie) (*GetSelectionOwnerReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(GetSelectionOwnerReply); |
| v.Owner = Id(get32(b[8:])); |
| return v, nil; |
| } |
| |
| func (c *Conn) ConvertSelection(Requestor Id, Selection Id, Target Id, Property Id, Time Timestamp) { |
| b := c.scratch[0:24]; |
| put16(b[2:], 6); |
| b[0] = 24; |
| put32(b[4:], uint32(Requestor)); |
| put32(b[8:], uint32(Selection)); |
| put32(b[12:], uint32(Target)); |
| put32(b[16:], uint32(Property)); |
| put32(b[20:], uint32(Time)); |
| c.sendRequest(b); |
| } |
| |
| const ( |
| SendEventDestPointerWindow = 0; |
| SendEventDestItemFocus = 1; |
| ) |
| |
| func (c *Conn) SendEvent(Propagate byte, Destination Id, EventMask uint32, Event []byte) { |
| b := make([]byte, 44); |
| put16(b[2:], 11); |
| b[0] = 25; |
| b[1] = Propagate; |
| put32(b[4:], uint32(Destination)); |
| put32(b[8:], EventMask); |
| copy(b[12:44], Event); |
| c.sendRequest(b); |
| } |
| |
| const ( |
| GrabModeSync = 0; |
| GrabModeAsync = 1; |
| ) |
| |
| const ( |
| GrabStatusSuccess = 0; |
| GrabStatusAlreadyGrabbed = 1; |
| GrabStatusInvalidTime = 2; |
| GrabStatusNotViewable = 3; |
| GrabStatusFrozen = 4; |
| ) |
| |
| const ( |
| CursorNone = 0; |
| ) |
| |
| func (c *Conn) GrabPointerRequest(OwnerEvents byte, GrabWindow Id, EventMask uint16, PointerMode byte, KeyboardMode byte, ConfineTo Id, Cursor Id, Time Timestamp) Cookie { |
| b := c.scratch[0:24]; |
| put16(b[2:], 6); |
| b[0] = 26; |
| b[1] = OwnerEvents; |
| put32(b[4:], uint32(GrabWindow)); |
| put16(b[8:], EventMask); |
| b[10] = PointerMode; |
| b[11] = KeyboardMode; |
| put32(b[12:], uint32(ConfineTo)); |
| put32(b[16:], uint32(Cursor)); |
| put32(b[20:], uint32(Time)); |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) GrabPointer(OwnerEvents byte, GrabWindow Id, EventMask uint16, PointerMode byte, KeyboardMode byte, ConfineTo Id, Cursor Id, Time Timestamp) (*GrabPointerReply, os.Error) { |
| return c.GrabPointerReply(c.GrabPointerRequest(OwnerEvents, GrabWindow, EventMask, PointerMode, KeyboardMode, ConfineTo, Cursor, Time)) |
| } |
| |
| type GrabPointerReply struct { |
| Status byte; |
| } |
| |
| func (c *Conn) GrabPointerReply(cookie Cookie) (*GrabPointerReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(GrabPointerReply); |
| v.Status = b[1]; |
| return v, nil; |
| } |
| |
| func (c *Conn) UngrabPointer(Time Timestamp) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 27; |
| put32(b[4:], uint32(Time)); |
| c.sendRequest(b); |
| } |
| |
| const ( |
| ButtonIndexAny = 0; |
| ButtonIndex1 = 1; |
| ButtonIndex2 = 2; |
| ButtonIndex3 = 3; |
| ButtonIndex4 = 4; |
| ButtonIndex5 = 5; |
| ) |
| |
| func (c *Conn) GrabButton(OwnerEvents byte, GrabWindow Id, EventMask uint16, PointerMode byte, KeyboardMode byte, ConfineTo Id, Cursor Id, Button byte, Modifiers uint16) { |
| b := c.scratch[0:24]; |
| put16(b[2:], 6); |
| b[0] = 28; |
| b[1] = OwnerEvents; |
| put32(b[4:], uint32(GrabWindow)); |
| put16(b[8:], EventMask); |
| b[10] = PointerMode; |
| b[11] = KeyboardMode; |
| put32(b[12:], uint32(ConfineTo)); |
| put32(b[16:], uint32(Cursor)); |
| b[20] = Button; |
| put16(b[22:], Modifiers); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) UngrabButton(Button byte, GrabWindow Id, Modifiers uint16) { |
| b := c.scratch[0:12]; |
| put16(b[2:], 3); |
| b[0] = 29; |
| b[1] = Button; |
| put32(b[4:], uint32(GrabWindow)); |
| put16(b[8:], Modifiers); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) ChangeActivePointerGrab(Cursor Id, Time Timestamp, EventMask uint16) { |
| b := c.scratch[0:16]; |
| put16(b[2:], 4); |
| b[0] = 30; |
| put32(b[4:], uint32(Cursor)); |
| put32(b[8:], uint32(Time)); |
| put16(b[12:], EventMask); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) GrabKeyboardRequest(OwnerEvents byte, GrabWindow Id, Time Timestamp, PointerMode byte, KeyboardMode byte) Cookie { |
| b := c.scratch[0:16]; |
| put16(b[2:], 4); |
| b[0] = 31; |
| b[1] = OwnerEvents; |
| put32(b[4:], uint32(GrabWindow)); |
| put32(b[8:], uint32(Time)); |
| b[12] = PointerMode; |
| b[13] = KeyboardMode; |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) GrabKeyboard(OwnerEvents byte, GrabWindow Id, Time Timestamp, PointerMode byte, KeyboardMode byte) (*GrabKeyboardReply, os.Error) { |
| return c.GrabKeyboardReply(c.GrabKeyboardRequest(OwnerEvents, GrabWindow, Time, PointerMode, KeyboardMode)) |
| } |
| |
| type GrabKeyboardReply struct { |
| Status byte; |
| } |
| |
| func (c *Conn) GrabKeyboardReply(cookie Cookie) (*GrabKeyboardReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(GrabKeyboardReply); |
| v.Status = b[1]; |
| return v, nil; |
| } |
| |
| func (c *Conn) UngrabKeyboard(Time Timestamp) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 32; |
| put32(b[4:], uint32(Time)); |
| c.sendRequest(b); |
| } |
| |
| const ( |
| GrabAny = 0; |
| ) |
| |
| func (c *Conn) GrabKey(OwnerEvents byte, GrabWindow Id, Modifiers uint16, Key byte, PointerMode byte, KeyboardMode byte) { |
| b := c.scratch[0:16]; |
| put16(b[2:], 4); |
| b[0] = 33; |
| b[1] = OwnerEvents; |
| put32(b[4:], uint32(GrabWindow)); |
| put16(b[8:], Modifiers); |
| b[10] = Key; |
| b[11] = PointerMode; |
| b[12] = KeyboardMode; |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) UngrabKey(Key byte, GrabWindow Id, Modifiers uint16) { |
| b := c.scratch[0:12]; |
| put16(b[2:], 3); |
| b[0] = 34; |
| b[1] = Key; |
| put32(b[4:], uint32(GrabWindow)); |
| put16(b[8:], Modifiers); |
| c.sendRequest(b); |
| } |
| |
| const ( |
| AllowAsyncPointer = 0; |
| AllowSyncPointer = 1; |
| AllowReplayPointer = 2; |
| AllowAsyncKeyboard = 3; |
| AllowSyncKeyboard = 4; |
| AllowReplayKeyboard = 5; |
| AllowAsyncBoth = 6; |
| AllowSyncBoth = 7; |
| ) |
| |
| func (c *Conn) AllowEvents(Mode byte, Time Timestamp) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 35; |
| b[1] = Mode; |
| put32(b[4:], uint32(Time)); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) GrabServer() { |
| b := c.scratch[0:4]; |
| put16(b[2:], 1); |
| b[0] = 36; |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) UngrabServer() { |
| b := c.scratch[0:4]; |
| put16(b[2:], 1); |
| b[0] = 37; |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) QueryPointerRequest(Window Id) Cookie { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 38; |
| put32(b[4:], uint32(Window)); |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) QueryPointer(Window Id) (*QueryPointerReply, os.Error) { |
| return c.QueryPointerReply(c.QueryPointerRequest(Window)) |
| } |
| |
| type QueryPointerReply struct { |
| SameScreen byte; |
| Root Id; |
| Child Id; |
| RootX int16; |
| RootY int16; |
| WinX int16; |
| WinY int16; |
| Mask uint16; |
| } |
| |
| func (c *Conn) QueryPointerReply(cookie Cookie) (*QueryPointerReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(QueryPointerReply); |
| v.SameScreen = b[1]; |
| v.Root = Id(get32(b[8:])); |
| v.Child = Id(get32(b[12:])); |
| v.RootX = int16(get16(b[16:])); |
| v.RootY = int16(get16(b[18:])); |
| v.WinX = int16(get16(b[20:])); |
| v.WinY = int16(get16(b[22:])); |
| v.Mask = get16(b[24:]); |
| return v, nil; |
| } |
| |
| type Timecoord struct { |
| Time Timestamp; |
| X int16; |
| Y int16; |
| } |
| |
| func getTimecoord(b []byte, v *Timecoord) int { |
| v.Time = Timestamp(get32(b[0:])); |
| v.X = int16(get16(b[4:])); |
| v.Y = int16(get16(b[6:])); |
| return 8; |
| } |
| |
| func (c *Conn) sendTimecoordList(list []Timecoord, count int) { |
| b0 := make([]byte, 8*count); |
| for k := 0; k < count; k++ { |
| b := b0[k*8:]; |
| put32(b[0:], uint32(list[k].Time)); |
| put16(b[4:], uint16(list[k].X)); |
| put16(b[6:], uint16(list[k].Y)); |
| } |
| c.sendBytes(b0); |
| } |
| |
| func (c *Conn) GetMotionEventsRequest(Window Id, Start Timestamp, Stop Timestamp) Cookie { |
| b := c.scratch[0:16]; |
| put16(b[2:], 4); |
| b[0] = 39; |
| put32(b[4:], uint32(Window)); |
| put32(b[8:], uint32(Start)); |
| put32(b[12:], uint32(Stop)); |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetMotionEvents(Window Id, Start Timestamp, Stop Timestamp) (*GetMotionEventsReply, os.Error) { |
| return c.GetMotionEventsReply(c.GetMotionEventsRequest(Window, Start, Stop)) |
| } |
| |
| type GetMotionEventsReply struct { |
| EventsLen uint32; |
| Events []Timecoord; |
| } |
| |
| func (c *Conn) GetMotionEventsReply(cookie Cookie) (*GetMotionEventsReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(GetMotionEventsReply); |
| v.EventsLen = get32(b[8:]); |
| offset := 32; |
| v.Events = make([]Timecoord, int(v.EventsLen)); |
| for i := 0; i < int(v.EventsLen); i++ { |
| offset += getTimecoord(b[offset:], &v.Events[i]) |
| } |
| return v, nil; |
| } |
| |
| func (c *Conn) TranslateCoordinatesRequest(SrcWindow Id, DstWindow Id, SrcX int16, SrcY int16) Cookie { |
| b := c.scratch[0:16]; |
| put16(b[2:], 4); |
| b[0] = 40; |
| put32(b[4:], uint32(SrcWindow)); |
| put32(b[8:], uint32(DstWindow)); |
| put16(b[12:], uint16(SrcX)); |
| put16(b[14:], uint16(SrcY)); |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) TranslateCoordinates(SrcWindow Id, DstWindow Id, SrcX int16, SrcY int16) (*TranslateCoordinatesReply, os.Error) { |
| return c.TranslateCoordinatesReply(c.TranslateCoordinatesRequest(SrcWindow, DstWindow, SrcX, SrcY)) |
| } |
| |
| type TranslateCoordinatesReply struct { |
| SameScreen byte; |
| Child Id; |
| DstX uint16; |
| DstY uint16; |
| } |
| |
| func (c *Conn) TranslateCoordinatesReply(cookie Cookie) (*TranslateCoordinatesReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(TranslateCoordinatesReply); |
| v.SameScreen = b[1]; |
| v.Child = Id(get32(b[8:])); |
| v.DstX = get16(b[12:]); |
| v.DstY = get16(b[14:]); |
| return v, nil; |
| } |
| |
| func (c *Conn) WarpPointer(SrcWindow Id, DstWindow Id, SrcX int16, SrcY int16, SrcWidth uint16, SrcHeight uint16, DstX int16, DstY int16) { |
| b := c.scratch[0:24]; |
| put16(b[2:], 6); |
| b[0] = 41; |
| put32(b[4:], uint32(SrcWindow)); |
| put32(b[8:], uint32(DstWindow)); |
| put16(b[12:], uint16(SrcX)); |
| put16(b[14:], uint16(SrcY)); |
| put16(b[16:], SrcWidth); |
| put16(b[18:], SrcHeight); |
| put16(b[20:], uint16(DstX)); |
| put16(b[22:], uint16(DstY)); |
| c.sendRequest(b); |
| } |
| |
| const ( |
| InputFocusNone = 0; |
| InputFocusPointerRoot = 1; |
| InputFocusParent = 2; |
| InputFocusFollowKeyboard = 3; |
| ) |
| |
| func (c *Conn) SetInputFocus(RevertTo byte, Focus Id, Time Timestamp) { |
| b := c.scratch[0:12]; |
| put16(b[2:], 3); |
| b[0] = 42; |
| b[1] = RevertTo; |
| put32(b[4:], uint32(Focus)); |
| put32(b[8:], uint32(Time)); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetInputFocusRequest() Cookie { |
| b := c.scratch[0:4]; |
| put16(b[2:], 1); |
| b[0] = 43; |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetInputFocus() (*GetInputFocusReply, os.Error) { |
| return c.GetInputFocusReply(c.GetInputFocusRequest()) |
| } |
| |
| type GetInputFocusReply struct { |
| RevertTo byte; |
| Focus Id; |
| } |
| |
| func (c *Conn) GetInputFocusReply(cookie Cookie) (*GetInputFocusReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(GetInputFocusReply); |
| v.RevertTo = b[1]; |
| v.Focus = Id(get32(b[8:])); |
| return v, nil; |
| } |
| |
| func (c *Conn) QueryKeymapRequest() Cookie { |
| b := c.scratch[0:4]; |
| put16(b[2:], 1); |
| b[0] = 44; |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) QueryKeymap() (*QueryKeymapReply, os.Error) { |
| return c.QueryKeymapReply(c.QueryKeymapRequest()) |
| } |
| |
| type QueryKeymapReply struct { |
| Keys [32]byte; |
| } |
| |
| func (c *Conn) QueryKeymapReply(cookie Cookie) (*QueryKeymapReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(QueryKeymapReply); |
| copy(v.Keys[0:32], b[8:]); |
| return v, nil; |
| } |
| |
| func (c *Conn) OpenFont(Fid Id, Name string) { |
| b := c.scratch[0:12]; |
| n := 12; |
| n += pad(len(Name) * 1); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 45; |
| put32(b[4:], uint32(Fid)); |
| put16(b[8:], uint16(len(Name))); |
| c.sendRequest(b); |
| c.sendString(Name); |
| } |
| |
| func (c *Conn) CloseFont(Font Id) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 46; |
| put32(b[4:], uint32(Font)); |
| c.sendRequest(b); |
| } |
| |
| const ( |
| FontDrawLeftToRight = 0; |
| FontDrawRightToLeft = 1; |
| ) |
| |
| type Fontprop struct { |
| Name Id; |
| Value uint32; |
| } |
| |
| func getFontprop(b []byte, v *Fontprop) int { |
| v.Name = Id(get32(b[0:])); |
| v.Value = get32(b[4:]); |
| return 8; |
| } |
| |
| func (c *Conn) sendFontpropList(list []Fontprop, count int) { |
| b0 := make([]byte, 8*count); |
| for k := 0; k < count; k++ { |
| b := b0[k*8:]; |
| put32(b[0:], uint32(list[k].Name)); |
| put32(b[4:], list[k].Value); |
| } |
| c.sendBytes(b0); |
| } |
| |
| type Charinfo struct { |
| LeftSideBearing int16; |
| RightSideBearing int16; |
| CharacterWidth int16; |
| Ascent int16; |
| Descent int16; |
| Attributes uint16; |
| } |
| |
| func getCharinfo(b []byte, v *Charinfo) int { |
| v.LeftSideBearing = int16(get16(b[0:])); |
| v.RightSideBearing = int16(get16(b[2:])); |
| v.CharacterWidth = int16(get16(b[4:])); |
| v.Ascent = int16(get16(b[6:])); |
| v.Descent = int16(get16(b[8:])); |
| v.Attributes = get16(b[10:]); |
| return 12; |
| } |
| |
| func (c *Conn) sendCharinfoList(list []Charinfo, count int) { |
| b0 := make([]byte, 12*count); |
| for k := 0; k < count; k++ { |
| b := b0[k*12:]; |
| put16(b[0:], uint16(list[k].LeftSideBearing)); |
| put16(b[2:], uint16(list[k].RightSideBearing)); |
| put16(b[4:], uint16(list[k].CharacterWidth)); |
| put16(b[6:], uint16(list[k].Ascent)); |
| put16(b[8:], uint16(list[k].Descent)); |
| put16(b[10:], list[k].Attributes); |
| } |
| c.sendBytes(b0); |
| } |
| |
| func (c *Conn) QueryFontRequest(Font Id) Cookie { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 47; |
| put32(b[4:], uint32(Font)); |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) QueryFont(Font Id) (*QueryFontReply, os.Error) { |
| return c.QueryFontReply(c.QueryFontRequest(Font)) |
| } |
| |
| type QueryFontReply struct { |
| MinBounds Charinfo; |
| MaxBounds Charinfo; |
| MinCharOrByte2 uint16; |
| MaxCharOrByte2 uint16; |
| DefaultChar uint16; |
| PropertiesLen uint16; |
| DrawDirection byte; |
| MinByte1 byte; |
| MaxByte1 byte; |
| AllCharsExist byte; |
| FontAscent int16; |
| FontDescent int16; |
| CharInfosLen uint32; |
| Properties []Fontprop; |
| CharInfos []Charinfo; |
| } |
| |
| func (c *Conn) QueryFontReply(cookie Cookie) (*QueryFontReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(QueryFontReply); |
| getCharinfo(b[8:], &v.MinBounds); |
| getCharinfo(b[24:], &v.MaxBounds); |
| v.MinCharOrByte2 = get16(b[40:]); |
| v.MaxCharOrByte2 = get16(b[42:]); |
| v.DefaultChar = get16(b[44:]); |
| v.PropertiesLen = get16(b[46:]); |
| v.DrawDirection = b[48]; |
| v.MinByte1 = b[49]; |
| v.MaxByte1 = b[50]; |
| v.AllCharsExist = b[51]; |
| v.FontAscent = int16(get16(b[52:])); |
| v.FontDescent = int16(get16(b[54:])); |
| v.CharInfosLen = get32(b[56:]); |
| offset := 60; |
| v.Properties = make([]Fontprop, int(v.PropertiesLen)); |
| for i := 0; i < int(v.PropertiesLen); i++ { |
| offset += getFontprop(b[offset:], &v.Properties[i]) |
| } |
| offset = pad(offset); |
| v.CharInfos = make([]Charinfo, int(v.CharInfosLen)); |
| for i := 0; i < int(v.CharInfosLen); i++ { |
| offset += getCharinfo(b[offset:], &v.CharInfos[i]) |
| } |
| return v, nil; |
| } |
| |
| func (c *Conn) QueryTextExtentsRequest(Font Id, String []Char2b) Cookie { |
| b := c.scratch[0:8]; |
| n := 8; |
| n += pad(len(String) * 2); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 48; |
| b[1] = byte((len(String) & 1)); |
| put32(b[4:], uint32(Font)); |
| cookie := c.sendRequest(b); |
| c.sendChar2bList(String, len(String)); |
| return cookie; |
| } |
| |
| func (c *Conn) QueryTextExtents(Font Id, String []Char2b) (*QueryTextExtentsReply, os.Error) { |
| return c.QueryTextExtentsReply(c.QueryTextExtentsRequest(Font, String)) |
| } |
| |
| type QueryTextExtentsReply struct { |
| DrawDirection byte; |
| FontAscent int16; |
| FontDescent int16; |
| OverallAscent int16; |
| OverallDescent int16; |
| OverallWidth int32; |
| OverallLeft int32; |
| OverallRight int32; |
| } |
| |
| func (c *Conn) QueryTextExtentsReply(cookie Cookie) (*QueryTextExtentsReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(QueryTextExtentsReply); |
| v.DrawDirection = b[1]; |
| v.FontAscent = int16(get16(b[8:])); |
| v.FontDescent = int16(get16(b[10:])); |
| v.OverallAscent = int16(get16(b[12:])); |
| v.OverallDescent = int16(get16(b[14:])); |
| v.OverallWidth = int32(get32(b[16:])); |
| v.OverallLeft = int32(get32(b[20:])); |
| v.OverallRight = int32(get32(b[24:])); |
| return v, nil; |
| } |
| |
| type Str struct { |
| NameLen byte; |
| Name []byte; |
| } |
| |
| func getStr(b []byte, v *Str) int { |
| v.NameLen = b[0]; |
| offset := 1; |
| v.Name = make([]byte, int(v.NameLen)); |
| copy(v.Name[0:len(v.Name)], b[offset:]); |
| offset += len(v.Name) * 1; |
| return offset; |
| } |
| |
| // omitting variable length sendStr |
| |
| func (c *Conn) ListFontsRequest(MaxNames uint16, Pattern []byte) Cookie { |
| b := c.scratch[0:8]; |
| n := 8; |
| n += pad(len(Pattern) * 1); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 49; |
| put16(b[4:], MaxNames); |
| put16(b[6:], uint16(len(Pattern))); |
| cookie := c.sendRequest(b); |
| c.sendBytes(Pattern[0:len(Pattern)]); |
| return cookie; |
| } |
| |
| func (c *Conn) ListFonts(MaxNames uint16, Pattern []byte) (*ListFontsReply, os.Error) { |
| return c.ListFontsReply(c.ListFontsRequest(MaxNames, Pattern)) |
| } |
| |
| type ListFontsReply struct { |
| NamesLen uint16; |
| Names []Str; |
| } |
| |
| func (c *Conn) ListFontsReply(cookie Cookie) (*ListFontsReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(ListFontsReply); |
| v.NamesLen = get16(b[8:]); |
| offset := 32; |
| v.Names = make([]Str, int(v.NamesLen)); |
| for i := 0; i < int(v.NamesLen); i++ { |
| offset += getStr(b[offset:], &v.Names[i]) |
| } |
| return v, nil; |
| } |
| |
| func (c *Conn) ListFontsWithInfoRequest(MaxNames uint16, Pattern []byte) Cookie { |
| b := c.scratch[0:8]; |
| n := 8; |
| n += pad(len(Pattern) * 1); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 50; |
| put16(b[4:], MaxNames); |
| put16(b[6:], uint16(len(Pattern))); |
| cookie := c.sendRequest(b); |
| c.sendBytes(Pattern[0:len(Pattern)]); |
| return cookie; |
| } |
| |
| func (c *Conn) ListFontsWithInfo(MaxNames uint16, Pattern []byte) (*ListFontsWithInfoReply, os.Error) { |
| return c.ListFontsWithInfoReply(c.ListFontsWithInfoRequest(MaxNames, Pattern)) |
| } |
| |
| type ListFontsWithInfoReply struct { |
| NameLen byte; |
| MinBounds Charinfo; |
| MaxBounds Charinfo; |
| MinCharOrByte2 uint16; |
| MaxCharOrByte2 uint16; |
| DefaultChar uint16; |
| PropertiesLen uint16; |
| DrawDirection byte; |
| MinByte1 byte; |
| MaxByte1 byte; |
| AllCharsExist byte; |
| FontAscent int16; |
| FontDescent int16; |
| RepliesHint uint32; |
| Properties []Fontprop; |
| Name []byte; |
| } |
| |
| func (c *Conn) ListFontsWithInfoReply(cookie Cookie) (*ListFontsWithInfoReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(ListFontsWithInfoReply); |
| v.NameLen = b[1]; |
| getCharinfo(b[8:], &v.MinBounds); |
| getCharinfo(b[24:], &v.MaxBounds); |
| v.MinCharOrByte2 = get16(b[40:]); |
| v.MaxCharOrByte2 = get16(b[42:]); |
| v.DefaultChar = get16(b[44:]); |
| v.PropertiesLen = get16(b[46:]); |
| v.DrawDirection = b[48]; |
| v.MinByte1 = b[49]; |
| v.MaxByte1 = b[50]; |
| v.AllCharsExist = b[51]; |
| v.FontAscent = int16(get16(b[52:])); |
| v.FontDescent = int16(get16(b[54:])); |
| v.RepliesHint = get32(b[56:]); |
| offset := 60; |
| v.Properties = make([]Fontprop, int(v.PropertiesLen)); |
| for i := 0; i < int(v.PropertiesLen); i++ { |
| offset += getFontprop(b[offset:], &v.Properties[i]) |
| } |
| offset = pad(offset); |
| v.Name = make([]byte, int(v.NameLen)); |
| copy(v.Name[0:len(v.Name)], b[offset:]); |
| offset += len(v.Name) * 1; |
| return v, nil; |
| } |
| |
| func (c *Conn) SetFontPath(FontQty uint16, Path []byte) { |
| b := c.scratch[0:6]; |
| n := 6; |
| n += pad(len(Path) * 1); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 51; |
| put16(b[4:], FontQty); |
| c.sendRequest(b); |
| c.sendBytes(Path[0:len(Path)]); |
| } |
| |
| func (c *Conn) GetFontPathRequest() Cookie { |
| b := c.scratch[0:4]; |
| put16(b[2:], 1); |
| b[0] = 52; |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetFontPath() (*GetFontPathReply, os.Error) { |
| return c.GetFontPathReply(c.GetFontPathRequest()) |
| } |
| |
| type GetFontPathReply struct { |
| PathLen uint16; |
| Path []Str; |
| } |
| |
| func (c *Conn) GetFontPathReply(cookie Cookie) (*GetFontPathReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(GetFontPathReply); |
| v.PathLen = get16(b[8:]); |
| offset := 32; |
| v.Path = make([]Str, int(v.PathLen)); |
| for i := 0; i < int(v.PathLen); i++ { |
| offset += getStr(b[offset:], &v.Path[i]) |
| } |
| return v, nil; |
| } |
| |
| func (c *Conn) CreatePixmap(Depth byte, Pid Id, Drawable Id, Width uint16, Height uint16) { |
| b := c.scratch[0:16]; |
| put16(b[2:], 4); |
| b[0] = 53; |
| b[1] = Depth; |
| put32(b[4:], uint32(Pid)); |
| put32(b[8:], uint32(Drawable)); |
| put16(b[12:], Width); |
| put16(b[14:], Height); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) FreePixmap(Pixmap Id) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 54; |
| put32(b[4:], uint32(Pixmap)); |
| c.sendRequest(b); |
| } |
| |
| const ( |
| GCFunction = 1; |
| GCPlaneMask = 2; |
| GCForeground = 4; |
| GCBackground = 8; |
| GCLineWidth = 16; |
| GCLineStyle = 32; |
| GCCapStyle = 64; |
| GCJoinStyle = 128; |
| GCFillStyle = 256; |
| GCFillRule = 512; |
| GCTile = 1024; |
| GCStipple = 2048; |
| GCTileStippleOriginX = 4096; |
| GCTileStippleOriginY = 8192; |
| GCFont = 16384; |
| GCSubwindowMode = 32768; |
| GCGraphicsExposures = 65536; |
| GCClipOriginX = 131072; |
| GCClipOriginY = 262144; |
| GCClipMask = 524288; |
| GCDashOffset = 1048576; |
| GCDashList = 2097152; |
| GCArcMode = 4194304; |
| ) |
| |
| const ( |
| GXClear = 0; |
| GXAnd = 1; |
| GXAndReverse = 2; |
| GXCopy = 3; |
| GXAndInverted = 4; |
| GXNoop = 5; |
| GXXor = 6; |
| GXOr = 7; |
| GXNor = 8; |
| GXEquiv = 9; |
| GXInvert = 10; |
| GXOrReverse = 11; |
| GXCopyInverted = 12; |
| GXOrInverted = 13; |
| GXNand = 14; |
| GXSet = 15; |
| ) |
| |
| const ( |
| LineStyleSolid = 0; |
| LineStyleOnOffDash = 1; |
| LineStyleDoubleDash = 2; |
| ) |
| |
| const ( |
| CapStyleNotLast = 0; |
| CapStyleButt = 1; |
| CapStyleRound = 2; |
| CapStyleProjecting = 3; |
| ) |
| |
| const ( |
| JoinStyleMiter = 0; |
| JoinStyleRound = 1; |
| JoinStyleBevel = 2; |
| ) |
| |
| const ( |
| FillStyleSolid = 0; |
| FillStyleTiled = 1; |
| FillStyleStippled = 2; |
| FillStyleOpaqueStippled = 3; |
| ) |
| |
| const ( |
| FillRuleEvenOdd = 0; |
| FillRuleWinding = 1; |
| ) |
| |
| const ( |
| SubwindowModeClipByChildren = 0; |
| SubwindowModeIncludeInferiors = 1; |
| ) |
| |
| const ( |
| ArcModeChord = 0; |
| ArcModePieSlice = 1; |
| ) |
| |
| func (c *Conn) CreateGC(Cid Id, Drawable Id, ValueMask uint32, ValueList []uint32) { |
| b := c.scratch[0:16]; |
| n := 16; |
| n += pad(popCount(int(ValueMask)) * 4); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 55; |
| put32(b[4:], uint32(Cid)); |
| put32(b[8:], uint32(Drawable)); |
| put32(b[12:], ValueMask); |
| c.sendRequest(b); |
| c.sendUInt32List(ValueList[0:popCount(int(ValueMask))]); |
| } |
| |
| func (c *Conn) ChangeGC(Gc Id, ValueMask uint32, ValueList []uint32) { |
| b := c.scratch[0:12]; |
| n := 12; |
| n += pad(popCount(int(ValueMask)) * 4); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 56; |
| put32(b[4:], uint32(Gc)); |
| put32(b[8:], ValueMask); |
| c.sendRequest(b); |
| c.sendUInt32List(ValueList[0:popCount(int(ValueMask))]); |
| } |
| |
| func (c *Conn) CopyGC(SrcGc Id, DstGc Id, ValueMask uint32) { |
| b := c.scratch[0:16]; |
| put16(b[2:], 4); |
| b[0] = 57; |
| put32(b[4:], uint32(SrcGc)); |
| put32(b[8:], uint32(DstGc)); |
| put32(b[12:], ValueMask); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) SetDashes(Gc Id, DashOffset uint16, Dashes []byte) { |
| b := c.scratch[0:12]; |
| n := 12; |
| n += pad(len(Dashes) * 1); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 58; |
| put32(b[4:], uint32(Gc)); |
| put16(b[8:], DashOffset); |
| put16(b[10:], uint16(len(Dashes))); |
| c.sendRequest(b); |
| c.sendBytes(Dashes[0:len(Dashes)]); |
| } |
| |
| const ( |
| ClipOrderingUnsorted = 0; |
| ClipOrderingYSorted = 1; |
| ClipOrderingYXSorted = 2; |
| ClipOrderingYXBanded = 3; |
| ) |
| |
| func (c *Conn) SetClipRectangles(Ordering byte, Gc Id, ClipXOrigin int16, ClipYOrigin int16, Rectangles []Rectangle) { |
| b := c.scratch[0:12]; |
| n := 12; |
| n += pad(len(Rectangles) * 8); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 59; |
| b[1] = Ordering; |
| put32(b[4:], uint32(Gc)); |
| put16(b[8:], uint16(ClipXOrigin)); |
| put16(b[10:], uint16(ClipYOrigin)); |
| c.sendRequest(b); |
| c.sendRectangleList(Rectangles, len(Rectangles)); |
| } |
| |
| func (c *Conn) FreeGC(Gc Id) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 60; |
| put32(b[4:], uint32(Gc)); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) ClearArea(Exposures byte, Window Id, X int16, Y int16, Width uint16, Height uint16) { |
| b := c.scratch[0:16]; |
| put16(b[2:], 4); |
| b[0] = 61; |
| b[1] = Exposures; |
| put32(b[4:], uint32(Window)); |
| put16(b[8:], uint16(X)); |
| put16(b[10:], uint16(Y)); |
| put16(b[12:], Width); |
| put16(b[14:], Height); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) CopyArea(SrcDrawable Id, DstDrawable Id, Gc Id, SrcX int16, SrcY int16, DstX int16, DstY int16, Width uint16, Height uint16) { |
| b := c.scratch[0:28]; |
| put16(b[2:], 7); |
| b[0] = 62; |
| put32(b[4:], uint32(SrcDrawable)); |
| put32(b[8:], uint32(DstDrawable)); |
| put32(b[12:], uint32(Gc)); |
| put16(b[16:], uint16(SrcX)); |
| put16(b[18:], uint16(SrcY)); |
| put16(b[20:], uint16(DstX)); |
| put16(b[22:], uint16(DstY)); |
| put16(b[24:], Width); |
| put16(b[26:], Height); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) CopyPlane(SrcDrawable Id, DstDrawable Id, Gc Id, SrcX int16, SrcY int16, DstX int16, DstY int16, Width uint16, Height uint16, BitPlane uint32) { |
| b := c.scratch[0:32]; |
| put16(b[2:], 8); |
| b[0] = 63; |
| put32(b[4:], uint32(SrcDrawable)); |
| put32(b[8:], uint32(DstDrawable)); |
| put32(b[12:], uint32(Gc)); |
| put16(b[16:], uint16(SrcX)); |
| put16(b[18:], uint16(SrcY)); |
| put16(b[20:], uint16(DstX)); |
| put16(b[22:], uint16(DstY)); |
| put16(b[24:], Width); |
| put16(b[26:], Height); |
| put32(b[28:], BitPlane); |
| c.sendRequest(b); |
| } |
| |
| const ( |
| CoordModeOrigin = 0; |
| CoordModePrevious = 1; |
| ) |
| |
| func (c *Conn) PolyPoint(CoordinateMode byte, Drawable Id, Gc Id, Points []Point) { |
| b := c.scratch[0:12]; |
| n := 12; |
| n += pad(len(Points) * 4); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 64; |
| b[1] = CoordinateMode; |
| put32(b[4:], uint32(Drawable)); |
| put32(b[8:], uint32(Gc)); |
| c.sendRequest(b); |
| c.sendPointList(Points, len(Points)); |
| } |
| |
| func (c *Conn) PolyLine(CoordinateMode byte, Drawable Id, Gc Id, Points []Point) { |
| b := c.scratch[0:12]; |
| n := 12; |
| n += pad(len(Points) * 4); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 65; |
| b[1] = CoordinateMode; |
| put32(b[4:], uint32(Drawable)); |
| put32(b[8:], uint32(Gc)); |
| c.sendRequest(b); |
| c.sendPointList(Points, len(Points)); |
| } |
| |
| type Segment struct { |
| X1 int16; |
| Y1 int16; |
| X2 int16; |
| Y2 int16; |
| } |
| |
| func getSegment(b []byte, v *Segment) int { |
| v.X1 = int16(get16(b[0:])); |
| v.Y1 = int16(get16(b[2:])); |
| v.X2 = int16(get16(b[4:])); |
| v.Y2 = int16(get16(b[6:])); |
| return 8; |
| } |
| |
| func (c *Conn) sendSegmentList(list []Segment, count int) { |
| b0 := make([]byte, 8*count); |
| for k := 0; k < count; k++ { |
| b := b0[k*8:]; |
| put16(b[0:], uint16(list[k].X1)); |
| put16(b[2:], uint16(list[k].Y1)); |
| put16(b[4:], uint16(list[k].X2)); |
| put16(b[6:], uint16(list[k].Y2)); |
| } |
| c.sendBytes(b0); |
| } |
| |
| func (c *Conn) PolySegment(Drawable Id, Gc Id, Segments []Segment) { |
| b := c.scratch[0:12]; |
| n := 12; |
| n += pad(len(Segments) * 8); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 66; |
| put32(b[4:], uint32(Drawable)); |
| put32(b[8:], uint32(Gc)); |
| c.sendRequest(b); |
| c.sendSegmentList(Segments, len(Segments)); |
| } |
| |
| func (c *Conn) PolyRectangle(Drawable Id, Gc Id, Rectangles []Rectangle) { |
| b := c.scratch[0:12]; |
| n := 12; |
| n += pad(len(Rectangles) * 8); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 67; |
| put32(b[4:], uint32(Drawable)); |
| put32(b[8:], uint32(Gc)); |
| c.sendRequest(b); |
| c.sendRectangleList(Rectangles, len(Rectangles)); |
| } |
| |
| func (c *Conn) PolyArc(Drawable Id, Gc Id, Arcs []Arc) { |
| b := c.scratch[0:12]; |
| n := 12; |
| n += pad(len(Arcs) * 12); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 68; |
| put32(b[4:], uint32(Drawable)); |
| put32(b[8:], uint32(Gc)); |
| c.sendRequest(b); |
| c.sendArcList(Arcs, len(Arcs)); |
| } |
| |
| const ( |
| PolyShapeComplex = 0; |
| PolyShapeNonconvex = 1; |
| PolyShapeConvex = 2; |
| ) |
| |
| func (c *Conn) FillPoly(Drawable Id, Gc Id, Shape byte, CoordinateMode byte, Points []Point) { |
| b := c.scratch[0:16]; |
| n := 16; |
| n += pad(len(Points) * 4); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 69; |
| put32(b[4:], uint32(Drawable)); |
| put32(b[8:], uint32(Gc)); |
| b[12] = Shape; |
| b[13] = CoordinateMode; |
| c.sendRequest(b); |
| c.sendPointList(Points, len(Points)); |
| } |
| |
| func (c *Conn) PolyFillRectangle(Drawable Id, Gc Id, Rectangles []Rectangle) { |
| b := c.scratch[0:12]; |
| n := 12; |
| n += pad(len(Rectangles) * 8); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 70; |
| put32(b[4:], uint32(Drawable)); |
| put32(b[8:], uint32(Gc)); |
| c.sendRequest(b); |
| c.sendRectangleList(Rectangles, len(Rectangles)); |
| } |
| |
| func (c *Conn) PolyFillArc(Drawable Id, Gc Id, Arcs []Arc) { |
| b := c.scratch[0:12]; |
| n := 12; |
| n += pad(len(Arcs) * 12); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 71; |
| put32(b[4:], uint32(Drawable)); |
| put32(b[8:], uint32(Gc)); |
| c.sendRequest(b); |
| c.sendArcList(Arcs, len(Arcs)); |
| } |
| |
| const ( |
| ImageFormatXYBitmap = 0; |
| ImageFormatXYPixmap = 1; |
| ImageFormatZPixmap = 2; |
| ) |
| |
| func (c *Conn) PutImage(Format byte, Drawable Id, Gc Id, Width uint16, Height uint16, DstX int16, DstY int16, LeftPad byte, Depth byte, Data []byte) { |
| b := c.scratch[0:24]; |
| n := 24; |
| n += pad(len(Data) * 1); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 72; |
| b[1] = Format; |
| put32(b[4:], uint32(Drawable)); |
| put32(b[8:], uint32(Gc)); |
| put16(b[12:], Width); |
| put16(b[14:], Height); |
| put16(b[16:], uint16(DstX)); |
| put16(b[18:], uint16(DstY)); |
| b[20] = LeftPad; |
| b[21] = Depth; |
| c.sendRequest(b); |
| c.sendBytes(Data[0:len(Data)]); |
| } |
| |
| func (c *Conn) GetImageRequest(Format byte, Drawable Id, X int16, Y int16, Width uint16, Height uint16, PlaneMask uint32) Cookie { |
| b := c.scratch[0:20]; |
| put16(b[2:], 5); |
| b[0] = 73; |
| b[1] = Format; |
| put32(b[4:], uint32(Drawable)); |
| put16(b[8:], uint16(X)); |
| put16(b[10:], uint16(Y)); |
| put16(b[12:], Width); |
| put16(b[14:], Height); |
| put32(b[16:], PlaneMask); |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetImage(Format byte, Drawable Id, X int16, Y int16, Width uint16, Height uint16, PlaneMask uint32) (*GetImageReply, os.Error) { |
| return c.GetImageReply(c.GetImageRequest(Format, Drawable, X, Y, Width, Height, PlaneMask)) |
| } |
| |
| type GetImageReply struct { |
| Depth byte; |
| Length uint32; |
| Visual Id; |
| Data []byte; |
| } |
| |
| func (c *Conn) GetImageReply(cookie Cookie) (*GetImageReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(GetImageReply); |
| v.Depth = b[1]; |
| v.Length = get32(b[4:]); |
| v.Visual = Id(get32(b[8:])); |
| offset := 32; |
| v.Data = make([]byte, (int(v.Length) * 4)); |
| copy(v.Data[0:len(v.Data)], b[offset:]); |
| offset += len(v.Data) * 1; |
| return v, nil; |
| } |
| |
| func (c *Conn) PolyText8(Drawable Id, Gc Id, X int16, Y int16, Items []byte) { |
| b := c.scratch[0:16]; |
| n := 16; |
| n += pad(len(Items) * 1); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 74; |
| put32(b[4:], uint32(Drawable)); |
| put32(b[8:], uint32(Gc)); |
| put16(b[12:], uint16(X)); |
| put16(b[14:], uint16(Y)); |
| c.sendRequest(b); |
| c.sendBytes(Items[0:len(Items)]); |
| } |
| |
| func (c *Conn) PolyText16(Drawable Id, Gc Id, X int16, Y int16, Items []byte) { |
| b := c.scratch[0:16]; |
| n := 16; |
| n += pad(len(Items) * 1); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 75; |
| put32(b[4:], uint32(Drawable)); |
| put32(b[8:], uint32(Gc)); |
| put16(b[12:], uint16(X)); |
| put16(b[14:], uint16(Y)); |
| c.sendRequest(b); |
| c.sendBytes(Items[0:len(Items)]); |
| } |
| |
| func (c *Conn) ImageText8(Drawable Id, Gc Id, X int16, Y int16, String []byte) { |
| b := c.scratch[0:16]; |
| n := 16; |
| n += pad(len(String) * 1); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 76; |
| b[1] = byte(len(String)); |
| put32(b[4:], uint32(Drawable)); |
| put32(b[8:], uint32(Gc)); |
| put16(b[12:], uint16(X)); |
| put16(b[14:], uint16(Y)); |
| c.sendRequest(b); |
| c.sendBytes(String[0:len(String)]); |
| } |
| |
| func (c *Conn) ImageText16(Drawable Id, Gc Id, X int16, Y int16, String []Char2b) { |
| b := c.scratch[0:16]; |
| n := 16; |
| n += pad(len(String) * 2); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 77; |
| b[1] = byte(len(String)); |
| put32(b[4:], uint32(Drawable)); |
| put32(b[8:], uint32(Gc)); |
| put16(b[12:], uint16(X)); |
| put16(b[14:], uint16(Y)); |
| c.sendRequest(b); |
| c.sendChar2bList(String, len(String)); |
| } |
| |
| const ( |
| ColormapAllocNone = 0; |
| ColormapAllocAll = 1; |
| ) |
| |
| func (c *Conn) CreateColormap(Alloc byte, Mid Id, Window Id, Visual Id) { |
| b := c.scratch[0:16]; |
| put16(b[2:], 4); |
| b[0] = 78; |
| b[1] = Alloc; |
| put32(b[4:], uint32(Mid)); |
| put32(b[8:], uint32(Window)); |
| put32(b[12:], uint32(Visual)); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) FreeColormap(Cmap Id) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 79; |
| put32(b[4:], uint32(Cmap)); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) CopyColormapAndFree(Mid Id, SrcCmap Id) { |
| b := c.scratch[0:12]; |
| put16(b[2:], 3); |
| b[0] = 80; |
| put32(b[4:], uint32(Mid)); |
| put32(b[8:], uint32(SrcCmap)); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) InstallColormap(Cmap Id) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 81; |
| put32(b[4:], uint32(Cmap)); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) UninstallColormap(Cmap Id) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 82; |
| put32(b[4:], uint32(Cmap)); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) ListInstalledColormapsRequest(Window Id) Cookie { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 83; |
| put32(b[4:], uint32(Window)); |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) ListInstalledColormaps(Window Id) (*ListInstalledColormapsReply, os.Error) { |
| return c.ListInstalledColormapsReply(c.ListInstalledColormapsRequest(Window)) |
| } |
| |
| type ListInstalledColormapsReply struct { |
| CmapsLen uint16; |
| Cmaps []Id; |
| } |
| |
| func (c *Conn) ListInstalledColormapsReply(cookie Cookie) (*ListInstalledColormapsReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(ListInstalledColormapsReply); |
| v.CmapsLen = get16(b[8:]); |
| offset := 32; |
| v.Cmaps = make([]Id, int(v.CmapsLen)); |
| for i := 0; i < len(v.Cmaps); i++ { |
| v.Cmaps[i] = Id(get32(b[offset+i*4:])) |
| } |
| offset += len(v.Cmaps) * 4; |
| return v, nil; |
| } |
| |
| func (c *Conn) AllocColorRequest(Cmap Id, Red uint16, Green uint16, Blue uint16) Cookie { |
| b := c.scratch[0:16]; |
| put16(b[2:], 4); |
| b[0] = 84; |
| put32(b[4:], uint32(Cmap)); |
| put16(b[8:], Red); |
| put16(b[10:], Green); |
| put16(b[12:], Blue); |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) AllocColor(Cmap Id, Red uint16, Green uint16, Blue uint16) (*AllocColorReply, os.Error) { |
| return c.AllocColorReply(c.AllocColorRequest(Cmap, Red, Green, Blue)) |
| } |
| |
| type AllocColorReply struct { |
| Red uint16; |
| Green uint16; |
| Blue uint16; |
| Pixel uint32; |
| } |
| |
| func (c *Conn) AllocColorReply(cookie Cookie) (*AllocColorReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(AllocColorReply); |
| v.Red = get16(b[8:]); |
| v.Green = get16(b[10:]); |
| v.Blue = get16(b[12:]); |
| v.Pixel = get32(b[16:]); |
| return v, nil; |
| } |
| |
| func (c *Conn) AllocNamedColorRequest(Cmap Id, Name string) Cookie { |
| b := c.scratch[0:12]; |
| n := 12; |
| n += pad(len(Name) * 1); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 85; |
| put32(b[4:], uint32(Cmap)); |
| put16(b[8:], uint16(len(Name))); |
| cookie := c.sendRequest(b); |
| c.sendString(Name); |
| return cookie; |
| } |
| |
| func (c *Conn) AllocNamedColor(Cmap Id, Name string) (*AllocNamedColorReply, os.Error) { |
| return c.AllocNamedColorReply(c.AllocNamedColorRequest(Cmap, Name)) |
| } |
| |
| type AllocNamedColorReply struct { |
| Pixel uint32; |
| ExactRed uint16; |
| ExactGreen uint16; |
| ExactBlue uint16; |
| VisualRed uint16; |
| VisualGreen uint16; |
| VisualBlue uint16; |
| } |
| |
| func (c *Conn) AllocNamedColorReply(cookie Cookie) (*AllocNamedColorReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(AllocNamedColorReply); |
| v.Pixel = get32(b[8:]); |
| v.ExactRed = get16(b[12:]); |
| v.ExactGreen = get16(b[14:]); |
| v.ExactBlue = get16(b[16:]); |
| v.VisualRed = get16(b[18:]); |
| v.VisualGreen = get16(b[20:]); |
| v.VisualBlue = get16(b[22:]); |
| return v, nil; |
| } |
| |
| func (c *Conn) AllocColorCellsRequest(Contiguous byte, Cmap Id, Colors uint16, Planes uint16) Cookie { |
| b := c.scratch[0:12]; |
| put16(b[2:], 3); |
| b[0] = 86; |
| b[1] = Contiguous; |
| put32(b[4:], uint32(Cmap)); |
| put16(b[8:], Colors); |
| put16(b[10:], Planes); |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) AllocColorCells(Contiguous byte, Cmap Id, Colors uint16, Planes uint16) (*AllocColorCellsReply, os.Error) { |
| return c.AllocColorCellsReply(c.AllocColorCellsRequest(Contiguous, Cmap, Colors, Planes)) |
| } |
| |
| type AllocColorCellsReply struct { |
| PixelsLen uint16; |
| MasksLen uint16; |
| Pixels []uint32; |
| Masks []uint32; |
| } |
| |
| func (c *Conn) AllocColorCellsReply(cookie Cookie) (*AllocColorCellsReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(AllocColorCellsReply); |
| v.PixelsLen = get16(b[8:]); |
| v.MasksLen = get16(b[10:]); |
| offset := 32; |
| v.Pixels = make([]uint32, int(v.PixelsLen)); |
| for i := 0; i < len(v.Pixels); i++ { |
| v.Pixels[i] = get32(b[offset+i*4:]) |
| } |
| offset += len(v.Pixels) * 4; |
| offset = pad(offset); |
| v.Masks = make([]uint32, int(v.MasksLen)); |
| for i := 0; i < len(v.Masks); i++ { |
| v.Masks[i] = get32(b[offset+i*4:]) |
| } |
| offset += len(v.Masks) * 4; |
| return v, nil; |
| } |
| |
| func (c *Conn) AllocColorPlanesRequest(Contiguous byte, Cmap Id, Colors uint16, Reds uint16, Greens uint16, Blues uint16) Cookie { |
| b := c.scratch[0:16]; |
| put16(b[2:], 4); |
| b[0] = 87; |
| b[1] = Contiguous; |
| put32(b[4:], uint32(Cmap)); |
| put16(b[8:], Colors); |
| put16(b[10:], Reds); |
| put16(b[12:], Greens); |
| put16(b[14:], Blues); |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) AllocColorPlanes(Contiguous byte, Cmap Id, Colors uint16, Reds uint16, Greens uint16, Blues uint16) (*AllocColorPlanesReply, os.Error) { |
| return c.AllocColorPlanesReply(c.AllocColorPlanesRequest(Contiguous, Cmap, Colors, Reds, Greens, Blues)) |
| } |
| |
| type AllocColorPlanesReply struct { |
| PixelsLen uint16; |
| RedMask uint32; |
| GreenMask uint32; |
| BlueMask uint32; |
| Pixels []uint32; |
| } |
| |
| func (c *Conn) AllocColorPlanesReply(cookie Cookie) (*AllocColorPlanesReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(AllocColorPlanesReply); |
| v.PixelsLen = get16(b[8:]); |
| v.RedMask = get32(b[12:]); |
| v.GreenMask = get32(b[16:]); |
| v.BlueMask = get32(b[20:]); |
| offset := 32; |
| v.Pixels = make([]uint32, int(v.PixelsLen)); |
| for i := 0; i < len(v.Pixels); i++ { |
| v.Pixels[i] = get32(b[offset+i*4:]) |
| } |
| offset += len(v.Pixels) * 4; |
| return v, nil; |
| } |
| |
| func (c *Conn) FreeColors(Cmap Id, PlaneMask uint32, Pixels []uint32) { |
| b := c.scratch[0:12]; |
| n := 12; |
| n += pad(len(Pixels) * 4); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 88; |
| put32(b[4:], uint32(Cmap)); |
| put32(b[8:], PlaneMask); |
| c.sendRequest(b); |
| c.sendUInt32List(Pixels[0:len(Pixels)]); |
| } |
| |
| const ( |
| ColorFlagRed = 1; |
| ColorFlagGreen = 2; |
| ColorFlagBlue = 4; |
| ) |
| |
| type Coloritem struct { |
| Pixel uint32; |
| Red uint16; |
| Green uint16; |
| Blue uint16; |
| Flags byte; |
| } |
| |
| func getColoritem(b []byte, v *Coloritem) int { |
| v.Pixel = get32(b[0:]); |
| v.Red = get16(b[4:]); |
| v.Green = get16(b[6:]); |
| v.Blue = get16(b[8:]); |
| v.Flags = b[10]; |
| return 12; |
| } |
| |
| func (c *Conn) sendColoritemList(list []Coloritem, count int) { |
| b0 := make([]byte, 12*count); |
| for k := 0; k < count; k++ { |
| b := b0[k*12:]; |
| put32(b[0:], list[k].Pixel); |
| put16(b[4:], list[k].Red); |
| put16(b[6:], list[k].Green); |
| put16(b[8:], list[k].Blue); |
| b[10] = list[k].Flags; |
| } |
| c.sendBytes(b0); |
| } |
| |
| func (c *Conn) StoreColors(Cmap Id, Items []Coloritem) { |
| b := c.scratch[0:8]; |
| n := 8; |
| n += pad(len(Items) * 12); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 89; |
| put32(b[4:], uint32(Cmap)); |
| c.sendRequest(b); |
| c.sendColoritemList(Items, len(Items)); |
| } |
| |
| func (c *Conn) StoreNamedColor(Flags byte, Cmap Id, Pixel uint32, Name string) { |
| b := c.scratch[0:16]; |
| n := 16; |
| n += pad(len(Name) * 1); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 90; |
| b[1] = Flags; |
| put32(b[4:], uint32(Cmap)); |
| put32(b[8:], Pixel); |
| put16(b[12:], uint16(len(Name))); |
| c.sendRequest(b); |
| c.sendString(Name); |
| } |
| |
| type Rgb struct { |
| Red uint16; |
| Green uint16; |
| Blue uint16; |
| } |
| |
| func getRgb(b []byte, v *Rgb) int { |
| v.Red = get16(b[0:]); |
| v.Green = get16(b[2:]); |
| v.Blue = get16(b[4:]); |
| return 8; |
| } |
| |
| func (c *Conn) sendRgbList(list []Rgb, count int) { |
| b0 := make([]byte, 8*count); |
| for k := 0; k < count; k++ { |
| b := b0[k*8:]; |
| put16(b[0:], list[k].Red); |
| put16(b[2:], list[k].Green); |
| put16(b[4:], list[k].Blue); |
| } |
| c.sendBytes(b0); |
| } |
| |
| func (c *Conn) QueryColorsRequest(Cmap Id, Pixels []uint32) Cookie { |
| b := c.scratch[0:8]; |
| n := 8; |
| n += pad(len(Pixels) * 4); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 91; |
| put32(b[4:], uint32(Cmap)); |
| cookie := c.sendRequest(b); |
| c.sendUInt32List(Pixels[0:len(Pixels)]); |
| return cookie; |
| } |
| |
| func (c *Conn) QueryColors(Cmap Id, Pixels []uint32) (*QueryColorsReply, os.Error) { |
| return c.QueryColorsReply(c.QueryColorsRequest(Cmap, Pixels)) |
| } |
| |
| type QueryColorsReply struct { |
| ColorsLen uint16; |
| Colors []Rgb; |
| } |
| |
| func (c *Conn) QueryColorsReply(cookie Cookie) (*QueryColorsReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(QueryColorsReply); |
| v.ColorsLen = get16(b[8:]); |
| offset := 32; |
| v.Colors = make([]Rgb, int(v.ColorsLen)); |
| for i := 0; i < int(v.ColorsLen); i++ { |
| offset += getRgb(b[offset:], &v.Colors[i]) |
| } |
| return v, nil; |
| } |
| |
| func (c *Conn) LookupColorRequest(Cmap Id, Name string) Cookie { |
| b := c.scratch[0:12]; |
| n := 12; |
| n += pad(len(Name) * 1); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 92; |
| put32(b[4:], uint32(Cmap)); |
| put16(b[8:], uint16(len(Name))); |
| cookie := c.sendRequest(b); |
| c.sendString(Name); |
| return cookie; |
| } |
| |
| func (c *Conn) LookupColor(Cmap Id, Name string) (*LookupColorReply, os.Error) { |
| return c.LookupColorReply(c.LookupColorRequest(Cmap, Name)) |
| } |
| |
| type LookupColorReply struct { |
| ExactRed uint16; |
| ExactGreen uint16; |
| ExactBlue uint16; |
| VisualRed uint16; |
| VisualGreen uint16; |
| VisualBlue uint16; |
| } |
| |
| func (c *Conn) LookupColorReply(cookie Cookie) (*LookupColorReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(LookupColorReply); |
| v.ExactRed = get16(b[8:]); |
| v.ExactGreen = get16(b[10:]); |
| v.ExactBlue = get16(b[12:]); |
| v.VisualRed = get16(b[14:]); |
| v.VisualGreen = get16(b[16:]); |
| v.VisualBlue = get16(b[18:]); |
| return v, nil; |
| } |
| |
| const ( |
| PixmapNone = 0; |
| ) |
| |
| func (c *Conn) CreateCursor(Cid Id, Source Id, Mask Id, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16, X uint16, Y uint16) { |
| b := c.scratch[0:32]; |
| put16(b[2:], 8); |
| b[0] = 93; |
| put32(b[4:], uint32(Cid)); |
| put32(b[8:], uint32(Source)); |
| put32(b[12:], uint32(Mask)); |
| put16(b[16:], ForeRed); |
| put16(b[18:], ForeGreen); |
| put16(b[20:], ForeBlue); |
| put16(b[22:], BackRed); |
| put16(b[24:], BackGreen); |
| put16(b[26:], BackBlue); |
| put16(b[28:], X); |
| put16(b[30:], Y); |
| c.sendRequest(b); |
| } |
| |
| const ( |
| FontNone = 0; |
| ) |
| |
| func (c *Conn) CreateGlyphCursor(Cid Id, SourceFont Id, MaskFont Id, SourceChar uint16, MaskChar uint16, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16) { |
| b := c.scratch[0:32]; |
| put16(b[2:], 8); |
| b[0] = 94; |
| put32(b[4:], uint32(Cid)); |
| put32(b[8:], uint32(SourceFont)); |
| put32(b[12:], uint32(MaskFont)); |
| put16(b[16:], SourceChar); |
| put16(b[18:], MaskChar); |
| put16(b[20:], ForeRed); |
| put16(b[22:], ForeGreen); |
| put16(b[24:], ForeBlue); |
| put16(b[26:], BackRed); |
| put16(b[28:], BackGreen); |
| put16(b[30:], BackBlue); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) FreeCursor(Cursor Id) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 95; |
| put32(b[4:], uint32(Cursor)); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) RecolorCursor(Cursor Id, ForeRed uint16, ForeGreen uint16, ForeBlue uint16, BackRed uint16, BackGreen uint16, BackBlue uint16) { |
| b := c.scratch[0:20]; |
| put16(b[2:], 5); |
| b[0] = 96; |
| put32(b[4:], uint32(Cursor)); |
| put16(b[8:], ForeRed); |
| put16(b[10:], ForeGreen); |
| put16(b[12:], ForeBlue); |
| put16(b[14:], BackRed); |
| put16(b[16:], BackGreen); |
| put16(b[18:], BackBlue); |
| c.sendRequest(b); |
| } |
| |
| const ( |
| QueryShapeOfLargestCursor = 0; |
| QueryShapeOfFastestTile = 1; |
| QueryShapeOfFastestStipple = 2; |
| ) |
| |
| func (c *Conn) QueryBestSizeRequest(Class byte, Drawable Id, Width uint16, Height uint16) Cookie { |
| b := c.scratch[0:12]; |
| put16(b[2:], 3); |
| b[0] = 97; |
| b[1] = Class; |
| put32(b[4:], uint32(Drawable)); |
| put16(b[8:], Width); |
| put16(b[10:], Height); |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) QueryBestSize(Class byte, Drawable Id, Width uint16, Height uint16) (*QueryBestSizeReply, os.Error) { |
| return c.QueryBestSizeReply(c.QueryBestSizeRequest(Class, Drawable, Width, Height)) |
| } |
| |
| type QueryBestSizeReply struct { |
| Width uint16; |
| Height uint16; |
| } |
| |
| func (c *Conn) QueryBestSizeReply(cookie Cookie) (*QueryBestSizeReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(QueryBestSizeReply); |
| v.Width = get16(b[8:]); |
| v.Height = get16(b[10:]); |
| return v, nil; |
| } |
| |
| func (c *Conn) QueryExtensionRequest(Name string) Cookie { |
| b := c.scratch[0:8]; |
| n := 8; |
| n += pad(len(Name) * 1); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 98; |
| put16(b[4:], uint16(len(Name))); |
| cookie := c.sendRequest(b); |
| c.sendString(Name); |
| return cookie; |
| } |
| |
| func (c *Conn) QueryExtension(Name string) (*QueryExtensionReply, os.Error) { |
| return c.QueryExtensionReply(c.QueryExtensionRequest(Name)) |
| } |
| |
| type QueryExtensionReply struct { |
| Present byte; |
| MajorOpcode byte; |
| FirstEvent byte; |
| FirstError byte; |
| } |
| |
| func (c *Conn) QueryExtensionReply(cookie Cookie) (*QueryExtensionReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(QueryExtensionReply); |
| v.Present = b[8]; |
| v.MajorOpcode = b[9]; |
| v.FirstEvent = b[10]; |
| v.FirstError = b[11]; |
| return v, nil; |
| } |
| |
| func (c *Conn) ListExtensionsRequest() Cookie { |
| b := c.scratch[0:4]; |
| put16(b[2:], 1); |
| b[0] = 99; |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) ListExtensions() (*ListExtensionsReply, os.Error) { |
| return c.ListExtensionsReply(c.ListExtensionsRequest()) |
| } |
| |
| type ListExtensionsReply struct { |
| NamesLen byte; |
| Names []Str; |
| } |
| |
| func (c *Conn) ListExtensionsReply(cookie Cookie) (*ListExtensionsReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(ListExtensionsReply); |
| v.NamesLen = b[1]; |
| offset := 32; |
| v.Names = make([]Str, int(v.NamesLen)); |
| for i := 0; i < int(v.NamesLen); i++ { |
| offset += getStr(b[offset:], &v.Names[i]) |
| } |
| return v, nil; |
| } |
| |
| func (c *Conn) ChangeKeyboardMapping(KeycodeCount byte, FirstKeycode byte, KeysymsPerKeycode byte, Keysyms []Keysym) { |
| b := c.scratch[0:6]; |
| n := 6; |
| n += pad((int(KeycodeCount) * int(KeysymsPerKeycode)) * 4); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 100; |
| b[1] = KeycodeCount; |
| b[4] = FirstKeycode; |
| b[5] = KeysymsPerKeycode; |
| c.sendRequest(b); |
| c.sendKeysymList(Keysyms, (int(KeycodeCount) * int(KeysymsPerKeycode))); |
| } |
| |
| func (c *Conn) GetKeyboardMappingRequest(FirstKeycode byte, Count byte) Cookie { |
| b := c.scratch[0:6]; |
| put16(b[2:], 1); |
| b[0] = 101; |
| b[4] = FirstKeycode; |
| b[5] = Count; |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetKeyboardMapping(FirstKeycode byte, Count byte) (*GetKeyboardMappingReply, os.Error) { |
| return c.GetKeyboardMappingReply(c.GetKeyboardMappingRequest(FirstKeycode, Count)) |
| } |
| |
| type GetKeyboardMappingReply struct { |
| KeysymsPerKeycode byte; |
| Length uint32; |
| Keysyms []Keysym; |
| } |
| |
| func (c *Conn) GetKeyboardMappingReply(cookie Cookie) (*GetKeyboardMappingReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(GetKeyboardMappingReply); |
| v.KeysymsPerKeycode = b[1]; |
| v.Length = get32(b[4:]); |
| offset := 32; |
| v.Keysyms = make([]Keysym, int(v.Length)); |
| for i := 0; i < len(v.Keysyms); i++ { |
| v.Keysyms[i] = Keysym(get32(b[offset+i*4:])) |
| } |
| offset += len(v.Keysyms) * 4; |
| return v, nil; |
| } |
| |
| const ( |
| KBKeyClickPercent = 1; |
| KBBellPercent = 2; |
| KBBellPitch = 4; |
| KBBellDuration = 8; |
| KBLed = 16; |
| KBLedMode = 32; |
| KBKey = 64; |
| KBAutoRepeatMode = 128; |
| ) |
| |
| const ( |
| LedModeOff = 0; |
| LedModeOn = 1; |
| ) |
| |
| const ( |
| AutoRepeatModeOff = 0; |
| AutoRepeatModeOn = 1; |
| AutoRepeatModeDefault = 2; |
| ) |
| |
| func (c *Conn) ChangeKeyboardControl(ValueMask uint32, ValueList []uint32) { |
| b := c.scratch[0:8]; |
| n := 8; |
| n += pad(popCount(int(ValueMask)) * 4); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 102; |
| put32(b[4:], ValueMask); |
| c.sendRequest(b); |
| c.sendUInt32List(ValueList[0:popCount(int(ValueMask))]); |
| } |
| |
| func (c *Conn) GetKeyboardControlRequest() Cookie { |
| b := c.scratch[0:4]; |
| put16(b[2:], 1); |
| b[0] = 103; |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetKeyboardControl() (*GetKeyboardControlReply, os.Error) { |
| return c.GetKeyboardControlReply(c.GetKeyboardControlRequest()) |
| } |
| |
| type GetKeyboardControlReply struct { |
| GlobalAutoRepeat byte; |
| LedMask uint32; |
| KeyClickPercent byte; |
| BellPercent byte; |
| BellPitch uint16; |
| BellDuration uint16; |
| AutoRepeats [32]byte; |
| } |
| |
| func (c *Conn) GetKeyboardControlReply(cookie Cookie) (*GetKeyboardControlReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(GetKeyboardControlReply); |
| v.GlobalAutoRepeat = b[1]; |
| v.LedMask = get32(b[8:]); |
| v.KeyClickPercent = b[12]; |
| v.BellPercent = b[13]; |
| v.BellPitch = get16(b[14:]); |
| v.BellDuration = get16(b[16:]); |
| copy(v.AutoRepeats[0:32], b[20:]); |
| return v, nil; |
| } |
| |
| func (c *Conn) Bell(Percent int8) { |
| b := c.scratch[0:4]; |
| put16(b[2:], 1); |
| b[0] = 104; |
| b[1] = byte(Percent); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) ChangePointerControl(AccelerationNumerator int16, AccelerationDenominator int16, Threshold int16, DoAcceleration byte, DoThreshold byte) { |
| b := c.scratch[0:12]; |
| put16(b[2:], 3); |
| b[0] = 105; |
| put16(b[4:], uint16(AccelerationNumerator)); |
| put16(b[6:], uint16(AccelerationDenominator)); |
| put16(b[8:], uint16(Threshold)); |
| b[10] = DoAcceleration; |
| b[11] = DoThreshold; |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetPointerControlRequest() Cookie { |
| b := c.scratch[0:4]; |
| put16(b[2:], 1); |
| b[0] = 106; |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetPointerControl() (*GetPointerControlReply, os.Error) { |
| return c.GetPointerControlReply(c.GetPointerControlRequest()) |
| } |
| |
| type GetPointerControlReply struct { |
| AccelerationNumerator uint16; |
| AccelerationDenominator uint16; |
| Threshold uint16; |
| } |
| |
| func (c *Conn) GetPointerControlReply(cookie Cookie) (*GetPointerControlReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(GetPointerControlReply); |
| v.AccelerationNumerator = get16(b[8:]); |
| v.AccelerationDenominator = get16(b[10:]); |
| v.Threshold = get16(b[12:]); |
| return v, nil; |
| } |
| |
| const ( |
| BlankingNotPreferred = 0; |
| BlankingPreferred = 1; |
| BlankingDefault = 2; |
| ) |
| |
| const ( |
| ExposuresNotAllowed = 0; |
| ExposuresAllowed = 1; |
| ExposuresDefault = 2; |
| ) |
| |
| func (c *Conn) SetScreenSaver(Timeout int16, Interval int16, PreferBlanking byte, AllowExposures byte) { |
| b := c.scratch[0:10]; |
| put16(b[2:], 2); |
| b[0] = 107; |
| put16(b[4:], uint16(Timeout)); |
| put16(b[6:], uint16(Interval)); |
| b[8] = PreferBlanking; |
| b[9] = AllowExposures; |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetScreenSaverRequest() Cookie { |
| b := c.scratch[0:4]; |
| put16(b[2:], 1); |
| b[0] = 108; |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetScreenSaver() (*GetScreenSaverReply, os.Error) { |
| return c.GetScreenSaverReply(c.GetScreenSaverRequest()) |
| } |
| |
| type GetScreenSaverReply struct { |
| Timeout uint16; |
| Interval uint16; |
| PreferBlanking byte; |
| AllowExposures byte; |
| } |
| |
| func (c *Conn) GetScreenSaverReply(cookie Cookie) (*GetScreenSaverReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(GetScreenSaverReply); |
| v.Timeout = get16(b[8:]); |
| v.Interval = get16(b[10:]); |
| v.PreferBlanking = b[12]; |
| v.AllowExposures = b[13]; |
| return v, nil; |
| } |
| |
| const ( |
| HostModeInsert = 0; |
| HostModeDelete = 1; |
| ) |
| |
| const ( |
| FamilyInternet = 0; |
| FamilyDECnet = 1; |
| FamilyChaos = 2; |
| FamilyServerInterpreted = 5; |
| FamilyInternet6 = 6; |
| ) |
| |
| func (c *Conn) ChangeHosts(Mode byte, Family byte, Address []byte) { |
| b := c.scratch[0:8]; |
| n := 8; |
| n += pad(len(Address) * 1); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 109; |
| b[1] = Mode; |
| b[4] = Family; |
| put16(b[6:], uint16(len(Address))); |
| c.sendRequest(b); |
| c.sendBytes(Address[0:len(Address)]); |
| } |
| |
| type Host struct { |
| Family byte; |
| AddressLen uint16; |
| Address []byte; |
| } |
| |
| func getHost(b []byte, v *Host) int { |
| v.Family = b[0]; |
| v.AddressLen = get16(b[2:]); |
| offset := 4; |
| v.Address = make([]byte, int(v.AddressLen)); |
| copy(v.Address[0:len(v.Address)], b[offset:]); |
| offset += len(v.Address) * 1; |
| return offset; |
| } |
| |
| // omitting variable length sendHost |
| |
| func (c *Conn) ListHostsRequest() Cookie { |
| b := c.scratch[0:4]; |
| put16(b[2:], 1); |
| b[0] = 110; |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) ListHosts() (*ListHostsReply, os.Error) { |
| return c.ListHostsReply(c.ListHostsRequest()) |
| } |
| |
| type ListHostsReply struct { |
| Mode byte; |
| HostsLen uint16; |
| Hosts []Host; |
| } |
| |
| func (c *Conn) ListHostsReply(cookie Cookie) (*ListHostsReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(ListHostsReply); |
| v.Mode = b[1]; |
| v.HostsLen = get16(b[8:]); |
| offset := 32; |
| v.Hosts = make([]Host, int(v.HostsLen)); |
| for i := 0; i < int(v.HostsLen); i++ { |
| offset += getHost(b[offset:], &v.Hosts[i]) |
| } |
| return v, nil; |
| } |
| |
| const ( |
| AccessControlDisable = 0; |
| AccessControlEnable = 1; |
| ) |
| |
| func (c *Conn) SetAccessControl(Mode byte) { |
| b := c.scratch[0:4]; |
| put16(b[2:], 1); |
| b[0] = 111; |
| b[1] = Mode; |
| c.sendRequest(b); |
| } |
| |
| const ( |
| CloseDownDestroyAll = 0; |
| CloseDownRetainPermanent = 1; |
| CloseDownRetainTemporary = 2; |
| ) |
| |
| func (c *Conn) SetCloseDownMode(Mode byte) { |
| b := c.scratch[0:4]; |
| put16(b[2:], 1); |
| b[0] = 112; |
| b[1] = Mode; |
| c.sendRequest(b); |
| } |
| |
| const ( |
| KillAllTemporary = 0; |
| ) |
| |
| func (c *Conn) KillClient(Resource uint32) { |
| b := c.scratch[0:8]; |
| put16(b[2:], 2); |
| b[0] = 113; |
| put32(b[4:], Resource); |
| c.sendRequest(b); |
| } |
| |
| func (c *Conn) RotateProperties(Window Id, Delta int16, Atoms []Id) { |
| b := c.scratch[0:12]; |
| n := 12; |
| n += pad(len(Atoms) * 4); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 114; |
| put32(b[4:], uint32(Window)); |
| put16(b[8:], uint16(len(Atoms))); |
| put16(b[10:], uint16(Delta)); |
| c.sendRequest(b); |
| c.sendIdList(Atoms, len(Atoms)); |
| } |
| |
| const ( |
| ScreenSaverReset = 0; |
| ScreenSaverActive = 1; |
| ) |
| |
| func (c *Conn) ForceScreenSaver(Mode byte) { |
| b := c.scratch[0:4]; |
| put16(b[2:], 1); |
| b[0] = 115; |
| b[1] = Mode; |
| c.sendRequest(b); |
| } |
| |
| const ( |
| MappingStatusSuccess = 0; |
| MappingStatusBusy = 1; |
| MappingStatusFailure = 2; |
| ) |
| |
| func (c *Conn) SetPointerMappingRequest(Map []byte) Cookie { |
| b := c.scratch[0:4]; |
| n := 4; |
| n += pad(len(Map) * 1); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 116; |
| b[1] = byte(len(Map)); |
| cookie := c.sendRequest(b); |
| c.sendBytes(Map[0:len(Map)]); |
| return cookie; |
| } |
| |
| func (c *Conn) SetPointerMapping(Map []byte) (*SetPointerMappingReply, os.Error) { |
| return c.SetPointerMappingReply(c.SetPointerMappingRequest(Map)) |
| } |
| |
| type SetPointerMappingReply struct { |
| Status byte; |
| } |
| |
| func (c *Conn) SetPointerMappingReply(cookie Cookie) (*SetPointerMappingReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(SetPointerMappingReply); |
| v.Status = b[1]; |
| return v, nil; |
| } |
| |
| func (c *Conn) GetPointerMappingRequest() Cookie { |
| b := c.scratch[0:4]; |
| put16(b[2:], 1); |
| b[0] = 117; |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetPointerMapping() (*GetPointerMappingReply, os.Error) { |
| return c.GetPointerMappingReply(c.GetPointerMappingRequest()) |
| } |
| |
| type GetPointerMappingReply struct { |
| MapLen byte; |
| Map []byte; |
| } |
| |
| func (c *Conn) GetPointerMappingReply(cookie Cookie) (*GetPointerMappingReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(GetPointerMappingReply); |
| v.MapLen = b[1]; |
| offset := 32; |
| v.Map = make([]byte, int(v.MapLen)); |
| copy(v.Map[0:len(v.Map)], b[offset:]); |
| offset += len(v.Map) * 1; |
| return v, nil; |
| } |
| |
| const ( |
| MapIndexShift = 0; |
| MapIndexLock = 1; |
| MapIndexControl = 2; |
| MapIndex1 = 3; |
| MapIndex2 = 4; |
| MapIndex3 = 5; |
| MapIndex4 = 6; |
| MapIndex5 = 7; |
| ) |
| |
| func (c *Conn) SetModifierMappingRequest(KeycodesPerModifier byte, Keycodes []byte) Cookie { |
| b := c.scratch[0:4]; |
| n := 4; |
| n += pad((int(KeycodesPerModifier) * 8) * 1); |
| put16(b[2:], uint16(n/4)); |
| b[0] = 118; |
| b[1] = KeycodesPerModifier; |
| cookie := c.sendRequest(b); |
| c.sendBytes(Keycodes[0:(int(KeycodesPerModifier) * 8)]); |
| return cookie; |
| } |
| |
| func (c *Conn) SetModifierMapping(KeycodesPerModifier byte, Keycodes []byte) (*SetModifierMappingReply, os.Error) { |
| return c.SetModifierMappingReply(c.SetModifierMappingRequest(KeycodesPerModifier, Keycodes)) |
| } |
| |
| type SetModifierMappingReply struct { |
| Status byte; |
| } |
| |
| func (c *Conn) SetModifierMappingReply(cookie Cookie) (*SetModifierMappingReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(SetModifierMappingReply); |
| v.Status = b[1]; |
| return v, nil; |
| } |
| |
| func (c *Conn) GetModifierMappingRequest() Cookie { |
| b := c.scratch[0:4]; |
| put16(b[2:], 1); |
| b[0] = 119; |
| return c.sendRequest(b); |
| } |
| |
| func (c *Conn) GetModifierMapping() (*GetModifierMappingReply, os.Error) { |
| return c.GetModifierMappingReply(c.GetModifierMappingRequest()) |
| } |
| |
| type GetModifierMappingReply struct { |
| KeycodesPerModifier byte; |
| Keycodes []byte; |
| } |
| |
| func (c *Conn) GetModifierMappingReply(cookie Cookie) (*GetModifierMappingReply, os.Error) { |
| b, error := c.waitForReply(cookie); |
| if error != nil { |
| return nil, error |
| } |
| v := new(GetModifierMappingReply); |
| v.KeycodesPerModifier = b[1]; |
| offset := 32; |
| v.Keycodes = make([]byte, (int(v.KeycodesPerModifier) * 8)); |
| copy(v.Keycodes[0:len(v.Keycodes)], b[offset:]); |
| offset += len(v.Keycodes) * 1; |
| return v, nil; |
| } |
| |
| func (c *Conn) NoOperation() { |
| b := c.scratch[0:4]; |
| put16(b[2:], 1); |
| b[0] = 127; |
| c.sendRequest(b); |
| } |
| |
| func parseEvent(buf []byte) (Event, os.Error) { |
| switch buf[0] { |
| case KeyPress: |
| return getKeyPressEvent(buf), nil |
| case KeyRelease: |
| return getKeyReleaseEvent(buf), nil |
| case ButtonPress: |
| return getButtonPressEvent(buf), nil |
| case ButtonRelease: |
| return getButtonReleaseEvent(buf), nil |
| case MotionNotify: |
| return getMotionNotifyEvent(buf), nil |
| case EnterNotify: |
| return getEnterNotifyEvent(buf), nil |
| case LeaveNotify: |
| return getLeaveNotifyEvent(buf), nil |
| case FocusIn: |
| return getFocusInEvent(buf), nil |
| case FocusOut: |
| return getFocusOutEvent(buf), nil |
| case KeymapNotify: |
| return getKeymapNotifyEvent(buf), nil |
| case Expose: |
| return getExposeEvent(buf), nil |
| case GraphicsExposure: |
| return getGraphicsExposureEvent(buf), nil |
| case NoExposure: |
| return getNoExposureEvent(buf), nil |
| case VisibilityNotify: |
| return getVisibilityNotifyEvent(buf), nil |
| case CreateNotify: |
| return getCreateNotifyEvent(buf), nil |
| case DestroyNotify: |
| return getDestroyNotifyEvent(buf), nil |
| case UnmapNotify: |
| return getUnmapNotifyEvent(buf), nil |
| case MapNotify: |
| return getMapNotifyEvent(buf), nil |
| case MapRequest: |
| return getMapRequestEvent(buf), nil |
| case ReparentNotify: |
| return getReparentNotifyEvent(buf), nil |
| case ConfigureNotify: |
| return getConfigureNotifyEvent(buf), nil |
| case ConfigureRequest: |
| return getConfigureRequestEvent(buf), nil |
| case GravityNotify: |
| return getGravityNotifyEvent(buf), nil |
| case ResizeRequest: |
| return getResizeRequestEvent(buf), nil |
| case CirculateNotify: |
| return getCirculateNotifyEvent(buf), nil |
| case CirculateRequest: |
| return getCirculateRequestEvent(buf), nil |
| case PropertyNotify: |
| return getPropertyNotifyEvent(buf), nil |
| case SelectionClear: |
| return getSelectionClearEvent(buf), nil |
| case SelectionRequest: |
| return getSelectionRequestEvent(buf), nil |
| case SelectionNotify: |
| return getSelectionNotifyEvent(buf), nil |
| case ColormapNotify: |
| return getColormapNotifyEvent(buf), nil |
| case ClientMessage: |
| return getClientMessageEvent(buf), nil |
| case MappingNotify: |
| return getMappingNotifyEvent(buf), nil |
| } |
| return nil, os.NewError("unknown event type"); |
| } |
| |
| var errorNames = map[byte]string{ |
| BadRequest: "Request", |
| BadValue: "Value", |
| BadWindow: "Window", |
| BadPixmap: "Pixmap", |
| BadAtom: "Atom", |
| BadCursor: "Cursor", |
| BadFont: "Font", |
| BadMatch: "Match", |
| BadDrawable: "Drawable", |
| BadAccess: "Access", |
| BadAlloc: "Alloc", |
| BadColormap: "Colormap", |
| BadGContext: "GContext", |
| BadIDChoice: "IDChoice", |
| BadName: "Name", |
| BadLength: "Length", |
| BadImplementation: "Implementation", |
| } |