You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
843 lines
33 KiB
843 lines
33 KiB
#!/usr/bin/python
|
|
#-*- coding: utf-8 -*-
|
|
|
|
# Copyright 2012 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.
|
|
|
|
from PySide import QtGui, QtCore
|
|
import urllib2, sudsds
|
|
|
|
from calculate.core.client.function import switch, create_obj
|
|
|
|
from more import get_sid, ClientServiceThread, show_msg, TaskWidget, ErrorWgt,\
|
|
ResultLayout, get_view_params
|
|
from more import LabelWordWrap as Label
|
|
from SelectTable import SelectedTableWidget
|
|
|
|
class LabelWordWrap(Label):
|
|
def __init__(self, name, parent = None):
|
|
Label.__init__(self, name, parent)
|
|
# set text selectable
|
|
self.setTextInteractionFlags(self.textInteractionFlags() | \
|
|
QtCore.Qt.TextSelectableByMouse)
|
|
|
|
class PlusButton(QtGui.QPushButton):
|
|
def __init__(self, parent, ClientObj, method):
|
|
QtGui.QPushButton.__init__(self, parent)
|
|
try:
|
|
self.setIcon(QtGui.QIcon.fromTheme('list-add'))
|
|
except:
|
|
self.setText('+')
|
|
self._parent = parent
|
|
self.ClientObj = ClientObj
|
|
self.method = method
|
|
self.setFixedWidth(30)
|
|
self.clicked.connect(self.call_method)
|
|
|
|
def call_method(self):
|
|
# Call server method
|
|
if hasattr (self, 'get_Frame_thread'):
|
|
if self.get_Frame_thread.isRunning():
|
|
return 1
|
|
sid = int(self.ClientObj.sid)
|
|
view_params = get_view_params(self.ClientObj.client, \
|
|
self.method + '_view')
|
|
self.get_Frame_thread = ClientServiceThread(self.ClientObj,\
|
|
self.method + '_view', sid, view_params)
|
|
self.get_Frame_thread.signal.connect(self.after_call)
|
|
self.get_Frame_thread.start()
|
|
|
|
def after_call(self, view):
|
|
if self.ClientObj.method_names.has_key(self.method):
|
|
view_method = self._parent.ClientObj.method_names \
|
|
[self.method]
|
|
else:
|
|
view_method = self.method
|
|
self._parent.ClientObj._parent.setWindowTitle(view_method + \
|
|
' - ' + self.ClientObj.Name)
|
|
self._parent._parent.main_frame_view(view, self.method)
|
|
|
|
class MainFrameRes(QtGui.QWidget):
|
|
valSignal = QtCore.Signal()
|
|
def __init__(self, parent, ClientObj, method_name, meth_result, \
|
|
change_offset = False):
|
|
# super(MainFrameRes, self).__init__(self, parent)
|
|
QtGui.QWidget.__init__(self, parent)
|
|
self._parent = parent
|
|
self.ClientObj = ClientObj
|
|
self.method_name = method_name
|
|
self.meth_result = meth_result
|
|
self.client = ClientObj.client
|
|
self.cur_pid = 0
|
|
self.change_offset = change_offset
|
|
|
|
if self.meth_result.type == "pid":
|
|
self.cur_pid = self.meth_result.message
|
|
|
|
self.work_layout = ResultLayout(self)
|
|
self.work_layout.kill_process_button.clicked.connect \
|
|
(self.kill_process(self.cur_pid))
|
|
self.valSignal.connect(ClientObj.MainWidget.setScrollBarVal)
|
|
|
|
self.progress_list = []
|
|
self.task_list = []
|
|
|
|
self._parent.methodname_wgt.show()
|
|
self._parent.control_button.show()
|
|
self._parent.control_button.del_button()
|
|
if self.ClientObj.method_names.has_key(self.method_name):
|
|
self._parent.methodname_wgt.setMethodName \
|
|
(self.ClientObj.method_names[self.method_name])
|
|
else:
|
|
self._parent.methodname_wgt.setMethodName(method_name)
|
|
parent.main_frame.viewport().setObjectName('main_frame')
|
|
parent.main_frame.viewport().setStyleSheet("#main_frame "
|
|
"{background-color: #E4E1E0;}")
|
|
self.setObjectName('Frame_Res')
|
|
self.setStyleSheet("#Frame_Res {background-color: transparent;}")
|
|
# "QWidget {border: 1px solid red;}")
|
|
|
|
def initUI(self):
|
|
self.updateGeometry()
|
|
|
|
################# API FUNCTION ###############################
|
|
def show_view(self, view):
|
|
pass
|
|
|
|
def show_table(self, table, item):
|
|
# method to display tables
|
|
add_offset_flag = False
|
|
|
|
if not table.body:
|
|
table.body = [[]]
|
|
self.show_normal(item)
|
|
|
|
if self.method_name in self.ClientObj.param_objects:
|
|
if len(table.body[0]) >= self.ClientObj.count_row_res_table or \
|
|
self.ClientObj.param_objects[self.method_name]['offset']:
|
|
|
|
if table.onClick:
|
|
self.add_offset_buttons(len(table.body[0]),table.addAction)
|
|
add_offset_flag = True
|
|
|
|
if table.addAction and not add_offset_flag:
|
|
self.work_layout._addWidget(PlusButton(self, self.ClientObj, \
|
|
table.addAction))
|
|
if table.onClick:
|
|
self.mytable = SelectedTableWidget(len(table.body[0]), \
|
|
len(table.head[0]), self)
|
|
|
|
if not hasattr (self, 'mytable'):
|
|
if table.body:
|
|
len_body = len(table.body[0])
|
|
else:
|
|
len_body = 1
|
|
if table.head:
|
|
len_head = len(table.head[0])
|
|
else:
|
|
len_head = 1
|
|
self.mytable = SelectedTableWidget(len_body, len_head, self,
|
|
readonly = True)
|
|
list_head = table.head[0]
|
|
self.mytable.setHorizontalHeaderLabels(list_head)
|
|
for line in range(len(table.body[0])):
|
|
for i in range(len(table.body[0][line][0])):
|
|
tablewidgetitem = QtGui.QTableWidgetItem \
|
|
(table.body[0][line][0][i])
|
|
self.mytable.setItem(line, i, tablewidgetitem)
|
|
# set writeonly
|
|
self.mytable.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
|
|
|
|
if table.onClick:
|
|
self.mytable.itemClicked.connect(self.row_activate(table))
|
|
|
|
self.mytable.setColor()
|
|
minimum = QtGui.QSizePolicy.Minimum
|
|
self.mytable.setSizePolicy(minimum, minimum)
|
|
self.mytable.verticalHeader().hide()
|
|
self.mytable.horizontalHeader().resizeSections \
|
|
(QtGui.QHeaderView.ResizeMode.ResizeToContents)
|
|
self.work_layout._addWidget(self.mytable)
|
|
self.ClientObj.app.processEvents()
|
|
|
|
self.initUI()
|
|
|
|
def row_activate(self, table):
|
|
def wrapper(item):
|
|
param_object = create_obj(self.client, table.onClick)
|
|
for field in table.fields.string:
|
|
if field:
|
|
if hasattr (param_object, field):
|
|
param_object[field] = self.mytable.item(item.row(),0).\
|
|
text()
|
|
# Calling method
|
|
sid = int(self.ClientObj.sid)
|
|
self.client.service[0][table.onClick](sid, param_object)
|
|
|
|
# Calling View
|
|
try:
|
|
view_params = get_view_params(self.client, \
|
|
table.onClick + '_view', step = 0)
|
|
view = self.client.service[0][table.onClick + '_view'] \
|
|
(sid, view_params)
|
|
except sudsds.MethodNotFound, e:
|
|
_print(e)
|
|
return
|
|
if self._parent.ClientObj.method_names.has_key(table.onClick):
|
|
view_method = self._parent.ClientObj.method_names \
|
|
[table.onClick]
|
|
else:
|
|
view_method = table.onClick
|
|
self._parent.ClientObj._parent.setWindowTitle(view_method + \
|
|
' - ' + self.ClientObj.Name)
|
|
self.ClientObj.param_objects[self.method_name]['offset'] = 0
|
|
self._parent.main_frame_view(view, table.onClick)
|
|
return wrapper
|
|
|
|
def add_offset_buttons(self, len_body, addAction):
|
|
offset_buttons = QtGui.QWidget()
|
|
layout = QtGui.QHBoxLayout(offset_buttons)
|
|
layout.setAlignment(QtCore.Qt.AlignLeft)
|
|
|
|
minus_offset = QtGui.QPushButton(offset_buttons)
|
|
minus_offset.setIcon(QtGui.QIcon.fromTheme('go-previous'))
|
|
minus_offset.setToolTip('Previous page')
|
|
minus_offset.clicked.connect(self.call_method_with_offset \
|
|
(-1*int(self.ClientObj.count_row_res_table)))
|
|
minus_offset.setFixedWidth(30)
|
|
|
|
if not self.ClientObj.param_objects[self.method_name]['offset']:
|
|
minus_offset.setDisabled(True)
|
|
|
|
layout.addWidget(minus_offset)
|
|
|
|
plus_offset = QtGui.QPushButton(offset_buttons)
|
|
plus_offset.setIcon(QtGui.QIcon.fromTheme('go-next'))
|
|
plus_offset.setToolTip('Next page')
|
|
plus_offset.clicked.connect(self.call_method_with_offset \
|
|
(int(self.ClientObj.count_row_res_table)))
|
|
plus_offset.setFixedWidth(30)
|
|
|
|
if len_body < self.ClientObj.count_row_res_table:
|
|
plus_offset.setDisabled(True)
|
|
layout.addWidget(plus_offset)
|
|
if addAction:
|
|
layout.addWidget(PlusButton(self, self.ClientObj, addAction))
|
|
|
|
self.work_layout._addWidget(offset_buttons)
|
|
|
|
def call_method_with_offset(self, offset):
|
|
def wrapper():
|
|
self.ClientObj.param_objects[self.method_name]['offset'] += offset
|
|
if self.ClientObj.param_objects[self.method_name]['offset'] < 0:
|
|
self.ClientObj.param_objects[self.method_name]['offset'] = 0
|
|
|
|
# Calling View
|
|
sid = int(self.ClientObj.sid)
|
|
try:
|
|
view_params = get_view_params(self.client, \
|
|
self.method_name + '_view', step = 0)
|
|
view = self.client.service[0][self.method_name + '_view'] \
|
|
(sid, view_params)
|
|
except sudsds.MethodNotFound:
|
|
return
|
|
if self._parent.ClientObj.method_names.has_key(self.method_name):
|
|
view_method = self._parent.ClientObj.method_names \
|
|
[self.method_name]
|
|
else:
|
|
view_method = self.method_name
|
|
self._parent.ClientObj._parent.setWindowTitle(view_method + \
|
|
' - ' + self.ClientObj.Name)
|
|
self._parent.main_frame_view(view, view_method, \
|
|
change_offset = True)
|
|
return wrapper
|
|
|
|
def show_normal(self, item):
|
|
if not hasattr (item, 'message'):
|
|
return
|
|
if item.message:
|
|
# add normal message label
|
|
lbl_temp = LabelWordWrap(item.message, self)
|
|
|
|
lbl_temp.setMinimumHeight(lbl_temp.sizeHint().height())
|
|
self.work_layout._addWidget(lbl_temp)
|
|
self.initUI()
|
|
|
|
def show_error(self, message):
|
|
# add error message label
|
|
self.set_result_task(True)
|
|
if self.progress_list:
|
|
self.progress_list[len(self.progress_list)-1].hide()
|
|
if message:
|
|
lbl_temp = ErrorWgt(message, self)
|
|
lbl_temp.set_error()
|
|
lbl_temp.setMinimumHeight(lbl_temp.sizeHint().height())
|
|
self.work_layout._addWidget(lbl_temp)
|
|
|
|
self.initUI()
|
|
|
|
def show_warning(self, item):
|
|
# add warning message label
|
|
if item.message:
|
|
lbl_temp = ErrorWgt(item.message, self)
|
|
lbl_temp.set_warning()
|
|
self.work_layout._addWidget(lbl_temp)
|
|
self.initUI()
|
|
|
|
def show_group(self, item):
|
|
pass
|
|
|
|
def show_result(self, result):
|
|
# add normal message label
|
|
lbl_temp = LabelWordWrap(result.message, self)
|
|
|
|
lbl_temp.setMinimumHeight(lbl_temp.sizeHint().height())
|
|
self.work_layout._addWidget(lbl_temp)
|
|
|
|
self.initUI()
|
|
|
|
def startTask(self, item):
|
|
if self.progress_list:
|
|
self.progress_list[len(self.progress_list)-1].hide()
|
|
task_widget = TaskWidget(item.message, self)
|
|
|
|
self.task_list.append(task_widget)
|
|
self.work_layout._addWidget(task_widget)
|
|
self.initUI()
|
|
|
|
def endTask(self, item, set_res = True):
|
|
if set_res:
|
|
self.set_result_task()
|
|
message = item.message if item.message else ''
|
|
if message:
|
|
lbl_temp = LabelWordWrap(message, self)
|
|
|
|
lbl_temp.setMinimumHeight(lbl_temp.sizeHint().height())
|
|
self.work_layout._addWidget(lbl_temp)
|
|
self.initUI()
|
|
|
|
def set_result_task(self, error = False):
|
|
if not len(self.task_list):
|
|
return
|
|
if error:
|
|
self.task_list[len(self.task_list) - 1].set_error()
|
|
else:
|
|
self.task_list[len(self.task_list) - 1].set_ok()
|
|
|
|
def beginFrame(self, item):
|
|
pass
|
|
|
|
def endFrame(self, item):
|
|
if self.progress_list:
|
|
self.progress_list[len(self.progress_list)-1].hide()
|
|
self.endTask(item)
|
|
|
|
self.initUI()
|
|
self.work_layout.hide_kill_button()
|
|
self.close_all_thread()
|
|
if self.change_offset:
|
|
self._parent.delete_MainFrameWgt()
|
|
self._parent.MainFrameWgt = self
|
|
self._parent.main_frame.setWidget (self._parent.MainFrameWgt)
|
|
self._parent.main_frame.setWidgetResizable(True)
|
|
self._parent.methodname_wgt.show()
|
|
self._parent.control_button.show()
|
|
self._parent.control_button.add_clear_cache_button(self.cur_pid)
|
|
self.initUI()
|
|
return 0
|
|
|
|
if hasattr (self, "mytable"):
|
|
if not self.mytable.readonly:
|
|
self.initUI()
|
|
return 0
|
|
|
|
self._parent.control_button.add_clear_cache_button(self.cur_pid)
|
|
self.initUI()
|
|
|
|
# def clear_pid_cache(self):
|
|
# self.clear_proc_cache_button.setDisabled(True)
|
|
# sid = int(self.ClientObj.sid)
|
|
# res = self.client.service.clear_pid_cache(sid, self.cur_pid)
|
|
# if res:
|
|
# _print (_('Error closing the process'))
|
|
# self._parent.back()
|
|
|
|
def startGroup(self, item):
|
|
pass
|
|
|
|
def endGroup(self, item):
|
|
pass
|
|
|
|
def callView(self, item, sid):
|
|
return 0
|
|
|
|
def kill_process(self, pid):
|
|
def wrapper():
|
|
sid = int(self.ClientObj.sid)
|
|
|
|
# Call server method
|
|
if hasattr (self, 'kill_process_thread'):
|
|
if self.kill_process_thread.isRunning():
|
|
return 1
|
|
self.kill_process_thread = ClientServiceThread(self.ClientObj,\
|
|
'pid_kill', pid, sid)
|
|
self.kill_process_thread.signal.connect(self.kill_process_after)
|
|
self.kill_process_thread.start()
|
|
return wrapper
|
|
|
|
def kill_process_after(self, result):
|
|
if result in [0,2]:
|
|
return 0
|
|
elif result == -1:
|
|
msg = _("Certificate not found in the server!")
|
|
elif result == -2:
|
|
msg = _("Session not matching your certificate!")
|
|
elif result == 1:
|
|
msg = _("Failed to kill the process!")
|
|
else:
|
|
msg = 'error'
|
|
|
|
show_msg(msg)
|
|
|
|
###############################################################################
|
|
|
|
def analysis(self, meth_result):
|
|
""" analysis of the bounced message method """
|
|
# for mess in meth_result:
|
|
self.ClientObj.app.processEvents()
|
|
mess = meth_result
|
|
if mess.type == 'pid':
|
|
self.get_messages(self.ClientObj.sid, mess.message)
|
|
if mess.type == 'error':
|
|
try:
|
|
self.show_error(self, mess.message)
|
|
except:
|
|
pass
|
|
if mess.type == 'warning':
|
|
try:
|
|
self.show_warning(self, mess)
|
|
except:
|
|
pass
|
|
|
|
def get_message(self, item, sid, pid):
|
|
try:
|
|
if self.cur_pid != pid:
|
|
return 1
|
|
except:
|
|
return 1
|
|
""" get one message by its type """
|
|
for case in switch(item.type):
|
|
if case('normal'):
|
|
self.show_normal(item)
|
|
return 1
|
|
if case('plain'):
|
|
self.show_normal(item)
|
|
return 1
|
|
if case('progress'):
|
|
self.get_Progress(sid, pid, item.id)
|
|
return 1
|
|
if case('error'):
|
|
# for i in range(20):
|
|
self.show_error(item.message)
|
|
if item.message == "403 Forbidden":
|
|
# show_msg(item.message, 'Access Denied')
|
|
return 0
|
|
return 1
|
|
if case('warning'):
|
|
self.show_warning(item)
|
|
return 1
|
|
if case('table'):
|
|
self.get_Table(sid, pid, item)
|
|
return 1
|
|
if case('group'):
|
|
self.show_group(sid, pid, item)
|
|
return 1
|
|
if case('question'):
|
|
self.send_Message(sid, pid, item)
|
|
return 1
|
|
if case('password'):
|
|
self.send_Password(sid, pid, item)
|
|
return 1
|
|
if case('startTask'):
|
|
self.startTask(item)
|
|
return 1
|
|
if case('taskNumber'):
|
|
# self.startTask(item)
|
|
return 1
|
|
if case('endTask'):
|
|
self.endTask(item)
|
|
return 1
|
|
if case('beginFrame'):
|
|
self.beginFrame(item)
|
|
return 1
|
|
if case('endFrame'):
|
|
self.endFrame(item)
|
|
self.resize(self.sizeHint())
|
|
return 0
|
|
if case('startGroup'):
|
|
self.startGroup(item)
|
|
return 1
|
|
if case('endGroup'):
|
|
self.endGroup(item)
|
|
return 1
|
|
if case('briefParams'):
|
|
self.callView(item, sid)
|
|
if case(): # default, could also just omit condition or 'if True'
|
|
return 1
|
|
|
|
def get_messages(self, sid, pid):
|
|
""" get frame in a separate thread """
|
|
#thread_messages = threading.Thread(target=get_Frame,\
|
|
#args = (client, sid, pid))
|
|
#thread_messages.start()
|
|
self.get_Frame(sid, pid)
|
|
|
|
def get_Frame(self, sid, pid, def_end_frame = 1):
|
|
""" get all messages, until type is not endFrame (or Error) """
|
|
self.not_end_frame = def_end_frame
|
|
|
|
if self.not_end_frame:
|
|
# Call server method
|
|
if hasattr (self, 'get_Frame_thread'):
|
|
if self.get_Frame_thread.isRunning():
|
|
self.get_Frame_thread.wait()
|
|
self.get_Frame_thread = ClientServiceThread(self.ClientObj,\
|
|
'get_frame', sid, pid, return_except = True, \
|
|
through_object = (sid, pid))
|
|
self.get_Frame_thread.signal_extended.connect(self.get_Frame_cycle)
|
|
self.get_Frame_thread.start()
|
|
|
|
def get_Frame_cycle(self, current_frame, through_object):
|
|
if type(current_frame) == Exception:
|
|
_print (_("Failed to get a frame from the server."))
|
|
show_msg(_("Failed to get a frame from the server.") +'\n'+ \
|
|
_('Try resfeshing this page later.'),'get frame error')
|
|
return 1
|
|
sid, pid = through_object
|
|
if current_frame in [None, [], ""]:
|
|
try:
|
|
if self.cur_pid != pid:
|
|
return 1
|
|
except:
|
|
return 1
|
|
else:
|
|
self.get_Frame_after(current_frame, sid, pid)
|
|
if self.not_end_frame:
|
|
# Call server method
|
|
if hasattr (self, 'get_Frame_thread'):
|
|
if self.get_Frame_thread.isRunning():
|
|
self.get_Frame_thread.wait()
|
|
self.get_Frame_thread = ClientServiceThread(self.ClientObj,\
|
|
'get_frame', sid, pid, return_except = True, \
|
|
sleeptime = int(self.ClientObj.client.frame_period),\
|
|
through_object = (sid, pid))
|
|
self.get_Frame_thread.signal_extended.connect(self.get_Frame_cycle)
|
|
self.get_Frame_thread.start()
|
|
|
|
def get_Frame_after(self, current_frame, sid, pid):
|
|
for item in range(len(current_frame[0])):
|
|
self.not_end_frame = self.get_message(current_frame[0][item], \
|
|
sid, pid)
|
|
try:
|
|
if self.cur_pid != pid:
|
|
return 1
|
|
except:
|
|
return 1
|
|
if len (current_frame[0]) > 3:
|
|
if not item % 10:
|
|
self.ClientObj.app.processEvents()
|
|
else:
|
|
self.ClientObj.app.processEvents()
|
|
self.valSignal.emit()
|
|
|
|
def get_entire_frame(self, pid = None):
|
|
""" get entire frame, from beginning (if client disconnected) """
|
|
self.ClientObj.app.processEvents()
|
|
|
|
sid = get_sid(self.ClientObj.client)
|
|
if not pid:
|
|
try:
|
|
list_pid = self.ClientObj.client.service.list_pid(sid = sid)
|
|
except urllib2.URLError, e:
|
|
_print ('get_entire_frame in MainFrameResult Exception')
|
|
show_msg (e, _("Not connected!"))
|
|
return 1
|
|
else:
|
|
list_pid = {}
|
|
list_pid[0] = [pid]
|
|
|
|
if list_pid[0] == [0]:
|
|
return 0
|
|
pid = list_pid[0][0]
|
|
|
|
|
|
# Call server method
|
|
if hasattr (self, 'get_Frame_thread'):
|
|
if self.get_Frame_thread.isRunning():
|
|
self.get_Frame_thread.wait()
|
|
self.get_Frame_thread = ClientServiceThread(self.ClientObj,\
|
|
'get_entire_frame', sid, pid, return_except = True, \
|
|
through_object = (sid, pid))
|
|
self.get_Frame_thread.signal_extended.connect \
|
|
(self.get_entire_frame_after)
|
|
self.get_Frame_thread.start()
|
|
|
|
def get_entire_frame_after(self, current_frame, through_object):
|
|
if type(current_frame) == Exception:
|
|
_print (_('Failed to get the complete frame from the server.'))
|
|
# show_msg(_("Failed to get a frame from the server.") +'\n'+ \
|
|
# _('Try resfeshing this page later.'),'get frame error')
|
|
return 1
|
|
sid, pid = through_object
|
|
end_frame = 1
|
|
if not current_frame in [None, [], ""]:
|
|
# for i in range (10):
|
|
for item in range(len(current_frame[0])):
|
|
end_frame = self.get_message(current_frame[0][item], sid, pid)
|
|
try:
|
|
if self.cur_pid != pid:
|
|
return 1
|
|
except:
|
|
return 1
|
|
if len (current_frame[0]) > 3:
|
|
if not item % 10:
|
|
self.ClientObj.app.processEvents()
|
|
else:
|
|
self.ClientObj.app.processEvents()
|
|
|
|
self.get_Frame(sid, pid, def_end_frame = end_frame)
|
|
|
|
def get_Progress(self, sid, pid, id):
|
|
""" get progress for the current job """
|
|
|
|
progressBar = QtGui.QProgressBar()
|
|
progressBar.setMinimumHeight(progressBar.sizeHint().height())
|
|
progressBar.setTextVisible(True)
|
|
self.progress_list.append(progressBar)
|
|
self.work_layout._addWidget(progressBar)
|
|
|
|
progressBar.setMinimum(0)
|
|
progressBar.setMaximum(0)
|
|
self.initUI()
|
|
temp_progress = -1
|
|
# Call server method
|
|
if hasattr (self, 'get_Progress_thread'):
|
|
if self.get_Progress_thread.isRunning():
|
|
self.get_Progress_thread.wait()
|
|
self.get_Progress_thread = ClientServiceThread(self.ClientObj,\
|
|
'get_progress', sid, pid, id, return_except = True, \
|
|
through_object = (sid, pid, id, temp_progress, \
|
|
progressBar))
|
|
self.get_Progress_thread.signal_extended.connect \
|
|
(self.get_Progress_cycle)
|
|
self.get_Progress_thread.start()
|
|
|
|
def get_Progress_cycle(self, returnProgr, through_object):
|
|
if type(returnProgr) == Exception:
|
|
_print (_('Failed to get the progress status from the server'))
|
|
# show_msg(_('Failed to get the progress status from the server') + \
|
|
# '\n'+ \
|
|
# _('Try resfeshing this page later.'),'get progress error')
|
|
return 1
|
|
sid, pid, id, temp_progress, progressBar = through_object
|
|
########################################
|
|
try:
|
|
percent = returnProgr.percent
|
|
except AttributeError:
|
|
if type(returnProgr) in [str,unicode]:
|
|
_print ('Server return:', returnProgr)
|
|
percent = temp_progress
|
|
if percent <= 100 and percent >= 0 :
|
|
if temp_progress != percent:
|
|
if percent:
|
|
# progressBar.setProperty("value", 100)
|
|
progressBar.setMaximum(100)
|
|
# progressBar.setValue(percent)
|
|
self.set_progress_value(progressBar, returnProgr)
|
|
if percent == 100:
|
|
return 0
|
|
self.initUI()
|
|
temp_progress = percent
|
|
try:
|
|
if self.cur_pid != pid:
|
|
return 1
|
|
except:
|
|
return 1
|
|
|
|
# Call server method
|
|
if hasattr (self, 'get_Progress_thread'):
|
|
if self.get_Progress_thread.isRunning():
|
|
self.get_Progress_thread.wait()
|
|
self.get_Progress_thread = ClientServiceThread(self.ClientObj,\
|
|
'get_progress', sid, pid, id, return_except = True,\
|
|
sleeptime = 1, through_object = \
|
|
(sid, pid, id, temp_progress, progressBar))
|
|
self.get_Progress_thread.signal_extended.connect \
|
|
(self.get_Progress_cycle)
|
|
self.get_Progress_thread.start()
|
|
|
|
if percent < 0:
|
|
progressBar.setMaximum(100)
|
|
returnProgr.percent = 0 - percent
|
|
self.set_progress_value(progressBar, returnProgr)
|
|
self.ClientObj.app.processEvents()
|
|
self.initUI()
|
|
|
|
def set_progress_value(self, progressBar, returnProgr):
|
|
if returnProgr.long_message:
|
|
if progressBar.fontMetrics().width(returnProgr.long_message) + \
|
|
progressBar.fontMetrics().width(' 000%') \
|
|
< progressBar.width():
|
|
progressBar.setFormat('%s %d%%' %(returnProgr.long_message, \
|
|
returnProgr.percent))
|
|
progressBar.setValue(returnProgr.percent)
|
|
self.ClientObj.app.processEvents()
|
|
return 0
|
|
if returnProgr.short_message:
|
|
progressBar.setFormat('%s %d%%' %(returnProgr.short_message, \
|
|
returnProgr.percent))
|
|
progressBar.setValue(returnProgr.percent)
|
|
self.ClientObj.app.processEvents()
|
|
return 0
|
|
progressBar.setFormat('%d%%' %returnProgr.percent)
|
|
progressBar.setValue(returnProgr.percent)
|
|
self.ClientObj.app.processEvents()
|
|
|
|
def get_Table(self, sid, pid, item):
|
|
try:
|
|
table = self.ClientObj.client.service.get_table(sid, pid, item.id)
|
|
except urllib2.URLError:
|
|
self.show_error('Error get table from server')
|
|
return 1
|
|
|
|
self.show_table(table, item)
|
|
self.ClientObj.app.processEvents()
|
|
# Resize table
|
|
h = self.mytable.horizontalHeader().height() + \
|
|
2 * self.mytable.frameWidth()
|
|
h += self.mytable.horizontalScrollBar().sizeHint().height()
|
|
for row_in_table in range (self.mytable.rowCount()):
|
|
h += self.mytable.rowHeight(row_in_table)
|
|
self.mytable.setFixedHeight(h)
|
|
|
|
def send_Message(self, sid, pid, item):
|
|
""" send answer to the question """
|
|
self.message = MessageDialog(self, item, sid, pid)
|
|
self.message.show()
|
|
|
|
def send_Password(self, sid, pid, item):
|
|
""" send password """
|
|
self.passwd = MessageDialog(self, item, sid, pid, True)
|
|
self.passwd.show()
|
|
|
|
def close_all_thread(self):
|
|
if hasattr (self, 'get_Frame_thread'):
|
|
if self.get_Frame_thread.isRunning():
|
|
self.get_Frame_thread.close()
|
|
self.get_Frame_thread.wait()
|
|
|
|
if hasattr (self, 'get_Progress_thread'):
|
|
if self.get_Progress_thread.isRunning():
|
|
self.get_Progress_thread.close()
|
|
self.get_Progress_thread.wait()
|
|
|
|
if hasattr (self, 'send_password_thread'):
|
|
if self.send_password_thread.isRunning():
|
|
self.send_password_thread.close()
|
|
self.send_password_thread.wait()
|
|
|
|
def closeEvent(self, event):
|
|
self.cur_pid = 'no'
|
|
self.close_all_thread()
|
|
self._parent.methodname_wgt._hide()
|
|
self._parent.control_button._hide()
|
|
event.accept()
|
|
|
|
class MessageDialog(QtGui.QWidget):
|
|
# answer to the server question
|
|
def __init__(self, parent, item, sid, pid, isPassword = False):
|
|
super(MessageDialog, self).__init__()
|
|
self._parent = parent
|
|
# self.item = item
|
|
self.sid = sid
|
|
self.pid = pid
|
|
self.layout = QtGui.QGridLayout(self)
|
|
|
|
self.label = LabelWordWrap(item.message, self)
|
|
|
|
self.pass_edit = QtGui.QLineEdit(self)
|
|
self.layout.addWidget(self.label,0,0)
|
|
self.layout.addWidget(self.pass_edit,0,1)
|
|
|
|
x = 1
|
|
if isPassword:
|
|
self.pass_edit.setEchoMode(self.pass_edit.Password)
|
|
if item.id == 2:
|
|
if hasattr(self,'pass_edit2'):
|
|
self.pass_edit2 = QtGui.QLineEdit(self)
|
|
self.pass_edit2.setEchoMode(self.pass_edit2.Password)
|
|
|
|
self.layout.addWidget(LabelWordWrap(_('Repeat'), self), x, 0)
|
|
self.layout.addWidget(self.pass_edit2, x, 1)
|
|
x += 1
|
|
self.pass_edit.textChanged.connect(self.check_passwd)
|
|
if hasattr(self,'pass_edit2'):
|
|
self.pass_edit2.textChanged.connect(self.check_passwd)
|
|
|
|
self.send_button = QtGui.QPushButton(_('Send'), self)
|
|
self.send_button.setShortcut(QtGui.QKeySequence(QtCore.Qt.Key_Return))
|
|
self.send_button.clicked.connect(self.send_password)
|
|
|
|
self.layout.addWidget(self.send_button,x,1)
|
|
|
|
self.move(parent.ClientObj._parent.geometry().x() + \
|
|
parent.ClientObj._parent.geometry().width() / 2 \
|
|
- self.sizeHint().width() / 2, \
|
|
parent.ClientObj._parent.geometry().y() + \
|
|
parent.ClientObj._parent.geometry().height() / 2 \
|
|
- self.sizeHint().height() / 2)
|
|
self.setWindowFlags (QtCore.Qt.WindowMinimizeButtonHint)
|
|
# self.setAttribute(QtCore.Qt.WA_ShowModal)
|
|
|
|
def send_password(self):
|
|
answer = self.pass_edit.text()
|
|
if not hasattr(self,"pass_edit2") or \
|
|
answer == self.pass_edit2.text():
|
|
|
|
# Call server method
|
|
if hasattr (self, 'send_password_thread'):
|
|
if self.send_password_thread.isRunning():
|
|
return 1
|
|
self.send_password_thread = ClientServiceThread(\
|
|
self._parent.ClientObj, 'send_message', self.sid, \
|
|
self.pid, answer, return_except = True)
|
|
self.send_password_thread.signal.connect(self.send_password_after)
|
|
self.send_password_thread.start()
|
|
else:
|
|
self.send_button.setDisabled(True)
|
|
|
|
def send_password_after(self, result):
|
|
if type(result) == Exception:
|
|
show_msg(_('Failed to send the message (password) to the server'))
|
|
self.close()
|
|
return 1
|
|
self._parent.show_result(result)
|
|
self.close()
|
|
|
|
def check_passwd(self):
|
|
if self.pass_edit.text() != self.pass_edit2.text():
|
|
self.send_button.setDisabled(True)
|
|
else:
|
|
self.send_button.setEnabled(True)
|