Esempio n. 1
0
func (m *Manager) newAccessPoint(devPath, apPath dbus.ObjectPath) (ap *accessPoint, err error) {
	nmAp, err := nmNewAccessPoint(apPath)
	if err != nil {
		return
	}
	ap = &accessPoint{
		nmAp:    nmAp,
		devPath: devPath,
		Path:    apPath,
	}
	ap.updateProps()
	if len(ap.Ssid) == 0 {
		err = fmt.Errorf("ignore hidden access point")
		return
	}

	// connect properties changed signals
	ap.nmAp.ConnectPropertiesChanged(func(properties map[string]dbus.Variant) {
		if !m.isAccessPointExists(apPath) {
			return
		}

		m.accessPointsLock.Lock()
		defer m.accessPointsLock.Unlock()
		ap.updateProps()
		apJSON, _ := marshalJSON(ap)
		dbus.Emit(m, "AccessPointPropertiesChanged", string(devPath), apJSON)
	})

	apJSON, _ := marshalJSON(ap)
	dbus.Emit(m, "AccessPointAdded", string(devPath), apJSON)

	return
}
Esempio n. 2
0
func grabKeyboardAndMouse(m *Manager) {
	if m == nil {
		return
	}

	//go func() {
	X, err := xgbutil.NewConn()
	if err != nil {
		logger.Info("Get New Connection Failed:", err)
		return
	}
	keybind.Initialize(X)
	mousebind.Initialize(X)

	err = keybind.GrabKeyboard(X, X.RootWin())
	if err != nil {
		logger.Info("Grab Keyboard Failed:", err)
		return
	}

	grabAllMouseButton(X)

	xevent.ButtonPressFun(
		func(X *xgbutil.XUtil, e xevent.ButtonPressEvent) {
			dbus.Emit(m, "KeyReleaseEvent", "")
			ungrabAllMouseButton(X)
			keybind.UngrabKeyboard(X)
			logger.Info("Button Press Event")
			xevent.Quit(X)
		}).Connect(X, X.RootWin())

	xevent.KeyPressFun(
		func(X *xgbutil.XUtil, e xevent.KeyPressEvent) {
			value := parseKeyEnvent(X, e.State, e.Detail)
			pressKeyStr = value
			dbus.Emit(m, "KeyPressEvent", value)
		}).Connect(X, X.RootWin())

	xevent.KeyReleaseFun(
		func(X *xgbutil.XUtil, e xevent.KeyReleaseEvent) {
			if strings.ToLower(pressKeyStr) == "super_l" ||
				strings.ToLower(pressKeyStr) == "super_r" {
				pressKeyStr = "Super"
			}

			dbus.Emit(m, "KeyReleaseEvent", pressKeyStr)
			pressKeyStr = ""
			ungrabAllMouseButton(X)
			keybind.UngrabKeyboard(X)
			logger.Infof("Key: %s\n", pressKeyStr)
			xevent.Quit(X)
		}).Connect(X, X.RootWin())

	xevent.Main(X)
	//}()
}
Esempio n. 3
0
func (self *Launcher) RequestUninstall(id string, purge bool) {
	go func(id ItemId) {
		logger.Warning("uninstall", id)
		err := self.itemManager.UninstallItem(id, purge, time.Minute*20)
		if err == nil {
			dbus.Emit(self, "UninstallSuccess", id)
			return
		}

		dbus.Emit(self, "UninstallFailed", id, err.Error())
	}(ItemId(id))
}
Esempio n. 4
0
func (self *Launcher) RequestRemoveFromDesktop(id string) bool {
	itemId := ItemId(id)
	if filepath.IsAbs(id) {
		dbus.Emit(self, "RemoveFromDesktopFailed", itemId, "app id is expected")
		return false
	}

	if err := self.itemManager.RemoveItemFromDesktop(itemId); err != nil {
		dbus.Emit(self, "RemoveFromDesktopFailed", itemId, err.Error())
		return false
	}

	dbus.Emit(self, "RemoveFromDesktopSuccess", itemId)
	return true
}
func (m *DockedAppManager) Dock(id, title, icon, cmd string) bool {
	idElement := m.findItem(id)
	if idElement != nil {
		logger.Info(id, "is already docked.")
		return false
	}

	id = strings.ToLower(id)
	idElement = m.findItem(id)
	if idElement != nil {
		logger.Info(id, "is already docked.")
		return false
	}

	logger.Debug("id", id, "title", title, "cmd", cmd)
	desktopID := guess_desktop_id(id)
	if desktopID == "" {
		m.items.PushBack(id)
		if e := createScratchFile(id, title, icon, cmd); e != nil {
			logger.Warning("create scratch file failed:", e)
			return false
		}
	} else {
		id = trimDesktop(desktopID)
		m.items.PushBack(id)
	}
	dbus.Emit(m, "Docked", id)
	app := ENTRY_MANAGER.runtimeApps[id]
	if app != nil {
		app.buildMenu()
	}
	return true
}
Esempio n. 6
0
func (media *MediaMount) listenGSettings() {
	media.settings.Connect("changed::autorun-x-content-ignore",
		func(s *gio.Settings, key string) {
			dbus.Emit(media, "MediaActionChanged")
		})

	media.settings.Connect("changed::autorun-x-content-open-folder",
		func(s *gio.Settings, key string) {
			dbus.Emit(media, "MediaActionChanged")
		})

	media.settings.Connect("changed::autorun-x-content-start-app",
		func(s *gio.Settings, key string) {
			dbus.Emit(media, "MediaActionChanged")
		})
}
Esempio n. 7
0
func (m *TrayManager) addTrayIcon(xid xproto.Window) {
	m.checkValid()
	for _, id := range m.TrayIcons {
		if xproto.Window(id) == xid {
			return
		}
	}

	if d, err := damage.NewDamageId(TrayXU.Conn()); err != nil {
		return
	} else {
		m.dmageInfo[xid] = d
		if err := damage.CreateChecked(TrayXU.Conn(), d, xproto.Drawable(xid), damage.ReportLevelRawRectangles).Check(); err != nil {
			logger.Debug("DamageCreate Failed:", err)
			return
		}
	}
	composite.RedirectWindow(TrayXU.Conn(), xid, composite.RedirectAutomatic)

	m.TrayIcons = append(m.TrayIcons, uint32(xid))
	icon := xwindow.New(TrayXU, xid)
	icon.Listen(xproto.EventMaskVisibilityChange | damage.Notify | xproto.EventMaskStructureNotify)
	icon.Change(xproto.CwBackPixel, 0)

	name, err := ewmh.WmNameGet(TrayXU, xid)
	if err != nil {
		logger.Debug("WmNameGet failed:", err, xid)
	}
	m.nameInfo[xid] = name
	m.notifyInfo[xid] = true
	dbus.Emit(m, "Added", uint32(xid))
	logger.Infof("Added try icon: \"%s\"(%d)", name, uint32(xid))
}
Esempio n. 8
0
func triggerSigErr(pid uint32, action, reason string) {
	if _m == nil {
		return
	}

	dbus.Emit(_m, "Error", pid, action, reason)
}
Esempio n. 9
0
func (m *EntryProxyerManager) registerEntry(name string) {
	if !isEntryNameValid(name) {
		return
	}
	logger.Debugf("register entry: %s", name)
	entryId, ok := getEntryId(name)
	if !ok {
		return
	}
	logger.Debugf("register entry id: %s", entryId)
	entry, err := NewEntryProxyer(entryId)
	if err != nil {
		logger.Warningf("register entry failed: %v", err)
		return
	}
	err = dbus.InstallOnSession(entry)
	if err != nil {
		logger.Warningf("register entry failed: %v", err)
		return
	}
	m.Entries = append(m.Entries, entry)

	dbus.Emit(m, "Added", dbus.ObjectPath(entry.GetDBusInfo().ObjectPath))

	logger.Infof("register entry success: %s", name)
}
Esempio n. 10
0
func (m *TrayManager) RetryManager() {
	m.Unmanage()
	m.Manage()

	for _, icon := range m.TrayIcons {
		dbus.Emit(m, "Added", icon)
	}
}
Esempio n. 11
0
func (m *TrayManager) handleTrayDamage(xid xproto.Window) {
	if m.notifyInfo[xid] {
		if md5 := icon2md5(xid); !md5Equal(m.md5Info[xid], md5) {
			m.md5Info[xid] = md5
			dbus.Emit(m, "Changed", uint32(xid))
			logger.Debugf("handleTrayDamage: %s(%d) changed (%v)", m.nameInfo[xid], xid, md5)
		}
	}
}
Esempio n. 12
0
func (a *agent) createPendingKey(connectionData map[string]map[string]dbus.Variant, keyId mapKey) chan string {
	autoConnect := nmGeneralGetConnectionAutoconnect(keyId.path)
	connectionId := getSettingConnectionId(connectionData)
	logger.Debug("createPendingKey:", keyId, connectionId, autoConnect)

	a.pendingKeys[keyId] = make(chan string)
	dbus.Emit(manager, "NeedSecrets", string(keyId.path), keyId.name, connectionId, autoConnect)
	return a.pendingKeys[keyId]
}
Esempio n. 13
0
func (self *Launcher) MarkLaunched(id string) {
	err := self.itemManager.MarkLaunched(ItemId(id))
	if err != nil {
		logger.Info(err)
		return
	}

	dbus.Emit(self, "NewAppLaunched", ItemId(id))
}
Esempio n. 14
0
func (c *config) setDeviceEnabled(devPath dbus.ObjectPath, enabled bool) {
	devConfig, err := c.getDeviceConfigForPath(devPath)
	if err != nil {
		return
	}
	devConfig.Enabled = enabled
	dbus.Emit(manager, "DeviceEnabled", string(devPath), enabled)
	c.save()
}
Esempio n. 15
0
func (m *Manager) handleUserDeleted(list []string) {
	var paths = m.UserList
	for _, p := range list {
		m.uninstallUser(p)
		paths = deleteStrFromList(p, paths)
		dbus.Emit(m, "UserDeleted", p)
	}

	m.setPropUserList(paths)
}
Esempio n. 16
0
func (ss *ScreenSaver) loop() {
	for {
		e, err := ss.xu.Conn().WaitForEvent()
		if err != nil {
			continue
		}
		switch ee := e.(type) {
		case screensaver.NotifyEvent:
			switch ee.State {
			case screensaver.StateCycle:
				dbus.Emit(ss, "CycleActive")
			case screensaver.StateOn:
				dbus.Emit(ss, "IdleOn")
			case screensaver.StateOff:
				dbus.Emit(ss, "IdleOff")
			}
		}
	}
}
Esempio n. 17
0
func (dapp *DefaultApps) handleMimeFileChanged(ev *fsnotify.FileEvent) {
	if ev == nil {
		return
	}

	if ev.IsDelete() {
		if dapp.watcher != nil {
			dapp.watcher.ResetFileListWatch()
		}
	} else {
		dbus.Emit(dapp, "DefaultAppChanged")
	}
}
Esempio n. 18
0
func (m *Manager) ejectVolume(uuid string, volume *gio.Volume) {
	volume.Eject(gio.MountUnmountFlagsNone, nil,
		gio.AsyncReadyCallback(
			func(o *gobject.Object, res *gio.AsyncResult) {
				if volume == nil || volume.Object.C == nil {
					return
				}
				_, err := volume.EjectFinish(res)
				if err != nil {
					dbus.Emit(m, "Error", uuid, err.Error())
				}
			}))
}
Esempio n. 19
0
func (m *Manager) unmountMount(uuid string, mount *gio.Mount) {
	mount.Unmount(gio.MountUnmountFlagsNone, nil,
		gio.AsyncReadyCallback(
			func(o *gobject.Object, res *gio.AsyncResult) {
				if mount == nil || mount.Object.C == nil {
					return
				}
				_, err := mount.UnmountFinish(res)
				if err != nil {
					dbus.Emit(m, "Error", uuid, err.Error())
				}
			}))
}
Esempio n. 20
0
func (m *TrayManager) removeTrayIcon(xid xproto.Window) {
	delete(m.dmageInfo, xid)
	delete(m.nameInfo, xid)
	delete(m.notifyInfo, xid)
	delete(m.md5Info, xid)
	var newIcons []uint32
	for _, id := range m.TrayIcons {
		if id != uint32(xid) {
			newIcons = append(newIcons, id)
		}
	}
	m.TrayIcons = newIcons
	dbus.Emit(m, "Removed", uint32(xid))
}
Esempio n. 21
0
func (m *HideStateManager) ToggleShow() {
	logger.Info("cancel ToggleShow on ToggleShow")
	m.CancelToggleShow()

	if m.state == HideStateHidden || m.state == HideStateHidding {
		dbus.Emit(m, "ChangeState", TriggerShow)
	} else if m.state == HideStateShown || m.state == HideStateShowing {
		dbus.Emit(m, "ChangeState", TriggerHide)
	}

	m.toggleShowTimer = time.After(time.Second * 3)
	go func() {
		select {
		case <-m.toggleShowTimer:
			logger.Info("ToggleShow is done")
			m.toggleShowTimer = nil
			m.UpdateState()
		case <-m.cleanToggleShowChan:
			logger.Info("ToggleShow is cancelled")
			return
		}
	}()
}
func (s *ConnectionSession) setProps() {
	s.setPropType()
	s.setPropAllowDelete()
	s.setPropAvailableVirtualSections()
	s.setPropAvailableSections()
	s.setPropAvailableKeys()
	s.setPropErrors()

	// notify connection data changed at end, for that this was used
	// by font-end to update widget value that with proeprty
	// "alwaysUpdate", which should only update value when visible, so
	// it depends on "AvailableSections" and "AvailableKeys"
	dbus.Emit(s, "ConnectionDataChanged")
}
Esempio n. 23
0
func NewSetting(core SettingCoreInterface) (*Setting, error) {
	if core == nil {
		return nil, errors.New("get failed")
	}
	s := &Setting{
		core: core,
	}

	s.listenSettingChange(CategoryDisplayModeKey, func(setting *gio.Settings, key string) {
		_newValue := int64(setting.GetEnum(key))
		newValue := CategoryDisplayMode(_newValue)
		s.lock.Lock()
		defer s.lock.Unlock()
		if newValue != s.categoryDisplayMode {
			s.categoryDisplayMode = newValue
			dbus.Emit(s, "CategoryDisplayModeChanged", _newValue)
		}
	})
	s.listenSettingChange(SortMethodkey, func(setting *gio.Settings, key string) {
		_newValue := int64(setting.GetEnum(key))
		newValue := SortMethod(_newValue)
		s.lock.Lock()
		defer s.lock.Unlock()
		if newValue != s.sortMethod {
			s.sortMethod = newValue
			dbus.Emit(s, "SortMethodChanged", _newValue)
		}
	})

	// at least one read operation must be called after signal connected, otherwise,
	// the signal connection won't work from glib 2.43.
	// NB: https://github.com/GNOME/glib/commit/8ff5668a458344da22d30491e3ce726d861b3619
	s.categoryDisplayMode = CategoryDisplayMode(core.GetEnum(CategoryDisplayModeKey))
	s.sortMethod = SortMethod(core.GetEnum(SortMethodkey))

	return s, nil
}
Esempio n. 24
0
func (m *Manager) handleUserAdded(list []string) {
	var paths = m.UserList
	for _, p := range list {
		err := m.installUserByPath(p)
		if err != nil {
			logger.Errorf("Install user '%s' failed: %v", p, err)
			continue
		}

		paths = append(paths, p)
		dbus.Emit(m, "UserAdded", p)
	}

	m.setPropUserList(paths)
}
Esempio n. 25
0
func (a *XMouseAreaProxyer) connectHandler(callback func(int32, int32, string)) func(x, y int32, id string) {
	return func(x, y int32, id string) {
		a.lock.Lock()
		if !a.idValid || id != a.areaId {
			if !a.idValid {
				dbus.Emit(a, "InvalidId")
			}
			logger.Debugf("valid: %v, event id: %v, areaId: %v", a.idValid, id, a.areaId)
			a.lock.Unlock()
			return
		}
		a.lock.Unlock()
		callback(x, y, id)
	}
}
Esempio n. 26
0
func (m *Manager) DeviceUnmount(uuid string) (bool, error) {
	value := m.getDiskCache(uuid)
	if value == nil {
		var reason = fmt.Sprintf("Unmount failed: invalid id '%s'", uuid)
		dbus.Emit(m, "Error", uuid, reason)
		return false, fmt.Errorf(reason)
	}

	switch value.Type {
	case diskTypeMount:
		mount := value.Obj.(*gio.Mount)
		m.unmountMount(uuid, mount)
	}

	return true, nil
}
Esempio n. 27
0
func (lang *LangSelector) handleLocaleChanged(ok bool, reason string) error {
	if !ok || lang.LocaleState != LocaleStateChanging {
		return ErrLocaleChangeFailed
	}

	err := writeUserLocale(lang.CurrentLocale)
	if err != nil {
		return err
	}

	err = i18n_dependency.InstallDependentPackages(lang.CurrentLocale)
	if err != nil {
		lang.logger.Warning(err)
	}
	dbus.Emit(lang, "Changed", lang.CurrentLocale)

	return nil
}
Esempio n. 28
0
func (m *EntryProxyerManager) unregisterEntry(name string) {
	if !isEntryNameValid(name) {
		return
	}
	logger.Debugf("unregister entry: %s", name)
	entryId, ok := getEntryId(name)
	if !ok {
		return
	}
	logger.Debugf("unregister entry id: %s", entryId)

	// find the index
	index := -1
	var entry *EntryProxyer = nil
	for i, e := range m.Entries {
		if e.entryId == entryId {
			index = i
			entry = e
			break
		}
	}

	if index < 0 {
		logger.Warningf("slice out of bounds, entry len: %d, index: %d", len(m.Entries), index)
		return
	}
	logger.Debugf("entry len: %d, index: %d", len(m.Entries), index)

	if entry != nil {
		dbus.UnInstallObject(entry)
	}

	// remove the entry from slice
	copy(m.Entries[index:], m.Entries[index+1:])
	m.Entries[len(m.Entries)-1] = nil
	m.Entries = m.Entries[:len(m.Entries)-1]

	dbus.Emit(m, "Removed", entry.Id)

	logger.Infof("unregister entry success: %s", name)
}
Esempio n. 29
0
func (self *Launcher) Search(key string) {
	close(self.cancelSearchingChan)
	self.cancelSearchingChan = make(chan struct{})
	go func() {
		resultChan := make(chan SearchResult)
		transaction, err := NewSearchTransaction(self.pinyinObj, resultChan, self.cancelSearchingChan, 0)
		if err != nil {
			return
		}

		dataSet := self.itemManager.GetAllItems()
		go func() {
			transaction.Search(key, dataSet)
			close(resultChan)
		}()

		select {
		case <-self.cancelSearchingChan:
			return
		default:
			resultMap := map[ItemId]SearchResult{}
			for result := range resultChan {
				resultMap[result.Id] = result
			}

			var res SearchResultList
			for _, data := range resultMap {
				res = append(res, data)
			}

			sort.Sort(res)

			itemIds := []ItemId{}
			for _, data := range res {
				itemIds = append(itemIds, data.Id)
			}
			dbus.Emit(self, "SearchDone", itemIds)
		}
	}()
}
Esempio n. 30
0
func (m *DockedAppManager) doUndock(id string) bool {
	removeItem := m.findItem(id)
	if removeItem == nil {
		logger.Warning("not find docked app:", id)
		return false
	}

	logger.Info("Undock", id)
	logger.Info("Remove", m.items.Remove(removeItem))
	m.core.SetStrv(DockedApps, m.toSlice())
	gio.SettingsSync()
	os.Remove(filepath.Join(scratchDir, id+".desktop"))
	os.Remove(filepath.Join(scratchDir, id+".sh"))
	os.Remove(filepath.Join(scratchDir, id+".png"))
	dbus.Emit(m, "Undocked", removeItem.Value.(string))
	app := ENTRY_MANAGER.runtimeApps[id]
	if app != nil {
		app.buildMenu()
	}

	return true
}