// maybe move to apps-builder
func (m *ClientManager) CloseWindow(xid uint32) bool {
err := ewmh.CloseWindow(XU, xproto.Window(xid))
if err != nil {
logger.Warning("Close window failed:", err)
return false
}
return true
}
//DispatchKeys interface method
func (sw *Switcher) DispatchKeys(t *sdl.KeyDownEvent) int {
app := sw.App
T := app.Widget
key := sdl.GetScancodeName(t.Keysym.Scancode)
if (key == "N" && t.Keysym.Mod == 64) || key == "Down" {
T.SetLine(sw.Selected, sw.getLine(sw.Selected, sw.Clients[sw.Selected], false))
if sw.Selected < len(sw.Clients)-1 {
sw.Selected++
} else {
sw.Selected = 0
}
T.SetLine(sw.Selected, sw.getLine(sw.Selected, sw.Clients[sw.Selected], true))
return 1
}
if (key == "P" && t.Keysym.Mod == 64) || key == "Up" {
T.SetLine(sw.Selected, sw.getLine(sw.Selected, sw.Clients[sw.Selected], false))
if sw.Selected > 0 {
sw.Selected--
} else {
sw.Selected = len(sw.Clients) - 1
}
T.SetLine(sw.Selected, sw.getLine(sw.Selected, sw.Clients[sw.Selected], true))
return 1
}
if key == "X" && t.Keysym.Mod == 64 {
wid := sw.Clients[sw.Selected].WID
ewmh.CloseWindow(X, wid)
sdl.Delay(500)
sw.Clients = GetClients()
sw.Draw()
return 1
}
if (key == "J" && t.Keysym.Mod == 64) || key == "Return" {
wid := sw.Clients[sw.Selected].WID
ewmh.ActiveWindowReq(X, wid)
return 0
}
if strings.Index("0123456789", key) > -1 {
i, err := strconv.Atoi(key)
if err == nil && len(sw.Clients) > i {
sw.Selected = i
if t.Keysym.Mod == 64 {
wid := sw.Clients[sw.Selected].WID
ewmh.ActiveWindowReq(X, wid)
return 0
}
sw.Draw()
return 1
}
}
if t.Keysym.Sym == sdl.K_ESCAPE || t.Keysym.Sym == sdl.K_CAPSLOCK {
return 0
}
return 1
}
func (Cmd *TasksCommand) task(line string) int {
// wid := client.WID
tokens := strings.Split(strings.ToLower(line), " ")
name := tokens[len(tokens)-1]
var client Client
for _, client = range Cmd.Clients {
if strings.ToLower(client.Class) == name {
break
}
}
if strings.ToLower(client.Class) != name {
return 1
}
if strings.HasPrefix(line, "x ") {
ewmh.CloseWindow(X, client.WID)
return 0
}
ewmh.ActiveWindowReq(X, client.WID)
return 0
}
func main() {
X, Xerr = xgbutil.NewConn()
if Xerr != nil {
panic(Xerr)
}
active, _ := ewmh.ActiveWindowGet(X)
parent, _ := xwindow.ParentWindow(X, active)
actOpacity, _ := ewmh.WmWindowOpacityGet(X, parent)
fmt.Printf("Opacity for active window: %f\n", actOpacity)
showDesk, _ := ewmh.ShowingDesktopGet(X)
fmt.Printf("Showing desktop? %v\n", showDesk)
wmName, err := ewmh.GetEwmhWM(X)
if err != nil {
fmt.Printf("No conforming window manager found... :-(\n")
fmt.Println(err)
} else {
fmt.Printf("Window manager: %s\n", wmName)
}
pager := xproto.Window(0x160001e)
middle := xproto.Window(0x3200016)
geom, _ := ewmh.DesktopGeometryGet(X)
desktops, _ := ewmh.DesktopNamesGet(X)
curdesk, _ := ewmh.CurrentDesktopGet(X)
clients, _ := ewmh.ClientListGet(X)
activeName, _ := ewmh.WmNameGet(X, active)
fmt.Printf("Active window: %x\n", active)
fmt.Printf("Current desktop: %d\n", curdesk)
fmt.Printf("Client list: %v\n", clients)
fmt.Printf("Desktop geometry: (width: %d, height: %d)\n",
geom.Width, geom.Height)
fmt.Printf("Active window name: %s\n", activeName)
fmt.Printf("Desktop names: %s\n", desktops)
var desk string
if curdesk < len(desktops) {
desk = desktops[curdesk]
} else {
desk = string(curdesk)
}
fmt.Printf("Current desktop: %s\n", desk)
// fmt.Printf("\nChanging current desktop to 25 from %d\n", curdesk)
ewmh.CurrentDesktopSet(X, curdesk)
// fmt.Printf("Current desktop is now: %d\n", ewmh.CurrentDesktop(X))
fmt.Printf("Setting active win to %x\n", middle)
// ewmh.ActiveWindowReq(X, middle)
rand.Seed(int64(time.Now().Nanosecond()))
randStr := make([]byte, 20)
for i, _ := range randStr {
if rf := rand.Float32(); rf < 0.40 {
randStr[i] = byte('a' + rand.Intn('z'-'a'))
} else if rf < 0.80 {
randStr[i] = byte('A' + rand.Intn('Z'-'A'))
} else {
randStr[i] = ' '
}
}
ewmh.WmNameSet(X, active, string(randStr))
newName, _ := ewmh.WmNameGet(X, active)
fmt.Printf("New name: %s\n", newName)
// deskNames := ewmh.DesktopNamesGet(X)
// fmt.Printf("Desktop names: %s\n", deskNames)
// deskNames[len(deskNames) - 1] = "xgbutil"
// ewmh.DesktopNamesSet(X, deskNames)
// fmt.Printf("Desktop names: %s\n", ewmh.DesktopNamesGet(X))
supported, _ := ewmh.SupportedGet(X)
fmt.Printf("Supported hints: %v\n", supported)
fmt.Printf("Setting supported hints...\n")
ewmh.SupportedSet(X, []string{"_NET_CLIENT_LIST", "_NET_WM_NAME",
"_NET_WM_DESKTOP"})
numDesks, _ := ewmh.NumberOfDesktopsGet(X)
fmt.Printf("Number of desktops: %d\n", numDesks)
// ewmh.NumberOfDesktopsReq(X.EwmhNumberOfDesktops(X) + 1)
// time.Sleep(time.Second)
// fmt.Printf("Number of desktops: %d\n", ewmh.NumberOfDesktops(X))
viewports, _ := ewmh.DesktopViewportGet(X)
fmt.Printf("Viewports (%d): %v\n", len(viewports), viewports)
// viewports[2].X = 50
// viewports[2].Y = 293
// ewmh.DesktopViewportSet(X, viewports)
// time.Sleep(time.Second)
//
// viewports = ewmh.DesktopViewport(X)
// fmt.Printf("Viewports (%d): %v\n", len(viewports), viewports)
// ewmh.CurrentDesktopReq(X, 3)
visDesks, _ := ewmh.VisibleDesktopsGet(X)
workarea, _ := ewmh.WorkareaGet(X)
fmt.Printf("Visible desktops: %v\n", visDesks)
fmt.Printf("Workareas: %v\n", workarea)
// fmt.Printf("Virtual roots: %v\n", ewmh.VirtualRoots(X))
// fmt.Printf("Desktop layout: %v\n", ewmh.DesktopLayout(X))
fmt.Printf("Closing window %x\n", 0x2e004c5)
ewmh.CloseWindow(X, 0x1e00cdf)
fmt.Printf("Moving/resizing window: %x\n", 0x2e004d0)
ewmh.MoveresizeWindow(X, 0x2e004d0, 1920, 30, 500, 500)
// fmt.Printf("Trying to initiate a moveresize...\n")
// ewmh.WmMoveresize(X, 0x2e004db, xgbutil.EwmhMove)
// time.Sleep(5 * time.Second)
// ewmh.WmMoveresize(X, 0x2e004db, xgbutil.EwmhCancel)
// fmt.Printf("Stacking window %x...\n", 0x2e00509)
// ewmh.RestackWindow(X, 0x2e00509)
fmt.Printf("Requesting frame extents for active window...\n")
ewmh.RequestFrameExtents(X, active)
activeDesk, _ := ewmh.WmDesktopGet(X, active)
activeType, _ := ewmh.WmWindowTypeGet(X, active)
fmt.Printf("Active window's desktop: %d\n", activeDesk)
fmt.Printf("Active's types: %v\n", activeType)
// fmt.Printf("Pager's types: %v\n", ewmh.WmWindowType(X, 0x180001e))
// fmt.Printf("Pager's state: %v\n", ewmh.WmState(X, 0x180001e))
// ewmh.WmStateReq(X, active, xgbutil.EwmhStateToggle,
// "_NET_WM_STATE_HIDDEN")
// ewmh.WmStateReqExtra(X, active, xgbutil.EwmhStateToggle,
// "_NET_WM_STATE_MAXIMIZED_VERT",
// "_NET_WM_STATE_MAXIMIZED_HORZ", 2)
activeAllowed, _ := ewmh.WmAllowedActionsGet(X, active)
fmt.Printf("Allowed actions on active: %v\n", activeAllowed)
struts, err := ewmh.WmStrutGet(X, pager)
if err != nil {
fmt.Printf("Pager struts: %v\n", err)
} else {
fmt.Printf("Pager struts: %v\n", struts)
}
pstruts, err := ewmh.WmStrutPartialGet(X, pager)
if err != nil {
fmt.Printf("Pager struts partial: %v - %v\n", pstruts, err)
} else {
fmt.Printf("Pager struts partial: %v\n", pstruts.BottomStartX)
}
// fmt.Printf("Icon geometry for active: %v\n",
// ewmh.WmIconGeometry(X, active))
icons, _ := ewmh.WmIconGet(X, active)
fmt.Printf("Active window's (%x) icon data: (length: %v)\n",
active, len(icons))
for _, icon := range icons {
fmt.Printf("\t(%d, %d)", icon.Width, icon.Height)
fmt.Printf(" :: %d == %d\n", icon.Width*icon.Height, len(icon.Data))
}
// fmt.Printf("Now set them again...\n")
// ewmh.WmIconSet(X, active, icons[:len(icons) - 1])
}
func (app *RuntimeApp) buildMenu() {
app.coreMenu = NewMenu()
itemName := strings.Title(app.Id)
core := app.createDesktopAppInfo()
if core != nil {
itemName = strings.Title(core.GetDisplayName())
defer core.Unref()
}
app.coreMenu.AppendItem(NewMenuItem(
itemName,
func() {
var a *gio.AppInfo
logger.Debug(itemName)
core := app.createDesktopAppInfo()
if core != nil {
logger.Debug("DesktopAppInfo")
a = (*gio.AppInfo)(core.DesktopAppInfo)
defer core.Unref()
} else {
logger.Debug("Non-DesktopAppInfo", app.exec)
var err error = nil
a, err = gio.AppInfoCreateFromCommandline(
app.exec,
"",
gio.AppInfoCreateFlagsNone,
)
if err != nil {
logger.Warning("Launch App Falied: ", err)
return
}
defer a.Unref()
}
if a == nil {
logger.Warning("create app info to run program failed")
return
}
_, err := a.Launch(make([]*gio.File, 0), nil)
if err != nil {
logger.Warning("Launch App Failed: ", err)
}
},
true,
))
app.coreMenu.AddSeparator()
if core != nil {
for _, actionName := range core.ListActions() {
name := actionName //NOTE: don't directly use 'actionName' with closure in an forloop
app.coreMenu.AppendItem(NewMenuItem(
core.GetActionName(actionName),
func() {
core := app.createDesktopAppInfo()
if core == nil {
return
}
defer core.Unref()
core.LaunchAction(name, nil)
},
true,
))
}
app.coreMenu.AddSeparator()
}
closeItem := NewMenuItem(
Tr("_Close All"),
func() {
logger.Debug("Close All")
for xid := range app.xids {
ewmh.CloseWindow(XU, xid)
}
},
true,
)
app.coreMenu.AppendItem(closeItem)
var err error
if DOCKED_APP_MANAGER == nil {
DOCKED_APP_MANAGER, err = dock.NewDockedAppManager(
"com.deepin.daemon.Dock",
"/dde/dock/DockedAppManager",
)
if err != nil {
logger.Warning("get DockedAppManager failed", err)
return
}
}
isDocked, err := DOCKED_APP_MANAGER.IsDocked(app.Id)
if err != nil {
isDocked = false
logger.Warning("get docked status failed:", err)
}
logger.Info(app.Id, "Item is docked:", isDocked)
var message string = ""
var action func() = nil
if isDocked {
logger.Info(app.Id, "change to undock")
message = Tr("_Undock")
action = func(id string) func() {
return func() {
app, ok := ENTRY_MANAGER.runtimeApps[id]
if !ok {
return
}
DOCKED_APP_MANAGER.Undock(app.Id)
}
}(app.Id)
} else {
logger.Info(app.Id, "change to dock")
message = Tr("_Dock")
action = actionGenarator(app.Id)
}
logger.Debug(app.Id, "New Menu Item:", message)
dockItem := NewMenuItem(message, action, true)
app.coreMenu.AppendItem(dockItem)
app.Menu = app.coreMenu.GenerateJSON()
app.notifyChanged()
}
