func NewXHandle(display string) (*xhandle, error) {
c, err := xgb.NewConnDisplay(display)
if err != nil {
return nil, err
}
s := xproto.Setup(c)
screen := s.DefaultScreen(c)
kb, err := NewKeyboard(s, c)
if err != nil {
return nil, err
}
h := &xhandle{
conn: c,
root: screen.Root,
Events: make([]Event, 0, 1000),
EvtsLck: &sync.RWMutex{},
keyboard: kb,
Keys: make(map[int]map[xproto.Window]map[Input][]Key),
KeysLck: &sync.RWMutex{},
}
return h, nil
}
// NewConnDisplay connects to the X server and creates a new XUtil.
// If 'display' is empty, the DISPLAY environment variable is used. Otherwise
// there are several different display formats supported:
//
// NewConn(":1") -> net.Dial("unix", "", "/tmp/.X11-unix/X1")
// NewConn("/tmp/launch-12/:0") -> net.Dial("unix", "", "/tmp/launch-12/:0")
// NewConn("hostname:2.1") -> net.Dial("tcp", "", "hostname:6002")
// NewConn("tcp/hostname:1.0") -> net.Dial("tcp", "", "hostname:6001")
func NewConnDisplay(display string) (*XUtil, error) {
c, err := xgb.NewConnDisplay(display)
if err != nil {
return nil, err
}
return NewConnXgb(c)
}
func NewXHandle(display string, ewhm []string) (*xhandle, error) {
c, err := xgb.NewConnDisplay(display)
if err != nil {
return nil, err
}
setup := xproto.Setup(c)
screen := setup.DefaultScreen(c)
meta, err := mkMeta(screen, c)
if err != nil {
return nil, err
}
motion, err := mkMotion(screen, c)
if err != nil {
return nil, err
}
h := &xhandle{
conn: c,
setup: setup,
screen: screen,
root: screen.Root,
meta: meta,
motion: motion,
Events: make([]Event, 0, 1000),
EvtsLck: &sync.RWMutex{},
}
mr := NewMotionRecorder(h.conn, h.root, h.motion)
h.pointer = NewPointer(mr)
h.Windower = NewWindower(h.conn, h.root)
h.InputFocus = NewInputFocus(h.conn, h.root)
h.Atomic = atomic.New(h.conn)
EWMH := ewmh.New(h.conn, h.root, h.Atomic)
err = EWMH.SupportedSet(ewhm)
if err != nil {
return nil, err
}
h.Ewmh = NewEwmh(EWMH)
//h.Ewmh.Set("string name", h.root, h.meta)
return h, nil
}
// NewConnDisplay connects to the X server and creates a new XUtil.
// If 'display' is empty, the DISPLAY environment variable is used. Otherwise
// there are several different display formats supported:
//
// NewConn(":1") -> net.Dial("unix", "", "/tmp/.X11-unix/X1")
// NewConn("/tmp/launch-12/:0") -> net.Dial("unix", "", "/tmp/launch-12/:0")
// NewConn("hostname:2.1") -> net.Dial("tcp", "", "hostname:6002")
// NewConn("tcp/hostname:1.0") -> net.Dial("tcp", "", "hostname:6001")
func NewConnDisplay(display string) (*XUtil, error) {
c, err := xgb.NewConnDisplay(display)
if err != nil {
return nil, err
}
setup := xproto.Setup(c)
screen := setup.DefaultScreen(c)
// Initialize our central struct that stores everything.
xu := &XUtil{
conn: c,
Quit: false,
Evqueue: make([]EventOrError, 0, 1000),
EvqueueLck: &sync.RWMutex{},
setup: setup,
screen: screen,
root: screen.Root,
eventTime: xproto.Timestamp(0), // last event time
Atoms: make(map[string]xproto.Atom, 50),
AtomsLck: &sync.RWMutex{},
AtomNames: make(map[xproto.Atom]string, 50),
AtomNamesLck: &sync.RWMutex{},
Callbacks: make(map[int]map[xproto.Window][]Callback, 33),
CallbacksLck: &sync.RWMutex{},
Keymap: nil, // we don't have anything yet
Modmap: nil,
KeyRedirect: 0,
Keybinds: make(map[KeyKey][]CallbackKey, 10),
KeybindsLck: &sync.RWMutex{},
Keygrabs: make(map[KeyKey]int, 10),
Mousebinds: make(map[MouseKey][]CallbackMouse, 10),
MousebindsLck: &sync.RWMutex{},
Mousegrabs: make(map[MouseKey]int, 10),
InMouseDrag: false,
MouseDragStepFun: nil,
MouseDragEndFun: nil,
ErrorHandler: func(err xgb.Error) { Logger.Println(err) },
}
// Create a general purpose graphics context
xu.gc, err = xproto.NewGcontextId(xu.conn)
if err != nil {
return nil, err
}
xproto.CreateGC(xu.conn, xu.gc, xproto.Drawable(xu.root),
xproto.GcForeground, []uint32{xu.screen.WhitePixel})
// Create a dummy window
xu.dummy, err = xproto.NewWindowId(xu.conn)
if err != nil {
return nil, err
}
xproto.CreateWindow(xu.conn, xu.Screen().RootDepth, xu.dummy, xu.RootWin(),
-1000, -1000, 1, 1, 0,
xproto.WindowClassInputOutput, xu.Screen().RootVisual,
xproto.CwEventMask|xproto.CwOverrideRedirect,
[]uint32{1, xproto.EventMaskPropertyChange})
xproto.MapWindow(xu.conn, xu.dummy)
// Register the Xinerama extension... because it doesn't cost much.
err = xinerama.Init(xu.conn)
// If we can't register Xinerama, that's okay. Output something
// and move on.
if err != nil {
Logger.Printf("WARNING: %s\n", err)
Logger.Printf("MESSAGE: The 'xinerama' package cannot be used " +
"because the XINERAMA extension could not be loaded.")
}
return xu, nil
}
