Example #1
0
File: main.go Project: dlintw/mdtwm
func connect() {
	var err error
	conn, err = xgb.Dial("")
	if err != nil {
		l.Fatal("Can't connect to display: ", err)
	}
	screen = conn.DefaultScreen()
	r, err := conn.GetKeyboardMapping(
		conn.Setup.MinKeycode,
		conn.Setup.MaxKeycode-conn.Setup.MinKeycode+1,
	)
	if err != nil {
		l.Fatal("Can't get keybboard mapping: ", err)
	}
	// Setup keycode <-> keysym mapping
	minKeycode := conn.Setup.MinKeycode
	codeNum := int(r.Length) / int(r.KeysymsPerKeycode)
	keyCodeToSym = make([]xgb.Keysym, int(minKeycode)+codeNum)
	keySymToCode = make(map[xgb.Keysym]byte)
	for i := 0; i < codeNum; i++ {
		s := r.Keysyms[i*int(r.KeysymsPerKeycode)]
		keyCodeToSym[byte(i)+minKeycode] = s
		keySymToCode[s] = byte(i) + minKeycode
	}
}
Example #2
0
func main() {
	c, err := xgb.Dial("")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer c.Close()

	for {
		hostname, err := os.Hostname()
		if err != nil {
			hostname = "<hostname unavailable>"
		}

		t := time.Now().Format("03:04   2 Jan 2006")

		title := fmt.Sprintf("%s   %s                  ", hostname, t)
		c.ChangeProperty(
			xgb.PropModeReplace,
			c.DefaultScreen().Root,
			xgb.AtomWmName,
			xgb.AtomString,
			8,
			[]byte(title))
		time.Sleep(time.Minute)
	}
}
Example #3
0
func connectToX() {
	lprintf("connecting to %v", envdisplay)
	var err error
	conn, err = xgb.Dial(envdisplay)
	if err != nil {
		lfatalf("%v", err)
	}
	lprintf("connected to %v", envdisplay)
}
Example #4
0
func main() {
	c, err := xgb.Dial(os.Getenv("DISPLAY"))
	if err != nil {
		fmt.Printf("cannot connect: %v\n", err)
		os.Exit(1)
	}

	fmt.Printf("vendor = '%s'\n", string(c.Setup.Vendor))

	win := c.NewId()
	gc := c.NewId()

	c.CreateWindow(0, win, c.DefaultScreen().Root, 150, 150, 200, 200, 0, 0, 0, 0, nil)
	c.ChangeWindowAttributes(win, xgb.CWEventMask,
		[]uint32{xgb.EventMaskExposure | xgb.EventMaskKeyRelease})
	c.CreateGC(gc, win, 0, nil)
	c.MapWindow(win)

	atom, _ := c.InternAtom(false, "HELLO")
	fmt.Printf("atom = %d\n", atom.Atom)

	points := make([]xgb.Point, 2)
	points[0] = xgb.Point{5, 5}
	points[1] = xgb.Point{100, 120}

	hosts, _ := c.ListHosts()
	fmt.Printf("hosts = %+v\n", hosts)

	ecookie := c.ListExtensionsRequest()
	exts, _ := c.ListExtensionsReply(ecookie)
	for _, name := range exts.Names {
		fmt.Printf("exts = '%s'\n", name.Name)
	}

	for {
		reply, err := c.WaitForEvent()
		if err != nil {
			fmt.Printf("error: %v\n", err)
			os.Exit(1)
		}
		fmt.Printf("event %T\n", reply)
		switch event := reply.(type) {
		case xgb.ExposeEvent:
			c.PolyLine(xgb.CoordModeOrigin, win, gc, points)
		case xgb.KeyReleaseEvent:
			fmt.Printf("key release!\n")
			points[0].X = event.EventX
			points[0].Y = event.EventY
			c.PolyLine(xgb.CoordModeOrigin, win, gc, points)
			c.Bell(75)
		}
	}

	c.Close()
}
func main() {
	c, err := xgb.Dial("")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer c.Close()

	strBytes := []byte("Hello XGB!")
	rectangles := []xgb.Rectangle{{40, 40, 20, 20}}

	// get the first screen
	s := c.DefaultScreen()

	// root window
	win := s.Root

	// create black (foreground) graphic context
	fg := c.NewId()
	mask := uint32(xgb.GCForeground | xgb.GCGraphicsExposures)
	values := []uint32{s.BlackPixel, 0}
	c.CreateGC(fg, win, mask, values)

	// create white (background) graphic context
	bg := c.NewId()
	mask = uint32(xgb.GCBackground | xgb.GCGraphicsExposures)
	values[0] = s.WhitePixel // (values[1] still 0)
	c.CreateGC(bg, win, mask, values)

	//  create the window
	win = c.NewId()
	mask = xgb.CWBackPixel | xgb.CWEventMask
	// values[0] still s.WhitePixel
	values[1] = xgb.EventMaskExposure | xgb.EventMaskKeyPress
	c.CreateWindow(0, win, s.Root, 0, 0, 150, 150, 10,
		xgb.WindowClassInputOutput, s.RootVisual, mask, values)
	c.MapWindow(win)

	for {
		event, err := c.WaitForEvent()
		if err != nil {
			fmt.Println(err)
			return
		}
		switch event.(type) {
		case xgb.ExposeEvent:
			c.PolyRectangle(win, fg, rectangles)
			c.ImageText8(win, bg, 20, 20, strBytes)
		case xgb.KeyPressEvent:
			return
		}
	}
}
Example #6
0
func main() {
	conn, err := xgb.Dial(":1")
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	// height := int(conn.Setup.Roots[0].HeightInPixels)
	// width := int(conn.Setup.Roots[0].WidthInPixels)

	width := 1920
	height := 1080

	desktop := Desktop{width, height, 0, 0, 0, nil}

	s := conn.DefaultScreen()

	for _, v := range Shortcuts {
		conn.GrabKey(true, s.Root, v.Mod, v.Key, xgb.GrabModeAsync, xgb.GrabModeAsync)
	}

	conn.ChangeWindowAttributes(s.Root, xgb.CWEventMask, []uint32{xgb.EventMaskSubstructureRedirect})

	for {
		event, _ := conn.WaitForEvent()
		switch ev := event.(type) {
		case xgb.KeyReleaseEvent:
			for _, v := range Shortcuts {
				if ev.Detail == v.Key {
					v.Function(conn)
					fmt.Println("shortcut hit:", v)
				}
			}
		case xgb.MapRequestEvent:
			if desktop.Head == 0 {
				desktop.Head = ev.Window
			} else if desktop.Clients == nil {
				desktop.Clients = []xgb.Id{ev.Window}
			} else {
				desktop.Clients = append(desktop.Clients, ev.Window)
			}

			desktop.Focus = ev.Window

			desktop.Tile(conn)
			conn.MapWindow(ev.Window)
		case xgb.DestroyNotifyEvent:
			fmt.Println("notify to destroy", ev)
		default:
			fmt.Println(reflect.TypeOf(ev))
		}
	}
}
Example #7
0
func main() {
	str = ""
	c, err := xgb.Dial("")

	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}

	defer c.Close()
	createWindow(c)
	handleEvents(c)
}
Example #8
0
func NewInstance() *Jake_Graphics {
	jg := Jake_Graphics{m_c: nil}
	c, err := xgb.Dial(os.Getenv("DISPLAY"))
	if err != nil {
		fmt.Printf("Jake_Graphics: cannot connect to X server: '%v'\n", err)
		return nil
	}
	jg.m_c = c
	jg.m_keyCodeStart = int(jg.m_c.Setup.MinKeycode)
	jg.m_keyCodeEnd = int(jg.m_c.Setup.MaxKeycode)
	fmt.Printf("Jake_Graphics: keyCode:%d->%d\n", jg.m_keyCodeStart, jg.m_keyCodeEnd)

	return &jg
}
Example #9
0
func main() {
	logger := cabin.New()
	output := make(chan *cabin.Event)
	logger.Subscribe(output)
	go cabin.StdoutLogger(output)

	conn, err := xgb.Dial(os.Getenv("DISPLAY"))
	if err != nil {
		fmt.Printf("Failed to connect to the X Server (%s)\n", os.Getenv("DISPLAY"))
		os.Exit(1)
	}

	logger.Log("OK")
	logger.Log(conn)
}
Example #10
0
func main() {
	var err error
	display := os.Getenv("DISPLAY")
	conn, err = xgb.Dial(display)
	if err != nil {
		l.Fatal(err)
	}
	setupAtoms()
	root = Window(conn.DefaultScreen().Root)

	createWindow()

	tr, err := conn.QueryTree(root.Id())
	for i, id := range append(tr.Children, root.Id()) {
		w := Window(id)

		inst, class := w.Class()

		tr, err := conn.QueryTree(id)
		if err != nil {
			l.Fatal("QueryTree: ", err)
		}
		wmName := w.Prop(AtomNetWmName, 128)

		info := struct {
			id, root, parent  xgb.Id
			ch_num            uint16
			name, inst, class string
			g                 Geometry
		}{
			id, tr.Root, tr.Parent,
			tr.ChildrenLen,
			string(wmName.Value), inst, class,
			Geometry{},
		}
		var ok bool
		info.g, ok = w.Geometry()
		if !ok {
			return
		}

		fmt.Printf("%d: %+v\n", i, info)
	}
}