// cutting windows in half on the Y axis
func splitHorizontal(target, incoming *xwindow.Window, incomingOnLeft bool) error {
bounds, err := target.DecorGeometry()
if err != nil {
log.Printf("splitHorizontal: error getting bounds of target: %v\n", err)
return err
}
left_width := bounds.Width() / 2
right_width := bounds.Width() - left_width
var left, right *xwindow.Window
if incomingOnLeft {
left = incoming
right = target
} else {
left = target
right = incoming
}
err = MoveResize(right, bounds.X()+left_width, bounds.Y(), right_width, bounds.Height())
if err != nil {
log.Printf("splitHorizontal: error configuring right: %v\n", err)
return err
}
err = MoveResize(left, bounds.X(), bounds.Y(), left_width, bounds.Height())
if err != nil {
log.Printf("splitHorizontal: error configuring left: %v\n", err)
return err
}
// cool
return nil
}
// Swap the position and size of the target and incoming windows
func Swap(target, incoming *xwindow.Window) error {
// get bounds for both windows
target_bounds, err := target.DecorGeometry()
if err != nil {
log.Printf("Swap: error getting bounds of target: %v\n", err)
return err
}
incoming_bounds, err := incoming.DecorGeometry()
if err != nil {
log.Printf("Swap: error getting bounds of incoming: %v\n", err)
return err
}
// configure windows, easy as pie!
err = MoveResize(target, incoming_bounds.X(), incoming_bounds.Y(),
incoming_bounds.Width(), incoming_bounds.Height())
if err != nil {
log.Printf("Swap: error configuring target: %v\n", err)
return err
}
err = MoveResize(incoming, target_bounds.X(), target_bounds.Y(),
target_bounds.Width(), target_bounds.Height())
if err != nil {
log.Printf("Swap: error configuring incoming: %v\n", err)
return err
}
// cool
return nil
}
func Geometries(win *xwindow.Window) (xrect.Rect, xrect.Rect, error) {
decor, err := win.DecorGeometry()
if err != nil {
return nil, nil, err
}
base, err := win.Geometry()
if err != nil {
return nil, nil, err
}
return decor, base, nil
}
// Put the incoming window on the `dir` side of the target,
// and transform the orthagonal dimension (eg, if `dir` is Up, then dim is `Width`
// to be the same as the target's dimension
// TODO: clip windows to display boundry
func Shove(target, incoming *xwindow.Window, dir Direction) error {
// get geometries
i, err := incoming.DecorGeometry()
if err != nil {
return err
}
t, err := target.DecorGeometry()
if err != nil {
return err
}
// move in the correct direction
if dir == Top {
err := MoveResize(incoming, t.X(), t.Y()-i.Height(), t.Width(), i.Height())
if err != nil {
return err
}
}
if dir == Bottom {
err := MoveResize(incoming, t.X(), t.Y()+t.Height(), t.Width(), i.Height())
if err != nil {
return err
}
}
if dir == Left {
err := MoveResize(incoming, t.X()-i.Width(), t.Y(), i.Width(), t.Height())
if err != nil {
return err
}
}
if dir == Right {
err := MoveResize(incoming, t.X()+t.Width(), t.Y(), i.Width(), t.Height())
if err != nil {
return err
}
}
return nil
}
// move the incoming window so that it is directly adjacent to the target's edge
func AdjoinEdge(target, incoming *xwindow.Window, dir wm.Direction) error {
t, err := target.DecorGeometry()
if err != nil {
return err
}
i, err := incoming.DecorGeometry()
if err != nil {
return err
}
delta := EdgePos(t, dir) - EdgePos(i, dir.Opposite())
if dir == wm.Left || dir == wm.Right {
return wm.Move(incoming, delta+i.X(), i.Y())
} else {
return wm.Move(incoming, i.X(), delta+i.Y())
}
return nil
}
func splitVertical(target, incoming *xwindow.Window, incomingOnTop bool) error {
bounds, err := target.DecorGeometry()
if err != nil {
log.Printf("splitVertical: error getting bounds of target: %v\n", err)
return err
}
bottom_height := bounds.Height() / 2
top_height := bounds.Height() - bottom_height
var top, bottom *xwindow.Window
if incomingOnTop {
top = incoming
bottom = target
} else {
top = target
bottom = incoming
}
// target goes on bottom...
err = MoveResize(bottom, bounds.X(), bounds.Y()+top_height, bounds.Width(), bottom_height)
if err != nil {
log.Printf("splitVertical: error configuring bottom: %v\n", err)
return err
}
// and incoming on top
err = MoveResize(top, bounds.X(), bounds.Y(), bounds.Width(), top_height)
if err != nil {
log.Printf("splitVertical: error configuring top: %v\n", err)
return err
}
// cool
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)
}
