class JsonHelper():
def __init__(self):
self.TAG = "JsonHelper"
self.log = Log("budgie-app-launcher")
def setDictIfNone(self, data, key):
if data is not None and key is not None:
if data.get(key, None) is None:
data[key] = {}
return data[key]
def setListIfNone(self, data, key):
if data is not None and key is not None:
if data.get(key, None) is None:
data[key] = []
return data[key]
def readData(self, filePath):
try:
with open(filePath, 'r+') as json_file:
data = json.load(json_file)
return data
except Exception as e:
self.log.e(self.TAG, Error.ERROR_1010, e)
def writeData(self, filePath, data):
try:
with open(filePath, 'w+') as outfile:
json.dump(data, outfile, indent=4)
except Exception as e:
self.log.e(self.TAG, Error.ERROR_1011, e)
def connect(self):
connected = False
while connected == False:
try:
server_address = (self.config['HubServer']['IP'],
int(self.config['HubServer']['PORT']))
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE,
1)
self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL,
1)
self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, 5)
self.sock.connect(server_address)
self.sock.settimeout(10)
self.sock.setblocking(1)
connected = True
except socket.error as e:
Log.e('DriverTCP', "Retrying...\n%s" % e)
self.sock.close()
connected = False
time.sleep(5)
threading.Thread(target=self.thread, args=(self.intfId, )).start()
#self.send("%s0000" % str(self.intfId).zfill(4) )
for id in self.devicesId:
self.send(id)
def send_sms(sms_text, phone=''):
global lastUsedPhNumb
global isSendingSMS
while (isSendingSMS == True):
pass
isSendingSMS = True
if phone == '':
Log.e("SendSmS", "No phone number specified!")
return
Log.i("SendSmS",
"Sending sms: '%s' to std numb: '%s'.." % (sms_text, phone))
#centr.printf("log:\r\nSend sms: '%s' to std numb: '%s'",sms_text,ph_numb[i])
send_at("AT+CMGF=1")
read_serial()
time.sleep(0.3)
modems.send(
"AT+CMGS=\"%s\"\r\n" % phone
) #send sms message, be careful need to add a country code before the cellphone number
read_serial()
time.sleep(0.3)
send_at(sms_text) #the content of the message
time.sleep(0.3)
modems.send("%c" % 26) #the ASCII code of the ctrl+z is 26
time.sleep(1.5)
if ("OK" in read_serial()):
print("Ok")
time.sleep(10)
isSendingSMS = False
def sendValueCheck(self, msg):
if (msg.cmd != "device.reg.new"
and (msg.setid == "" or msg.setid == "0000")):
Log.e('DriverTCP/Send', 'sending TO HUB without setID!')
return
Log.i('DriverTCP/SendValCheck', 'sending TO HUB:"%s"' % msg.toJSON())
self.outgoingMSG.append(msg)
return 0
def get(key):
if (key in Config.data):
Log.d(
'ConfigParser',
"Got property '%s' with value '%s'." % (key, Config.data[key]))
return Config.data[key]
elif (key in Config.defaultConfig):
Config.set(key, Config.defaultConfig[key])
return Config.defaultConfig[key]
else:
Log.e('ConfigParser', "No property '%s' found in config." % key)
return ""
def DoAfterLogout(user, userinfo, uent, mode):
if mode == 0:
# no TMPFS
if userinfo.pid > 1:
tmp_path = "tmp/%d/%s/" % (userinfo.pid, userinfo.userid)
try:
shutil.rmtree(tmp_path)
except:
pass
if userinfo.currentboard:
board = BoardManager.BoardManager.GetBoardByIndex(userinfo.currentboard)
if board is not None:
board.ModCurrentUsers(-1)
else:
Log.e("Fail to modify user count of board '%r'" % userinfo.currentboard)
def sendMsg(self, msg):
if (msg.cmd != "device.reg.new"
and (msg.setid == "" or msg.setid == "0000")):
Log.e('DriverTCP/Send', 'sending TO HUB without setID!')
return
str = msg.toJSON()
Log.i('DriverTCP/Send', 'sending TO HUB:"%s"' % str)
try:
self.sock.send(str.encode())
except socket.error as e:
Log.e('DriverTCP/Send', 'Exception: ', e)
if e.errno == errno.EPIPE:
time.sleep(2)
self.sock.close()
self.connect()
def fromJSONstr(socket, jsonStr):
try:
jsonObj = json.loads(jsonStr)
msg = Msg(cmd=jsonObj["cmd"],
unid=jsonObj["unid"],
setid=jsonObj["setid"],
value=jsonObj["value"])
if ("id" in jsonObj):
msg.id = jsonObj["id"]
msg.socket = socket
return msg
except json.decoder.JSONDecodeError:
Log.e("MSG/JSON", "Invalid JSON: " + jsonStr)
return Msg(cmd=-1)
def sendAlarm(on, setid):
#IP,port,user,pwd,sens,
(IP, port, login, passw, camSens, up) = getConfBySetId(setid)
Log.i('Send/Alarm/http', "IP: %s:%s, camSens:%s" % (IP, port, camSens))
url = "http://%s:%s@%s/cgi-bin/hi3510/param.cgi?cmd=setmdattr&-enable=%i&-name=1&-s=%s&user=admin&pwd=admin" % (
login, passw, IP, on, camSens)
headers = {
"Host": IP,
"Authorization": "Basic YWRtaW46YWRtaW4=",
"User-Agent": "wget/1.12",
"content-type": "text"
}
Log.i('Send/Alarm/http', "Final url: " + url + "Headers:" + str(headers))
req = requests.get(url, headers=headers)
if req.status_code != 200 or "ok" not in req.text:
Log.e('Send/Alarm/http',
'Error setting cam +' + str(req) + '; ' + req.text)
else:
HUB_sendACK(setid)
def sendCamsUp(setid):
i = 0
(IP, port, login, passw, camSens, up) = getConfBySetId(setid)
isOk = True
HUB_sendACK(setid)
if (up != ""):
for q in range(10):
url = "http://%s:%s@%s/web/cgi-bin/hi3510/ytup.cgi" % (login,
passw, IP)
headers = {
"Host": IP,
"Authorization": "Basic YWRtaW46YWRtaW4=",
"User-Agent": "wget/1.12",
"content-type": "text"
}
Log.i('Send/UP/http',
"Final url: " + url + "Headers:" + str(headers))
req = requests.get(url, headers=headers)
if req.status_code != 200 or "ok" not in req.text:
isOk = False
Log.e('Send/UP/http',
'Error setting cam +' + str(req) + '; ' + req.text)
i += 1
class AppLauncherApplet(Budgie.Applet):
# Budgie.Applet is in fact a Gtk.Bin
def __init__(self, uuid):
self.TAG = "budgie-app-launcher.AppLauncher"
self.APPINDICATOR_ID = "io_serdarsen_github_budgie_app_launcher"
self.APPS_ID = "gnome-applications.menu"
self.log = Log("budgie-app-launcher")
self.sortHelper = SortHelper()
self.filterHelper = FilterHelper()
self.localHelper = LocaleHelper()
self.iconSize = 24
self.showOnPanel = 0
self.tree = None # GMenu.Tree
self.appButtonsContainer = None # Gtk.ListBox
self.contentScroll = None # Gtk.ScrolledWindow
self.allAppsContentScroll = None
self.currentMenuButton = None
self.menuButtons = []
self.allApps = []
self.filteredActiveApps = []
self.activeApps = []
self.inactiveApps = []
self.appLimitOnPanel = 10
self.manager = None
self.popover = None
self.popoverHeight = 0
self.popoverWidth = 300
self.popoverHeight = 510
Budgie.Applet.__init__(self)
self.iconSize = self.localHelper.retriveIconSize()
self.showOnPanel = self.localHelper.retriveShowOnPanel()
self.buildIndicator()
self.buildPopover()
self.buildStack()
self.loadAllApps()
self.loadAppButtons()
self.loadPanelButtons()
self.vertical = False
def do_panel_position_changed(self, position):
# wait for signal, change orientation if it occurs
check_or = any(
[position == Budgie.PanelPosition(pos) for pos in [8, 16]])
self.vertical = True if check_or else False
self.reload_elements()
def reload_elements(self):
# on orientation change of the panel, set applet accordingly
self.panelButtonsContainer.destroy()
self.panelButtonsContainer = Gtk.VBox() if self.vertical \
else Gtk.HBox()
self.indicatorBox.add(self.panelButtonsContainer)
self.update()
####################################
# build START
####################################
def buildIndicator(self):
self.indicatorBox = Gtk.EventBox()
self.panelButtonsContainer = Gtk.VBox()
self.indicatorBox.add(self.panelButtonsContainer)
self.add(self.indicatorBox)
def buildPopover(self):
self.popover = Budgie.Popover.new(self.indicatorBox)
self.popover.set_default_size(self.popoverWidth, self.popoverHeight)
self.popover.get_child().show_all()
self.show_all()
def buildStack(self):
self.stack = Gtk.Stack()
self.stack.set_homogeneous(False)
self.stack.set_transition_type(
Gtk.StackTransitionType.SLIDE_LEFT_RIGHT)
self.popover.add(self.stack)
self.buildStackPage1()
self.buildStackPage2()
def buildStackPage1(self):
# page 1
page1 = Gtk.Box(Gtk.Orientation.VERTICAL, 0)
page1.border_width = 0
self.stack.add_named(page1, "page1")
page1.get_style_context().add_class("budgie-menu")
# page 1 content
page1InnerBox = Gtk.VBox()
page1.pack_start(page1InnerBox, True, True, 0)
titleBox = Gtk.HBox()
page1InnerBox.pack_start(titleBox, False, False, 0)
self.setMargins(titleBox, 3, 3, 3, 0)
self.searchEntry = Gtk.SearchEntry()
titleBox.pack_start(self.searchEntry, True, True, 0)
self.searchEntry.connect("search-changed", self.searchEntryOnChange)
self.searchEntry.connect("activate", self.searchEntryOnActivate)
editButton = EditButton("Edit")
editButton.connect("clicked", self.editButtonOnClick)
titleBox.pack_end(editButton, False, False, 0)
self.contentScroll = Gtk.ScrolledWindow(None, None)
page1InnerBox.pack_start(self.contentScroll, True, True, 0)
self.contentScroll.set_overlay_scrolling(True)
self.contentScroll.set_policy(Gtk.PolicyType.NEVER,
Gtk.PolicyType.AUTOMATIC)
self.appButtonsContainer = Gtk.ListBox()
self.contentScroll.add(self.appButtonsContainer)
# self.content.row_activated.connect(on_row_activate)
self.appButtonsContainer.set_selection_mode(Gtk.SelectionMode.NONE)
# placeholder in case of no results
placeholder = Gtk.Label("App Launcher")
placeholder.use_markup = True
placeholder.get_style_context().add_class("dim-label")
placeholder.show()
placeholder.margin = 6
self.appButtonsContainer.valign = Gtk.Align.START
self.appButtonsContainer.set_placeholder(placeholder)
def buildStackPage2(self):
# page 2
page2 = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
page2.border_width = 0
self.setMargins(page2, 10, 3, 3, 3)
self.stack.add_named(page2, "page2")
# page 2 toolbar
page2Toolbar = Gtk.HBox()
page2.pack_start(page2Toolbar, False, False, 0)
# page 2 toolbar content
# cancel
backButton = DirectionalButton("Back", Gtk.PositionType.LEFT)
page2Toolbar.pack_start(backButton, True, True, 0)
backButton.connect("clicked", self.backButtonOnClick)
# up
self.upButton = ArrowButton(Gtk.PositionType.TOP)
page2Toolbar.pack_start(self.upButton, True, True, 0)
self.upButton.connect("clicked", self.upButtonOnClick)
self.upButton.set_sensitive(False)
# down
self.downButton = ArrowButton(Gtk.PositionType.BOTTOM)
page2Toolbar.pack_start(self.downButton, True, True, 0)
self.setMargins(page2Toolbar, 0, 3, 0, 0)
self.downButton.connect("clicked", self.downButtonOnClick)
self.downButton.set_sensitive(False)
# done
self.doneButton = Gtk.Button("Apply")
self.doneButton.get_style_context().add_class("flat")
page2Toolbar.pack_end(self.doneButton, True, True, 0)
self.doneButton.connect("clicked", self.doneButtonOnClick)
# page 2 toolbar 2
page2Toolbar2 = Gtk.HBox()
page2.pack_start(page2Toolbar2, False, False, 0)
self.deselectButton = SelectButton(False)
page2Toolbar2.pack_start(self.deselectButton, False, False, 0)
self.deselectButton.addOnClickMethod(self.deselectButtonOnClick)
self.selectButton = SelectButton(True)
page2Toolbar2.pack_end(self.selectButton, False, False, 0)
self.selectButton.addOnClickMethod(self.selectButtonOnClick)
self.setMargins(page2Toolbar2, 0, 3, 0, 0)
# page 2 allAppsContainer
self.allAppsContainer = Gtk.VBox()
page2.pack_start(self.allAppsContainer, True, True, 0)
self.allAppsContentScroll = Gtk.ScrolledWindow(None, None)
self.allAppsContainer.pack_start(self.allAppsContentScroll, True, True,
0)
self.allAppsContentScroll.set_overlay_scrolling(True)
self.allAppsContentScroll.set_policy(Gtk.PolicyType.NEVER,
Gtk.PolicyType.AUTOMATIC)
self.menuButtonsContainer = Gtk.VBox()
self.setMargins(self.menuButtonsContainer, 0, 0, 0, 7)
self.allAppsContentScroll.add(self.menuButtonsContainer)
# page 2 bottom bar
page2BottomBar = Gtk.VBox()
page2.pack_start(page2BottomBar, False, False, 0)
self.setMargins(page2BottomBar, 10, 3, 3, 3)
# page2BottomBar show panel Container
page2BottomBarShowPanelContainer = Gtk.HBox()
page2BottomBar.pack_start(page2BottomBarShowPanelContainer, False,
False, 0)
showOnPanelLabel = Gtk.Label("Show on panel", xalign=0)
page2BottomBarShowPanelContainer.pack_start(showOnPanelLabel, True,
True, 0)
showOnPanelLabel.get_style_context().add_class("dim-label")
self.showOnPanelSpinButton = Gtk.SpinButton()
self.showOnPanelSpinButton.set_adjustment(
Gtk.Adjustment(0, 0, 900, 1, 10, 0))
self.showOnPanelSpinButton.set_value(self.showOnPanel)
page2BottomBarShowPanelContainer.pack_start(self.showOnPanelSpinButton,
False, False, 0)
func = self.showOnPanelSpinButtonOnValueChange
self.showOnPanelSpinButton.connect("value-changed", func)
# page2BottomBar icon size Container
page2BottomBarIconSizeContainer = Gtk.HBox()
page2BottomBar.pack_start(page2BottomBarIconSizeContainer, False,
False, 0)
iconSizeLabel = Gtk.Label("Icon size", xalign=0)
page2BottomBarIconSizeContainer.pack_start(iconSizeLabel, True, True,
0)
iconSizeLabel.get_style_context().add_class("dim-label")
iconSizeSpinButton = Gtk.SpinButton()
iconSizeSpinButton.set_adjustment(Gtk.Adjustment(0, 16, 512, 1, 10, 0))
iconSizeSpinButton.set_value(self.iconSize)
page2BottomBarIconSizeContainer.pack_start(
iconSizeSpinButton,
False,
False,
0,
)
iconSizeSpinButton.connect(
"value-changed",
self.iconSizeSpinButtonOnValueChange,
)
def openStackPage1(self):
self.stack.set_visible_child_name("page1")
def openStackPage2(self):
self.stack.set_visible_child_name("page2")
def indicatorBoxOnPress(self, box, e):
self.openStackPage1()
if e.button != 1:
return Gdk.EVENT_PROPAGATE
if self.popover.get_visible():
self.popover.hide()
else:
self.update()
self.manager.show_popover(self.indicatorBox)
return Gdk.EVENT_STOP
def editButtonOnClick(self, editButton):
self.currentMenuButton = None
self.updateSensitiveUpDownButtons()
self.doneButton.set_sensitive(False)
self.update()
self.openStackPage2()
def upButtonOnClick(self, button):
if self.currentMenuButton in self.menuButtons:
newIndex = self.menuButtons.index(self.currentMenuButton) - 1
if newIndex >= 0:
self.menuButtonsContainer.reorder_child(
self.currentMenuButton, newIndex)
self.menuButtons.remove(self.currentMenuButton)
self.menuButtons.insert(newIndex, self.currentMenuButton)
self.activeApps.remove(self.currentMenuButton.getApp())
self.activeApps.insert(newIndex,
self.currentMenuButton.getApp())
self.allApps.remove(self.currentMenuButton.getApp())
self.allApps.insert(newIndex, self.currentMenuButton.getApp())
self.updateAllAppsIndexes()
self.updateSensitiveUpDownButtons()
def downButtonOnClick(self, button):
if self.currentMenuButton in self.menuButtons:
newIndex = self.menuButtons.index(self.currentMenuButton) + 1
self.menuButtonsContainer.reorder_child(self.currentMenuButton,
newIndex)
self.menuButtons.remove(self.currentMenuButton)
self.menuButtons.insert(newIndex, self.currentMenuButton)
self.activeApps.remove(self.currentMenuButton.getApp())
self.activeApps.insert(newIndex, self.currentMenuButton.getApp())
self.allApps.remove(self.currentMenuButton.getApp())
self.allApps.insert(newIndex, self.currentMenuButton.getApp())
self.updateAllAppsIndexes()
self.updateSensitiveUpDownButtons()
def backButtonOnClick(self, button):
self.update()
self.openStackPage1()
def doneButtonOnClick(self, button):
self.localHelper.saveApps(self.activeApps)
self.loadAppButtons()
self.loadPanelButtons()
self.loadMenuButtons()
self.allAppsContentScroll.get_vadjustment().set_value(0)
self.doneButton.set_sensitive(False)
self.showOnPanelSpinButton.get_adjustment().set_upper(
len(self.activeApps))
self.showOnPanelSpinButton.get_adjustment().set_value(self.showOnPanel)
def selectButtonOnClick(self, selectButton):
self.selectAll()
def deselectButtonOnClick(self, deselectButton):
self.deselectAll()
def menuButtonOnToggle(self, toggleButton, *data):
self.doneButton.set_sensitive(True)
menuButton = data[0]
# if current menu button toggled again set current None
if self.currentMenuButton is not None and \
self.currentMenuButton is menuButton:
self.currentMenuButton = None
self.updateSensitiveUpDownButtons()
return
# toggle false old current button
if self.currentMenuButton is not None and \
self.currentMenuButton is not menuButton:
self.currentMenuButton.setToggled(False)
# set new currentMenuButton
self.currentMenuButton = menuButton
self.updateSensitiveUpDownButtons()
def menuButtonOnCheck(self, checkButton, *data):
self.doneButton.set_sensitive(True)
menuButton = data[0]
app = menuButton.getApp()
if not app.getActive():
app.setActive(True)
if app in self.inactiveApps:
self.inactiveApps.remove(app)
self.activeApps.append(app)
else:
app.setActive(False)
if app in self.activeApps:
self.activeApps.remove(app)
self.inactiveApps.insert(0, app)
self.inactiveApps = self.sortHelper.sortedAppsByName(self.inactiveApps)
self.allApps = self.activeApps + self.inactiveApps
self.updateAllAppsIndexes()
self.updateSensitiveSelectButtons()
def showOnPanelSpinButtonOnValueChange(self, spinButton):
# print("value changed : %s" % int(spinButton.get_value()))
self.showOnPanel = int(spinButton.get_value())
self.localHelper.saveShowOnPanel(self.showOnPanel)
self.update()
self.panelButtonsContainer.set_size_request(0, 0)
spinButton.get_adjustment().set_upper(len(self.activeApps))
def iconSizeSpinButtonOnValueChange(self, spinButton):
# print("value changed : %s" % int(spinButton.get_value()))
self.iconSize = int(spinButton.get_value())
self.localHelper.saveIconSize(self.iconSize)
self.update()
def searchEntryOnChange(self, searchEntry):
text = searchEntry.get_text().strip()
self.filteredActiveApps = self.filterHelper.filteredAppsByName(
self.activeApps, self.showOnPanel, text)
if text is "":
self.loadAppButtons()
else:
self.loadFilteredActiveAppButtons()
def treeOnChange(self, tree):
# self.log.d(self.TAG, "treeOnChange")
self.tree = None
self.update()
self.localHelper.saveApps(self.activeApps)
def searchEntryOnActivate(self, searchEntry):
if len(self.filteredActiveApps) != 0:
info = self.filteredActiveApps[0].getInfo()
if info is not None:
self.hidePopover()
info.launch(None, None)
def update(self):
# self.popover.resize(self.popoverWidth, self.popoverHeight)
self.searchEntry.set_text("")
self.loadAllApps()
self.loadAppButtons()
self.loadMenuButtons()
self.loadPanelButtons()
self.updateSensitiveSelectButtons()
self.popover.set_size_request(self.popoverWidth, self.popoverHeight)
self.popover.get_child().show_all()
self.show_all()
def do_update_popovers(self, manager):
self.manager = manager
self.manager.register_popover(self.indicatorBox, self.popover)
def updateSensitiveUpDownButtons(self):
if self.currentMenuButton is not None:
currentMenuButtonIndex = self.menuButtons.index(
self.currentMenuButton)
activeAppsLenght = len(self.activeApps)
if currentMenuButtonIndex is 0:
self.upButton.set_sensitive(False)
self.downButton.set_sensitive(True)
elif currentMenuButtonIndex is activeAppsLenght - 1:
self.upButton.set_sensitive(True)
self.downButton.set_sensitive(False)
else:
self.upButton.set_sensitive(True)
self.downButton.set_sensitive(True)
else:
self.upButton.set_sensitive(False)
self.downButton.set_sensitive(False)
def updateSensitiveSelectButtons(self):
if len(self.activeApps) is 0:
self.selectButton.set_sensitive(True)
self.deselectButton.set_sensitive(False)
elif len(self.activeApps) > 0:
self.selectButton.set_sensitive(True)
self.deselectButton.set_sensitive(True)
else:
self.selectButton.set_sensitive(False)
self.deselectButton.set_sensitive(True)
def updateAllAppsIndexes(self):
tempApps = []
for app in self.allApps:
app.setIndex(self.allApps.index(app))
tempApps.append(app)
self.allApps = tempApps
def hidePopover(self):
if (self.popover is not None):
if self.popover.get_visible():
self.popover.hide()
def loadAllApps(self):
# self.log.d(self.TAG, "loadAllApps")
self.iconSize = self.localHelper.retriveIconSize()
self.showOnPanel = self.localHelper.retriveShowOnPanel()
# reset all apps lists
self.allApps = []
self.activeApps = []
self.inactiveApps = []
# load our active apps data from local
self.activeAppsDict = self.localHelper.retriveAppsDict()
# load all apps from system all applications
appsDict = {}
self.loadAndExtractApps(appsDict)
# sort and combine active and inactiveApps to build allApps
self.activeApps = self.sortHelper.sortedAppsByIndex(self.activeApps)
self.inactiveApps = self.sortHelper.sortedAppsByName(self.inactiveApps)
self.allApps = self.activeApps + self.inactiveApps
def loadAndExtractApps(self, appsDict, treeRoot=None):
# self.log.d(self.TAG, "loadAndExtractApps")
if self.tree is None:
# self.log.d(self.TAG, "loadAndExtractApps self.tree is None")
self.tree = GMenu.Tree.new(self.APPS_ID,
GMenu.TreeFlags.SORT_DISPLAY_NAME)
self.tree.connect("changed", self.treeOnChange)
try:
self.tree.load_sync()
except Exception as e:
self.log.e(self.TAG, Error.ERROR_8011, e)
if treeRoot is None:
root = self.tree.get_root_directory()
else:
root = treeRoot
it = None
if root is not None:
it = root.iter()
if it is not None:
while True:
treeItemType = it.next()
if treeItemType is GMenu.TreeItemType.INVALID:
break
if treeItemType is GMenu.TreeItemType.DIRECTORY:
dir = it.get_directory()
# self.log.d(self.TAG, "loadAppList dir %s : " % dir)
self.loadAndExtractApps(appsDict, dir)
elif treeItemType is GMenu.TreeItemType.ENTRY:
info = it.get_entry().get_app_info()
# self.log.d(self.TAG, info.get_display_name())
id = info.get_id()
if id not in appsDict:
appsDict[id] = info
if id in self.activeAppsDict:
app = self.activeAppsDict[id]
app.setId(id)
app.setInfo(info)
self.activeApps.insert(app.getIndex(), app)
else:
app = App(id, info.get_display_name(), False)
app.setInfo(info)
self.inactiveApps.append(app)
def loadFilteredActiveAppButtons(self):
if self.appButtonsContainer is not None: # empty allAppsContent
for appButton in self.appButtonsContainer.get_children():
appButton.destroy()
for app in self.filteredActiveApps:
row = Gtk.HBox()
self.appButtonsContainer.add(row)
appButton = AppButton(app, 24, self.popover)
row.pack_start(appButton, True, True, 0)
appButton.show_all()
row.show_all()
self.appButtonsContainer.show_all()
def loadAppButtons(self):
if self.appButtonsContainer is not None: # empty allAppsContent
for appButton in self.appButtonsContainer.get_children():
appButton.destroy()
counter = 0
for app in self.allApps:
if counter >= self.showOnPanel and app.getActive():
row = Gtk.HBox()
self.appButtonsContainer.add(row)
appButton = AppButton(app, 24, self.popover)
row.pack_start(appButton, True, True, 0)
appButton.show_all()
row.show_all()
counter += 1
self.appButtonsContainer.show_all()
def loadPanelButtons(self):
if self.panelButtonsContainer is not None: # empty allAppsContent
for panelButton in self.panelButtonsContainer.get_children():
panelButton.destroy()
# add the applet's button as first item
appletbutton = Gtk.Button()
applet_icon = Gtk.Image.new_from_icon_name(
"budgie-app-launcher-applet-symbolic", Gtk.IconSize.MENU)
appletbutton.set_image(applet_icon)
appletbutton.set_relief(Gtk.ReliefStyle.NONE)
self.panelButtonsContainer.add(appletbutton)
appletbutton.connect("button-press-event", self.indicatorBoxOnPress)
counter = 0
for app in self.allApps:
if counter < self.showOnPanel and app.getActive():
panelButton = PanelButton(app, self.iconSize, self.popover)
self.panelButtonsContainer.add(panelButton)
counter += 1
self.panelButtonsContainer.show_all()
def loadMenuButtons(self):
self.menuButtons = []
if self.menuButtonsContainer is not None:
for menuButton in self.menuButtonsContainer.get_children():
menuButton.destroy()
for app in self.allApps:
menuButton = MenuButton(app, 24)
menuButton.setChecked(app.getActive())
menuButton.setToggButtonSensitive(app.getActive())
menuButton.addOnToggleMethod(self.menuButtonOnToggle)
menuButton.addOnCheckMethod(self.menuButtonOnCheck)
menuButton.show_all()
self.menuButtons.append(menuButton)
self.menuButtonsContainer.add(menuButton)
self.menuButtonsContainer.show_all()
def setMargins(self, widget, top, bottom, left, right):
widget.set_margin_top(top)
widget.set_margin_bottom(bottom)
widget.set_margin_left(left)
widget.set_margin_right(right)
def selectAll(self):
self.doneButton.set_sensitive(True)
for menuButton in self.menuButtons:
if not menuButton.getChecked():
menuButton.setChecked(True)
def deselectAll(self):
self.doneButton.set_sensitive(True)
for menuButton in self.menuButtons:
if menuButton.getChecked():
menuButton.setChecked(False)
class PanelButton(Gtk.Button):
def __init__(self, app, iconSize, popover):
Gtk.Button.__init__(self)
self.popover = popover
self.TAG = "budgie-app-launcher.PanelButton"
self.log = Log("budgie-app-launcher")
self.app = app
self.info = self.app.getInfo() # DesktopAppInfo
self.get_style_context().add_class("flat")
self.isActionsAvailable = False
self.menu = None
img = Gtk.Image.new_from_gicon(self.info.get_icon(),
Gtk.IconSize.INVALID)
img.set_pixel_size(iconSize)
self.add(img)
# self.set_tooltip_text(parent.get_description())
self.set_tooltip_text(self.info.get_display_name())
self.connect("button-press-event", self.onPress)
self.buildMenu()
def showMenu(self, button, event):
if self.isActionsAvailable:
self.menu.popup_at_pointer(event)
def buildMenu(self):
self.menu = Gtk.Menu()
actions = self.info.list_actions()
if len(actions) != 0:
self.isActionsAvailable = True
for action in actions:
displayName = self.info.get_action_name(action)
item = Gtk.MenuItem.new_with_label(displayName)
item.connect("activate", self.itemActivate, action)
item.show_all()
self.menu.append(item)
def itemActivate(self, item, *data):
action = data[0]
if action is None:
return
self.hidePopover()
self.info.launch_action(action, None)
def getApp(self):
return self.app
def getInfo(self):
return self.info
def hidePopover(self):
if (self.popover is not None):
if self.popover.get_visible():
self.popover.hide()
def onPress(self, button, event):
if event.button != 1:
self.showMenu(button, event)
return Gdk.EVENT_PROPAGATE
else:
self.hidePopover()
self.launchApp()
return Gdk.EVENT_STOP
def launchApp(self):
try:
self.info.launch(None, None)
except Exception as e:
self.log.e(self.TAG, Error.ERROR_8010, e)
def thread(self, intfId):
try:
start = time.clock()
Log.i('DriverTCP/Thread', 'Connected')
while True:
#try:
if ((time.clock() - start) > 5.0):
#Log.d('PortalConnect/Thread','Keep Alvie sent')
self.sock.sendall("\n".encode())
start = time.clock()
try:
ready_to_read, ready_to_write, in_error = select.select([
self.sock,
], [
self.sock,
], [], 5)
except select.error:
#conn.shutdown(2) # 0 = done receiving, 1 = done sending, 2 = both
# connection error event here, maybe reconnect
break
#if len(ready_to_read) > 0:
data = self.sock.recv(2048).decode('utf-8')
if not data:
break
if len(data) > 5:
for line in data.split("\n"):
if len(line) > 5:
Log.i('DriverTCP/Thread', 'received "%s"' % line)
from DriverTCP import Msg
msg = Msg.fromJSONstr(self, line)
if (msg.cmd == "ACK" or msg.cmd == "0"
or msg.cmd == "device.reg.res"):
#msg.cmd = "ACK"
Log.i(
'DriverTCP/Thread',
"ACK recived. Looking for awating msgs " +
msg.toJSON())
isAckThere = False
toRemove = []
for i in range(len(self.outgoingMSG)):
msgS = self.outgoingMSG[i]
if (msgS.setid == msg.setid
and msgS.unid == msg.unid):
Log.i(
'DriverTCP/ACK',
"Msg for ACK found:" +
msgS.toJSON(), msg)
if (msgS.callback != None):
Log.d('DriverTCP/ACK',
"Calling callback")
msgS.callback(msg)
if (msgS.socket != None):
msgS.socket.sendAck(
setid=msgS.setid,
unid=msgS.unid)
toRemove.append(i)
isAckThere = True
#break
for i in range(len(toRemove)):
try:
del self.outgoingMSG[i]
except:
pass
Log.i('DriverTCP/Thread',
"ACK proceed complete")
if ((isAckThere == False
or msg.cmd == "device.reg.res")
and self.onRecieveCallback != None):
Log.i('DriverTCP/Thread',
"Calling callback", msg.cmd)
self.onRecieveCallback(msg)
elif (msg != None and self != None
and self.onRecieveCallback != None):
self.onRecieveCallback(msg)
#else:
#break
#time.sleep(0.3)
'''except ValueError as e:
Log.e('DriverTCP/Thread',"While E: %s"%e)
except ConnectionError as e:
Log.e('DriverTCP/Thread',"While E: %s"%e)'''
#except socket.error:
# Log.e('DriverTCP/Thread',"Closing driver: ", socket.error)
except socket.error:
Log.e('DriverTCP/Thread/1', "Closing socket: %s " % socket.error,
traceback.format_exc())
except Exception as e:
exc = str(e)
Log.e('DriverTCP/Thread/2', exc, traceback.format_exc())
#except ValueError:
Log.d('DriverTCP/Thread', 'closing socket', ValueError)
self.sock.close()
self.connect()
class AppButton(Gtk.Button):
def __init__(self, app, iconSize, popover):
Gtk.Button.__init__(self)
self.popover = popover
self.TAG = "budgie-app-launcher.AppButton"
self.log = Log("budgie-app-launcher")
self.app = app
self.info = self.app.getInfo() # DesktopAppInfo
self.get_style_context().add_class("flat")
self.isActionsAvailable = False
icon = self.info.get_icon()
if icon:
img = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.INVALID)
img.set_pixel_size(iconSize)
else:
img = None
lab = Gtk.Label(self.info.get_display_name(), xalign=0)
lab.set_margin_left(7)
lab.halign = Gtk.Align.START
lab.valign = Gtk.Align.CENTER
layout = Gtk.Box(Gtk.Orientation.HORIZONTAL, 0)
if img:
layout.pack_start(img, False, False, 0)
layout.pack_start(lab, True, True, 0)
self.add(layout)
# self.set_size_request(0, 36)
# self.set_tooltip_text(self.info.get_description())
# self.set_tooltip_text(self.info.get_display_name())
self.connect("button-press-event", self.onPress)
self.buildMenu()
def getApp(self):
return self.app
def getInfo(self):
return self.info
def showMenu(self, button, event):
if self.isActionsAvailable:
self.menu.popup_at_pointer(event)
def buildMenu(self):
self.menu = Gtk.Menu()
actions = self.info.list_actions()
if len(actions) != 0:
self.isActionsAvailable = True
for action in actions:
displayName = self.info.get_action_name(action)
item = Gtk.MenuItem.new_with_label(displayName)
item.connect("activate", self.itemActivate, action)
item.show_all()
self.menu.append(item)
def itemActivate(self, item, *data):
action = data[0]
if action is None:
return
self.hidePopover()
self.info.launch_action(action, None)
def hidePopover(self):
if (self.popover is not None):
if self.popover.get_visible():
self.popover.hide()
def onPress(self, button, event):
if event.button != 1:
self.showMenu(button, event)
return Gdk.EVENT_PROPAGATE
else:
self.hidePopover()
self.launchApp()
return Gdk.EVENT_STOP
def launchApp(self):
try:
self.info.launch(None, None)
except Exception as e:
self.log.e(self.TAG, Error.ERROR_8010, e)
def CAN_onRecieve(msg):
global pi
bytes = msg.data
data = []
for byte in bytes:
data.append(int(byte))
remote = msg.is_remote_frame
id = msg.arbitration_id
fd = msg.is_fd
err = msg.is_error_frame
strId = ('%.8x' % (id)).lower()
print("1")
if err == False and len(data) > 0 and len(strId) == 8:
unid = strId[:4]
setid = strId[4:]
powerSupply = pi.read(PS_PIN) == 0
if (len(unid) == 4 and unid != "0000" and unid != ""
and powerSupply == True):
Log.i('Recv', ("Received: From %s with data: %s" %
(strId, ';'.join(map(str, data)))))
cmd = int(data[0] / 16)
Log.i('Recv', "CMD: %i" % cmd)
frameCount = data[0] % 16
if (frameCount > 1):
curFrame = data[1]
if (curFrame > 0 and id in messagesWaitingComplete):
messagesWaitingComplete[id].value += ';'.join(
map(str, data[2:]))
elif (curFrame == 0):
if (setid == "0000"):
setid = ""
messagesWaitingComplete[id] = Msg(unid=unid,
setid=setid,
cmd=cmdIntToStr(cmd),
value=','.join(
map(str, data[2:])),
callback=ACK_clb)
elif (curFrame == (frameCount - 1)
and id in messagesWaitingComplete):
DriverTCP.sendMsg(messagesWaitingComplete[id])
del messagesWaitingComplete[id]
else:
Log.e('Recv',
"ERROR: Lost first frames or message incomplete")
else:
if (setid == "0000"):
setid = ""
msg = Msg(unid=unid,
setid=setid,
cmd=cmdIntToStr(cmd),
value=';'.join(map(str, data[1:])),
callback=ACK_clb)
Log.d("Recv/TCPSend", "MSG:", msg.toJSON())
DriverTCP.sendMsg(msg)
elif (powerSupply == False):
Log.w('Recv', "Skipping garbage")
else:
Log.w('Recv', "id:", id, "data:", data)
else:
Log.w('Recv', "Er:", err, "id:", id, "data:", data)
Log.i('Start', 'Bring up CAN0....')
os.system("sudo /sbin/ip link set can0 down")
#os.system("sudo ifconfig can0 txqueuelen 50000")
os.system("sudo ifconfig can0 ")
os.system("sudo ip link set can0 up type can bitrate 125000 loopback off "
) # restart-ms 500
time.sleep(0.1)
pi = pigpio.pi()
try:
bus = can.interface.Bus(channel='can0',
interface='socketcan_native',
receive_own_messages=False)
#bus.state = BusState.ACTIVE
except OSError:
Log.e('Start', 'Cannot find CAN board.')
exit()
def CAN_restart():
os.system("sudo ip link set can0 down")
os.system("sudo ip link set can0 up type can bitrate 125000 loopback off "
) # restart-ms 500
Log.i('Start', 'CAN Ready')
def ACK_clb(msg):
if (msg.unid + msg.setid) == "":
id = 1
