// same as above, but moveresize instead of just move at the first step, // then resize to the provided w/h instead of a snapshotted one // this implementation differs from Move in that it makes no effort to be end-synchronous // This function waits only on the window's inner geometry resizing, not on actual movement occuring func MoveResize(win *xwindow.Window, x, y, width, height int) error { // snapshot window dimensions base, err := win.Geometry() if err != nil { return err } // move window then wait... err = win.WMMoveResize(x, y, width, height) if err != nil { return err } err = PollFor(win, GeometryDiffers(base)) if err != nil { return err } // check that the new geometry is what we requested // this may be inadvisable: what about window hints? geom, err := win.Geometry() if err != nil { return err } if geom.Width() != width || geom.Height() != height { // something derped! resize to make it right! // if window hints constrained us, this won't upset them log.Println("MoveResize: resizing again after incorrect new dimensions") err = win.WMResize(width, height) if err != nil { return err } } return nil }
// Sometimes window managers are really slow about // re-implemented here because under Fluxbox, win.WMMove() results in the window // growing vertically by the height of the titlebar! // So we snapshot the size of the window before we move it, // move it, compare the sizes, then resize it vertically to be in line with our intentions // // this is synchronous: it waits for the window to finish moving before it releases control // because it would be impossible to selectivley poll for just the move. func Move(win *xwindow.Window, x, y int) error { // snapshot both sorts of window geometries decor_geom, geom, err := Geometries(win) if err != nil { return err } log.Printf("Move: detected geometry to be %v\n", geom) // move the window, then wait for it to finish moving err = win.WMMove(x, y) if err != nil { return err } // this waits 30MS under non-Fluxbox window manager // WHAT DO err = PollFor(win, GeometryDiffers(geom)) if err != nil { // if we had a timeout, that means that the geometry didn't derp during // moving, and everything is A-OK! // skip the rest of the function if _, wasTimeout := err.(*TimeoutError); wasTimeout { return nil } return err } // compare window widths before/after move _, post_move_base, err := Geometries(win) if err != nil { return err } delta_w := post_move_base.Width() - geom.Width() delta_h := post_move_base.Height() - geom.Height() if delta_h != 0 || delta_w != 0 { // fluxbox has done it again. We issued a move, and we got a taller window, too! log.Printf("Move: resetting dimensions to %v due to w/h delta: %v/%v\n", geom, delta_w, delta_h) err = win.WMResize(geom.Width(), geom.Height()) if err != nil { return err } // wait for that to succeed err = PollFor(win, GeometryDiffers(post_move_base)) if err != nil { return err } } // make sure window did actually move err = PollFor(win, DecorDiffers(decor_geom)) if err != nil { // if we had a timeout, that means that the window didn't move // we want to send an error mentioning that fact specifically // instead of a generic "lol timeout happan in polling :DDD" if te, wasTimeout := err.(*TimeoutError); wasTimeout { return &TimeoutError{"Move: window didn't move", te.Timeout} } // return whatever other error stymied the polling return err } return nil }
// resize a window by a certain number of pixels in a given direction. // This function tries to prevent the window from moving func ResizeDirection(X *xgbutil.XUtil, win *xwindow.Window, dir wm.Direction, px int) error { // we resize around the decor_geometry of the window if px == 0 { // no need to resize return nil } geom, err := win.Geometry() if err != nil { return fmt.Errorf("Resize: coudn't get normal geometry: %v", err) } w, h := geom.Width(), geom.Height() log.Printf("ResizeDirection: pre_geom == %v\n", geom) if dir == wm.Left || dir == wm.Right { // horizontal resize w += px } else { h += px } // two-step resize -> move process, to compensate for WM peculiarities and window sizing hints // first save the initial position info pre_decor, err := win.DecorGeometry() if err != nil { return fmt.Errorf("Resize: coudn't get decorated geometry: %v", err) } // resize the window err = win.WMResize(w, h) if err != nil { return err } // wait for the geometry to change // we use a goroutine to query X a bunch while waiting for the window // to finish resizing err = wm.PollFor(win, wm.DecorDiffers(pre_decor), wm.GeometryDiffers(geom)) if err != nil { return fmt.Errorf("ResizeDirection: error waiting for window geometries to change: %v", err) } post_decor, post_geom, err := wm.Geometries(win) if err != nil { return err } log.Printf("ResizeDirection: post_decor == %v\n", post_decor) log.Printf("ResizeDirection: post_geom == %v\n", post_geom) // the opposite edge should stay in the same place op := dir.Opposite() pre_edge := EdgePos(pre_decor, op) post_edge := EdgePos(post_decor, op) delta := post_edge - pre_edge x, y := post_decor.X(), post_decor.Y() // move the window upwards by our height resize so that the bottom edge stays in the same place if dir == wm.Top || dir == wm.Bottom { y -= delta } // move the window right by our resize so that the right stays in the same place if dir == wm.Left || dir == wm.Right { x -= delta } // move to lock opposite edge return wm.Move(win, x, y) }