Добавлен автоматическая проверка наличия обновлений

для пользователя
master3.3 3.2.0_alpha11
Mike khiretskiy 10 years ago
parent 7982c8add8
commit b66aaeb81e

@ -276,7 +276,8 @@ class MainWgt(QtGui.QMainWindow):
self.control_button.setEnabled(True)
def main_frame_view(self, view, method_name, step_change = False, \
change_offset = False, error_output = True):
change_offset = False, error_output = True,
skip_options=False):
if change_offset:
self.MainFrameWgt = MainFrame(self, self.ClientObj, view, \
method_name, error_output)
@ -284,7 +285,7 @@ class MainWgt(QtGui.QMainWindow):
return
self.delete_MainFrameWgt()
self.MainFrameWgt = MainFrame(self, self.ClientObj, view, method_name,\
error_output)
error_output, skip_options=skip_options)
self.MainFrameWgt.initUI()
self.main_frame.setWidget (self.MainFrameWgt)
self.main_frame.setWidgetResizable(True)

@ -25,7 +25,7 @@ import ConfigParser
from TrayIcon import TrayIcon
from more import get_sid, get_view_params
from more import get_sid, get_view_params, _print
from MainClass import ApiClient
from calculate.consolegui.datavars import DataVarsGui
from pid_information import client_pid_info
@ -39,6 +39,7 @@ class SelectedMethodWgt(QtGui.QWidget):
self.user_changed_flag = False
self.lang = args.lang
self.method = args.method
self.skip_options = args.skip_options
# Initialization GUI variables
self.VarsGui = DataVarsGui()
@ -89,7 +90,7 @@ class SelectedMethodWgt(QtGui.QWidget):
view = self.ClientObj.client.service[0][self.args.method + \
'_view'](int(self.ClientObj.sid), view_params)
except sudsds.MethodNotFound:
_print ('Method not found: ', self.args.method + '_view')
_print('Method not found: ', self.args.method + '_view')
self.close()
sys.exit(1)
if self.ClientObj.method_names.has_key(self.args.method):
@ -98,7 +99,11 @@ class SelectedMethodWgt(QtGui.QWidget):
view_method = self.args.method
self.setWindowTitle(view_method + ' - ' + \
self.ClientObj._parent.windowTitle())
self.MethodWidget.main_frame_view(view, self.args.method)
#self.MethodWidget.MainFrameWgt.call_server_method(False)
#self.MethodWidget.main_frame_view(view, self.args.method,
# skip_options=not self.args.skip_options)
self.MethodWidget.main_frame_view(view, self.args.method,
skip_options=self.args.skip_options)
return 0
def translate(self, lang = None):
@ -106,6 +111,9 @@ class SelectedMethodWgt(QtGui.QWidget):
def connect_count_changed(self, host, port, count):
pass
def has_update(self, update):
print "Update", update
def get_size(self):
self.config = ConfigParser.ConfigParser()
self.config.read(self.user_config)
@ -226,7 +234,11 @@ def parse():
parser.add_argument(
'--method', type=str, dest='method',
help=_('call method'))
parser.add_argument(
parser.add_argument(
'--skip-options', action='store_true',
dest='skip_options', default=False,
help=_('run method without options'))
parser.add_argument(
'-p', '--port', type=int, dest='port',
help=_('port number'))
parser.add_argument(
@ -234,17 +246,6 @@ def parse():
help=_('destination host'))
return parser
class DBusWidget(dbus.service.Object):
def __init__(self, name, session, parent):
self._parent = parent
# export this object to dbus
dbus.service.Object.__init__(self, name, session)
# You can export methods to dbus like you do in python-dbus.
@dbus.service.method("org.calculate.consolegui", in_signature='', \
out_signature='')
def show(self):
self._parent.showNormal()
class MyTabBar(QtGui.QTabBar):
def __init__(self, _parent):

@ -17,6 +17,7 @@
from PySide import QtGui, QtCore
import time, urllib2
from calculate.core.client.function import create_obj
from calculate.update.update_info import UpdateInfo
import dbus
from ReturnMessage import ReturnedMessage
@ -220,9 +221,27 @@ class TrayIcon (QtGui.QSystemTrayIcon):
menu.addSeparator()
return menu
def set_icon(self, online):
def check_for_update(self):
if self._parent.localhost_ClientObj:
uinfo = UpdateInfo(self._parent.localhost_ClientObj.VarsApi)
return (uinfo.need_update() and not uinfo.update_already_run() and
not self.get_update_pid() and
not self.update_thread.isRunning())
return False
def set_icon(self, online, has_update=None):
if has_update is None:
if self.check_for_update():
has_update = True
else:
has_update = False
if online:
self.setIcon(QtGui.QIcon \
if has_update:
self.setIcon(QtGui.QIcon \
('/usr/share/pixmaps/calculate-console-update.png'))
else:
self.setIcon(QtGui.QIcon \
('/usr/share/pixmaps/calculate-console-online.png'))
else:
self.setIcon(QtGui.QIcon \
@ -300,7 +319,9 @@ class TrayIcon (QtGui.QSystemTrayIcon):
if reason == QtGui.QSystemTrayIcon.MiddleClick:
self.windowVisible()
elif reason == QtGui.QSystemTrayIcon.Trigger:
if self.check_for_update():
self.start_update_system()
return
if QtGui.QCursor.pos().y() < self.left_menu.sizeHint().height():
self.left_menu.move(QtCore.QPoint \
(self.geometry().x(), self.geometry().y()) + \
@ -338,6 +359,7 @@ class TrayIcon (QtGui.QSystemTrayIcon):
self._parent.move(self._parent.cur_pos)
def start_update_system(self):
self.set_icon(True, False)
if self.get_update_pid():
self.show_update()
else:

@ -0,0 +1,56 @@
#-*- coding: utf-8 -*-
# Copyright 2014 Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import dbus
import dbus.service
import dbus.mainloop.glib
DBUS_NAME = "org.calculate.consolegui"
DBUS_METHOD_APP = "/org/calculate/consolegui/%s"
DBUS_MAINAPP = "/org/calculate/consolegui/app"
DBUS_NAME_UPDATER = "org.calculate.updater"
DBUS_APP_UPDATER = "/org/calculate/updater"
class DBusWidget(dbus.service.Object):
def __init__(self, name, session, parent):
self._parent = parent
# export this object to dbus
dbus.service.Object.__init__(self, name, session)
# You can export methods to dbus like you do in python-dbus.
@dbus.service.method(DBUS_NAME, in_signature='', out_signature='')
def show(self):
self._parent.hide()
self._parent.show()
self._parent.showNormal()
@dbus.service.method(DBUS_NAME, in_signature='', out_signature='b')
def ping(self):
return True
def dbus_updater_hide_tray(bus):
"""
:param bus: SessionBus
"""
try:
remote_object = bus.get_object(DBUS_NAME_UPDATER, DBUS_APP_UPDATER)
obj = dbus.Interface(remote_object, DBUS_NAME_UPDATER)
if obj:
obj.hide_systray()
except dbus.DBusException:
pass

@ -24,7 +24,7 @@ from more import show_msg, LabelWordWrap, MultipleChoice, SelectTable, \
ComboFileWgt, PasswordWidget, get_sid, ClientServiceThread, \
ExpertWidget, ButtonsWidget, show_question, PlusRow, \
ReadonlyCheckBox, get_view_params, ImageLabel, SelectList, \
QComboWgt
QComboWgt, _print
from sudsds import WebFault
from SelectTable import SelectedTableWidget
from ReturnMessage import ReturnedMessage
@ -64,11 +64,12 @@ class RadioButton(QtGui.QRadioButton):
class MainFrame(QtGui.QWidget):
def __init__(self, parent, ClientObj, view, method_name, \
error_output = True):
error_output = True, skip_options=False):
super(MainFrame, self).__init__(parent)
self.ClientObj = ClientObj
self._parent = parent
self.view = view
self.skip_options = skip_options
self.method_name = method_name
self.error_output = error_output
@ -163,6 +164,16 @@ class MainFrame(QtGui.QWidget):
self.print_brief(self.view.groups.GroupField, x)
return
lastTable = None
for Group in self.view.groups.GroupField:
for field in Group.fields.Field:
if field.element == 'table' and field.type == 'steps':
self.add_element_steps (field)
if self.skip_options:
self.call_server_method(collect_flag = False)
return
for Group in self.view.groups.GroupField:
if Group.name:
self.group_name_label = LabelWordWrap(Group.name, self)
@ -247,9 +258,6 @@ class MainFrame(QtGui.QWidget):
self.add_element_expert (field, x, y)
x += 1
elif field.element == 'table' and field.type == 'steps':
self.add_element_steps (field)
elif field.element == 'table' and field.type != 'steps':
self.add_element_table (field, x, y)
lastTable = self.view_dict[field.name]
@ -316,6 +324,7 @@ class MainFrame(QtGui.QWidget):
Expanding, QtGui.QSizePolicy.Expanding), x+1, y, 1, 2)
self.common_layout.addLayout(self.grid)
# add spacer
#self.common_layout.addItem(QtGui.QSpacerItem( 0, 0, \
# QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding))
@ -2256,6 +2265,15 @@ class MainFrame(QtGui.QWidget):
error = True
if error:
#view_params = get_view_params(self.ClientObj.client, \
# self.method_name + '_view', step = num, \
# expert = expert, brief = brief)
#self.button_call_thread = ClientServiceThread(self.ClientObj, \
# self.method_name + '_view', \
# int(self.ClientObj.sid), view_params)
#self.button_call_thread.signal.connect(self.expert_clicked_after)
# self.button_call_thread.start()
self.error_display(from_left_frame)
# self.ClientObj.param_objects[self.method_name]['error'] =\
# None
@ -2299,6 +2317,40 @@ class MainFrame(QtGui.QWidget):
left_check_step = QtCore.Signal(str, int)
left_check_step_after = QtCore.Signal()
def refresh_view(self, step=0, expert=False, from_left_frame=False):
"""
Обновить элемены view
:param step: текущая закладка параметров
:param expert: отображать экспертные параметры
:param brief: отображение предварительных установок
:param from_left_frame: запуск из закладок
"""
try:
brief = self.isBrief(step)
view_name = self.method_name + '_view'
view_params = get_view_params(self.ClientObj.client,
view_name,
step=None if brief else step,
expert=True if brief else expert,
brief=brief)
view_method = self.ClientObj.client.service[0][view_name]
view = view_method(int(self.ClientObj.sid), view_params)
except urllib2.URLError is e:
_print ('_view in mainframe Exception')
return 1
self.ClientObj.param_objects[self.method_name]['step'] = step
# display view in main frame
self.ClientObj.MainWidget.main_frame_view(view, self.method_name)
left_frame = self.ClientObj.MainWidget.left_frame
if from_left_frame and expert:
if left_frame.step == step:
self.left_check_step_after.connect(left_frame.check_step_after)
self.left_check_step_after.emit()
if from_left_frame and left_frame.step != step:
left_frame.check_step(str(self.method_name), left_frame.step)
def error_display(self, from_left_frame = False):
'''display error and warning in current view'''
if not self.error_output:
@ -2306,88 +2358,60 @@ class MainFrame(QtGui.QWidget):
return
self.button_enabled()
self.error_fined = False
curError = dict([(str(x.field),x)
for x in self.ClientObj.param_objects[self.method_name]['error']])
errorKeys = self.error_label_dict.keys()
for field in errorKeys + filter(lambda x:x not in errorKeys,curError):
if field in curError.keys():
error = curError[field]
for step_num in range (len (self.ClientObj.param_objects \
[self.method_name]['fields'])):
if error.field in self.ClientObj.param_objects \
[self.method_name]['fields'][step_num]:
self.error_fined = True
# Проверка на экспертное поле
field_names = self.ClientObj.param_objects \
[self.method_name]['fields'][step_num]
ind = field_names.index(error.field)
expert = True if (None in field_names[:ind]) else False
if from_left_frame and self.ClientObj.param_objects \
[self.method_name]['step'] != step_num:
continue
brief = self.isBrief(self.ClientObj.param_objects \
[self.method_name]['step'])
if (self.ClientObj.param_objects[self.method_name]['step']\
!= self.ClientObj.MainWidget.left_frame.step \
or expert) or brief:
try:
brief = self.isBrief(step_num)
if brief:
expert = True
num = None
else:
num = step_num
view_params = get_view_params(self.ClientObj. \
client, self.method_name + '_view', \
step = num, expert=expert, brief=brief)
view = self.ClientObj.client.service[0]\
[self.method_name+'_view']\
(int(self.ClientObj.sid), view_params)
except urllib2.URLError, e:
_print ('_view in mainframe Exception')
return 1
self.ClientObj.param_objects[self.method_name] \
['step'] = step_num
# display view in main frame
self.ClientObj.MainWidget.main_frame_view \
(view, self.method_name)
left_frame = self.ClientObj.MainWidget.left_frame
if from_left_frame and expert:
if left_frame.step == step_num:
self.left_check_step_after.connect( \
left_frame.check_step_after)
self.left_check_step_after.emit()
if from_left_frame and left_frame.step != step_num:
left_frame.check_step(str(self.method_name), \
left_frame.step)
# self.left_check_step.connect(left_frame.check_step\
# (str(self.method_name), left_frame.step))
# self.left_check_step.emit()
return
if not self.error_fined:
fields_name = ''
for error in self.ClientObj.param_objects[self.method_name] \
['error']:
fields_name += error.field + ', '
if fields_name:
fields_name = fields_name[:-2]
show_msg('Fields %s not found' %fields_name,'Field Error')
if self.error_label_dict.has_key(str(error.field)):
self.error_label_dict[error.field].setStyleSheet \
("QLabel { color : red; }")
error_msg = error.message.strip('\n')
self.error_label_dict[error.field].setText(error_msg)
self.error_label_dict[error.field].show()
if self.view_dict.has_key(str(error.field)):
self.highlight_element_error(error.field)
else:
if field in self.error_label_dict:
self.error_label_dict[field].hide()
self.unhighliht_element_errors(field)
curError = {str(x.field): x
for x in
self.ClientObj.param_objects[self.method_name]['error']}
for field in filter(lambda x:x not in curError,self.error_label_dict):
self.error_label_dict[field].hide()
self.unhighliht_element_errors(field)
for field in curError:
error = curError[field]
for step_num in range(len(self.ClientObj.param_objects \
[self.method_name]['fields'])):
if error.field in self.ClientObj.param_objects \
[self.method_name]['fields'][step_num]:
self.error_fined = True
# Проверка на экспертное поле
field_names = self.ClientObj.param_objects \
[self.method_name]['fields'][step_num]
ind = field_names.index(error.field)
# None - экспертный разделитель
expert = True if (None in field_names[:ind]) else False
if self.skip_options:
self.skip_options = False
self.refresh_view(step_num, expert, from_left_frame)
return
if from_left_frame and self.ClientObj.param_objects \
[self.method_name]['step'] != step_num:
continue
brief = self.isBrief(self.ClientObj.param_objects \
[self.method_name]['step'])
if (self.ClientObj.param_objects[self.method_name]['step']\
!= self.ClientObj.MainWidget.left_frame.step \
or expert) or brief:
self.refresh_view(step_num, expert, from_left_frame)
return
if not self.error_fined:
fields_name = ''
for error in self.ClientObj.param_objects[self.method_name] \
['error']:
fields_name += error.field + ', '
if fields_name:
fields_name = fields_name[:-2]
show_msg('Fields %s not found' %fields_name,'Field Error')
if self.error_label_dict.has_key(str(error.field)):
self.error_label_dict[error.field].setStyleSheet \
("QLabel { color : red; }")
error_msg = error.message.strip('\n')
self.error_label_dict[error.field].setText(error_msg)
self.error_label_dict[error.field].show()
if self.view_dict.has_key(str(error.field)):
self.highlight_element_error(error.field)
def unhighliht_element_errors(self,field_name):
if type (self.view_dict[field_name]) in [QGroupBox, SelectList]:

@ -27,6 +27,7 @@ from PIL import Image
from calculate.lib.utils.files import listDirectory
from calculate.lib.utils.colortext.palette import (
GreyPalette as WorkPalette)
from calculate.update.update_info import UpdateInfo
_('The user must not be root')
@ -2444,15 +2445,15 @@ class ClientSignal(QtCore.QThread):
except Exception, e:
show_msg (e.message, 'no connection to server!')
if reply == 0:
if not self.ClientObj.has_connect:
self.connect_count.emit(self.ClientObj.host_name,
#if not self.ClientObj.has_connect:
self.connect_count.emit(self.ClientObj.host_name,
self.ClientObj.port, 1)
self.ClientObj.has_connect = 1
#self.ClientObj.has_connect = 1
else:
if self.ClientObj.has_connect:
self.connect_count.emit(self.ClientObj.host_name,
#if self.ClientObj.has_connect:
self.connect_count.emit(self.ClientObj.host_name,
self.ClientObj.port, 0)
self.ClientObj.has_connect = 0
#self.ClientObj.has_connect = 0
self.sid_sig.emit(sid, reply)
for i in range (5):
time.sleep(float(client_active)/15.0)

@ -0,0 +1,8 @@
[Desktop Entry]
Type=Application
Name=Update checker
Comment=Check the system for updates
Icon=calculate-update
Exec=cl-update-checker
TryExec=cl-update-checker
OnlyShowIn=XFCE;

@ -28,8 +28,10 @@ signal.signal(signal.SIGINT, signal.SIG_DFL)
#signal.signal(signal.SIGINT, sigint_handler)
def main():
from calculate.consolegui.application.ConnectionTabs import ToolTabWidget,\
DBusWidget, parse, SelectedMethodWgt
from calculate.consolegui.application.ConnectionTabs import (ToolTabWidget,
parse, SelectedMethodWgt)
from calculate.consolegui.application.dbus_service import (DBUS_MAINAPP,
DBUS_NAME, DBUS_METHOD_APP, DBusWidget, dbus_updater_hide_tray)
__builtin__.__dict__['_print'] = _print
host, port, args = None, None, None
if len(sys.argv) > 1:
@ -42,6 +44,14 @@ def main():
app = QtGui.QApplication(sys.argv)
app.setQuitOnLastWindowClosed(True)
ex = SelectedMethodWgt(app, args)
if args.method == 'update':
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
session_bus = dbus.SessionBus()
# Export the service
name = dbus.service.BusName(DBUS_NAME, session_bus)
# Export the object
widget = DBusWidget(session_bus, DBUS_METHOD_APP % args.method,
ex)
sys.exit(app.exec_())
if args.host:
host = args.host
@ -64,10 +74,9 @@ def main():
iface = None
try:
# Get the remote object
remote_object = bus.get_object("org.calculate.consolegui",
"/org/calculate/consolegui")
remote_object = bus.get_object(DBUS_NAME, DBUS_MAINAPP)
# Get the remote interface for the remote object
iface = dbus.Interface(remote_object, "org.calculate.consolegui")
iface = dbus.Interface(remote_object, DBUS_NAME)
except dbus.DBusException:
pass
@ -88,17 +97,19 @@ def main():
second = True
# Do not complete the program then last window is closed
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
session_bus = dbus.SessionBus()
dbus_updater_hide_tray(session_bus)
app.setQuitOnLastWindowClosed(False)
ex = ToolTabWidget(app, args = args, host = host, port = port)
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
session_bus = dbus.SessionBus()
# Export the service
name = dbus.service.BusName("org.calculate.consolegui", session_bus)
name = dbus.service.BusName(DBUS_NAME, session_bus)
# Export the object
widget = DBusWidget(session_bus, '/org/calculate/consolegui', ex)
widget = DBusWidget(session_bus, DBUS_MAINAPP, ex)
sys.exit(app.exec_())
if __name__=='__main__':

@ -0,0 +1,189 @@
#!/usr/bin/env python
#-*- coding: utf-8 -*-
# Copyright 2012-2013 Calculate Ltd. http://www.calculate-linux.org
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
from PySide import QtCore, QtGui
import time
from calculate.core.client.cert_info import user_can_run_update
import dbus
import dbus.service
import dbus.mainloop.glib
from calculate.lib.utils.tools import debug
from calculate.consolegui.application.dbus_service import (DBUS_NAME,
DBUS_METHOD_APP, DBUS_MAINAPP, DBUS_APP_UPDATER, DBUS_NAME_UPDATER)
from calculate.update.update_info import UpdateInfo
GUI_UPDATE_APP = DBUS_METHOD_APP % "update"
class SysTray(QtGui.QSystemTrayIcon):
ICON = "/usr/share/pixmaps/calculate-console-update.png"
def __init__(self, parent):
super(SysTray, self).__init__()
self.parent = parent
self.timeout = 0
self.setIcon(QtGui.QIcon(self.ICON))
self.activated.connect(self.systrayActivate)
def run_cl_gui_update(self):
cmd = '/usr/bin/cl-console-gui'
method = "update"
params = ["--skip-options"]
os.system("{cmd} --method {method} {params} &>/dev/null &".format(
cmd=cmd, method=method, params=" ".join(params)))
def show_update(self):
try:
iface = self.parent.get_dbus_iface(GUI_UPDATE_APP)
if iface:
iface.show()
return True
except dbus.DBusException:
return False
return False
def systrayActivate(self, reason):
if time.time() > self.timeout:
self.timeout = time.time() + 5
self.show_update() or self.run_cl_gui_update()
self.parent.step()
class DBusChecker(dbus.service.Object):
def __init__(self, name, session, parent):
self.parent = parent
# export this object to dbus
dbus.service.Object.__init__(self, name, session)
@dbus.service.method(DBUS_NAME_UPDATER, in_signature='', out_signature='')
def hide_systray(self):
self.parent.systray.hide()
@dbus.service.method(DBUS_NAME_UPDATER, in_signature='', out_signature='')
def show_systray(self):
self.parent.systray.show()
@dbus.service.method(DBUS_NAME_UPDATER, in_signature='', out_signature='b')
def ping(self):
return True
@dbus.service.method(DBUS_NAME_UPDATER, in_signature='', out_signature='')
def quit(self):
QtGui.qApp.quit()
@dbus.service.method(DBUS_NAME_UPDATER, in_signature='', out_signature='')
def check(self):
self.parent.step()
class CheckThread(QtGui.QMainWindow, UpdateInfo):
interval = 10
def __init__(self, bus):
super(CheckThread, self).__init__()
UpdateInfo.__init__(self)
self.bus = bus
self.already_timer = QtCore.QTimer(self)
self.already_timer.timeout.connect(self.step_already)
self.already_timer.start(1000)
self.check_timer = QtCore.QTimer(self)
self.check_timer.timeout.connect(self.step)
self.check_timer.start(self.interval * 1000)
self.systray = SysTray(self)
self.gui_runned = False
self.step()
def get_dbus_iface(self, app_name):
try:
remote_object = self.bus.get_object(DBUS_NAME, app_name)
return dbus.Interface(remote_object, DBUS_NAME)
except dbus.DBusException:
return None
def ping_app(self, app_name):
try:
obj = self.get_dbus_iface(app_name)
if obj:
obj.ping()
return True
except dbus.DBusException:
pass
return False
def is_console_gui_run(self):
return self.ping_app(DBUS_MAINAPP)
def is_gui_update_run(self):
return self.ping_app(GUI_UPDATE_APP)
def step_already(self):
now_gui_runned = self.is_gui_update_run()
if (self.is_console_gui_run() or
(not now_gui_runned and
(self.update_already_run() or self.gui_runned))):
self.systray.hide()
self.gui_runned = now_gui_runned
def step(self):
if not self.is_console_gui_run():
if (self.need_update() and not self.update_already_run() or
self.is_gui_update_run()):
self.systray.show()
return
self.systray.hide()
if __name__ == '__main__':
import sys
if not user_can_run_update():
sys.stderr.write(_("User can not to perform the system update")+"\n")
sys.exit(1)
app = QtGui.QApplication(sys.argv)
for i in [0.5, 1, 2, 5]:
if QtGui.QSystemTrayIcon.isSystemTrayAvailable():
break
time.sleep(i)
else:
QtGui.QMessageBox.critical(None, "Systray",
"I couldn't detect any system tray on this system.")
sys.exit(1)
# Enable glib main loop support
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
# Get the session bus
try:
bus = dbus.SessionBus()
except dbus.exceptions.DBusException, e:
sys.exit(1)
QtGui.QApplication.setQuitOnLastWindowClosed(False)
# Export the service
name = dbus.service.BusName(DBUS_NAME_UPDATER, bus)
# Export the object
ct = CheckThread(bus)
DBusChecker(bus, DBUS_APP_UPDATER, ct)
sys.exit(app.exec_())

@ -41,6 +41,8 @@ data_files.append(('/usr/share/applications',
['data/cl-console-gui-install.desktop',
'data/cl-console-gui-update.desktop',
'data/cl-console-gui.desktop']))
data_files.append(('/etc/xdg/autostart',
['data/cl-update-checker.desktop']))
data_files.append(('/usr/share/calculate/themes/install',
['data/install/conf','data/install/welcome.jpg',
'data/install/finish.jpg']))
@ -100,6 +102,6 @@ setup(
package_dir = {'calculate.consolegui': "consolegui"},
packages = ['calculate.consolegui','calculate.consolegui.variables',
'calculate.consolegui.application'],
scripts = ['./scripts/cl-console-gui'],
scripts = ['./scripts/cl-console-gui','./scripts/cl-update-checker'],
cmdclass={'cl_console_data': cl_console_data}
)

Loading…
Cancel
Save