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.
1047 lines
54 KiB
1047 lines
54 KiB
#-*- 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, \
|
|
QComboBox
|
|
from calculate.api.client.function import create_obj, get_sid, listToArrayArray, \
|
|
listToArray
|
|
#import analysis
|
|
from more import show_msg, LabelWordWrap, MultipleChoice, PlusRow, \
|
|
CentralCheckBox, ErrorLabel, icon_visible, FileOpenWgt
|
|
from suds import WebFault
|
|
from ReturnMessage import ReturnedMessage
|
|
#import multiprocessing, subprocess, threading
|
|
|
|
|
|
class TableValue():
|
|
values = []
|
|
head = []
|
|
body = []
|
|
|
|
class Table():
|
|
label = str
|
|
help = str
|
|
tablevalue = TableValue
|
|
|
|
class MFWgt(QtGui.QWidget):
|
|
def __init__(self, parent, ClientObj, view, method_name):
|
|
super(MFWgt, self).__init__()
|
|
self.ClientObj = ClientObj
|
|
self.view = view
|
|
self.method_name = method_name
|
|
|
|
# for clear memory after closed this window
|
|
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
|
|
icon_visible(ClientObj.MainWidget, 'Methods', True)
|
|
|
|
self.initUI()
|
|
|
|
def initUI(self):
|
|
self.grid = QtGui.QGridLayout()
|
|
self.grid.setSpacing(10)
|
|
x = 0
|
|
y = 0
|
|
|
|
# for advanced settings
|
|
self.expert = False
|
|
self.expert_list = []
|
|
minimum = QtGui.QSizePolicy.Minimum
|
|
# maximum = QtGui.QSizePolicy.Maximum
|
|
|
|
self.view_dict = {}
|
|
|
|
self.radio_dict = {}
|
|
self.ButGrp_dict = {}
|
|
self.label_dict = {}
|
|
self.error_label_dict = {}
|
|
|
|
self.table_dict = {}
|
|
|
|
if not self.ClientObj.param_objects.has_key(self.method_name):
|
|
self.ClientObj.param_objects[self.method_name] = {}
|
|
# self.ClientObj.param_objects[self.method_name]['object'] \
|
|
# = create_obj(self.ClientObj.client, self.method_name)
|
|
self.ClientObj.param_objects[self.method_name]['step'] = 0
|
|
self.ClientObj.param_objects[self.method_name]['error'] = None
|
|
self.ClientObj.param_objects[self.method_name]['fields'] = {}
|
|
|
|
|
|
# print '%%%%%%%%', self.method_name, \
|
|
# 'step:', self.ClientObj.param_objects[self.method_name]['step']
|
|
self.param_object = create_obj(self.ClientObj.client, self.method_name)
|
|
# print "=======>>",self.param_object
|
|
# print "=======>>",self.view
|
|
list_param = dir (self.param_object)
|
|
|
|
param_list = []
|
|
for param in list_param:
|
|
if not param.startswith('_'):
|
|
param_list.append(param)
|
|
|
|
for Group in self.view.groups.GroupField:
|
|
self.group_name_label = LabelWordWrap(Group.name, self)
|
|
self.group_name_label.setAlignment(QtCore.Qt.AlignCenter)
|
|
|
|
self.grid.addWidget(self.group_name_label, x, y, 1, 2)
|
|
x += 1
|
|
|
|
for field in Group.fields.Field:
|
|
# add element in frame
|
|
if field.element == 'input':
|
|
#add label
|
|
self.error_label_dict[field.name] = ErrorLabel(self)
|
|
self.grid.addWidget(self.error_label_dict[field.name], x, y, 1, 2)
|
|
x += 1
|
|
|
|
self.label_dict[field.name] = LabelWordWrap(field.label, self)
|
|
self.grid.addWidget(self.label_dict[field.name], x, y)
|
|
|
|
self.view_dict[field.name] = QLineEdit(self)
|
|
if field.default:
|
|
self.view_dict[field.name].setText(field.default)
|
|
if field.type == 'int':
|
|
self.rx = QtCore.QRegExp ("^[\d]{1,50}$")
|
|
self.validator = QtGui.QRegExpValidator(self.rx, self)
|
|
self.view_dict[field.name].setValidator(self.validator)
|
|
elif field.type == 'float':
|
|
self.rx = QtCore.QRegExp ("^[\d]{1,50}[.][\d]{1,50}$")
|
|
self.validator = QtGui.QRegExpValidator(self.rx, self)
|
|
self.view_dict[field.name].setValidator(self.validator)
|
|
|
|
# advanced settings (expert)
|
|
if self.expert:
|
|
# self.expert_list.append(self.label_dict[field.name])
|
|
self.expert_list.append(self.view_dict[field.name])
|
|
# self.view_dict[field.name].setMinimumHeight \
|
|
# (self.view_dict[field.name].size().height())
|
|
# print self.view_dict[field.name].size()
|
|
# self.view_dict[field.name].setSizePolicy(maximum, maximum)
|
|
self.grid.addWidget(self.view_dict[field.name], x, y+1)
|
|
x += 1
|
|
|
|
elif field.element in ['check', 'check_tristate']:
|
|
self.error_label_dict[field.name] = ErrorLabel(self)
|
|
self.grid.addWidget(self.error_label_dict[field.name], x, y, 1, 2)
|
|
x += 1
|
|
|
|
self.label_dict[field.name] = QLabel(field.label,self)
|
|
self.grid.addWidget(self.label_dict[field.name], x, y)
|
|
self.view_dict[field.name] = QCheckBox(self)
|
|
if field.element.lower() == 'check_tristate':
|
|
self.view_dict[field.name].setTristate()
|
|
if field.default == 'on':
|
|
self.view_dict[field.name].setCheckState(QtCore.Qt.CheckState.Checked)
|
|
elif field.default == 'off':
|
|
self.view_dict[field.name].setCheckState(QtCore.Qt.CheckState.Unchecked)
|
|
elif field.default == 'auto':
|
|
self.view_dict[field.name].setCheckState(QtCore.Qt.CheckState.PartiallyChecked)
|
|
else:
|
|
if field.default == 'on':
|
|
self.view_dict[field.name].setChecked(True)
|
|
# else:
|
|
# self.view_dict[field.name].setChecked(False)
|
|
if self.expert:
|
|
self.expert_list.append(self.view_dict[field.name])
|
|
self.grid.addWidget(self.view_dict[field.name], x, y+1)
|
|
x += 1
|
|
|
|
elif field.element == 'radio':
|
|
self.error_label_dict[field.name] = ErrorLabel(self)
|
|
self.grid.addWidget(self.error_label_dict[field.name], x, y, 1, 2)
|
|
x += 1
|
|
|
|
self.label_dict[field.name] = QLabel(self)
|
|
self.grid.addWidget(self.label_dict[field.name], x, y)
|
|
|
|
choice = field.choice[0]
|
|
|
|
self.GroupBox = QGroupBox(field.label)
|
|
self.ButGrp_dict[field.name] = QtGui.QButtonGroup(self)
|
|
layout = QtGui.QVBoxLayout(self)
|
|
radiolist = []
|
|
|
|
for i in range(0,len(choice)):
|
|
radiolist.append (QtGui.QRadioButton(choice[i]))
|
|
# set default values
|
|
if field.default == choice[i]:
|
|
radiolist[i].setChecked(True)
|
|
self.ButGrp_dict[field.name].addButton(radiolist[i])
|
|
layout.addWidget(radiolist[i])
|
|
|
|
# self.radio_dict[field.name] = self.ButGrp_dict[field.name]
|
|
|
|
layout.addStretch(1)
|
|
self.GroupBox.setLayout(layout)
|
|
|
|
self.view_dict[field.name] = self.GroupBox
|
|
if self.expert:
|
|
self.expert_list.append(self.view_dict[field.name])
|
|
self.grid.addWidget(self.view_dict[field.name], x, y+1)
|
|
x += 1
|
|
|
|
elif field.element == 'combo':
|
|
self.error_label_dict[field.name] = ErrorLabel(self)
|
|
self.grid.addWidget(self.error_label_dict[field.name], x, y, 1, 2)
|
|
x += 1
|
|
|
|
self.ButGrp_dict[field.name] = False
|
|
|
|
if field.comments:
|
|
if hasattr (field.comments, 'string'):
|
|
choice = field.comments.string
|
|
values = field.choice.string
|
|
else:
|
|
values = None
|
|
if field.choice:
|
|
choice = field.choice.string
|
|
else:
|
|
choice = []
|
|
|
|
#add label
|
|
self.label_dict[field.name] = QLabel(field.label, self)
|
|
self.grid.addWidget(self.label_dict[field.name], x, y)
|
|
self.ComboBox = QComboBox(self)
|
|
for i in range(len(choice)):
|
|
self.ComboBox.addItem(choice[i])
|
|
if values:
|
|
self.ComboBox.setItemData(i,values[i])
|
|
if field.default == choice[i]:
|
|
self.ComboBox.setCurrentIndex(i)
|
|
|
|
def combo_checked(self, name):
|
|
def wrapper():
|
|
self.ButGrp_dict[name] = True
|
|
return wrapper
|
|
self.ComboBox.currentIndexChanged.connect(combo_checked(self, field.name))
|
|
|
|
self.view_dict[field.name] = self.ComboBox
|
|
if self.expert:
|
|
# self.expert_list.append(self.label_dict[field.name])
|
|
self.expert_list.append(self.view_dict[field.name])
|
|
self.grid.addWidget(self.view_dict[field.name], x, y+1)
|
|
x += 1
|
|
|
|
elif field.element == 'comboEdit':
|
|
self.error_label_dict[field.name] = ErrorLabel(self)
|
|
self.grid.addWidget(self.error_label_dict[field.name], x, y, 1, 2)
|
|
x += 1
|
|
|
|
self.ButGrp_dict[field.name] = True
|
|
|
|
if field.comments:
|
|
if hasattr (field.comments, 'string'):
|
|
choice = field.comments.string
|
|
values = field.choice.string
|
|
else:
|
|
choice = field.choice.string
|
|
values = None
|
|
|
|
if not choice:
|
|
choice = []
|
|
#add label
|
|
self.label_dict[field.name] = QLabel(field.label, self)
|
|
self.grid.addWidget(self.label_dict[field.name], x, y)
|
|
self.ComboBox = QComboBox(self)
|
|
self.ComboBox.setDuplicatesEnabled(False)
|
|
self.ComboBox.setEditable(True)
|
|
self.ComboBox.setLineEdit(QtGui.QLineEdit(self))
|
|
for i in range(0,len(choice)):
|
|
self.ComboBox.addItem(choice[i])
|
|
if values:
|
|
self.ComboBox.setItemData(i,values[i])
|
|
if field.default == choice[i]:
|
|
self.ComboBox.setCurrentIndex(i)
|
|
|
|
self.view_dict[field.name] = self.ComboBox
|
|
if self.expert:
|
|
# self.expert_list.append(self.label_dict[field.name])
|
|
self.expert_list.append(self.view_dict[field.name])
|
|
self.grid.addWidget(self.view_dict[field.name], x, y+1)
|
|
x += 1
|
|
|
|
|
|
elif field.element in ['multichoice', 'multichoice_add']:
|
|
self.error_label_dict[field.name] = ErrorLabel(self)
|
|
self.grid.addWidget(self.error_label_dict[field.name], x, y, 1, 2)
|
|
x += 1
|
|
|
|
if field.element == 'multichoice_add':
|
|
add_ability = True
|
|
else:
|
|
add_ability = False
|
|
choice = field.choice.string if field.choice else []
|
|
|
|
if field.listvalue:
|
|
default = field.listvalue.string
|
|
elif field.default:
|
|
default = field.default.split(',')
|
|
else:
|
|
default = []
|
|
comments = field.comments
|
|
self.view_dict[field.name] = \
|
|
MultipleChoice(self, choice, default, comments, add_ability)
|
|
#add label
|
|
self.label_dict[field.name] = QLabel(field.label, self)
|
|
if self.expert:
|
|
# self.expert_list.append(self.label_dict[field.name])
|
|
self.expert_list.append(self.view_dict[field.name])
|
|
self.grid.addWidget(self.label_dict[field.name], x, y)
|
|
self.grid.addWidget(self.view_dict[field.name], x, y+1)
|
|
x += 1
|
|
|
|
# add file open dialog
|
|
elif field.element == 'openfile':
|
|
self.error_label_dict[field.name] = ErrorLabel(self)
|
|
self.grid.addWidget(self.error_label_dict[field.name], x, y, 1, 2)
|
|
x += 1
|
|
|
|
self.label_dict[field.name] = QLabel(field.label,self)
|
|
self.grid.addWidget(self.label_dict[field.name], x, y)
|
|
|
|
# field.type in ['file','files','dir']
|
|
self.view_dict[field.name] = FileOpenWgt(self, field.type,\
|
|
field.label, field.default, field.value)
|
|
if self.expert:
|
|
self.expert_list.append(self.view_dict[field.name])
|
|
self.grid.addWidget(self.view_dict[field.name], x, y+1)
|
|
x += 1
|
|
|
|
elif field.element == 'expert':
|
|
self.expert = True
|
|
# choice = field.choice[0]
|
|
#add label
|
|
if field.label:
|
|
self.view_dict[field.name] = QPushButton(field.label, self)
|
|
else:
|
|
self.view_dict[field.name] = QPushButton\
|
|
(_('Press for advanced settings.'), self)
|
|
self.view_dict[field.name].setFlat(True)
|
|
self.grid.addWidget(self.view_dict[field.name], x, y+1)
|
|
|
|
def expert_clicked(self, cur_field):
|
|
def wrapper():
|
|
if cur_field.value == 'open':
|
|
expert = False
|
|
else:
|
|
expert = True
|
|
num = self.ClientObj.param_objects[self.method_name]['step']
|
|
view = self.ClientObj.client.service[0][self.method_name+'_view']\
|
|
(int(self.ClientObj.sid), num, expert)
|
|
|
|
# display view in main frame
|
|
self.ClientObj.MainWidget.main_frame_view(view, self.method_name)
|
|
return wrapper
|
|
|
|
self.view_dict[field.name].clicked.connect(self.collect_object(True))
|
|
self.view_dict[field.name].clicked.connect(self.calling(True))
|
|
self.view_dict[field.name].clicked.connect(expert_clicked(self, field))
|
|
x += 1
|
|
|
|
elif field.element == 'table' and field.type == 'steps':
|
|
steps = field.tablevalue.head.string
|
|
val_steps = field.tablevalue.body.stringArray
|
|
|
|
#add all field name in param_object for highlight error
|
|
for num_step in range (len(steps)):
|
|
self.ClientObj.param_objects[self.method_name] \
|
|
['fields'][num_step] = []
|
|
|
|
for step_field_name in val_steps[num_step].string:
|
|
self.ClientObj.param_objects[self.method_name] \
|
|
['fields'][num_step].append(step_field_name)
|
|
|
|
# create links on steps for each steps
|
|
self.ClientObj.MainWidget.left_frame.create_steps \
|
|
(self.method_name, steps)
|
|
|
|
elif field.element == 'table' and field.type != 'steps':
|
|
self.error_label_dict[field.name] = ErrorLabel(self)
|
|
self.grid.addWidget(self.error_label_dict[field.name], x, y, 1, 2)
|
|
x += 1
|
|
|
|
# print field
|
|
self.table_dict[field.name] = field
|
|
table = field.tablevalue
|
|
|
|
self.table_widget = QtGui.QTableWidget \
|
|
(len(table.body.stringArray), \
|
|
len(table.head.string), self)
|
|
|
|
self.table_widget.setHorizontalHeaderLabels(table.head.string)
|
|
|
|
self.table_combo_list = []
|
|
self.table_comboEdit_list = []
|
|
self.table_check_list = []
|
|
self.table_multi_list = []
|
|
|
|
for column in range(len(table.head.string)):
|
|
# for readonly view
|
|
if column > (len(table.values.ChoiceValue) - 1):
|
|
for row in range (len(table.body.stringArray)):
|
|
|
|
tablewidgetitem = QtGui.QTableWidgetItem \
|
|
(table.body.stringArray[row].string[column])
|
|
self.table_widget.setItem(row, column, tablewidgetitem)
|
|
|
|
# if column > len(table.values.ChoiceValue):
|
|
# i = self.table_widget.item(row, column)
|
|
|
|
self.table_widget.item(row, column).setFlags(QtCore.Qt.ItemIsEditable)
|
|
font = self.table_widget.item(row, column).font()
|
|
font.setWeight(QtGui.QFont.Black)
|
|
self.table_widget.item(row, column).setFont(font)
|
|
|
|
# if not readonly
|
|
elif table.values.ChoiceValue[column].typefield == 'combo':
|
|
for row in range (len(table.body.stringArray)):
|
|
pCombo = QtGui.QComboBox(self)
|
|
if not '' in table.values.ChoiceValue[column].values.string:
|
|
pCombo.addItem('')
|
|
offset = 1
|
|
else:
|
|
offset = 0
|
|
for i in table.values.ChoiceValue[column].values.string:
|
|
pCombo.addItem(i)
|
|
if not table.body.stringArray[row].string[column] in\
|
|
table.values.ChoiceValue[column].values.string\
|
|
and table.body.stringArray[row].string[column]:
|
|
pCombo.addItem(table.body.stringArray[row].string[column])
|
|
pCombo.setCurrentIndex(len\
|
|
(table.values.ChoiceValue[column].values.string)+1)
|
|
else:
|
|
try:
|
|
ind = table.values.ChoiceValue[column].values.string.index \
|
|
(table.body.stringArray[row].string[column])
|
|
pCombo.setCurrentIndex(ind + offset)
|
|
except:
|
|
pCombo.setCurrentIndex(0)
|
|
self.table_combo_list.append(pCombo)
|
|
|
|
# OnChange Action
|
|
if table.values.ChoiceValue[column].onChanged:
|
|
|
|
self.table_combo_list[len(self.table_combo_list) - 1].\
|
|
currentIndexChanged.connect(self.OnChanged\
|
|
(row, column, self.table_dict[field.name]))
|
|
# pCombo.currentIndexChanged.connect(self.OnChanged(row, column, field))
|
|
|
|
self.table_widget.setCellWidget(row, column, \
|
|
self.table_combo_list[len(self.table_combo_list)-1])
|
|
|
|
|
|
|
|
elif table.values.ChoiceValue[column].typefield == 'comboEdit':
|
|
for row in range (len(table.body.stringArray)):
|
|
pCombo = QtGui.QComboBox(self)
|
|
lb = QtGui.QLineEdit()
|
|
pCombo.setDuplicatesEnabled(False)
|
|
pCombo.setEditable(True)
|
|
pCombo.setLineEdit(lb)
|
|
if not '' in table.values.ChoiceValue[column].values.string:
|
|
pCombo.addItem('')
|
|
offset = 1
|
|
else:
|
|
offset = 0
|
|
offset = 1
|
|
for i in table.values.ChoiceValue[column].values.string:
|
|
pCombo.addItem(i)
|
|
if not table.body.stringArray[row].string[column] in\
|
|
table.values.ChoiceValue[column].values.string\
|
|
and table.body.stringArray[row].string[column]:
|
|
pCombo.addItem(table.body.stringArray[row].string[column])
|
|
pCombo.setCurrentIndex(len\
|
|
(table.values.ChoiceValue[column].values.string)+1)
|
|
else:
|
|
try:
|
|
ind = table.values.ChoiceValue[column].values.string.index \
|
|
(table.body.stringArray[row].string[column])
|
|
pCombo.setCurrentIndex(ind + offset)
|
|
except:
|
|
pCombo.setCurrentIndex(0)
|
|
self.table_comboEdit_list.append(pCombo)
|
|
|
|
self.table_widget.setCellWidget(row, column, \
|
|
self.table_comboEdit_list[len(self.table_comboEdit_list)-1])
|
|
|
|
elif table.values.ChoiceValue[column].typefield in ['multichoice', 'multichoice_add']:
|
|
for row in range (len(table.body.stringArray)):
|
|
if table.values.ChoiceValue[column].typefield == 'multichoice_add':
|
|
add_ability = True
|
|
else:
|
|
add_ability = False
|
|
|
|
choice = table.values.ChoiceValue[column].values.string
|
|
default = table.body.stringArray[row].string[column].split(',')
|
|
|
|
if table.values.ChoiceValue[column].comments:
|
|
comments = table.values.ChoiceValue[column].comments.string
|
|
else:
|
|
comments = []
|
|
|
|
self.multi_obj = MultipleChoice(self, choice, default, comments, add_ability)
|
|
|
|
self.table_multi_list.append(self.multi_obj)
|
|
self.table_widget.setCellWidget(row, column, \
|
|
self.table_multi_list[len(self.table_multi_list)-1])
|
|
|
|
elif table.values.ChoiceValue[column].typefield in ['check', 'check_tristate']:
|
|
for row in range (len(table.body.stringArray)):
|
|
if table.values.ChoiceValue[column].typefield == 'check_tristate':
|
|
pCheckB = CentralCheckBox(self, True)
|
|
else:
|
|
pCheckB = CentralCheckBox(self, False)
|
|
ind = table.body.stringArray[row].string[column]
|
|
if table.values.ChoiceValue[column].typefield == 'check_tristate':
|
|
if ind == 'on':
|
|
pCheckB.setCheckState(QtCore.Qt.CheckState.Checked)
|
|
elif ind == 'off':
|
|
pCheckB.setCheckState(QtCore.Qt.CheckState.Unchecked)
|
|
elif ind == 'auto':
|
|
pCheckB.setCheckState(QtCore.Qt.CheckState.PartiallyChecked)
|
|
else:
|
|
if ind == 'on':
|
|
pCheckB.setChecked(True)
|
|
self.table_check_list.append(pCheckB)
|
|
self.table_widget.setCellWidget(row, column, \
|
|
self.table_check_list[len(self.table_check_list)-1])
|
|
|
|
|
|
elif table.values.ChoiceValue[column].typefield == 'input':
|
|
for row in range (len(table.body.stringArray)):
|
|
|
|
tablewidgetitem = QtGui.QTableWidgetItem(table.body.stringArray[row].string[column])
|
|
self.table_widget.setItem(row, column, tablewidgetitem)
|
|
if column > len(table.values.ChoiceValue):
|
|
i = self.table_widget.item(row, column)
|
|
self.table_widget.item(row, column).setFlags(QtCore.Qt.ItemIsEditable)
|
|
font = self.table_widget.item(row, column).font()
|
|
font.setWeight(QtGui.QFont.Black)
|
|
self.table_widget.item(row, column).setFont(font)
|
|
|
|
self.table_widget.setSizePolicy(minimum, minimum)
|
|
self.view_dict[field.name] = self.table_widget
|
|
self.label_dict[field.name] = LabelWordWrap(field.label, self)
|
|
self.table_dict[field.name] = field
|
|
|
|
if self.expert:
|
|
# self.expert_list.append(self.label_dict[field.name])
|
|
self.expert_list.append(self.view_dict[field.name])
|
|
|
|
self.grid.addWidget(self.label_dict[field.name], x, y)
|
|
x += 1
|
|
|
|
|
|
# add 2 button if field type = writable
|
|
if field.type == 'writable':# or True:
|
|
self.view_dict[field.name].horizontalHeader().setClickable(False)
|
|
|
|
unit_widget = QtGui.QWidget(self)
|
|
unit_layout = QtGui.QHBoxLayout(self)
|
|
|
|
plus_but = QtGui.QPushButton(self)
|
|
try:
|
|
plus_but.setIcon(QtGui.QIcon.fromTheme('list-add'))
|
|
except:
|
|
plus_but.setText('+')
|
|
|
|
plus_but.setFixedWidth(30)
|
|
|
|
minus_but = QtGui.QPushButton(self)
|
|
try:
|
|
minus_but.setIcon(QtGui.QIcon.fromTheme('list-remove'))
|
|
except:
|
|
minus_but.setText('-')
|
|
minus_but.setFixedWidth(30)
|
|
plus_but.clicked.connect(self.plus_row(self.view_dict[field.name],\
|
|
self.table_dict[field.name]))
|
|
|
|
minus_but.clicked.connect(self.minus_row(self.view_dict[field.name]))
|
|
|
|
unit_layout.addWidget(plus_but)
|
|
unit_layout.addWidget(minus_but)
|
|
unit_layout.setAlignment(QtCore.Qt.AlignLeft)
|
|
unit_widget.setLayout(unit_layout)
|
|
self.grid.addWidget(unit_widget, x, y)
|
|
x +=1
|
|
# if self.expert:
|
|
# self.expert_list.append(unit_widget)
|
|
|
|
self.grid.addWidget(self.view_dict[field.name], x, y, 1, 2)
|
|
x += 1
|
|
|
|
# add 1 or 2 button to bottom
|
|
def button_call_view(self, step):
|
|
'''if call next view'''
|
|
def wrapper():
|
|
# break if error
|
|
if self.ClientObj.param_objects[self.method_name]['error']:
|
|
if step != (-1):
|
|
return
|
|
# call view
|
|
self.ClientObj.param_objects[self.method_name]['step'] += step
|
|
num = self.ClientObj.param_objects[self.method_name]['step']
|
|
|
|
view = self.ClientObj.client.service[0][self.method_name+'_view']\
|
|
(int(self.ClientObj.sid), num)
|
|
|
|
# change step in left frame
|
|
try:
|
|
self.ClientObj.MainWidget.left_frame.changed_step(num)
|
|
except KeyError:
|
|
pass
|
|
except Exception, e:
|
|
show_msg (e, 'Change Step Error')
|
|
|
|
# display view in main frame
|
|
# print '===========>>>>>>', view
|
|
self.ClientObj.MainWidget.main_frame_view(view, self.method_name)
|
|
return wrapper
|
|
|
|
# add 1 (or 2) button ok (next) [and previous]
|
|
self.end_layout = QtGui.QHBoxLayout()
|
|
self.end_layout.addItem(QtGui.QSpacerItem( 0, 0, \
|
|
QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Maximum ))
|
|
|
|
if self.ClientObj.param_objects[self.method_name]['step'] != 0:
|
|
self.prev_button = QtGui.QPushButton(self)
|
|
try:
|
|
self.prev_button.setIcon(QtGui.QIcon.fromTheme("go-previous"))
|
|
finally:
|
|
self.prev_button.setText(_('Previous'))
|
|
|
|
self.prev_button.clicked.connect(button_call_view (self, -1))
|
|
self.prev_button.setMinimumWidth(100)
|
|
self.end_layout.addWidget(self.prev_button)
|
|
# self.grid.addWidget(self.prev_button, x, y)
|
|
|
|
if self.view.groups.GroupField[0].last:
|
|
self.next_button = QtGui.QPushButton(self)
|
|
try:
|
|
self.next_button.setIcon(QtGui.QIcon.fromTheme("dialog-ok-apply"))
|
|
finally:
|
|
self.next_button.setText(_('Ok'))
|
|
self.next_button.clicked.connect(self.collect_object(False))
|
|
self.next_button.clicked.connect(self.calling(False))
|
|
self.end_layout.addWidget(self.next_button)
|
|
else:
|
|
self.next_button = QtGui.QPushButton(self)
|
|
try:
|
|
self.next_button.setIcon(QtGui.QIcon.fromTheme("go-next"))
|
|
finally:
|
|
self.next_button.setText(_('Next'))
|
|
# self.next_button.setSizePolicy(maximum, maximum)
|
|
# self.next_button.resize(100, self.next_button.size().height())
|
|
|
|
self.next_button.clicked.connect(self.collect_object(False))
|
|
self.next_button.clicked.connect(self.calling(True))
|
|
self.next_button.clicked.connect(button_call_view (self, +1))
|
|
self.end_layout.addWidget(self.next_button)
|
|
# self.grid.addWidget(self.next_button, x, y+1)
|
|
|
|
self.next_button.setMinimumWidth(100)
|
|
|
|
self.end_layout.setContentsMargins(0,0,20,0)
|
|
|
|
self.grid.addLayout(self.end_layout, x, y+1)
|
|
x += 1
|
|
|
|
# add spacer
|
|
self.grid.addItem(QtGui.QSpacerItem( 0, 0, \
|
|
QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding ), x, y, 1, 2)
|
|
# self.grid.setSizeConstraint(self.grid.SizeConstraint.SetMinimumSize)
|
|
self.grid.setSizeConstraint(QtGui.QLayout.SizeConstraint.SetMaximumSize)
|
|
# hide expert settings
|
|
|
|
self.grid.setContentsMargins(10,10,10,0)
|
|
self.setLayout(self.grid)
|
|
|
|
# If errors came in parameters
|
|
if self.ClientObj.param_objects[self.method_name]['error']:
|
|
self.highlight_errors()
|
|
|
|
self.update()
|
|
self.updateGeometry()
|
|
|
|
def plus_row (self, table, field):
|
|
def wrapper():
|
|
# print 'plus_field'
|
|
self.PlusWgt = PlusRow(self, table, field)
|
|
self.PlusWgt.setAttribute(QtCore.Qt.WA_ShowModal)
|
|
self.PlusWgt.show()
|
|
return wrapper
|
|
|
|
def minus_row (self, table):
|
|
def wrapper():
|
|
try:
|
|
top = table.selectedRanges()[0].topRow()
|
|
bottom = table.selectedRanges()[0].bottomRow()
|
|
for i in range (top, bottom + 1):
|
|
table.model().removeRow(top)
|
|
except IndexError:
|
|
show_msg ('Not selected a not single row', 'Selected Error')
|
|
return wrapper
|
|
|
|
def collect_object(self, expert = False):
|
|
def wrapper():
|
|
'''add variable values from widget in param_object'''
|
|
# store params name if list for each step
|
|
step_num = self.ClientObj.param_objects[self.method_name]['step']
|
|
self.ClientObj.param_objects[self.method_name]['fields'][step_num] = []
|
|
for Group in self.view.groups.GroupField:
|
|
for field in Group.fields.Field:
|
|
self.ClientObj.param_objects[self.method_name] \
|
|
['fields'][step_num].append(field.name)
|
|
|
|
if not self.view_dict.has_key(field.name):
|
|
continue
|
|
|
|
if self.view_dict[field.name] in self.expert_list and expert:
|
|
continue
|
|
|
|
if type (self.view_dict[field.name]) == QGroupBox:
|
|
if self.ButGrp_dict[field.name].checkedButton():
|
|
self.param_object[field.name] = \
|
|
self.ButGrp_dict[field.name].checkedButton().text()
|
|
# elif self.default_list[field.name]:
|
|
# self.param_object[field.name] = self.default_list[field.name]
|
|
elif field.default:
|
|
self.param_object[field.name] = field.default
|
|
else:
|
|
self.param_object[field.name] = ''
|
|
|
|
elif type (self.view_dict[field.name]) == QCheckBox:
|
|
if self.view_dict[field.name].isTristate():
|
|
if self.view_dict[field.name].checkState() \
|
|
== QtCore.Qt.CheckState.PartiallyChecked:
|
|
self.param_object[field.name] = None
|
|
elif self.view_dict[field.name].checkState() \
|
|
== QtCore.Qt.CheckState.Checked:
|
|
self.param_object[field.name] = True
|
|
else:
|
|
self.param_object[field.name] = False
|
|
|
|
else:
|
|
self.param_object[field.name] = \
|
|
self.view_dict[field.name].isChecked()
|
|
|
|
elif type (self.view_dict[field.name]) == QComboBox:
|
|
ind = self.view_dict[field.name].currentIndex()
|
|
# if user change value
|
|
if self.view_dict[field.name].currentText() != \
|
|
self.view_dict[field.name].itemText(ind):
|
|
self.param_object[field.name] = \
|
|
self.view_dict[field.name].currentText()
|
|
elif self.ButGrp_dict[field.name]:
|
|
# if there is a data
|
|
if self.view_dict[field.name].itemData(ind):
|
|
self.param_object[field.name] = \
|
|
self.view_dict[field.name].itemData(ind)
|
|
else:
|
|
self.param_object[field.name] = \
|
|
self.view_dict[field.name].currentText()
|
|
# if exists a default value
|
|
elif field.default:
|
|
if self.view_dict[field.name].itemData(ind):
|
|
self.param_object[field.name] = \
|
|
self.view_dict[field.name].itemData(ind)
|
|
self.param_object[field.name] = field.default
|
|
# if user not change value and not exists default value
|
|
else:
|
|
self.param_object[field.name] = ''
|
|
|
|
elif type (self.view_dict[field.name]) == QLineEdit:
|
|
self.param_object[field.name] = \
|
|
str(self.view_dict[field.name].text())
|
|
|
|
elif type (self.view_dict[field.name]) == MultipleChoice:
|
|
list_result = self.view_dict[field.name].values()
|
|
# text = self.view_dict[field.name].text().split(',')
|
|
self.param_object[field.name] = listToArray(self.ClientObj.client, list_result)
|
|
|
|
elif type (self.view_dict[field.name]) == FileOpenWgt:
|
|
self.param_object[field.name] = \
|
|
str(self.view_dict[field.name].data)
|
|
|
|
elif type (self.view_dict[field.name]) == QtGui.QTableWidget:
|
|
column = self.view_dict[field.name].columnCount()
|
|
row = self.view_dict[field.name].rowCount()
|
|
table_result = []
|
|
for i in range(row):
|
|
temp = []
|
|
for j in range(column):
|
|
# not adding if readonly
|
|
if j > (len(self.table_dict[field.name].tablevalue.values.ChoiceValue)-1):
|
|
continue
|
|
if self.view_dict[field.name].item(i,j):
|
|
text = self.view_dict[field.name].item(i,j).text()
|
|
|
|
elif self.view_dict[field.name].cellWidget(i,j):
|
|
|
|
if type(self.view_dict[field.name].cellWidget(i,j)) == QtGui.QComboBox:
|
|
text = self.view_dict[field.name].cellWidget(i,j).currentText()
|
|
elif type(self.view_dict[field.name].cellWidget(i,j)) == MultipleChoice:
|
|
list_result = self.view_dict[field.name].cellWidget(i,j).values()
|
|
text = ','.join(list_result)
|
|
elif type(self.view_dict[field.name].cellWidget(i,j)) == CentralCheckBox:
|
|
text = self.view_dict[field.name].cellWidget(i,j).getState()
|
|
|
|
temp.append(text)
|
|
table_result.append(temp)
|
|
|
|
self.param_object[field.name] = listToArrayArray(self.ClientObj.client, table_result)
|
|
|
|
# print 'self.param_object', self.param_object
|
|
return wrapper
|
|
|
|
def calling(self, CheckOnly = False):
|
|
# call method on server
|
|
def wrapper():
|
|
if hasattr (self.param_object, 'CheckOnly'):
|
|
self.param_object['CheckOnly'] = CheckOnly
|
|
|
|
print self.method_name, "$$$$$$$$$$$$$$$$"
|
|
# print self.param_object
|
|
|
|
if self.ClientObj.param_objects[self.method_name]['error'] and \
|
|
type(self.ClientObj.param_objects[self.method_name]['error']) == list:
|
|
|
|
for error in self.ClientObj.param_objects[self.method_name]['error']:
|
|
if self.error_label_dict.has_key(str(error.field)):
|
|
self.error_label_dict[error.field].hide()
|
|
if self.label_dict.has_key(str(error.field)):
|
|
self.label_dict[error.field].setStyleSheet \
|
|
("QLabel { color : black; }")
|
|
|
|
self.ClientObj.param_objects[self.method_name]['error'] = None
|
|
|
|
self.ClientObj.sid = get_sid(self.ClientObj.client.SID_FILE)
|
|
|
|
try:
|
|
sid = int(self.ClientObj.sid)
|
|
# call method on server
|
|
meth_result_temp = self.ClientObj.client.service[0][self.method_name] \
|
|
(sid, self.param_object)
|
|
meth_result = []
|
|
error = False
|
|
for res in meth_result_temp[0]:
|
|
meth_result.append(ReturnedMessage(res.type, res.field, res.message))
|
|
if res.type == 'error':
|
|
self.ClientObj.param_objects[self.method_name]['error'] = meth_result
|
|
error = True
|
|
|
|
if error:
|
|
self.error_display()
|
|
return
|
|
if hasattr (self.param_object, 'CheckOnly'):
|
|
if self.param_object['CheckOnly']:
|
|
return
|
|
self.ClientObj.param_objects[self.method_name]['step'] = 0
|
|
if meth_result[0].type == "pid":
|
|
# create process dict
|
|
self.ClientObj.process_dict[meth_result[0].message] = {}
|
|
self.ClientObj.process_dict[meth_result[0].message]\
|
|
['result'] = meth_result[0]
|
|
self.ClientObj.process_dict[meth_result[0].message]\
|
|
['name'] = self.method_name
|
|
self.ClientObj.process_dict[meth_result[0].message] \
|
|
['layout'] = QtGui.QVBoxLayout()
|
|
|
|
# Вызвать метод вывода результатов процесса
|
|
self.ClientObj.MainWidget.main_frame_res(self.method_name, \
|
|
meth_result[0])
|
|
self.ClientObj.app.processEvents()
|
|
if hasattr(self.ClientObj.MainWidget.main_frame, 'verticalScrollBar'):
|
|
self.ClientObj.MainWidget.main_frame.verticalScrollBar().setValue \
|
|
(self.ClientObj.MainWidget.main_frame.verticalScrollBar().maximum())
|
|
except WebFault, f:
|
|
show_msg(f.message, 'Error from Server!')
|
|
self.ClientObj.param_objects[self.method_name]['error'] = 'transmitted data is incorrect'
|
|
return wrapper
|
|
|
|
|
|
def error_display(self):
|
|
'''display error and warning in current view'''
|
|
print 'ERROR_DISPLAY!!!!!!'
|
|
self.error_fined = False
|
|
for error in self.ClientObj.param_objects[self.method_name]['error']:
|
|
print "Error field = ", error.field
|
|
for step_num in range (len (self.ClientObj.param_objects[self.method_name]['fields'])):
|
|
# step_num = self.ClientObj.param_objects[self.method_name]['step']
|
|
if error.field in self.ClientObj.param_objects[self.method_name]['fields'][step_num]:
|
|
self.error_fined = True
|
|
if self.ClientObj.param_objects[self.method_name]['step'] != step_num:
|
|
|
|
view = self.ClientObj.client.service[0][self.method_name+'_view']\
|
|
(int(self.ClientObj.sid), step_num)
|
|
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)
|
|
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; }")
|
|
self.error_label_dict[error.field].setText(error.message)
|
|
self.error_label_dict[error.field].show()
|
|
if self.label_dict.has_key(str(error.field)):
|
|
self.label_dict[error.field].setStyleSheet \
|
|
("QLabel { color : red; }")
|
|
# ("QLabel { background-color : yellow; color : red; }")
|
|
|
|
def highlight_errors(self):
|
|
'''display error in current view If errors came in parameters'''
|
|
step_num = self.ClientObj.param_objects[self.method_name]['step']
|
|
|
|
print self.ClientObj.param_objects[self.method_name]['error']
|
|
print step_num
|
|
|
|
for error in self.ClientObj.param_objects[self.method_name]['error']:
|
|
try:
|
|
error.field
|
|
except:
|
|
show_msg(self.ClientObj.param_objects[self.method_name]['error'])
|
|
self.ClientObj.param_objects[self.method_name]['error'] = None
|
|
return 1
|
|
if error.field in self.ClientObj.param_objects[self.method_name]['fields'][step_num]:
|
|
if self.error_label_dict.has_key(str(error.field)):
|
|
self.error_label_dict[error.field].setStyleSheet \
|
|
("QLabel { color : red; }")
|
|
self.error_label_dict[error.field].setText(error.message)
|
|
self.error_label_dict[error.field].show()
|
|
if self.label_dict.has_key(str(error.field)):
|
|
self.label_dict[error.field].setStyleSheet \
|
|
("QLabel { color : red; }")
|
|
# self.updateGeomerty()
|
|
|
|
# method changed value table items
|
|
def OnChanged(self, row, column, field):
|
|
def wrapper():
|
|
table = field.tablevalue
|
|
print field.name
|
|
for i in range(len(table.values.ChoiceValue[column].onChanged.string)):
|
|
if table.values.ChoiceValue[column].onChanged.string[i] == '':
|
|
# print i, "=====> ''"
|
|
''' do nothing '''
|
|
pass
|
|
|
|
elif table.values.ChoiceValue[column].onChanged.string[i] == None:
|
|
'''remove value'''
|
|
# print i, 'i = None'
|
|
if self.view_dict[field.name].item(row,i):
|
|
self.view_dict[field.name].item(row,i).setText('')
|
|
elif type(self.view_dict[field.name].cellWidget(row,i)) == QComboBox:
|
|
try:
|
|
self.view_dict[field.name].cellWidget(row,i).setEditText('')
|
|
except:
|
|
pass
|
|
elif type(self.view_dict[field.name].cellWidget(row,i)) == MultipleChoice:
|
|
self.view_dict[field.name].cellWidget(row,i).avail += \
|
|
self.view_dict[field.name].cellWidget(row,i).select
|
|
self.view_dict[field.name].cellWidget(row,i).Selected = []
|
|
self.view_dict[field.name].cellWidget(row,i).change_value()
|
|
|
|
# Event when the state of the widget QComboBox changed
|
|
elif table.values.ChoiceValue[column].onChanged.string[i] == 'get_body':
|
|
'''insert the value specified in "body table" for this'''
|
|
# print "i == 'get_body'"
|
|
text = self.view_dict[field.name].cellWidget(row,column).currentText()
|
|
# print '===> ', text
|
|
if self.view_dict[field.name].item(row,i):
|
|
for q in (table.body.stringArray):
|
|
try:
|
|
ind = q.string.index(text)
|
|
print ind
|
|
self.view_dict[field.name].item(row,i).setText(q.string[i])
|
|
print q.string[i]
|
|
break
|
|
except Exception, e:
|
|
print 'EXCEPT', e
|
|
pass
|
|
elif type(self.view_dict[field.name].cellWidget(row,i)) == QComboBox:
|
|
for q in (table.body.stringArray):
|
|
try:
|
|
ind = q.string.index(text)
|
|
cur_text = q.string[ind]
|
|
cur_ind = table.values.ChoiceValue[column].values.string.index(cur_text)
|
|
self.view_dict[field.name].cellWidget(row,i).setCurrentIndex(cur_ind)
|
|
break
|
|
except:
|
|
pass
|
|
elif type(self.view_dict[field.name].cellWidget(row,i)) == CentralCheckBox:
|
|
for q in (table.body.stringArray):
|
|
try:
|
|
print "====++++++++++++++++==============++++++++==", text
|
|
ind = q.string.index(text)
|
|
cur_text = q.string[ind]
|
|
if q.string[i] == 'on':
|
|
self.view_dict[field.name].cellWidget(row,i).setChecked(True)
|
|
elif q.string[i] == 'off':
|
|
self.view_dict[field.name].cellWidget(row,i).setChecked(False)
|
|
break
|
|
except:
|
|
pass
|
|
elif type(self.view_dict[field.name].cellWidget(row,i)) == MultipleChoice:
|
|
for q in (table.body.stringArray):
|
|
try:
|
|
ind = q.string.index(text)
|
|
cur_text = q.string[i]
|
|
self.view_dict[field.name].cellWidget(row,i).avail = \
|
|
table.values.ChoiceValue[column].values.string
|
|
self.view_dict[field.name].cellWidget(row,i).Selected = cur_text.split(',')
|
|
self.view_dict[field.name].cellWidget(row,i).change_value()
|
|
break
|
|
except:
|
|
pass
|
|
|
|
elif table.values.ChoiceValue[column].onChanged.string[i] == 'on':
|
|
'''set Check'''
|
|
if type(self.view_dict[field.name].cellWidget(row,i)) == CentralCheckBox:
|
|
self.view_dict[field.name].cellWidget(row,i).setChecked(True)
|
|
|
|
elif table.values.ChoiceValue[column].onChanged.string[i] == 'off':
|
|
'''set unCheck'''
|
|
if type(self.view_dict[field.name].cellWidget(row,i)) == CentralCheckBox:
|
|
self.view_dict[field.name].cellWidget(row,i).setChecked(False)
|
|
|
|
elif table.values.ChoiceValue[column].onChanged.string[i] == 'auto':
|
|
'''set unCheck'''
|
|
if type(self.view_dict[field.name].cellWidget(row,i)) == CentralCheckBox:
|
|
self.view_dict[field.name].cellWidget(row,i).setCheckState \
|
|
(QtCore.Qt.CheckState.PartiallyChecked)
|
|
return wrapper
|
|
|
|
|
|
class MainFrame (QtGui.QScrollArea):
|
|
def __init__(self, parent, ClientObj, view, method_name):
|
|
self.parent = parent
|
|
QtGui.QScrollArea.__init__(self)
|
|
self.MainFrameWgt = MFWgt(self, ClientObj, view, method_name)
|
|
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)
|