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,