class Window(QWidget):
def __init__(self):
QWidget.__init__(self)
self.textBrowser = QTextBrowser(self)
self.textBrowser.setTextFormat(QTextBrowser.LogText)
self.lineEdit = QLineEdit(self)
self.startButton = QPushButton(self.tr("Start"), self)
self.stopButton = QPushButton(self.tr("Stop"), self)
self.stopButton.setEnabled(False)
self.connect(self.lineEdit, SIGNAL("returnPressed()"), self.startCommand)
self.connect(self.startButton, SIGNAL("clicked()"), self.startCommand)
self.connect(self.stopButton, SIGNAL("clicked()"), self.stopCommand)
layout = QGridLayout(self, 2, 3)
layout.setSpacing(8)
layout.addMultiCellWidget(self.textBrowser, 0, 0, 0, 2)
layout.addWidget(self.lineEdit, 1, 0)
layout.addWidget(self.startButton, 1, 1)
layout.addWidget(self.stopButton, 1, 2)
self.process = QProcess()
self.connect(self.process, SIGNAL("readyReadStdout()"), self.readOutput)
self.connect(self.process, SIGNAL("readyReadStderr()"), self.readErrors)
self.connect(self.process, SIGNAL("processExited()"), self.resetButtons)
def startCommand(self):
self.process.setArguments(QStringList.split(" ", self.lineEdit.text()))
self.process.closeStdin()
self.startButton.setEnabled(False)
self.stopButton.setEnabled(True)
self.textBrowser.clear()
if not self.process.start():
self.textBrowser.setText(
QString("*** Failed to run %1 ***").arg(self.lineEdit.text())
)
self.resetButtons()
return
def stopCommand(self):
self.resetButtons()
self.process.tryTerminate()
QTimer.singleShot(5000, self.process, SLOT("kill()"))
def readOutput(self):
self.textBrowser.append(QString(self.process.readStdout()))
def readErrors(self):
self.textBrowser.append("error: " + QString(self.process.readLineStderr()))
def resetButtons(self):
self.startButton.setEnabled(True)
self.stopButton.setEnabled(False)
class EWOEntradaTexto(ElementoWidgetOpciones, QHBox):
"""Es una entrada de texto, con un nombre, que devuelve un valor insertado por el usuario"""
def __init__(self, parent, nombre, valorpordefecto = ""):
ElementoWidgetOpciones.__init__(self)
QHBox.__init__(self, parent, "EntradaTexto")
self.__etiqueta = QLabel(nombre, self)
self.__entrada = QLineEdit(self, "Linea")
self.__entrada.setText(valorpordefecto)
self.nombre = nombre
def opciones(self):
"""Devuelve las opciones seleccionadas"""
if self.__entrada.text():
return {self.nombre:self.__entrada.text().latin1()}
else:
return {}
def activar(self):
"""Activa el widget"""
self.__entrada.setEnabled(True)
def desactivar(self):
"""Desactiva el widget"""
self.__entrada.setEnabled(False)
class PassDialog(QDialog):
def __init__(self):
QDialog.__init__(self)
self.l = QVBoxLayout(self)
self.passwd = QLineEdit(self, "password")
self.passwd.setEchoMode(QLineEdit.Password)
self.l.addWidget(self.passwd)
self.connect(self.passwd, SIGNAL("returnPressed()"), self.slotSetPass)
def slotSetPass(self):
global password
password = str(self.passwd.text())
self.done(0)
class ChatWindow(QWidget):
"""a widget for showing chat messages"""
def __init__(self, scene=None, table=None):
super(ChatWindow, self).__init__(None)
self.scene = scene
self.table = table or scene.game.client.table
self.table.chatWindow = self
self.setObjectName('chatWindow')
title = m18n(
'Chat on table %1 at %2',
self.table.tableid,
self.table.client.connection.url)
decorateWindow(self, title)
self.messageView = ChatView()
self.messageView.setModel(ChatModel())
self.messageView.setFocusPolicy(Qt.NoFocus)
self.messageView.setShowGrid(False)
self.messageView.setWordWrap(False)
self.messageView.setSelectionMode(QAbstractItemView.NoSelection)
if Debug.modelTest:
self.debugModelTest = ModelTest(
self.messageView.model(),
self.messageView)
self.edit = QLineEdit()
layout = QVBoxLayout()
layout.addWidget(self.messageView)
layout.addWidget(self.edit)
self.setLayout(layout)
self.edit.returnPressed.connect(self.sendLine)
self.edit.setFocus()
self.show()
StateSaver(self)
def show(self):
"""not only show but also restore and raise"""
self.activateWindow()
self.setWindowState(self.windowState() & ~Qt.WindowMinimized)
self.raise_()
QWidget.show(self)
def isVisible(self):
"""not only visible but also not minimized"""
return QWidget.isVisible(self) and not self.windowState() & Qt.WindowMinimized
def kill(self):
"""hide and null on table"""
if Debug.chat:
logDebug(u'chat.kill for %s on table %s' % (self, self.table))
self.hide()
self.table.chatWindow = None
def sendLine(self, line=None, isStatusMessage=False):
"""send line to others. Either the edited line or parameter line."""
if line is None:
line = unicode(self.edit.text())
self.edit.clear()
if line:
if Debug.chat:
logDebug(u'sending line %s to others' % line)
msg = ChatMessage(
self.table.tableid,
self.table.client.name,
line,
isStatusMessage)
self.table.client.sendChat(msg).addErrback(self.chatError)
def chatError(self, result):
"""tableList may already have gone away"""
if self.table.client.tableList:
self.table.client.tableList.tableError(result)
def leave(self):
"""leaving the chat"""
self.hide()
def receiveLine(self, chatLine):
"""show a new line in protocol"""
self.show()
self.messageView.model().appendLines(chatLine)
for row in range(self.messageView.model().rowCount()):
self.messageView.setRowHeight(
row,
self.messageView.fontMetrics().height())
self.messageView.resizeColumnsToContents()
self.messageView.scrollToBottom()
def text(self):
txt = QLineEdit.text(self)
if txt.isEmpty():
return None
else:
return unicode(txt)
class ChatWindow(QWidget):
"""a widget for showing chat messages"""
def __init__(self, scene=None, table=None):
super(ChatWindow, self).__init__(None)
self.scene = scene
self.table = table or scene.game.client.table
self.table.chatWindow = self
self.setObjectName('chatWindow')
title = i18n('Chat on table %1 at %2', self.table.tableid,
self.table.client.connection.url)
decorateWindow(self, title)
self.messageView = ChatView()
self.messageView.setModel(ChatModel())
self.messageView.setFocusPolicy(Qt.NoFocus)
self.messageView.setShowGrid(False)
self.messageView.setWordWrap(False)
self.messageView.setSelectionMode(QAbstractItemView.NoSelection)
if Debug.modelTest:
self.debugModelTest = ModelTest(self.messageView.model(),
self.messageView)
self.edit = QLineEdit()
layout = QVBoxLayout()
layout.addWidget(self.messageView)
layout.addWidget(self.edit)
self.setLayout(layout)
self.edit.returnPressed.connect(self.sendLine)
self.edit.setFocus()
self.show()
StateSaver(self)
def show(self):
"""not only show but also restore and raise"""
self.activateWindow()
self.setWindowState(self.windowState() & ~Qt.WindowMinimized)
self.raise_()
QWidget.show(self)
def isVisible(self):
"""not only visible but also not minimized"""
return QWidget.isVisible(
self) and not self.windowState() & Qt.WindowMinimized
def kill(self):
"""hide and null on table"""
if Debug.chat:
logDebug('chat.kill for %s on table %s' % (self, self.table))
self.hide()
self.table.chatWindow = None
def sendLine(self, line=None, isStatusMessage=False):
"""send line to others. Either the edited line or parameter line."""
if line is None:
line = self.edit.text()
self.edit.clear()
if line:
if Debug.chat:
logDebug('sending line %s to others' % line)
msg = ChatMessage(self.table.tableid, self.table.client.name, line,
isStatusMessage)
self.table.client.sendChat(msg).addErrback(self.chatError)
def chatError(self, result):
"""tableList may already have gone away"""
if self.table.client.tableList:
self.table.client.tableList.tableError(result)
def leave(self):
"""leaving the chat"""
self.hide()
def receiveLine(self, chatLine):
"""show a new line in protocol"""
self.show()
self.messageView.model().appendLines(chatLine)
for row in range(self.messageView.model().rowCount()):
self.messageView.setRowHeight(
row,
self.messageView.fontMetrics().height())
self.messageView.resizeColumnsToContents()
self.messageView.scrollToBottom()
class AddUserDialog(KDialog):
"""add a user account on a server: This dialog asks for the needed attributes"""
# pylint: disable=too-many-instance-attributes
def __init__(self, url, username, password):
KDialog.__init__(self)
decorateWindow(self, i18n('Create User Account'))
self.setButtons(KDialog.ButtonCode(KDialog.Ok | KDialog.Cancel))
vbox = QVBoxLayout()
grid = QFormLayout()
self.lbServer = QLabel()
self.lbServer.setText(url)
grid.addRow(i18n('Game server:'), self.lbServer)
self.lbUser = QLabel()
grid.addRow(i18n('Username:'******'Password:'******'Repeat password:'), self.edPassword2)
vbox.addLayout(grid)
widget = QWidget(self)
widget.setLayout(vbox)
self.setMainWidget(widget)
pol = QSizePolicy()
pol.setHorizontalPolicy(QSizePolicy.Expanding)
self.lbUser.setSizePolicy(pol)
self.edPassword.textChanged.connect(self.passwordChanged)
self.edPassword2.textChanged.connect(self.passwordChanged)
StateSaver(self)
self.username = username
self.password = password
self.passwordChanged()
self.edPassword2.setFocus()
def passwordChanged(self, dummyText=None):
"""password changed"""
self.validate()
def validate(self):
"""does the dialog hold valid data?"""
equal = self.edPassword.size() and self.edPassword.text(
) == self.edPassword2.text()
self.button(KDialog.Ok).setEnabled(equal)
@property
def username(self):
"""abstracts the username of the dialog"""
return self.lbUser.text()
@username.setter
def username(self, username):
"""abstracts the username of the dialog"""
self.lbUser.setText(username)
@property
def password(self):
"""abstracts the password of the dialog"""
return self.edPassword.text()
@password.setter
def password(self, password):
"""abstracts the password of the dialog"""
self.edPassword.setText(password)
class LoginDlg(QDialog):
"""login dialog for server"""
def __init__(self):
"""self.servers is a list of tuples containing server and last playername"""
QDialog.__init__(self, None)
decorateWindow(self, i18nc('kajongg', 'Login'))
self.setupUi()
localName = i18nc('kajongg name for local game server',
Query.localServerName)
self.servers = Query(
'select url,lastname from server order by lasttime desc').records
servers = list(x[0] for x in self.servers
if x[0] != Query.localServerName)
# the first server combobox item should be default: either the last used server
# or localName for autoPlay
if localName not in servers:
servers.append(localName)
if 'kajongg.org' not in servers:
servers.append('kajongg.org')
if Internal.autoPlay:
demoHost = Options.host or localName
if demoHost in servers:
servers.remove(
demoHost
) # we want a unique list, it will be re-used for all following games
servers.insert(0, demoHost)
# in this process but they will not be autoPlay
self.cbServer.addItems(servers)
self.passwords = Query(
'select url, p.name, passwords.password from passwords, player p '
'where passwords.player=p.id').records
Players.load()
self.cbServer.editTextChanged.connect(self.serverChanged)
self.cbUser.editTextChanged.connect(self.userChanged)
self.serverChanged()
StateSaver(self)
def returns(self, dummyButton=None):
"""login data returned by this dialog"""
return (Url(self.url), self.username, self.password,
self.__defineRuleset())
def setupUi(self):
"""create all Ui elements but do not fill them"""
self.buttonBox = KDialogButtonBox(self)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
# Ubuntu 11.10 unity is a bit strange - without this, it sets focus on
# the cancel button (which it shows on the left). I found no obvious
# way to use setDefault and setAutoDefault for fixing this.
self.buttonBox.button(QDialogButtonBox.Ok).setFocus(True)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
vbox = QVBoxLayout(self)
self.grid = QFormLayout()
self.cbServer = QComboBox()
self.cbServer.setEditable(True)
self.grid.addRow(i18n('Game server:'), self.cbServer)
self.cbUser = QComboBox()
self.cbUser.setEditable(True)
self.grid.addRow(i18n('Username:'******'Password:'******'kajongg', 'Ruleset:'), self.cbRuleset)
vbox.addLayout(self.grid)
vbox.addWidget(self.buttonBox)
pol = QSizePolicy()
pol.setHorizontalPolicy(QSizePolicy.Expanding)
self.cbUser.setSizePolicy(pol)
self.__port = None
def serverChanged(self, dummyText=None):
"""the user selected a different server"""
records = Query(
'select player.name from player, passwords '
'where passwords.url=? and passwords.player = player.id',
(self.url, )).records
players = list(x[0] for x in records)
preferPlayer = Options.player
if preferPlayer:
if preferPlayer in players:
players.remove(preferPlayer)
players.insert(0, preferPlayer)
self.cbUser.clear()
self.cbUser.addItems(players)
if not self.cbUser.count():
user = KUser() if os.name == 'nt' else KUser(os.geteuid())
self.cbUser.addItem(user.fullName() or user.loginName())
if not preferPlayer:
userNames = [x[1] for x in self.servers if x[0] == self.url]
if userNames:
userIdx = self.cbUser.findText(userNames[0])
if userIdx >= 0:
self.cbUser.setCurrentIndex(userIdx)
showPW = bool(self.url) and not Url(self.url).isLocalHost
self.grid.labelForField(self.edPassword).setVisible(showPW)
self.edPassword.setVisible(showPW)
self.grid.labelForField(self.cbRuleset).setVisible(
not showPW and not Options.ruleset)
self.cbRuleset.setVisible(not showPW and not Options.ruleset)
if not showPW:
self.cbRuleset.clear()
if Options.ruleset:
self.cbRuleset.items = [Options.ruleset]
else:
self.cbRuleset.items = Ruleset.selectableRulesets(self.url)
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(bool(self.url))
def __defineRuleset(self):
"""find out what ruleset to use"""
if Options.ruleset:
return Options.ruleset
elif Internal.autoPlay or bool(Options.host):
return Ruleset.selectableRulesets()[0]
else:
return self.cbRuleset.current
def userChanged(self, text):
"""the username has been changed, lookup password"""
if text == '':
self.edPassword.clear()
return
passw = None
for entry in self.passwords:
if entry[0] == self.url and entry[1] == text:
passw = entry[2]
if passw:
self.edPassword.setText(passw)
else:
self.edPassword.clear()
@property
def url(self):
"""abstracts the url of the dialog"""
return english(self.cbServer.currentText())
@property
def username(self):
"""abstracts the username of the dialog"""
return self.cbUser.currentText()
@property
def password(self):
"""abstracts the password of the dialog"""
return self.edPassword.text()
@password.setter
def password(self, password):
"""abstracts the password of the dialog"""
self.edPassword.setText(password)
class ImportPage(QWidget):
update_command_lst_low_level = Signal(list)
"""
This stacked widget basically helps the user to browse the input images
path, there is no auto-generated GUI form Phil parameters in use withing
this widget.
"""
def __init__(self, parent=None):
super(ImportPage, self).__init__(parent=None)
main_v_box = QVBoxLayout()
label_font = QFont()
sys_font_point_size = label_font.pointSize()
label_font.setPointSize(sys_font_point_size + 2)
step_label = QLabel(str("Import"))
step_label.setFont(label_font)
self.simple_lin = QLineEdit(self)
self.simple_lin.textChanged.connect(self.update_command)
self.x_spn_bx = QSpinBox()
self.x_spn_bx.setMaximum(99999)
self.x_spn_bx.setSpecialValueText(" ")
self.y_spn_bx = QSpinBox()
self.y_spn_bx.setMaximum(99999)
self.y_spn_bx.setSpecialValueText(" ")
self.x_spn_bx.valueChanged.connect(self.x_beam_changed)
self.y_spn_bx.valueChanged.connect(self.y_beam_changed)
self.chk_invert = QCheckBox("Invert rotation axis")
self.chk_invert.stateChanged.connect(self.inv_rota_changed)
self.opn_fil_btn = QPushButton(" \n Select file(s) \n ")
main_path = get_main_path()
self.opn_fil_btn.setIcon(QIcon(main_path + "/resources/import.png"))
self.opn_fil_btn.setIconSize(QSize(80, 48))
main_v_box.addWidget(step_label)
main_v_box.addWidget(self.opn_fil_btn)
main_v_box.addWidget(self.simple_lin)
self.b_cetre_label = QLabel("\n\n Beam centre")
main_v_box.addWidget(self.b_cetre_label)
cent_hbox = QHBoxLayout()
self.x_label = QLabel(" X: ")
cent_hbox.addWidget(self.x_label)
cent_hbox.addWidget(self.x_spn_bx)
self.y_label = QLabel(" Y: ")
cent_hbox.addWidget(self.y_label)
cent_hbox.addWidget(self.y_spn_bx)
# cent_hbox.addWidget(QLabel(" \n "))
cent_hbox.addStretch()
main_v_box.addLayout(cent_hbox)
main_v_box.addWidget(self.chk_invert)
main_v_box.addStretch()
self.opn_fil_btn.clicked.connect(self.open_files)
self.defa_dir = str(os.getcwd())
self.setLayout(main_v_box)
# self.show()
self.reset_par()
def reset_par(self):
logger.info("reset_par(ImportPage)")
self.cmd_list = []
self.simple_lin.setText(" ? ")
self.x_spn_bx.setValue(0.0)
self.y_spn_bx.setValue(0.0)
self.chk_invert.setChecked(False)
self.x_beam, self.y_beam = 0.0, 0.0
self.path_file_str = ""
self.second_half = ""
self.third_half = ""
def update_param_w_lst(self, lst_in):
self.reset_par()
logger.info("update_param_w_lst(ImportPage) \n lst: \n", lst_in)
for singl_com in lst_in:
if singl_com[0:1] == "/":
self.path_file_str = str(singl_com)
self.put_str_lin()
if singl_com[0:12] == "image_range=":
self.path_file_str += " "
self.path_file_str += str(singl_com)
self.put_str_lin()
if singl_com == "invert_rotation_axis=True":
self.chk_invert.setChecked(True)
if singl_com[0:22] == "slow_fast_beam_centre=":
yb_xb_str = singl_com[22:]
yb_str, xb_str = yb_xb_str.split(",")
yb = float(yb_str)
xb = float(xb_str)
self.y_spn_bx.setValue(yb)
self.x_spn_bx.setValue(xb)
def inv_rota_changed(self):
if self.chk_invert.checkState():
self.third_half = "invert_rotation_axis=True"
else:
self.third_half = ""
self.put_str_lin()
def x_beam_changed(self, value):
self.x_beam = value
self.build_second_half()
def y_beam_changed(self, value):
self.y_beam = value
self.build_second_half()
def build_second_half(self):
if self.x_beam != 0.0 and self.y_beam != 0.0:
self.second_half = (
"slow_fast_beam_centre=" + str(self.y_beam) + "," + str(self.x_beam)
)
else:
self.second_half = ""
self.put_str_lin()
def open_files(self):
lst_file_path = QFileDialog.getOpenFileNames(
self, "Open File(s)", self.defa_dir, "All Files (*.*)"
)
if len(lst_file_path) > 0:
new_dir, new_command = get_import_run_string(lst_file_path)
# logger.info("\n new_dir=", new_dir, ">>")
# logger.info("\n new_command =", new_command, ">>")
self.path_file_str = new_command
self.defa_dir = new_dir
self.put_str_lin()
def put_str_lin(self):
# logger.info("self.path_file_str =", self.path_file_str, ">>")
self.cmd_list = [
self.path_file_str,
self.second_half.lstrip(),
self.third_half.lstrip(),
]
txt_lin = " ".join(self.cmd_list).rstrip()
while " " in txt_lin:
txt_lin = txt_lin.replace(" ", " ")
self.simple_lin.setText(txt_lin)
def set_arg_obj(self, sys_arg_in):
"""Pass the system argument object to handle launch arguments."""
if sys_arg_in.template is not None:
str_arg = str(sys_arg_in.template)
self.simple_lin.setText(str_arg)
def update_command(self):
self.command_lst = [["import"]]
param_com = str(self.simple_lin.text())
cmd_lst = param_com.split(" ")
for single_com in cmd_lst:
self.command_lst[0].append(single_com)
self.update_command_lst_low_level.emit(self.command_lst[0])
def gray_me_out(self):
self.simple_lin.setEnabled(False)
self.opn_fil_btn.setEnabled(False)
self.x_spn_bx.setEnabled(False)
self.y_spn_bx.setEnabled(False)
self.x_label.setEnabled(False)
self.y_label.setEnabled(False)
self.b_cetre_label.setEnabled(False)
self.chk_invert.setEnabled(False)
def activate_me(self, cur_nod=None):
self.simple_lin.setEnabled(True)
self.opn_fil_btn.setEnabled(True)
self.y_spn_bx.setEnabled(True)
self.x_spn_bx.setEnabled(True)
self.x_label.setEnabled(True)
self.y_label.setEnabled(True)
self.b_cetre_label.setEnabled(True)
self.chk_invert.setEnabled(True)
class ExportPage(QWidget):
update_command_lst_low_level = Signal(list)
"""
This stacked widget basically helps the user to export by
generating an MTZ file, there is no auto-generated GUI
form Phil parameters in use withing this widget.
"""
def __init__(self, parent=None):
super(ExportPage, self).__init__(parent=None)
main_v_box = QVBoxLayout()
label_font = QFont()
sys_font_point_size = label_font.pointSize()
label_font.setPointSize(sys_font_point_size + 2)
step_label = QLabel(str("Export"))
step_label.setFont(label_font)
out_file_label = QLabel(str("mtz output name:"))
self.simple_lin = QLineEdit(self)
self.simple_lin.textChanged.connect(self.update_command)
self.check_scale = QCheckBox("Output Scaled Intensities")
self.check_scale.setChecked(False)
self.check_scale.stateChanged.connect(self.update_command)
self.warning_label = QLabel(str(" "))
self.warning_label.setWordWrap(True)
main_v_box.addWidget(step_label)
main_v_box.addWidget(out_file_label)
main_v_box.addWidget(self.simple_lin)
main_v_box.addWidget(self.check_scale)
main_v_box.addStretch()
main_v_box.addWidget(self.warning_label)
main_v_box.addStretch()
self.setLayout(main_v_box)
self.fist_time = False
# self.show()
self.simple_lin.setText("integrated.mtz")
def update_command(self):
self.command_lst = [["export"]]
param1_com = str(self.simple_lin.text())
self.command_lst[0].append("mtz.hklout=" + param1_com)
if self.check_scale.checkState():
param2_com = "intensity=scale"
self.command_lst[0].append(param2_com)
self.update_command_lst_low_level.emit(self.command_lst[0])
self.check_repeated_file()
def check_repeated_file(self):
param1_com = str(self.simple_lin.text())
cwd_path = os.path.join(sys_arg.directory, "dui_files")
mtz_file_path = os.path.join(cwd_path, param1_com)
if os.path.isfile(mtz_file_path):
txt_warning = "Warning, file: " + param1_com + " already exists"
self.warning_label.setText(txt_warning)
self.warning_label.setStyleSheet("color: rgba(255, 55, 55, 255)")
"""
self.warning_label.setStyleSheet(
"color: rgba(255, 55, 55, 255);" "background-color: yellow;"
)
"""
else:
self.warning_label.setText(" ")
self.warning_label.setStyleSheet("color: rgba(0, 155, 255, 255)")
def gray_me_out(self):
self.simple_lin.setEnabled(False)
self.check_scale.setEnabled(False)
self.fist_time = False
def activate_me(self, cur_nod=None):
self.simple_lin.setEnabled(True)
self.check_scale.setEnabled(True)
if self.fist_time is False:
self.fist_time = True
self.simple_lin.setText("integrated.mtz")
self.check_scale.setChecked(False)
my_node = cur_nod
found_scale = False
for iters in range(5):
try:
if my_node.ll_command_lst[0][0] == "scale":
found_scale = True
break
except AttributeError as at_err:
logger.info("found ", at_err, " in for loop, not to worry")
my_node = my_node.prev_step
if found_scale is True:
self.simple_lin.setText("scaled.mtz")
self.check_scale.setChecked(True)
self.check_repeated_file()
def reset_par(self):
logger.info("command_lst(ExportPage.reset_par) = ", self.command_lst)
logger.info(" Not supposed to reset export page")