func grabKeyboardAndMouse(m *Manager) { if m == nil { return } //go func() { X, err := xgbutil.NewConn() if err != nil { logger.Info("Get New Connection Failed:", err) return } keybind.Initialize(X) mousebind.Initialize(X) err = keybind.GrabKeyboard(X, X.RootWin()) if err != nil { logger.Info("Grab Keyboard Failed:", err) return } grabAllMouseButton(X) xevent.ButtonPressFun( func(X *xgbutil.XUtil, e xevent.ButtonPressEvent) { dbus.Emit(m, "KeyReleaseEvent", "") ungrabAllMouseButton(X) keybind.UngrabKeyboard(X) logger.Info("Button Press Event") xevent.Quit(X) }).Connect(X, X.RootWin()) xevent.KeyPressFun( func(X *xgbutil.XUtil, e xevent.KeyPressEvent) { value := parseKeyEnvent(X, e.State, e.Detail) pressKeyStr = value dbus.Emit(m, "KeyPressEvent", value) }).Connect(X, X.RootWin()) xevent.KeyReleaseFun( func(X *xgbutil.XUtil, e xevent.KeyReleaseEvent) { if strings.ToLower(pressKeyStr) == "super_l" || strings.ToLower(pressKeyStr) == "super_r" { pressKeyStr = "Super" } dbus.Emit(m, "KeyReleaseEvent", pressKeyStr) pressKeyStr = "" ungrabAllMouseButton(X) keybind.UngrabKeyboard(X) logger.Infof("Key: %s\n", pressKeyStr) xevent.Quit(X) }).Connect(X, X.RootWin()) xevent.Main(X) //}() }
func (cmd Quit) Run() gribble.Value { return syncRun(func() gribble.Value { logger.Message.Println("The User has told us to quit.") xevent.Quit(wm.X) return nil }) }
func newWindow(X *xgbutil.XUtil, width, height int) *xwindow.Window { var ( err error win *xwindow.Window ) win, err = xwindow.Generate(X) if err != nil { log.Fatal(err) } win.Create(X.RootWin(), 0, 0, width, height, xproto.CwBackPixel|xproto.CwEventMask, 0, xproto.EventMaskButtonRelease) win.WMGracefulClose( func(w *xwindow.Window) { xevent.Detach(w.X, w.Id) mousebind.Detach(w.X, w.Id) w.Destroy() xevent.Quit(X) }) win.Map() if err != nil { log.Fatal(err) } return win }
func newWindow(X *xgbutil.XUtil) { win, err := xwindow.Generate(X) if err != nil { log.Fatal(err) } win.Create(X.RootWin(), 0, 0, 200, 200, xproto.CwBackPixel|xproto.CwEventMask, 0, xproto.EventMaskButtonRelease) win.WMGracefulClose( func(w *xwindow.Window) { xevent.Detach(w.X, w.Id) mousebind.Detach(w.X, w.Id) w.Destroy() xevent.Quit(X) Done <- true }) win.Map() err = mousebind.ButtonReleaseFun( func(X *xgbutil.XUtil, ev xevent.ButtonReleaseEvent) { newWindow(X) }).Connect(X, win.Id, "1", false, false) if err != nil { log.Fatal(err) } }
// create creates the window, initializes the keybind and mousebind packages // and sets up the window to act like a real top-level client. func (w *window) create() { keybind.Initialize(w.X) mousebind.Initialize(w.X) err := w.CreateChecked(w.X.RootWin(), 0, 0, flagWidth, flagHeight, xproto.CwBackPixel, 0xffffff) if err != nil { errLg.Fatalf("Could not create window: %s", err) } // Make the window close gracefully using the WM_DELETE_WINDOW protocol. w.WMGracefulClose(func(w *xwindow.Window) { xevent.Detach(w.X, w.Id) keybind.Detach(w.X, w.Id) mousebind.Detach(w.X, w.Id) w.Destroy() xevent.Quit(w.X) }) // Set WM_STATE so it is interpreted as top-level and is mapped. err = icccm.WmStateSet(w.X, w.Id, &icccm.WmState{ State: icccm.StateNormal, }) if err != nil { // not a fatal error lg("Could not set WM_STATE: %s", err) } // _NET_WM_STATE = _NET_WM_STATE_NORMAL ewmh.WmStateSet(w.X, w.Id, []string{"_NET_WM_STATE_NORMAL"}) // Set the name to something. w.nameSet("Decoding all images...") w.Map() }
func showOne(testNum int) { X, err := xgbutil.NewConn() if err != nil { log.Fatal(err) } fname := testImages[testNum] fmt.Printf("Working on %s\n", fname) file, err := os.Open(testDir + fname) if err != nil { log.Fatal(err) } defer file.Close() // Decode the image. img, _, err := image.Decode(file) if err != nil { log.Fatal(err) } ximg := xgraphics.NewConvert(X, img) ximg.XShowExtra(fname, true) xevent.Main(X) time.Sleep(4 * time.Second) xevent.Quit(X) }
func newWindow(controlCh *controlCh, X *xgbutil.XUtil, width, height int) *xwindow.Window { var ( err error win *xwindow.Window ) win, err = xwindow.Generate(X) if err != nil { panic(err) } win.Create(X.RootWin(), 0, 0, width, height, xproto.CwBackPixel|xproto.CwEventMask, 0, xproto.EventMaskButtonRelease) // Xorg application exits when the window is closed. win.WMGracefulClose( func(w *xwindow.Window) { xevent.Detach(w.X, w.Id) mousebind.Detach(w.X, w.Id) w.Destroy() xevent.Quit(X) controlCh.exit <- true }) // In order to get ConfigureNotify events, we must listen to the window // using the 'StructureNotify' mask. win.Listen(xproto.EventMaskButtonPress | xproto.EventMaskButtonRelease | xproto.EventMaskKeyPress | xproto.EventMaskKeyRelease | xproto.EventMaskStructureNotify) win.Map() return win }
func showAll() { X, err := xgbutil.NewConn() if err != nil { log.Fatal(err) } for i := 0; i < len(testImages); i++ { fname := testImages[i] fmt.Printf("%d Working on %s\n", i, fname) file, err := os.Open(testDir + fname) if err != nil { continue } defer file.Close() var img image.Image // Decode the image. // using true forces bmp decoder, otherwise whatever is registered for ext is used // result slightly different if non-bmps fed to it if true { img, err = bmp.Decode(file) } else { img, _, err = image.Decode(file) } if err != nil { continue } ximg := xgraphics.NewConvert(X, img) ximg.XShowExtra(fname, true) time.Sleep(1 * time.Second) } xevent.Main(X) time.Sleep(4 * time.Second) xevent.Quit(X) }
func (cmd Restart) Run() gribble.Value { return syncRun(func() gribble.Value { wm.Restart = true // who says globals are bad? xevent.Quit(wm.X) return nil }) }
func endKeyBinding() { if X == nil { return } stopXRecord() grabMediaKeys(false) grabKeyPairs(getSystemKeyPairs(), false) grabKeyPairs(getCustomKeyPairs(), false) xevent.Quit(X) X = nil }
// This is a slightly modified version of xgraphics.XShowExtra that does // not set any resize constraints on the window (so that it can go // fullscreen). func showImage(im *xgraphics.Image, name string, quit bool) *xwindow.Window { if len(name) == 0 { name = "xgbutil Image Window" } w, h := im.Rect.Dx(), im.Rect.Dy() win, err := xwindow.Generate(im.X) if err != nil { xgbutil.Logger.Printf("Could not generate new window id: %s", err) return nil } // Create a very simple window with dimensions equal to the image. win.Create(im.X.RootWin(), 0, 0, w, h, 0) // Make this window close gracefully. win.WMGracefulClose(func(w *xwindow.Window) { xevent.Detach(w.X, w.Id) keybind.Detach(w.X, w.Id) mousebind.Detach(w.X, w.Id) w.Destroy() if quit { xevent.Quit(w.X) } }) // Set WM_STATE so it is interpreted as a top-level window. err = icccm.WmStateSet(im.X, win.Id, &icccm.WmState{ State: icccm.StateNormal, }) if err != nil { // not a fatal error xgbutil.Logger.Printf("Could not set WM_STATE: %s", err) } // Set _NET_WM_NAME so it looks nice. err = ewmh.WmNameSet(im.X, win.Id, name) if err != nil { // not a fatal error xgbutil.Logger.Printf("Could not set _NET_WM_NAME: %s", err) } // Paint our image before mapping. im.XSurfaceSet(win.Id) im.XDraw() im.XPaint(win.Id) // Now we can map, since we've set all our properties. // (The initial map is when the window manager starts managing.) win.Map() return win }
func newWindow(X *xgbutil.XUtil, width, height int) *xwindow.Window { var ( err error win *xwindow.Window ) win, err = xwindow.Generate(X) if err != nil { log.Fatal(err) } win.Create(X.RootWin(), 0, 0, width, height, xproto.CwBackPixel|xproto.CwEventMask, 0, xproto.EventMaskButtonRelease) win.WMGracefulClose( func(w *xwindow.Window) { xevent.Detach(w.X, w.Id) mousebind.Detach(w.X, w.Id) // w.Destroy() xevent.Quit(X) application.Exit() }) // In order to get ConfigureNotify events, we must listen to the window // using the 'StructureNotify' mask. win.Listen(xproto.EventMaskStructureNotify) win.Map() xevent.ConfigureNotifyFun( func(X *xgbutil.XUtil, ev xevent.ConfigureNotifyEvent) { reshape(int(ev.Width), int(ev.Height)) }).Connect(X, win.Id) // err = mousebind.ButtonReleaseFun( // func(X *xgbutil.XUtil, ev xevent.ButtonReleaseEvent) { // newWindow(X) // }).Connect(X, win.Id, "1", false, false) if err != nil { log.Fatal(err) } return win }
// newWindow creates the window, initializes the keybind and mousebind packages // and sets up the window to act like a real top-level client. func newWindow(X *xgbutil.XUtil) *Window { w, err := xwindow.Generate(X) if err != nil { errLg.Fatalf("Could not create window: %s", err) } keybind.Initialize(w.X) mousebind.Initialize(w.X) err = w.CreateChecked(w.X.RootWin(), 0, 0, 600, 600, xproto.CwBackPixel, 0xffffff) if err != nil { errLg.Fatalf("Could not create window: %s", err) } // Make the window close gracefully using the WM_DELETE_WINDOW protocol. w.WMGracefulClose(func(w *xwindow.Window) { xevent.Detach(w.X, w.Id) keybind.Detach(w.X, w.Id) mousebind.Detach(w.X, w.Id) w.Destroy() xevent.Quit(w.X) }) // Set WM_STATE so it is interpreted as top-level and is mapped. err = icccm.WmStateSet(w.X, w.Id, &icccm.WmState{State: icccm.StateNormal}) if err != nil { lg("Could not set WM_STATE: %s", err) } // _NET_WM_STATE = _NET_WM_STATE_NORMAL // not needed because we we set FS later anyway? //ewmh.WmStateSet(w.X, w.Id, []string{"_NET_WM_STATE_NORMAL"}) w.Map() err = ewmh.WmStateReq(w.X, w.Id, ewmh.StateToggle, "_NET_WM_STATE_FULLSCREEN") if err != nil { lg("Failed to go FullScreen:", err) } return &Window{w} }
func showNamed(fname string) { fmt.Printf("Working on %s\n", fname) file, err := os.Open(fname) if err != nil { log.Fatal(err) } defer file.Close() X, err := xgbutil.NewConn() if err != nil { log.Fatal(err) } // Decode the image. img, _, err := image.Decode(file) if err != nil { log.Fatal(err) } ximg := xgraphics.NewConvert(X, img) ximg.XShowExtra(fname, true) xevent.Main(X) time.Sleep(4 * time.Second) xevent.Quit(X) }
func NewWindow() *Window { win, err := xwindow.Generate(X) if err != nil { log.Fatal("cannot generate window %v\n", err) return nil } width, height := 800, 600 win.Create(X.RootWin(), 0, 0, width, height, xproto.CwBackPixel, 0x0) win.WMGracefulClose(func(w *xwindow.Window) { xevent.Detach(w.X, w.Id) keybind.Detach(w.X, w.Id) mousebind.Detach(w.X, w.Id) w.Destroy() xevent.Quit(w.X) }) icccm.WmStateSet(X, win.Id, &icccm.WmState{ State: icccm.StateNormal, }) win.Listen(xproto.EventMaskKeyPress) win.Clear(0, 0, 0, 0) win.Map() self := &Window{ win, nil, false, nil, } self.bindKeys() return self }
// disown responds to SelectionClear events on our dummy window. // This means another window manager is trying to run, so quit. func disown(X *xgbutil.XUtil, ev xevent.SelectionClearEvent) { logger.Message.Println( "Some other window manager is replacing us. Exiting...") xevent.Quit(X) }
func main() { X, err := xgbutil.NewConn() if err != nil { log.Println(err) return } //Initialize the keybind package keybind.Initialize(X) //Create a window win, err := xwindow.Generate(X) if err != nil { log.Fatalf("Could not generate a new window X id: %s", err) } win.Create(X.RootWin(), 0, 0, 1024, 768, xproto.CwBackPixel, 0x606060ff) // Listen for Key{Press,Release} events. win.Listen(xproto.EventMaskKeyPress, xproto.EventMaskKeyRelease) // Map the window. This is what makes it on the screen win.Map() //Make a ...callback... for the events and connect xevent.KeyPressFun( func(X *xgbutil.XUtil, e xevent.KeyPressEvent) { modStr := keybind.ModifierString(e.State) keyStr := keybind.LookupString(X, e.State, e.Detail) if len(modStr) > 0 { log.Printf("Key: %s-%s\n", modStr, keyStr) } else { log.Println("Key:", keyStr) } if keybind.KeyMatch(X, "Escape", e.State, e.Detail) { if e.State&xproto.ModMaskControl > 0 { log.Println("Control-Escape detected. Quitting...") xevent.Quit(X) } } }).Connect(X, win.Id) //So here i'm going to try to make a image..' img := xgraphics.New(X, image.Rect(0, 0, 1024, 768)) err = img.XSurfaceSet(win.Id) if err != nil { log.Printf("Error while setting window surface to image %d: %s\n", win, err) } else { log.Printf("Window %d surface set to image OK\n", win) } // I /think/ XDraw actually sends data to server? img.XDraw() // I /think/ XPaint tells the server to paint image to window img.XPaint(win.Id) //Start the routine that updates the window go updater(img, win) //This seems to start a main loop for listening to xevents xevent.Main(X) }
func makeWindow(ximage *xgraphics.Image) (*xwindow.Window, *bool) { w, h := ximage.Rect.Dx(), ximage.Rect.Dy() window, err := xwindow.Generate(ximage.X) if err != nil { xgbutil.Logger.Printf("Could not generate new window id: %s", err) return nil, nil } window.Create(ximage.X.RootWin(), 0, 0, w, h, xproto.CwBackPixel, 0x00000000) window.Listen(xproto.EventMaskExposure, xproto.EventMaskKeyPress, xproto.EventMaskStructureNotify, xproto.EventMaskVisibilityChange) window.WMGracefulClose(func(w *xwindow.Window) { xevent.Detach(w.X, w.Id) keybind.Detach(w.X, w.Id) mousebind.Detach(w.X, w.Id) w.Destroy() xevent.Quit(w.X) }) err = icccm.WmStateSet(ximage.X, window.Id, &icccm.WmState{ State: icccm.StateNormal, }) if err != nil { xgbutil.Logger.Printf("Could not set WM_STATE: %s", err) } err = ewmh.WmNameSet(ximage.X, window.Id, "Computer System Monitor") if err != nil { xgbutil.Logger.Printf("Could not set _NET_WM_NAME: %s", err) } err = keybind.KeyPressFun( func(X *xgbutil.XUtil, ev xevent.KeyPressEvent) { err := ewmh.WmStateReq(ximage.X, window.Id, ewmh.StateToggle, "_NET_WM_STATE_FULLSCREEN") if err != nil { log.Fatal(err) } }).Connect(ximage.X, window.Id, "f", false) if err != nil { log.Fatal(err) } xevent.ExposeFun( func(xu *xgbutil.XUtil, event xevent.ExposeEvent) { ximage.XExpPaint(window.Id, 0, 0) }).Connect(ximage.X, window.Id) obscured := false xevent.VisibilityNotifyFun( func(xu *xgbutil.XUtil, event xevent.VisibilityNotifyEvent) { obscured = event.State == xproto.VisibilityFullyObscured }).Connect(ximage.X, window.Id) window.Map() return window, &obscured }
// Quit terminates the main event loop. func (app *DockApp) Quit() { xevent.Quit(app.x) }
func main() { // Connect to the X server using the DISPLAY environment variable. X, err := xgbutil.NewConn() if err != nil { log.Fatal(err) } // Anytime the keybind (mousebind) package is used, keybind.Initialize // *should* be called once. It isn't strictly necessary, but allows your // keybindings to persist even if the keyboard mapping is changed during // run-time. (Assuming you're using the xevent package's event loop.) // It also handles the case when your modifier map is changed. keybind.Initialize(X) // Create a new window. We will listen for key presses and translate them // only when this window is in focus. (Similar to how `xev` works.) win, err := xwindow.Generate(X) if err != nil { log.Fatalf("Could not generate a new window X id: %s", err) } win.Create(X.RootWin(), 0, 0, 500, 500, xproto.CwBackPixel, 0xffffffff) // Listen for Key{Press,Release} events. win.Listen(xproto.EventMaskKeyPress, xproto.EventMaskKeyRelease) // Map the window. win.Map() // Notice that we use xevent.KeyPressFun instead of keybind.KeyPressFun, // because we aren't trying to make a grab *and* because we want to listen // to *all* key press events, rather than just a particular key sequence // that has been pressed. wid := win.Id if flagRoot { wid = X.RootWin() } xevent.KeyPressFun( func(X *xgbutil.XUtil, e xevent.KeyPressEvent) { // keybind.LookupString does the magic of implementing parts of // the X Keyboard Encoding to determine an english representation // of the modifiers/keycode tuple. // N.B. It's working for me, but probably isn't 100% correct in // all environments yet. modStr := keybind.ModifierString(e.State) keyStr := keybind.LookupString(X, e.State, e.Detail) if len(modStr) > 0 { log.Printf("Key: %s-%s\n", modStr, keyStr) } else { log.Println("Key:", keyStr) } if keybind.KeyMatch(X, "Escape", e.State, e.Detail) { if e.State&xproto.ModMaskControl > 0 { log.Println("Control-Escape detected. Quitting...") xevent.Quit(X) } } }).Connect(X, wid) // If we want root, then we take over the entire keyboard. if flagRoot { if err := keybind.GrabKeyboard(X, X.RootWin()); err != nil { log.Fatalf("Could not grab keyboard: %s", err) } log.Println("WARNING: We are taking *complete* control of the root " + "window. The only way out is to press 'Control + Escape' or to " + "close the window with the mouse.") } // Finally, start the main event loop. This will route any appropriate // KeyPressEvents to your callback function. log.Println("Program initialized. Start pressing keys!") xevent.Main(X) }
func main() { X, err := xgbutil.NewConn() fatal(err) // Remember to always initialize the keybind package before usage. keybind.Initialize(X) // We create a benign parent window. Its only value in this example is // instructional. In particular, it shows how to have a sub-window get // focus using the ICCCM WM_TAKE_FOCUS protocol. (Since by default, // the window manager will assign focus to your top-level window.) // The real magic happens below with the WMTakeFocus method call. parentWin, err := xwindow.Create(X, X.RootWin()) fatal(err) // NewInput creates a new input window and handles all of the text drawing // for you. It can be any width, but the height will be automatically // determined by the height extents of the font size chosen. input := text.NewInput(X, parentWin.Id, width, padding, font, fontSize, fontColor, bgColor) parentWin.Resize(input.Geom.Width(), input.Geom.Height()) // Make sure X reports KeyPress events when this window is focused. input.Listen(xproto.EventMaskKeyPress) // Listen to KeyPress events. If it's a BackSpace, remove the last // character in the input box. If it's "Return" quit. If it's "Escape", // clear the input box. // Otherwise, try to add the key pressed to the input box. // (Not all key presses correspond to a single character that is added.) xevent.KeyPressFun( func(X *xgbutil.XUtil, ev xevent.KeyPressEvent) { mods, kc := ev.State, ev.Detail switch { case keybind.KeyMatch(X, "BackSpace", mods, kc): input.Remove() case keybind.KeyMatch(X, "Return", mods, kc): log.Println("Return has been pressed.") log.Printf("The current text is: %s", string(input.Text)) log.Println("Quitting...") xevent.Quit(X) case keybind.KeyMatch(X, "Escape", mods, kc): input.Reset() default: input.Add(mods, kc) } }).Connect(X, input.Id) // Implement the WM_DELETE_WINDOW protocol. parentWin.WMGracefulClose(func(w *xwindow.Window) { xevent.Quit(X) }) // Implement the WM_TAKE_FOCUS protocol. The callback function provided // is executed when a valid WM_TAKE_FOCUS ClientMessage event has been // received from the window manager. // According to ICCCM Section 4.2.7, this is one of the three valid ways // of setting input focus to a sub-window. (It's also easiest since it // doesn't require us to monitor FocusChange events. EW.) // If you have multiple sub-windows that can be focused, this callback // function is where the logic would go to pick which sub-window should // be focused upon receipt of a WM_TAKE_FOCUS message. parentWin.WMTakeFocus(func(w *xwindow.Window, tstamp xproto.Timestamp) { input.FocusParent(tstamp) }) // Map the window and start the main X event loop. input.Map() parentWin.Map() xevent.Main(X) }
func (wa *fullScreenWorkaround) stop() { xevent.Quit(wa.xu) }
func cmdQuit() func() { return func() { logger.Message.Println("The User has told us to quit.") xevent.Quit(X) } }
func main() { // Signal Handling. sigChan := make(chan os.Signal) signal.Notify(sigChan, syscall.SIGTERM, syscall.SIGINT) paths := basedir.Paths{ XDGSuffix: "gobar", GoImportPath: "github.com/AmandaCameron/gobar/data", } file, err := paths.ConfigFile("config.wini") utils.FailMeMaybe(err) cfg := loadConfig(file) //os.Getenv("HOME") + "/.config/gobar/config.wini") // Load Images. images.Init(paths) // Setup the X Connection X, err := xgbutil.NewConn() utils.FailMeMaybe(err) win, err := xwindow.Create(X, X.RootWin()) utils.FailMeMaybe(err) win.Resize(cfg.BarWidth, cfg.BarSize) // Setup the EWMH Stuff utils.FailMeMaybe(ewmh.RestackWindow(X, win.Id)) var strut *ewmh.WmStrutPartial if cfg.Position == "Top" { strut = &ewmh.WmStrutPartial{ Top: uint(cfg.BarSize), TopStartX: 0, TopEndX: uint(cfg.BarWidth), } win.Move(0, 0) } else if cfg.Position == "Bottom" { strut = &ewmh.WmStrutPartial{ Bottom: uint(cfg.BarSize), BottomStartX: 0, BottomEndX: uint(cfg.BarWidth), } win.Move(0, 600-cfg.BarSize) } else { println("Invalid Position:", cfg.Position) os.Exit(1) } utils.FailMeMaybe(ewmh.WmStrutPartialSet(X, win.Id, strut)) utils.FailMeMaybe(ewmh.WmWindowTypeSet(X, win.Id, []string{ "_NET_WM_WINDOW_TYPE_DOCK", })) // Put us everywhere. utils.FailMeMaybe(ewmh.WmDesktopSet(X, win.Id, 0xFFFFFFFF)) win.Map() keybind.Initialize(X) // Get the DE settings, if we can. xs, err := xsettings.New(X) if err != nil { // Maybe this should be an error, maybe not? xs = nil } // Draw the background bg := xgraphics.BGRA{ R: 64, G: 64, B: 64, A: 255, } img := xgraphics.New(X, image.Rect(0, 0, cfg.BarWidth, cfg.BarSize)) img.For(func(x, y int) xgraphics.BGRA { return bg }) utils.FailMeMaybe(img.XSurfaceSet(win.Id)) img.XDraw() img.XPaint(win.Id) // Connect to DBus sys, err := dbus.Connect(dbus.SystemBus) utils.FailMeMaybe(err) // The session bus, too. sess, err := dbus.Connect(dbus.SessionBus) utils.FailMeMaybe(err) // Blah x := xdg.New() // TODO: How should this fail? I imagine defaulting to gnome is the wrong thing to do, // but I'm not really sure what it should do. if xs != nil { theme, err := xs.GetString("Net/IconThemeName") if err == nil { x.SetTheme(theme) } } var dev *nm.Device var batt *upower.Device up := upower.New(sys) cli := nm.New(sys) if devs, err := cli.GetDevices(); err == nil { for _, d := range devs { if d.Type() == nm.Wireless { dev = d break } } } if pdevs, err := up.GetDevices(); err == nil { for _, d := range pdevs { if d.Type() == upower.Battery { batt = d break } } } // Clock clck := &Clock{ X: X, Position: cfg.Clock.Position, Width: cfg.Clock.Width, Height: cfg.BarSize, Parent: win, Format: cfg.ClockFormat, Background: xgraphics.BGRA{R: 48, G: 48, B: 48, A: 255}, Foreground: xgraphics.BGRA{R: 255, G: 255, B: 255, A: 255}, Font: utils.OpenFont(cfg.Clock.Font.Name), FontSize: cfg.Clock.Font.Size, } clck.Init() // App Launch Tracker tracker := &Tracker{ X: X, Position: cfg.Tracker.Position, Size: cfg.BarSize, Background: bg, Parent: win, } tracker.Init() // Command Tray ct := &commandtray.CommandTray{ X: X, Width: cfg.Command.Width, Height: cfg.BarSize, Position: cfg.Command.Position, Parent: win, Font: utils.OpenFont(cfg.Command.Font.Name), FontSize: cfg.Command.Font.Size, } commandtray.Register(commandtray.AppSource{ Xdg: x, X: X, AppTracker: tracker, }) if sess != nil { commandtray.Register(commandtray.GnomeSessionSource{ Obj: sess.Object("org.gnome.SessionManager", "/org/gnome/SessionManager"), Xdg: x, }) commandtray.Register(commandtray.NewShellSource(sess, x)) commandtray.Register(&commandtray.AppMenuSource{ Conn: sess, }) } // Done, maybe? ct.Init() ct.Bind(cfg.CommandAccel) ct.Draw() // Status Bar sb := &statbar.StatusBar{ X: X, Width: cfg.StatusBar.Width, Position: cfg.StatusBar.Position, Height: cfg.BarSize, Parent: win, } sb.Init() if batt != nil { sb.Add(&statbar.SbPower{batt}) } if dev != nil { sb.Add(&statbar.SbNmWifi{dev}) commandtray.Register(commandtray.NmSource{dev}) } sb.Draw() // My My this anikin guy... go func() { for { select { case <-sigChan: sb.Teardown() time.Sleep(1 * time.Second) // Anybody else? xevent.Quit(X) } } }() xevent.Main(X) }
// canceled is the callback that gets executed whenever the prompt is canceled. // This can occur when the user presses escape (the "cancel" key). func canceled(inp *prompt.Input) { xevent.Quit(inp.X) }
func(w *window) { w.chans.resizeToImageChan <- struct{}{} }, }, { "h", "Pan left.", func(w *window) { w.stepLeft() }, }, { "j", "Pan down.", func(w *window) { w.stepDown() }, }, { "k", "Pan up.", func(w *window) { w.stepUp() }, }, { "l", "Pan right.", func(w *window) { w.stepRight() }, }, { "q", "Quit.", func(w *window) { xevent.Quit(w.X) }, }, } ) func init() { // Set GOMAXPROCS, since imgv can benefit greatly from parallelism. runtime.GOMAXPROCS(runtime.NumCPU()) // Set the prefix for verbose output. log.SetPrefix("[imgv] ") // Set all of the flags. flag.BoolVar(&flagVerbose, "v", false, "If set, logging output will be printed to stderr.") flag.IntVar(&flagWidth, "width", 600,