// CreateChecked issues a CreateWindow checked request for Window. // A checked request is a synchronous request. Meaning that if the request // fails, you can get the error returned to you. However, it also forced your // program to block for a round trip to the X server, so it is slower. // See the docs for Create for more info. func (w *Window) CreateChecked(parent xproto.Window, x, y, width, height, valueMask int, valueList ...uint32) error { s := w.X.Screen() return xproto.CreateWindowChecked(w.X.Conn(), s.RootDepth, w.Id, parent, int16(x), int16(y), uint16(width), uint16(height), 0, xproto.WindowClassInputOutput, s.RootVisual, uint32(valueMask), valueList).Check() }
func (m *TrayManager) Manage() bool { m.destroyOwnerWindow() win, _ := xwindow.Generate(TrayXU) m.owner = win.Id xproto.CreateWindowChecked(TrayXU.Conn(), 0, m.owner, TrayXU.RootWin(), 0, 0, 1, 1, 0, xproto.WindowClassInputOnly, m.visual, 0, nil) TrayXU.Sync() win.Listen(xproto.EventMaskStructureNotify) return m.tryOwner() }
func start_server(c *xgb.Conn, s *xproto.ScreenInfo, rl_execute_atom xproto.Atom) { win, err := xproto.NewWindowId(c) if err != nil { panic(err) } // Make a window which can be communicated with err = xproto.CreateWindowChecked(c, s.RootDepth, win, s.Root, 0, 0, 1, 1, 0, 0, 0, 0, nil).Check() if err != nil { panic(err) } err = xproto.ChangePropertyChecked(c, xproto.PropModeReplace, win, rl_execute_atom, xproto.AtomString, 8, xproto.PropModeReplace, []byte("\x00")).Check() if err != nil { panic(err) } err = xproto.ChangeWindowAttributesChecked(c, win, xproto.CwEventMask, []uint32{xproto.EventMaskPropertyChange}).Check() if err != nil { panic(err) } get_execute_value := func() string { response, err := xproto.GetProperty(c, false, win, rl_execute_atom, xproto.GetPropertyTypeAny, 0, 1024).Reply() if err != nil { panic(err) } result := string(response.Value) return result } log.Print("Ready and waiting..") // Event loop for { reply, err := c.WaitForEvent() if err != nil { log.Panic("Error in event loop:", err) } switch event := reply.(type) { case xproto.PropertyNotifyEvent: if event.Window == win && event.Atom == rl_execute_atom { values := strings.Split(get_execute_value(), "\x00") run(values) } } } }
func newParent(X *xgbutil.XUtil, cid xproto.Window) (*Parent, error) { parent, err := xwindow.Generate(X) if err != nil { logger.Error.Printf("Could not create a parent window for client "+ "with id '%d' because: %s", cid, err) logger.Error.Fatalf("In a state where no new windows can be created. " + "Unfortunately, we must exit.") } // clientAttrs, err := xproto.GetWindowAttributes(X.Conn(), cid).Reply() // if err != nil { // return nil, fmt.Errorf("Could not get window attributes: %s", err) // } // visual := clientAttrs.Visual // vdepth := getVisualDepth(X, visual) visual := X.Screen().RootVisual vdepth := X.Screen().RootDepth // logger.Debug.Printf("Visualid: %x, Depth: %d", visual, vdepth) err = xproto.CreateWindowChecked(X.Conn(), vdepth, parent.Id, X.RootWin(), 0, 0, 1, 1, 0, xproto.WindowClassInputOutput, visual, xproto.CwEventMask, []uint32{ xproto.EventMaskSubstructureRedirect | xproto.EventMaskButtonPress | xproto.EventMaskButtonRelease | xproto.EventMaskFocusChange, }).Check() if err != nil { return nil, fmt.Errorf("Could not create window: %s", err) } err = xproto.ReparentWindowChecked(X.Conn(), cid, parent.Id, 0, 0).Check() if err != nil { return nil, fmt.Errorf("Could not reparent window: %s", err) } return &Parent{ Window: parent, MoveState: &MoveState{}, ResizeState: &ResizeState{}, isMapped: false, }, nil }
func Open(c *xgb.Conn, ctx, title, text string) (*Window, error) { gc, ok := ctxs[ctx] if !ok { return nil, BadContextError(ctx) } scr := xproto.Setup(c).DefaultScreen(c) wdwid, err := xproto.NewWindowId(c) if err != nil { return nil, err } lines := cutLines(c, gc.width-2*gc.border, gc.font, text) height := uint32(len(lines)) * gc.fontHeight var mask uint32 = xproto.CwBackPixel | xproto.CwOverrideRedirect | xproto.CwEventMask values := make([]uint32, 3) values[0] = scr.WhitePixel values[1] = 1 values[2] = xproto.EventMaskExposure err = xproto.CreateWindowChecked(c, xproto.WindowClassCopyFromParent, wdwid, scr.Root, 0, 0, uint16(gc.width), uint16(height+2*gc.border), 1, xproto.WindowClassInputOutput, scr.RootVisual, mask, values).Check() if err != nil { return nil, err } xproto.ChangeProperty(c, xproto.PropModeReplace, wdwid, xproto.AtomWmName, xproto.AtomString, 8, uint32(len(title)), []byte(title)) var wdw Window wdw.id = wdwid wdw.conn = c wdw.lines = lines wdw.gc = gc wdw.geom = types.Geometry{0, 0, int32(gc.width), int32(height + 2*gc.border)} return &wdw, nil }
func initDesktop(xScreen *xp.ScreenInfo) { xFont, err := xp.NewFontId(xConn) if err != nil { log.Fatal(err) } xCursor, err := xp.NewCursorId(xConn) if err != nil { log.Fatal(err) } err = xp.OpenFontChecked(xConn, xFont, uint16(len("cursor")), "cursor").Check() if err != nil { log.Fatal(err) } const xcLeftPtr = 68 // XC_left_ptr from cursorfont.h. err = xp.CreateGlyphCursorChecked( xConn, xCursor, xFont, xFont, xcLeftPtr, xcLeftPtr+1, 0xffff, 0xffff, 0xffff, 0, 0, 0).Check() if err != nil { log.Fatal(err) } err = xp.CloseFontChecked(xConn, xFont).Check() if err != nil { log.Fatal(err) } desktopXWin, err = xp.NewWindowId(xConn) if err != nil { log.Fatal(err) } desktopXGC, err = xp.NewGcontextId(xConn) if err != nil { log.Fatal(err) } desktopWidth = xScreen.WidthInPixels desktopHeight = xScreen.HeightInPixels if err := xp.CreateWindowChecked( xConn, xScreen.RootDepth, desktopXWin, xScreen.Root, 0, 0, desktopWidth, desktopHeight, 0, xp.WindowClassInputOutput, xScreen.RootVisual, xp.CwOverrideRedirect|xp.CwEventMask, []uint32{ 1, xp.EventMaskExposure, }, ).Check(); err != nil { log.Fatal(err) } if len(xSettings) != 0 { initXSettings() } if err := xp.ConfigureWindowChecked( xConn, desktopXWin, xp.ConfigWindowStackMode, []uint32{ xp.StackModeBelow, }, ).Check(); err != nil { log.Fatal(err) } if err := xp.ChangeWindowAttributesChecked( xConn, desktopXWin, xp.CwBackPixel|xp.CwCursor, []uint32{ xScreen.BlackPixel, uint32(xCursor), }, ).Check(); err != nil { log.Fatal(err) } if err := xp.CreateGCChecked( xConn, desktopXGC, xp.Drawable(xScreen.Root), 0, nil, ).Check(); err != nil { log.Fatal(err) } if err := xp.MapWindowChecked(xConn, desktopXWin).Check(); err != nil { log.Fatal(err) } }