// AddButtonsEntry adds an item with button entries to the menu. // func (m *DockMenu) AddButtonsEntry(label string, btns ...MenuBtn) *menus.ButtonsEntry { entry := m.Menu.AddButtonsEntry(label) for _, btnID := range btns { switch btnID { case MenuWindowClose: entry.AddButton( tran.Slate("Close")+actionMiddleClick(m.Icon, 1), globals.DirShareData("icons", "icon-close.svg"), m.Icon.CallbackActionWindow((cdglobal.Window).Close)) case MenuWindowCloseAll: entry.AddButton( tran.Slate("Close all")+actionMiddleClick(m.Icon, 1), globals.DirShareData("icons", "icon-close.svg"), m.Icon.CallbackActionSubWindows((cdglobal.Window).Close)) case MenuWindowMax: max := m.Icon.Window().IsMaximized() entry.AddButton( ternary.String(max, tran.Slate("Unmaximise"), tran.Slate("Maximise")), globals.DirShareData("icons", ternary.String(max, "icon-restore.svg", "icon-maximize.svg")), m.Icon.CallbackActionWindowToggle((cdglobal.Window).Maximize, (cdglobal.Window).IsMaximized)) case MenuWindowMin: entry.AddButton( tran.Slate("Minimise")+actionMiddleClick(m.Icon, 2), globals.DirShareData("icons", "icon-minimize.svg"), m.Icon.CallbackActionWindow((cdglobal.Window).Minimize)) case MenuWindowMinAll: entry.AddButton( tran.Slate("Minimise all")+actionMiddleClick(m.Icon, 2), globals.DirShareData("icons", "icon-minimize.svg"), m.Icon.CallbackActionSubWindows((cdglobal.Window).Minimize)) case MenuWindowShow: entry.AddButton( tran.Slate("Show"), globals.IconNameFind, m.Icon.CallbackActionWindow((cdglobal.Window).Show)) case MenuWindowShowAll: entry.AddButton( tran.Slate("Show all"), globals.IconNameFind, m.Icon.CallbackActionSubWindows((cdglobal.Window).Show)) default: log.NewWarn(fmt.Sprintf("invalid id: %d", btnID), "AddButtonsEntry") } } return entry }
func init() { dirShareData = globals.DirShareData() iconCore = globals.FileCairoDockIcon() AppletInfo = func(log cdtype.Logger, name string) (dir, icon string) { mod := gldi.ModuleGet(name) if mod == nil { return "", "" } vc := mod.VisitCard() return vc.GetShareDataDir(), vc.GetIconFilePath() } AppletRestart = func(name string) { mod := gldi.ModuleGet(name) if mod == nil { return } for _, mi := range mod.InstancesList() { gldi.ObjectDelete(mi) } mod.Activate() } CloseGui = backendgui.CloseGui }
func getChangelog() string { changelogPath := globals.DirShareData(cdglobal.FileChangelog) msg := "" e := config.GetFromFile(log, changelogPath, func(cfg cdtype.ConfUpdater) { major, minor, micro := globals.VersionSplit() // Get first line strver := fmt.Sprintf("%d.%d.%d", major, minor, micro) // version without "alpha", "beta", "rc", etc. msg = cfg.Valuer("ChangeLog", strver).String() if msg == "" { log.Debug("changelog", "no info for version", globals.Version()) return } msg = tran.Slate(msg) // Add all changelog lines for that version. i := 0 for { strver := fmt.Sprintf("%d.%d.%d.%d", major, minor, micro, i) sub := cfg.Valuer("ChangeLog", strver).String() msg += "\n " + tran.Slate(sub) i++ } }) log.Err(e, "load changelog", changelogPath) return msg }
func (o *AppManager) registerApplets() { dir := globals.DirShareData(cdglobal.ConfigDirAppletsGo) packs, e := packages.ListFromDir(o.log, dir, packages.TypeGoInternal, packages.SourceApplet) if o.log.Err(e, "registerapplets") { return } for _, pack := range packs { if cdtype.Applets.GetNewFunc(pack.DisplayedName) != nil { o.registerOneApplet(pack) } } }
func createConfigDir(settings *DockSettings) { log.Info("creating configuration directory", globals.DirDockData()) themeName := "Default-Single" if os.Getenv("DESKTOP_SESSION") == "cairo-dock" { // We're using the CD session for the first time themeName = "Default-Panel" settings.sessionWasUsed = true updateHiddenFile("cd session", true) } files.CopyDir(globals.DirShareData(cdglobal.ConfigDirDockThemes, themeName), globals.CurrentThemePath()) }
// Init will try to load the own config data from the file, and create it if missing. // func Init(log cdtype.Logger, file string, e error) error { if e != nil { return e } // Create file if needed. if !files.IsExist(file) { source := globals.DirShareData(GuiFilename) e := files.CopyFile(source, file, os.FileMode(0644)) if e != nil { return e } log.Info("created config file", file) } // Create our user settings Settings = ConfigSettings{ File: file, log: log, } return Settings.Load() }
// Init is the first step to initialize the dock. // func (settings *DockSettings) Init() { confdir := cdglobal.ConfigDirDock(settings.UserDefinedDataDir) settings.isFirstLaunch = !files.IsExist(confdir) // TODO: need test is dir. hidden := loadHidden(confdir) settings.isNewVersion = hidden.LastVersion != globals.Version() settings.sessionWasUsed = hidden.SessionWasUsed // MISSING // //\___________________ build the command line used to respawn, and check if we have been launched from another life. // mute all output messages if CD is not launched from a terminal // if (getenv("TERM") == NULL) /// why not isatty(stdout) ?... // g_set_print_handler(PrintMuteFunc); gldi.DbusGThreadInit() // it's a wrapper: it will use dbus_threads_init_default (); gtk.Init(nil) //\___________________ C dock log. if settings.Verbosity != "" { gldi.LogSetLevelFromName(settings.Verbosity) } if settings.ForceColor { gldi.LogForceUseColor() } //\___________________ delay the startup if specified. if settings.Delay > 0 { <-time.After(time.Duration(settings.Delay) * time.Second) } //\___________________ initialize libgldi. var rendering gldi.RenderingMethod switch { case settings.ForceOpenGL: rendering = gldi.RenderingOpenGL case settings.ForceCairo: rendering = gldi.RenderingCairo default: rendering = gldi.RenderingDefault } gldi.Init(int(rendering)) //\___________________ set custom user options. if settings.KeepAbove { gldi.ForceDocksAbove() } if settings.NoSticky { gldi.SetContainersNonSticky() } if settings.MetacityWorkaround { gldi.DisableContainersOpacity() } env := DesktopEnvironment(settings.Env) if env != gldi.DeskEnvUnknown { gldi.FMForceDeskEnv(env) } if settings.IndirectOpenGL { gldi.GLBackendForceIndirectRendering() } if settings.ThemeServer == "" { settings.ThemeServer = cdglobal.DownloadServerURL } gldi.SetPaths(confdir, // will later be available as DirDockData (g_cCairoDockDataDir) cdglobal.ConfigDirExtras, cdglobal.ConfigDirDockThemes, cdglobal.ConfigDirCurrentTheme, cdglobal.CairoDockShareThemesDir, cdglobal.DockThemeServerTag, settings.ThemeServer) about.Img = globals.DirShareData(cdglobal.ConfigDirDockImages, cdglobal.FileCairoDockLogo) //\___________________ Check that OpenGL is safely usable, if not ask the user what to do. // Unsafe OpenGL requires to be confirmed to use (need forced in conf or user validation). if settings.AskBackend || (gldi.GLBackendIsUsed() && !gldi.GLBackendIsSafe() && !settings.ForceOpenGL && !settings.IndirectOpenGL) { if settings.AskBackend || hidden.DefaultBackend == "" { // no backend defined. dialogAskBackend() } else if hidden.DefaultBackend != "opengl" { // disable opengl if unused, revert to cairo. gldi.GLBackendDeactivate() } } // Remove excluded applets. for _, name := range settings.Exclude { cdtype.Applets.Unregister(name) } //\___________________ load plug-ins (must be done after everything is initialized). if !settings.SafeMode { err := gldi.ModulesNewFromDirectory("") log.Err(err, "no module will be available") if settings.ModulesDir != "" { err := gldi.ModulesNewFromDirectory(settings.ModulesDir) log.Err(err, "no additionnal module will be available") } } }
func firstLaunchSetup() { log.Info("firstLaunchScript", globals.DirShareData("scripts", "initial-setup.sh")) log.ExecShow(globals.DirShareData("scripts", "initial-setup.sh")) }
// ListIcons builds the list of all icons. // func (Data) ListIcons() *datatype.ListIcon { list := datatype.NewListIcon() // Add icons in docks. taskbarSet := false for _, dock := range gldi.GetAllAvailableDocks(nil, nil) { // for _, dock := range gldi.ListDocksRoot() { var found []datatype.Iconer for _, icon := range dock.Icons() { if dock.GetRefCount() == 0 { // Maindocks. // Group taskbar icons and separators. if icon.ConfigPath() == "" || icon.IsSeparatorAuto() { // if icon.IsTaskbar() || icon.IsSeparatorAuto() { if !taskbarSet { taskbarSet = true ic := datatype.NewIconSimple( globals.ConfigFile(), datatype.FieldTaskBar, datatype.TitleTaskBar, globals.DirShareData("icons/icon-taskbar.png")) ic.Taskbar = true found = append(found, ic) } } else { found = append(found, &IconConf{icon}) } } else { // Subdock. parentName := icon.GetParentDockName() list.Subdocks[parentName] = append(list.Subdocks[parentName], &IconConf{icon}) } } if len(found) > 0 { var file, group string if dock.IsMainDock() { // Only maindocks after the first one have a config file. // So the first maindock use a custom group. group = datatype.KeyMainDock } else { // Other maindocks have a dedicated config file. // So the group is empty to load all of them (auto find). file = globals.CurrentThemePath(dock.GetDockName() + ".conf") } container := datatype.NewIconSimple( file, group, dock.GetReadableName(), "") // TODO: maybe get an icon for the maindock. list.Add(container, found) } } // Add modules in desklets. var desklets []datatype.Iconer for _, desklet := range docklist.Desklet() { icon := desklet.GetIcon() if icon != nil { desklets = append(desklets, &IconConf{icon}) } } if len(desklets) > 0 { container := datatype.NewIconSimple( globals.ConfigFile(), datatype.GroupDesklets, datatype.TitleDesklets, "") // TODO: maybe get an icon for the desklets group. list.Add(container, desklets) } // Add other modules (not in a dock or a desklet) : plug-in or detached applet. // We need to create custom icons for them. var services []datatype.Iconer for _, mod := range docklist.Module() { cat := mod.VisitCard().GetCategory() if cat != gldi.CategoryBehavior && cat != gldi.CategoryTheme && !mod.IsAutoLoaded() { for _, mi := range mod.InstancesList() { if mi.Icon() == nil || (mi.Dock() != nil && mi.Icon().GetContainer() == nil) { icon := datatype.NewIconSimple( mi.GetConfFilePath(), "", // no group, we need all of them for an applet. mod.VisitCard().GetTitle(), mod.VisitCard().GetIconFilePath()) services = append(services, icon) } } } } if len(services) > 0 { container := datatype.NewIconSimple( "", // no config file available. datatype.GroupServices, // so we set a custom group. tran.Slate(datatype.TitleServices), "") // TODO: maybe get an icon for the services group. list.Add(container, services) } return list }
// DirShareData returns the path to the shared data dir. func (Data) DirShareData(path ...string) string { return globals.DirShareData(path...) }
func (v *dockTheme) IconState() string { return globals.DirShareData(v.AppletPackage.IconState()) }
// IconState returns the icon location for the state for the applet. // func (v *AppletDownload) IconState() string { return globals.DirShareData(v.AppletPackage.IconState()) }
// Entry adds a defined entry to the menu. Returns if a separator is needed. // func (m *DockMenu) Entry(entry MenuEntry) bool { switch entry { case MenuAbout: m.AddEntry( tran.Slate("About"), globals.IconNameAbout, about.New, ) case MenuAddApplet: m.AddEntry( tran.Slate("Applet"), globals.IconNameAdd, backendgui.ShowAddons) case MenuAddLauncher: m.AddEntry( tran.Slate("Custom launcher"), globals.IconNameAdd, func() { newIcon := gldi.LauncherAddNew("", m.Dock, nextOrder(m.Icon, m.Dock)) if newIcon == nil { // TODO: use log println("Couldn't create create the icon.\nCheck that you have writing permissions on ~/.config/cairo-dock and its sub-folders") } else { backendgui.ShowItems(newIcon, nil, nil, -1) } }, ).SetTooltipText(tran.Slate("Usually you would drag a launcher from the menu and drop it on the dock.")) case MenuAddMainDock: m.AddEntry( tran.Slate("Main dock"), globals.IconNameAdd, func() { key := gldi.DockAddConfFile() gldi.DockNew(key) backendgui.ReloadItems() // g_timeout_add_seconds (1, (GSourceFunc)_show_new_dock_msg, cDockName); // delai, car sa fenetre n'est pas encore bien placee (0,0). }) case MenuAddSeparator: m.AddEntry( tran.Slate("Separator"), globals.IconNameAdd, func() { newIcon := gldi.SeparatorIconAddNew(m.Dock, nextOrder(m.Icon, m.Dock)) if newIcon == nil { // TODO: use log println("Couldn't create create the icon.\nCheck that you have writing permissions on ~/.config/cairo-dock and its sub-folders") } }) case MenuAddSubDock: m.AddEntry( tran.Slate("Sub-dock"), globals.IconNameAdd, func() { newIcon := gldi.StackIconAddNew(m.Dock, nextOrder(m.Icon, m.Dock)) if newIcon == nil { // TODO: use log println("Couldn't create create the icon.\nCheck that you have writing permissions on ~/.config/cairo-dock and its sub-folders") } }) case MenuClassItems: //\_________________________ class actions. items := m.Icon.GetClass().MenuItems() for _, it := range items { cmd := strings.Fields(it[1]) m.AddEntry( it[0], // name it[2], // icon func() { log.ExecAsync(cmd[0], cmd[1:]...) }) // was gldi.LaunchCommand(cmd) } return len(items) > 0 case MenuConfigure: m.AddEntry( tran.Slate("Configure"), globals.IconNamePreferences, backendgui.ShowMainGui, ).SetTooltipText(tran.Slate("Configure behaviour, appearance, and applets.")) case MenuCustomIconRemove: classIcon := m.Icon.GetClass().Icon() if classIcon == "" { classIcon = m.Icon.GetClass().String() } path := filepath.Join(globals.DirCurrentIcons(), classIcon+".png") if _, e := os.Stat(path); e != nil { path = filepath.Join(globals.DirCurrentIcons(), classIcon+".svg") if _, e := os.Stat(path); e != nil { path = "" } } // println("custom icon", path) if path != "" { m.AddEntry( tran.Slate("Remove custom icon"), globals.IconNameRemove, func() { C._cairo_dock_remove_custom_appli_icon((*C.Icon)(unsafe.Pointer(m.Icon.ToNative())), (*C.CairoDock)(unsafe.Pointer(m.Dock.Ptr))) }) } case MenuCustomIconSet: m.AddEntry( tran.Slate("Set a custom icon"), globals.IconNameSelectColor, func() { C._cairo_dock_set_custom_appli_icon((*C.Icon)(unsafe.Pointer(m.Icon.ToNative())), (*C.CairoDock)(unsafe.Pointer(m.Dock.Ptr))) }) case MenuDeleteDock: m.AddEntry( tran.Slate("Delete this dock"), globals.IconNameDelete, func() { if m.Dock.GetRefCount() != 0 { dialog.ShowWithQuestion("Delete this dock?", m.Dock.GetPointedIcon(), m.Container, globals.FileCairoDockIcon(), cbDialogIsOK(func() { gldi.ObjectDelete(m.Dock) })) } }) case MenuDeskletLock: desklet := m.Container.ToDesklet() m.AddCheckEntry( tran.Slate("Lock position"), desklet.PositionLocked(), func(c *gtk.CheckMenuItem) { desklet.LockPosition(c.GetActive()) backendgui.UpdateDeskletVisibility(desklet) }) case MenuDeskletSticky: desklet := m.Container.ToDesklet() m.AddCheckEntry( tran.Slate("On all desktops"), m.Container.ToDesklet().IsSticky(), func(c *gtk.CheckMenuItem) { desklet.SetSticky(c.GetActive()) // TODO: check why SetSticky isn't working... println("get stick", desklet.IsSticky()) backendgui.UpdateDeskletVisibility(desklet) }) case MenuDeskletVisibility: submenu := m.AddSubMenu(tran.Slate("Visibility"), globals.IconNameFind) desklet := m.Container.ToDesklet() callback := func(radio *gtk.RadioMenuItem, val cdtype.DeskletVisibility) { if radio.GetActive() { desklet.SetVisibility(val, true) // with true, also save to conf. backendgui.UpdateDeskletVisibility(desklet) } } group := 42 visibility := desklet.Visibility() addRadio := func(vis cdtype.DeskletVisibility, label string) { radio := submenu.AddRadioEntry(label, visibility == vis, group, nil) radio.Connect("toggled", callback, vis) } addRadio(cdtype.DeskletVisibilityNormal, tran.Slate("Normal")) addRadio(cdtype.DeskletVisibilityKeepAbove, tran.Slate("Always on top")) addRadio(cdtype.DeskletVisibilityKeepBelow, tran.Slate("Always below")) if gldi.CanSetOnWidgetLayer() { addRadio(cdtype.DeskletVisibilityWidgetLayer, tran.Slate("Widget Layer")) } addRadio(cdtype.DeskletVisibilityReserveSpace, tran.Slate("Reserve space")) case MenuDetachApplet: m.AddEntry( ternary.String(m.Dock != nil, tran.Slate("Detach"), tran.Slate("Return to the dock")), ternary.String(m.Dock != nil, globals.IconNameGotoTop, globals.IconNameGotoBottom), func() { // if (CAIRO_DOCK_IS_DESKLET (pContainer)) // icon = (CAIRO_DESKLET (pContainer))->pIcon; // l'icone cliquee du desklet n'est pas forcement celle qui contient le module ! // g_return_if_fail (CAIRO_DOCK_IS_APPLET (icon)); m.Icon.ModuleInstance().Detach() }) case MenuDuplicateApplet: m.AddEntry( tran.Slate("Duplicate"), globals.IconNameAdd, func() { // if (CAIRO_DOCK_IS_DESKLET (pContainer)) // icon = (CAIRO_DESKLET (pContainer))->pIcon; // l'icone cliquee du desklet n'est pas forcement celle qui contient le module ! // g_return_if_fail (CAIRO_DOCK_IS_APPLET (icon)); m.Icon.ModuleInstance().Module().AddInstance() // gldi_module_add_instance (icon->pModuleInstance->pModule); }) case MenuEditApplet: m.AddEntry( tran.Slate("Edit"), globals.IconNameEdit, func() { // if (CAIRO_DOCK_IS_DESKLET (pContainer)) // icon = (CAIRO_DESKLET (pContainer))->pIcon; // l'icone cliquee du desklet n'est pas forcement celle qui contient le module. // g_return_if_fail (CAIRO_DOCK_IS_APPLET (icon)); backendgui.ShowItems(m.Icon, nil, nil, -1) }) case MenuEditDock: m.AddEntry( tran.Slate("Configure this dock"), globals.IconNameExecute, func() { backendgui.ShowItems(nil, m.Container, nil, 0) }, ).SetTooltipText(tran.Slate("Customize the position, visibility and appearance of this main dock.")) case MenuEditIcon: m.AddEntry(tran.Slate( tran.Slate("Edit")), globals.IconNameEdit, func() { switch m.Icon.GetDesktopFileName() { case "", "none": dialog.ShowTemporaryWithIcon("Sorry, this icon doesn't have a configuration file.", m.Icon, m.Container, 4000, "same icon") default: backendgui.ShowItems(m.Icon, nil, nil, -1) } }) case MenuEditTarget: _, img := m.Icon.DefaultNameIcon() m.AddEntry( tran.Slate("Edit icon"), img, func() { // if (CAIRO_DOCK_IS_DESKLET (pContainer)) // icon = (CAIRO_DESKLET (pContainer))->pIcon; // l'icone cliquee du desklet n'est pas forcement celle qui contient le module. // g_return_if_fail (CAIRO_DOCK_IS_APPLET (icon)); backendgui.ShowItems(m.Icon, nil, nil, -1) }) case MenuHandbook: m.AddEntry( tran.Slate("Applet's handbook"), globals.IconNameAbout, m.Icon.ModuleInstance().PopupAboutApplet) // handbook + 5x to facto // picon := icon // if container.IsDesklet() { // picon = container.Icon() // icon = (CAIRO_DESKLET (pContainer))->pIcon; // l'icone cliquee du desklet n'est pas forcement celle qui contient le module ! // } case MenuHelp: m.AddEntry( tran.Slate("Help"), globals.IconNameHelp, func() { backendgui.ShowModuleGui("Help") }, ).SetTooltipText(tran.Slate("There are no problems, only solutions (and a lot of useful hints!)")) case MenuLaunchNew: m.AddEntry( tran.Slate("Launch a new (Shift+clic)"), globals.IconNameAdd, func() { m.Icon.LaunchCommand(log) }) case MenuLockIcons: m.AddCheckEntry( tran.Slate("Lock icons position"), current.Docks.LockIcons(), func() { current.Docks.LockIcons(!current.Docks.LockIcons()) config.UpdateFile(log, globals.ConfigFile(), "Accessibility", "lock icons", current.Docks.LockIcons()) }, ).SetTooltipText(tran.Slate("This will (un)lock the position of the icons.")) case MenuMakeLauncher: m.AddEntry( tran.Slate("Make it a launcher"), globals.IconNameNew, func() { C._cairo_dock_make_launcher_from_appli((*C.Icon)(unsafe.Pointer(m.Icon.ToNative())), (*C.CairoDock)(unsafe.Pointer(m.Dock.Ptr))) }) case MenuMoveToDesktopClass: m.moveToDesktop(true) case MenuMoveToDesktopWindow: m.moveToDesktop(false) case MenuMoveToDock: sub := m.AddSubMenu(tran.Slate("Move to another dock"), globals.IconNameJumpTo) docks := gldi.GetAllAvailableDocks(m.Icon.GetContainer().ToCairoDock(), m.Icon.GetSubDock()) docks = append(docks, nil) for _, dock := range docks { name := "" key := "" icon := "" if dock == nil { name = tran.Slate("New main dock") icon = globals.IconNameAdd // globals.IconNameNew } else { name = ternary.String(dock.GetReadableName() != "", dock.GetReadableName(), dock.GetDockName()) key = dock.GetDockName() if dock.GetRefCount() == 0 { // Maindocks icon switch dock.Container().ScreenBorder() { case cdtype.ContainerPositionBottom: icon = "go-down" case cdtype.ContainerPositionTop: icon = "go-up" case cdtype.ContainerPositionLeft: icon = "go-previous" case cdtype.ContainerPositionRight: icon = "go-next" } } else { // Subdocks icon. dockicon := dock.SearchIconPointingOnDock(nil) if dockicon != nil { icon = dockicon.GetFileName() } } } sub.AddEntry( name, icon, func() { if key == "" { key = gldi.DockAddConfFile() } m.Icon.WriteContainerNameInConfFile(key) // Update icon conf file. if m.Icon.IsLauncher() || m.Icon.IsStackIcon() || m.Icon.IsSeparator() { // Reload icon (creating the dock). gldi.ObjectReload(m.Icon) } else if m.Icon.IsApplet() { gldi.ObjectReload(m.Icon.ModuleInstance()) } newdock := gldi.DockGet(key) if newdock != nil && newdock.GetRefCount() == 0 && len(newdock.Icons()) == 1 { str := tran.Slate("The new dock has been created.\nYou can customize it by right-clicking on it -> cairo-dock -> configure this dock.") dialog.ShowGeneralMessage(str, 8000) // we don't show it on the new dock as its window isn't positioned yet (0,0). } }) } case MenuQuickHide: m.AddEntry( tran.Slate("Quick-Hide"), globals.IconNameGotoBottom, gldi.QuickHideAllDocks, ).SetTooltipText(tran.Slate("This will hide the dock until you hover over it with the mouse.")) case MenuQuit: item := m.AddEntry( tran.Slate("Quit"), globals.IconNameQuit, func() { backendgui.CloseGui() // gtk.MainQuit() // TODO: remove SQP HACK, easy quit no confirm for tests. dialog.ShowWithQuestion("Quit Cairo-Dock?", GetIconForDesklet(m.Icon, m.Container), m.Container, globals.FileCairoDockIcon(), cbDialogIsOK(gtk.MainQuit)) }) // const gchar *cDesktopSession = g_getenv ("DESKTOP_SESSION"); // gboolean bIsCairoDockSession = cDesktopSession && g_str_has_prefix (cDesktopSession, "cairo-dock"); // // if we're using a Cairo-Dock session and we quit the dock we have... nothing to relaunch it! // if bIsCairoDockSession { // item.SetSensitive(false) // item.SetTooltipText("You're using a Cairo-Dock Session!\nIt's not advised to quit the dock but you can press Shift to unlock this menu entry.") // static void _cairo_dock_set_sensitive_quit_menu (G_GNUC_UNUSED GtkWidget *pMenuItem, GdkEventKey *pKey, GtkWidget *pQuitEntry) // { // pMenuItem not used because we want to only modify one entry // if (pKey->type == GDK_KEY_PRESS && // (pKey->keyval == GDK_KEY_Shift_L || // pKey->keyval == GDK_KEY_Shift_R)) // pressed // gtk_widget_set_sensitive (pQuitEntry, TRUE); // unlocked // else if (pKey->state & GDK_SHIFT_MASK) // released // gtk_widget_set_sensitive (pQuitEntry, FALSE); // locked) // } cbSensitive := func(_ *gtk.CheckMenuItem, event *gdk.Event) { key := &gdk.EventKey{Event: event} println("key", key.KeyVal()) if key.KeyVal() == uint(C.GDK_KEY_Shift_R) { // pressed. item.SetSensitive(true) } else if gdk.ModifierType(key.State())&gdk.GDK_SHIFT_MASK > 0 { // released. item.SetSensitive(false) } } _, e := item.Connect("key-press-event", cbSensitive) if e != nil { println((e.Error())) } item.Connect("key-release-event", cbSensitive) // gtk_widget_set_sensitive (pMenuItem, FALSE); // locked // gtk_widget_set_tooltip_text (pMenuItem, _("You're using a Cairo-Dock Session!\nIt's not advised to quit the dock but you can press Shift to unlock this menu entry.")); // // signal to unlock the entry (signal monitored only in the submenu) // g_signal_connect (pSubMenu, "key-press-event", G_CALLBACK (_cairo_dock_set_sensitive_quit_menu), pMenuItem); // g_signal_connect (pSubMenu, "key-release-event", G_CALLBACK (_cairo_dock_set_sensitive_quit_menu), pMenuItem); // } // case MenuAutostart: // gchar *cCairoAutoStartDirPath = g_strdup_printf ("%s/.config/autostart", g_getenv ("HOME")); // gchar *cCairoAutoStartEntryPath = g_strdup_printf ("%s/cairo-dock.desktop", cCairoAutoStartDirPath); // gchar *cCairoAutoStartEntryPath2 = g_strdup_printf ("%s/cairo-dock-cairo.desktop", cCairoAutoStartDirPath); // if (! bIsCairoDockSession && ! g_file_test (cCairoAutoStartEntryPath, G_FILE_TEST_EXISTS) && ! g_file_test (cCairoAutoStartEntryPath2, G_FILE_TEST_EXISTS)) // { // cairo_dock_add_in_menu_with_stock_and_data (_("Launch Cairo-Dock on startup"), // GLDI_ICON_NAME_ADD, // G_CALLBACK (_cairo_dock_add_autostart), // pSubMenu, // NULL); // } // g_free (cCairoAutoStartEntryPath); // g_free (cCairoAutoStartEntryPath2); // g_free (cCairoAutoStartDirPath); // case MenuThirdParty: // pMenuItem = cairo_dock_add_in_menu_with_stock_and_data (_("Get more applets!"), // GLDI_ICON_NAME_ADD, // G_CALLBACK (_cairo_dock_show_third_party_applets), // pSubMenu, // NULL); // gtk_widget_set_tooltip_text (pMenuItem, _("Third-party applets provide integration with many programs, like Pidgin")); case MenuRemoveApplet: m.AddEntry( tran.Slate("Remove"), globals.IconNameRemove, func() { // if (CAIRO_DOCK_IS_DESKLET (pContainer)) // icon = (CAIRO_DESKLET (pContainer))->pIcon; // l'icone cliquee du desklet n'est pas forcement celle qui contient le module ! // g_return_if_fail (CAIRO_DOCK_IS_APPLET (icon)); dialog.ShowWithQuestion( fmt.Sprintf("You're about to remove this applet (%s) from the dock. Are you sure?", m.Icon.ModuleInstance().Module().VisitCard().GetTitle()), m.Icon, m.Container, "same icon", cbDialogIsOK(func() { gldi.ObjectDelete(m.Icon.ModuleInstance()) })) }) case MenuRemoveIcon: m.AddEntry( tran.Slate("Remove"), globals.IconNameRemove, func() { name := ternary.String(m.Icon.GetInitialName() != "", m.Icon.GetInitialName(), m.Icon.GetName()) if name == "" { name = ternary.String(m.Icon.IsSeparator(), tran.Slate("separator"), "no name") } dialog.ShowWithQuestion( fmt.Sprintf(tran.Slate("You're about to remove this icon (%s) from the dock. Are you sure?"), name), m.Icon, m.Container, "same icon", cbDialogIsOK(func() { if m.Icon.IsStackIcon() && m.Icon.GetSubDock() != nil && len(m.Icon.GetSubDock().Icons()) > 0 { dialog.ShowWithQuestion( tran.Slate("Do you want to re-dispatch the icons contained inside this container into the dock?\n(otherwise they will be destroyed)"), m.Icon, m.Container, globals.FileCairoDockIcon(), cbDialogIsOK(func() { m.Icon.RemoveIconsFromSubdock(m.Dock) })) } m.Icon.RemoveFromDock() })) }).SetTooltipText(tran.Slate("You can remove a launcher by dragging it out of the dock with the mouse .")) case MenuThemes: // pMenuItem = cairo_dock_add_in_menu_with_stock_and_data (_("Manage themes"), // CAIRO_DOCK_SHARE_DATA_DIR"/icons/icon-appearance.svg", // G_CALLBACK (_cairo_dock_initiate_theme_management), // pSubMenu, // NULL); // gtk_widget_set_tooltip_text (pMenuItem, _("Choose from amongst many themes on the server or save your current theme.")); case MenuWindowAbove: flag := m.Icon.Window().IsAbove() m.AddEntry( ternary.String(flag, tran.Slate("Don't keep above"), tran.Slate("Keep above")), ternary.String(flag, globals.IconNameGotoBottom, globals.IconNameGotoTop), m.Icon.CallbackActionWindowToggle((cdglobal.Window).SetAbove, (cdglobal.Window).IsAbove)) case MenuWindowBelow: if !m.Icon.Window().IsHidden() { // this could be a button in the menu, if we find an icon that doesn't look too much like the "minimise" one m.AddEntry( tran.Slate("Below other windows")+actionMiddleClick(m.Icon, 4), globals.DirShareData("icons", "icon-lower.svg"), m.Icon.CallbackActionWindow((cdglobal.Window).Lower)) } case MenuWindowFullScreen: flag := m.Icon.Window().IsFullScreen() m.AddEntry( ternary.String(flag, tran.Slate("Not Fullscreen"), tran.Slate("Fullscreen")), ternary.String(flag, globals.IconNameLeaveFullScreen, globals.IconNameFullScreen), m.Icon.CallbackActionWindowToggle((cdglobal.Window).SetFullScreen, (cdglobal.Window).IsFullScreen)) case MenuWindowKill: m.AddEntry( tran.Slate("Kill"), globals.IconNameClose, m.Icon.CallbackActionWindow((cdglobal.Window).Kill)) case MenuWindowMoveAllHere: m.AddEntry( tran.Slate("Move all to this desktop"), globals.IconNameJumpTo, m.Icon.CallbackActionSubWindows((cdglobal.Window).MoveToCurrentDesktop)) case MenuWindowMoveHere: var callback func() if !m.Icon.Window().IsOnCurrentDesktop() { callback = m.Icon.CallbackActionWindow(func(win cdglobal.Window) { win.MoveToCurrentDesktop() if !win.IsHidden() { win.Show() } }) } m.AddEntry(tran.Slate("Move to this desktop"), globals.IconNameJumpTo, callback) case MenuWindowSticky: m.AddEntry( ternary.String(m.Icon.Window().IsSticky(), tran.Slate("Visible only on this desktop"), tran.Slate("Visible on all desktops")), globals.IconNameJumpTo, m.Icon.CallbackActionWindowToggle((cdglobal.Window).SetSticky, (cdglobal.Window).IsSticky)) } return notif.AnswerLetPass }