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.
496 lines
18 KiB
496 lines
18 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
|
|
#from PySide.QtGui import QLabel#, QLineEdit, QPushButton, QCheckBox, QGroupBox
|
|
from more import LabelWordWrap, MultipleChoice
|
|
from calculate.api.client.function import get_sid, switch
|
|
#from more import show_msg
|
|
|
|
import time
|
|
|
|
|
|
|
|
class MainFrameResWgt(QtGui.QWidget):
|
|
|
|
def __init__(self, parent, ClientObj, method_name, meth_result):
|
|
super(MainFrameResWgt, self).__init__()
|
|
self.parent = parent
|
|
self.ClientObj = ClientObj
|
|
self.method_name = method_name
|
|
self.meth_result = meth_result
|
|
self.client = ClientObj.client
|
|
self.cur_pid = 0
|
|
|
|
# for clear memory after closed this window
|
|
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
|
|
|
|
if self.meth_result.type == "pid":
|
|
self.cur_pid = self.meth_result.message
|
|
self.work_layout = self.ClientObj.process_dict \
|
|
[self.meth_result.message]['layout']
|
|
else:
|
|
self.work_layout = QtGui.QVBoxLayout()
|
|
self.work_layout.addStretch(1)
|
|
|
|
if self.work_layout.count() == 1:
|
|
self.title_lbl = LabelWordWrap(method_name)
|
|
self.work_layout.addWidget(self.title_lbl)
|
|
|
|
# self.work_layout.setAlignment(QtCore.Qt.AlignTop)
|
|
self.setLayout(self.work_layout)
|
|
|
|
|
|
def initUI(self):
|
|
if self.meth_result.type == "pid":
|
|
self.ClientObj.process_dict [self.meth_result.message]['layout'] = \
|
|
self.work_layout
|
|
# self.ClientObj.res_layout = self.work_layout
|
|
self.setLayout(self.work_layout)
|
|
self.parent.create(self.meth_result)
|
|
self.updateGeometry()
|
|
|
|
|
|
################# API FUNCTION ###############################
|
|
def show_view(self, view):
|
|
print "+====== show view! ======+"
|
|
def show_table(self, table, item):
|
|
# method to display tables
|
|
self.mytable = QtGui.QTableWidget(len(table.body[0]), len(table.head[0]))
|
|
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)
|
|
|
|
# pCheckB = QtGui.QCheckBox()
|
|
# pCheckB.setText('Ok? Be or not to be?')
|
|
# pCheckB.setObjectName('Check #2')
|
|
# pCheckB.clicked.connect(self.tempComboLine)
|
|
# self.mytable.setCellWidget(1, 4, pCheckB)
|
|
#
|
|
# pCheckA = QtGui.QCheckBox()
|
|
# pCheckA.setText('No=)')
|
|
# pCheckA.setObjectName('Check #1')
|
|
# pCheckA.clicked.connect(self.tempComboLine)
|
|
# self.mytable.setCellWidget(2, 4, pCheckA)
|
|
#
|
|
# pCombo = QtGui.QComboBox()
|
|
# pCombo.addItem('one')
|
|
# pCombo.addItem('two')
|
|
# pCombo.currentIndexChanged.connect(self.tempComboLine)
|
|
# self.mytable.setCellWidget(3, 4, pCombo)
|
|
#
|
|
# pComboB = QtGui.QComboBox()
|
|
# pComboB.addItem('House')
|
|
# pComboB.addItem('Village')
|
|
# pComboB.currentIndexChanged.connect(self.tempComboLine)
|
|
# self.mytable.setCellWidget(4, 4, pComboB)
|
|
#
|
|
# bb = QtGui.QComboBox()
|
|
# lb = QtGui.QLineEdit()
|
|
# bb.setDuplicatesEnabled(False)
|
|
# bb.setEditable(True)
|
|
# bb.setLineEdit(lb)
|
|
# bb.addItem("1")
|
|
# bb.addItem("2")
|
|
# bb.addItem("3")
|
|
# bb.currentIndexChanged.connect(self.tempComboLine)
|
|
#
|
|
# self.mytable.takeItem (0, 3)
|
|
# self.mytable.setCellWidget(0, 3, bb)
|
|
## bb.setStyleSheet("QComboBox{color:cyan}")
|
|
## lb.setStyleSheet("QLineEdit{color:magenta}")
|
|
#
|
|
# self.mcd = MultipleChoice(self, ['111','222','333'], ['44','55'], [],True)
|
|
# self.mytable.setCellWidget(0, 4, self.mcd)
|
|
|
|
self.work_layout.addWidget(self.mytable)
|
|
self.initUI()
|
|
|
|
def tempComboLine(self):
|
|
# method of reading values table
|
|
for j in range(3,5):
|
|
for i in range(5):
|
|
if self.mytable.item(i,j):
|
|
text = self.mytable.item(i,j).text()
|
|
elif self.mytable.cellWidget(i,j):
|
|
print i,j,type(self.mytable.cellWidget(i,j))
|
|
if type(self.mytable.cellWidget(i,j)) == MultipleChoice:
|
|
text = self.mytable.cellWidget(i,j).text()
|
|
if type(self.mytable.cellWidget(i,j)) == QtGui.QComboBox:
|
|
text = self.mytable.cellWidget(i,j).currentText()
|
|
elif type(self.mytable.cellWidget(i,j)) == QtGui.QCheckBox:
|
|
text = self.mytable.cellWidget(i,j).isChecked()
|
|
print i,j, text
|
|
print "\n"
|
|
print "\n\n"
|
|
|
|
def show_normal(self, item):
|
|
# add normal message label
|
|
lbl_temp = LabelWordWrap(item.message)
|
|
lbl_temp.setWordWrap(True)
|
|
self.work_layout.addWidget(lbl_temp)
|
|
|
|
self.initUI()
|
|
|
|
def show_error(self, message):
|
|
# add error message label
|
|
lbl_temp = LabelWordWrap("ERROR!\n" + message)
|
|
lbl_temp.setWordWrap(True)
|
|
lbl_temp.setStyleSheet("border-style: solid; border-width: 2px;border-color: #ff2222;");
|
|
self.work_layout.addWidget(lbl_temp)
|
|
self.initUI()
|
|
|
|
def show_warning(self, item):
|
|
# add warning message label
|
|
lbl_temp = LabelWordWrap("WARNING!\n" + item.message)
|
|
lbl_temp.setWordWrap(True)
|
|
self.work_layout.addWidget(lbl_temp)
|
|
self.initUI()
|
|
|
|
def show_group(self, item):
|
|
print "Group"
|
|
print item.message
|
|
|
|
def show_result(self, result):
|
|
print "Result = ", result.message
|
|
|
|
def startTask(self, item):
|
|
print "start Task"
|
|
print item.message
|
|
|
|
def endTask(self, item):
|
|
print item.message
|
|
print "end Task\n\n"
|
|
|
|
def beginFrame(self, item):
|
|
pass
|
|
|
|
def endFrame(self, item):
|
|
pass
|
|
|
|
def startGroup(self, item):
|
|
pass
|
|
|
|
def endGruop(self, item):
|
|
pass
|
|
|
|
def callView(self, item, sid):
|
|
print "\n\n",item.message
|
|
try:
|
|
view = self.client.service[0][item.message] (sid)
|
|
self.show_view (view)
|
|
except:
|
|
pass
|
|
|
|
###############################################################################
|
|
|
|
def analysis(self, meth_result):
|
|
""" analysis of the bounced message method """
|
|
# for mess in meth_result:
|
|
mess = meth_result
|
|
if mess.type == 'pid':
|
|
get_messages(self, self.ClientObj.sid, mess.message)
|
|
if mess.type == 'error':
|
|
try:
|
|
self.main_frame.MainFrameWgt.show_error(self, mess.message)
|
|
except:
|
|
pass
|
|
if mess.type == 'warning':
|
|
try:
|
|
self.main_frame.MainFrameWgt.show_warning(self, mess)
|
|
except:
|
|
pass
|
|
|
|
def get_message(self, item, sid, pid):
|
|
try:
|
|
if self.main_frame.MainFrameWgt.cur_pid != pid:
|
|
return 1
|
|
except:
|
|
return 1
|
|
""" get one message by its type """
|
|
for case in switch(item.type):
|
|
if case('normal'):
|
|
|
|
self.main_frame.MainFrameWgt.show_normal(item)
|
|
return 1
|
|
if case('progress'):
|
|
get_Progress(self, sid, pid, item.id)
|
|
return 1
|
|
if case('error'):
|
|
# for i in range(20):
|
|
self.main_frame.MainFrameWgt.show_error(item.message)
|
|
if item.message == "403 Forbidden":
|
|
# show_msg(item.message, 'Access Denied')
|
|
return 0
|
|
return 1
|
|
if case('warning'):
|
|
self.main_frame.MainFrameWgt.show_warning(item)
|
|
return 1
|
|
if case('table'):
|
|
get_Table(self, sid, pid, item)
|
|
return 1
|
|
if case('group'):
|
|
self.main_frame.MainFrameWgt.show_group(sid, pid, item)
|
|
return 1
|
|
if case('question'):
|
|
send_Message(self, sid, pid, item)
|
|
return 1
|
|
if case('password'):
|
|
send_Password(self, sid, pid, item)
|
|
return 1
|
|
if case('startTask'):
|
|
self.main_frame.MainFrameWgt.startTask(item)
|
|
return 1
|
|
if case('endTask'):
|
|
self.main_frame.MainFrameWgt.endTask(item)
|
|
return 1
|
|
if case('beginFrame'):
|
|
self.main_frame.MainFrameWgt.beginFrame(item)
|
|
return 1
|
|
if case('endFrame'):
|
|
self.main_frame.MainFrameWgt.endFrame(item)
|
|
return 0
|
|
if case('startGroup'):
|
|
self.main_frame.MainFrameWgt.startGroup(item)
|
|
return 1
|
|
if case('endGruop'):
|
|
self.main_frame.MainFrameWgt.endGruop(item)
|
|
return 1
|
|
if case('briefParams'):
|
|
self.main_frame.MainFrameWgt.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()
|
|
get_Frame(self, sid, pid)
|
|
|
|
|
|
def get_Frame(self, sid, pid):
|
|
""" get all messages, until type is not endFrame (or Error) """
|
|
end_frame = 1
|
|
while end_frame:
|
|
current_frame = self.ClientObj.client.service.get_frame(sid, pid)
|
|
|
|
while current_frame in [None, [], ""]:
|
|
for i in range (int(self.ClientObj.client.frame_period) * 5):
|
|
self.ClientObj.app.processEvents()
|
|
time.sleep(int(self.ClientObj.client.frame_period)/5.0)
|
|
try:
|
|
if self.main_frame.MainFrameWgt.cur_pid != pid:
|
|
return 1
|
|
except:
|
|
return 1
|
|
current_frame = self.ClientObj.client.service.get_frame(sid, pid)
|
|
for item in range(len(current_frame[0])):
|
|
end_frame = get_message(self, current_frame[0][item], sid, pid)
|
|
try:
|
|
if self.main_frame.MainFrameWgt.cur_pid != pid:
|
|
return 1
|
|
except:
|
|
return 1
|
|
if len (current_frame[0]) > 3:
|
|
pass
|
|
if not item % 10:
|
|
self.result_create(self.ClientObj.process_dict [pid]['result'])
|
|
temp = self.mainwidth
|
|
self.ClientObj.app.processEvents()
|
|
self.mainwidth = temp
|
|
else:
|
|
self.result_create(self.ClientObj.process_dict [pid]['result'])
|
|
temp = self.mainwidth
|
|
self.ClientObj.app.processEvents()
|
|
self.mainwidth = temp
|
|
self.valSignal.emit()
|
|
|
|
def get_entire_frame(self, pid = None):
|
|
""" get entire frame, from beginning (if client disconnected) """
|
|
sid = get_sid(self.ClientObj.client.SID_FILE)
|
|
if not pid:
|
|
list_pid = self.ClientObj.client.service.list_pid(sid = sid)
|
|
else:
|
|
list_pid = {}
|
|
list_pid[0] = [pid]
|
|
|
|
if list_pid[0] == [0]:
|
|
return 0
|
|
for pid in list_pid[0]:
|
|
end_frame = 1
|
|
while end_frame:
|
|
current_frame = self.ClientObj.client.service.get_entire_frame(sid, pid)
|
|
while current_frame in [None, [], ""]:
|
|
self.ClientObj.app.processEvents()
|
|
time.sleep(1)
|
|
try:
|
|
if self.main_frame.MainFrameWgt.cur_pid != pid:
|
|
return 1
|
|
except:
|
|
return 1
|
|
current_frame = self.ClientObj.client.service.get_frame(sid, pid)
|
|
for item in range(len(current_frame[0])):
|
|
end_frame = get_message(self, current_frame[0][item], sid, pid)
|
|
try:
|
|
if self.main_frame.MainFrameWgt.cur_pid != pid:
|
|
return 1
|
|
except:
|
|
return 1
|
|
if len (current_frame[0]) > 3:
|
|
if not item % 10:
|
|
self.result_create(self.ClientObj.process_dict [pid]['result'])
|
|
temp = self.mainwidth
|
|
self.ClientObj.app.processEvents()
|
|
self.mainwidth = temp
|
|
else:
|
|
temp = self.mainwidth
|
|
self.ClientObj.app.processEvents()
|
|
self.mainwidth = temp
|
|
self.result_create(self.ClientObj.process_dict [pid]['result'])
|
|
# self.main_frame.
|
|
# for item in current_frame[0]:
|
|
# end_frame = get_message(self, item, sid, pid)
|
|
|
|
def get_Progress(self, sid, pid, id):
|
|
""" get progress for the current job """
|
|
percent = self.ClientObj.client.service.get_progress(sid, pid, id)
|
|
|
|
progressBar = QtGui.QProgressBar(self)
|
|
progressBar.setProperty("value", 100)
|
|
progressBar.setObjectName("Progress")
|
|
progressBar.setValue(percent)
|
|
self.main_frame.MainFrameWgt.work_layout.addWidget(progressBar)
|
|
|
|
# if
|
|
self.main_frame.MainFrameWgt.initUI()
|
|
self.result_create(self.ClientObj.process_dict [pid]['result'])
|
|
self.ClientObj.app.processEvents()
|
|
|
|
temp_progress = -1
|
|
while percent < 100 and percent >= 0 :
|
|
if temp_progress != percent:
|
|
|
|
print _("Percent = %s") %percent
|
|
progressBar.setValue(percent)
|
|
# self.main_frame.MainFrameWgt.initUI()
|
|
self.result_create(self.ClientObj.process_dict [pid]['result'])
|
|
self.ClientObj.app.processEvents()
|
|
temp_progress = percent
|
|
time.sleep(1)
|
|
try:
|
|
if self.main_frame.MainFrameWgt.cur_pid != pid:
|
|
return 1
|
|
except:
|
|
return 1
|
|
percent = self.ClientObj.client.service.get_progress(sid, pid, id)
|
|
if percent < 0:
|
|
progressBar.setValue(0 - percent)
|
|
# self.result_create(self.ClientObj.process_dict [pid]['result'])
|
|
self.ClientObj.app.processEvents()
|
|
try:
|
|
self.main_frame.MainFrameWgt.show_error('Error task by %d' %(0 - percent) + '%')
|
|
except AttributeError:
|
|
pass
|
|
# print _("Error task by %d") %(0 - percent) + "%"
|
|
else:
|
|
# print _("Percent = %s") %percent
|
|
progressBar.setValue(percent)
|
|
# self.main_frame.MainFrameWgt.initUI()
|
|
# self.result_create(self.ClientObj.process_dict [pid]['result'])
|
|
self.ClientObj.app.processEvents()
|
|
|
|
|
|
|
|
def get_Table(self, sid, pid, item):
|
|
table = self.ClientObj.client.service.get_table(sid, pid, item.id)
|
|
self.main_frame.MainFrameWgt.show_table(table, item)
|
|
|
|
def send_Message(self, sid, pid, item):
|
|
""" send answer to the question """
|
|
self.passwd = MessageDialog(self, item, sid, pid)
|
|
self.passwd.show()
|
|
while self.passwd.isVisible():
|
|
time.sleep(0.3)
|
|
self.ClientObj.app.processEvents()
|
|
|
|
def send_Password(self, sid, pid, item):
|
|
""" send password """
|
|
self.passwd = MessageDialog(self, item, sid, pid, True)
|
|
self.passwd.show()
|
|
while self.passwd.isVisible():
|
|
time.sleep(0.3)
|
|
self.ClientObj.app.processEvents()
|
|
|
|
|
|
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)
|
|
if isPassword:
|
|
self.pass_edit.setEchoMode(self.pass_edit.Password)
|
|
|
|
self.send_button = QtGui.QPushButton(_('Send'), self)
|
|
self.send_button.clicked.connect(self.send_password)
|
|
|
|
self.layout.addWidget(self.label,0,0)
|
|
self.layout.addWidget(self.pass_edit,0,1)
|
|
self.layout.addWidget(self.send_button,1,1)
|
|
|
|
def send_password(self):
|
|
answer = self.pass_edit.text()
|
|
result = self.parent.ClientObj.client.service.send_message(self.sid, self.pid, answer)
|
|
self.parent.main_frame.MainFrameWgt.show_result(result)
|
|
self.close()
|
|
|
|
|
|
class MainFrameRes (QtGui.QScrollArea):
|
|
def __init__(self, parent, ClientObj, method_name, meth_result):
|
|
|
|
QtGui.QScrollArea.__init__(self)
|
|
self.parent = parent
|
|
# верхнее правое
|
|
self.MainFrameWgt = MainFrameResWgt(self, ClientObj, method_name, \
|
|
meth_result)
|
|
# self.MainFrameWgt.setMinimumWidth(self.width()-50)
|
|
self.setWidget(self.MainFrameWgt)
|
|
|
|
# self.setWidgetResizable(True)
|
|
|
|
def resizeEvent(self, resize_var):
|
|
self.parent.set_wid (self.size().width())
|
|
if self.size().width() > 30:
|
|
self.MainFrameWgt.setFixedWidth(self.parent.mainwidth - 30)
|
|
|
|
def create(self, meth_result):
|
|
self.setWidget(self.MainFrameWgt) |