class _StatusBar(QStatusBar):
"""Extended status bar. Supports HTML messages
"""
def __init__(self, *args):
QStatusBar.__init__(self, *args)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.setSizeGripEnabled(False)
self.setStyleSheet(
"QStatusBar {border: 0} QStatusBar::item {border: 0}")
self._label = QLabel(self)
self._label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self._label.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self._label.setStyleSheet("color: red")
self.addWidget(self._label)
self._timer = QTimer()
self._timer.setSingleShot(True)
self._timer.timeout.connect(self.clearMessage)
def showMessage(self, text, timeout=0):
"""QStatusBar.showMessage()
"""
self._label.setText(text)
self._timer.stop()
if timeout > 0:
self._timer.start(timeout)
def clearMessage(self):
"""QStatusBar.clearMessage()
"""
self._label.clear()
def currentMessage(self):
return self._label.text()
class _StatusBar(QStatusBar):
"""Extended status bar. Supports HTML messages
"""
def __init__(self, *args):
QStatusBar.__init__(self, *args)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.setSizeGripEnabled(False)
self.setStyleSheet("QStatusBar {border: 0} QStatusBar::item {border: 0}")
self._label = QLabel(self)
self._label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self._label.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self._label.setStyleSheet("color: red")
self.addWidget(self._label)
self._timer = QTimer()
self._timer.setSingleShot(True)
self._timer.timeout.connect(self.clearMessage)
def showMessage(self, text, timeout=0):
"""QStatusBar.showMessage()
"""
self._label.setText(text)
self._timer.stop()
if timeout > 0:
self._timer.start(timeout)
def clearMessage(self):
"""QStatusBar.clearMessage()
"""
self._label.clear()
class ImageFrame(QGroupBox):
""" GUI component. Displays an image of the currently selected barcode.
"""
def __init__(self, title):
super(ImageFrame, self).__init__()
self.setTitle(title)
self._init_ui()
def _init_ui(self):
# Image frame - displays image of the currently selected scan record
self._frame = QLabel()
self._frame.setStyleSheet(
"background-color: black; color: red; font-size: 30pt; text-align: center"
)
self._frame.setFixedWidth(500)
self._frame.setFixedHeight(500)
self._frame.setAlignment(Qt.AlignCenter)
vbox = QVBoxLayout()
vbox.addWidget(self._frame)
self.setLayout(vbox)
def clear_frame(self, message):
self._frame.clear()
self._frame.setText(message)
def display_puck_image(self, image):
""" Called when a new row is selected on the record table. Displays the specified
image (image of the highlighted scan) in the image frame
"""
self._frame.clear()
self._frame.setAlignment(Qt.AlignCenter)
if image is not None and image.is_valid():
pixmap = image.to_qt_pixmap(self._frame.size())
self._frame.setPixmap(pixmap)
else:
self._frame.setText("Image Not Found")
class ImageFrame(QGroupBox):
""" GUI component. Displays an image of the currently selected barcode.
"""
def __init__(self):
super(ImageFrame, self).__init__()
self.setTitle("Scan Image")
self._init_ui()
def _init_ui(self):
# Image frame - displays image of the currently selected scan record
self._frame = QLabel()
self._frame.setStyleSheet("background-color: black; color: red; font-size: 30pt; text-align: center")
self._frame.setFixedWidth(600)
self._frame.setFixedHeight(600)
self._frame.setAlignment(Qt.AlignCenter)
vbox = QVBoxLayout()
vbox.addWidget(self._frame)
self.setLayout(vbox)
def clear_frame(self):
self._frame.clear()
self._frame.setText("No Scan Selected")
def display_puck_image(self, image):
""" Called when a new row is selected on the record table. Displays the specified
image (image of the highlighted scan) in the image frame
"""
self._frame.clear()
self._frame.setAlignment(Qt.AlignCenter)
if image is not None and image.is_valid():
pixmap = image.to_qt_pixmap(self._frame.size())
self._frame.setPixmap(pixmap)
else:
self._frame.setText("Image Not Found")
class MessageBox(QGroupBox):
"""GUI component. Displays messages for the user."""
def __init__(self):
super(MessageBox, self).__init__()
self.setTitle("Information")
self._style_sheets = {
MessageType.INFO: BASIC_STYLE_SHEET + BLACK,
MessageType.WARNING: BASIC_STYLE_SHEET + RED
}
self._init_ui()
# Start a timer to clear old messages
self._timer = QtCore.QTimer()
self._timer.timeout.connect(self._clear_old_message)
self._timer.start(1000)
def _init_ui(self):
self._message_lbl = QLabel()
self._message_lbl.setStyleSheet(BASIC_STYLE_SHEET)
vbox = QVBoxLayout()
vbox.addWidget(self._message_lbl)
vbox.addStretch()
self.setLayout(vbox)
def display(self, message):
self._message = message
self._message_lbl.setText(self._message.content())
self._message_lbl.setStyleSheet(
self._style_sheets[self._message.type()])
def _clear_old_message(self):
if self._message_lbl.text() and self._message.has_expired():
self._message_lbl.clear()
self._message = None
class MailInfoFrame(QWidget):
def __init__(self, parent):
QWidget.__init__(self, parent)
self.setAutoFillBackground(True)
pal = self.palette()
pal.setColor(10, QtCore.Qt.white)
self.setPalette(pal)
fromText = QLabel('<font color=gray>From :</font>', self)
dateText = QLabel('<font color=gray>Date :</font>', self)
self.fromLabel = QLabel(self)
self.subjectLabel = QLabel(self)
self.dateLabel = QLabel(self)
fromText.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Preferred)
dateText.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Preferred)
self.fromLabel.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Preferred)
self.subjectLabel.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Preferred)
self.dateLabel.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Preferred)
layout = QGridLayout(self)
layout.addWidget(fromText, 0, 0, 1, 1)
layout.addWidget(self.fromLabel, 0, 1, 1, 1)
layout.addWidget(dateText, 1, 0, 1, 1)
layout.addWidget(self.dateLabel, 1, 1, 1, 1)
layout.addWidget(self.subjectLabel, 2, 0, 1, 2)
def setData(self, cellWidget):
# Set Values
self.sender = cellWidget.sender
self.msg_id = cellWidget.msg_id
self.subject = cellWidget.subject
name, addr = splitEmailAddr(self.sender)
if addr == '': addr = name
setElidedText(self.fromLabel, addr)
setElidedText(self.dateLabel, fromRfc2822(cellWidget.date))
setElidedText(self.subjectLabel, '<b>%s</b>' % self.subject)
def clear(self):
self.sender, self.msg_id, self.subject = '', '', ''
self.fromLabel.clear()
self.dateLabel.clear()
self.subjectLabel.clear()
class typicalWindow(QtGui.QMainWindow):
def __init__(self):
QtGui.QMainWindow.__init__(self)
#window
self.setWindowTitle(winTitle)
self.central_widget=QWidget(self)
self.setCentralWidget(self.central_widget)
self.masterLayout=QGridLayout(self.central_widget)
self.masterLayout.setAlignment(QtCore.Qt.AlignTop)
#mainlayout
self.vertical_order_layout=QtGui.QBoxLayout(2)
self.vertical_order_layout.setAlignment(QtCore.Qt.AlignTop | QtCore.Qt.AlignVCenter)
self.masterLayout.addLayout(self.vertical_order_layout, 0,0,1,1)
self.topDivideLayout=QGridLayout()
self.botDivideLayout=QGridLayout()
self.upper_layout=QGridLayout()
self.topDivideLayout.addLayout(self.upper_layout, 0,0,1,1)
self.lower_layout=QGridLayout()
self.lower_layout.setAlignment(QtCore.Qt.AlignTop)
self.botDivideLayout.addLayout(self.lower_layout, 0,0,1,1)
self.midLayout=QGridLayout()
self.midLayout.setAlignment(QtCore.Qt.AlignTop)
self.base_layout=QGridLayout()
self.base_layout.setAlignment(QtCore.Qt.AlignTop)
self.botDivideLayout.addLayout(self.base_layout, 4,0,1,1)
sshFile=open(os.path.join(__location__, styleSheetFile+".stylesheet"), 'r')
self.styleData=sshFile.read()
sshFile.close
self.setStyleSheet(self.styleData)
self.top=QtGui.QFrame(self)
self.top.setFrameShape(QtGui.QFrame.StyledPanel)
self.top.setLayout(self.topDivideLayout)
self.bottom=QtGui.QFrame(self)
self.bottom.setFrameShape(QtGui.QFrame.StyledPanel)
self.bottom.setLayout(self.botDivideLayout)
self.splitPlane=QtGui.QSplitter(QtCore.Qt.Vertical)
self.splitPlane.addWidget(self.top)
self.splitPlane.addWidget(self.bottom)
self.splitPlane.setSizes([650, 650])
self.vertical_order_layout.addWidget(self.splitPlane)
#layouts
self.window_layer_00=QGridLayout()
self.upper_layout.addLayout(self.window_layer_00, 0,0,1,1)
self.window_layer_01=QGridLayout()
self.upper_layout.addLayout(self.window_layer_01,1,0,1,1)
self.window_layer_02=QGridLayout()
self.upper_layout.addLayout(self.window_layer_02, 2,0,1,1)
self.window_layer_03=QGridLayout()
self.upper_layout.addLayout(self.window_layer_03,3,0,1,1)
self.window_layer_04=QGridLayout()
self.upper_layout.addLayout(self.window_layer_04, 4,0,1,1)
self.window_layer_05=QGridLayout()
self.upper_layout.addLayout(self.window_layer_05,5,0,1,1)
self.window_layer_06=QGridLayout()
self.midLayout.addLayout(self.window_layer_06, 6,0,1,1)
self.frame_layout=QGridLayout()
self.frame_layout.setAlignment(QtCore.Qt.AlignTop)
self.lower_layout.addLayout(self.frame_layout, 0,0,1,1)
self.frameWidget=QtGui.QGridLayout()
self.frameWidget.setContentsMargins(5,10,5,10)
self.frameOverride=QtGui.QFrame()
self.frameOverride.setStyleSheet("background-color: #434343; border-style: solid; border-width: 2px; border-color:#434343;border-radius:8px;")
self.frameOverride.setFixedHeight(100)
self.frame_layout.addLayout(self.frameWidget, 0,0,1,1)
self.frame_layout.addWidget(self.frameOverride, 0,0,1,1)
self.frame_title_layout=QGridLayout()
self.frameWidget.addLayout(self.frame_title_layout, 0,0,1,1)
self.frame_radio_layout=QGridLayout()
self.frameWidget.addLayout(self.frame_radio_layout, 1,0,1,1)
self.frame_btn_layout=QGridLayout()
self.frameWidget.addLayout(self.frame_btn_layout, 2,0,1,1)
self.btm_btn_layout=QtGui.QGridLayout()
self.btm_btn_layout.setAlignment(QtCore.Qt.AlignTop)
self.btm_btn_layout.setContentsMargins(5,10,5,10)
self.wbFrame=QtGui.QFrame()
self.wbFrame.setStyleSheet("background-color: #434343; border-style: solid; border-width: 2px; border-color:#434343;border-radius:8px;")
self.btm_over_layout=QtGui.QGridLayout()
self.btm_over_layout.setAlignment(QtCore.Qt.AlignTop)
self.btm_over_layout.addLayout(self.btm_btn_layout, 0,0,1,1)
self.btm_over_layout.addWidget(self.wbFrame, 0,0,1,1)
self.pkt_layout= QGridLayout()
self.pkt_layout.setAlignment(QtCore.Qt.AlignTop)
self.pkt_widget=QGridLayout()
self.pkt_widget.setContentsMargins(5,5,5,5)
self.pkt_frame=QFrame()
self.pkt_frame.setMinimumWidth(650)
self.pkt_frame.setStyleSheet("background-color: #434343; border-style: solid; border-width: 2px; border-color:#434343;border-radius:8px;")
self.base_layout.addLayout(self.pkt_layout, 0,0,1,1)
self.wndw_layer_pkt=QtGui.QGridLayout()
self.wndw_layer_pkt.setAlignment(QtCore.Qt.AlignTop)
self.pkt_widget.addLayout(self.wndw_layer_pkt, 0,0,1,1)
self.park_btn_pkt=QtGui.QBoxLayout(2)
self.park_btn_pkt.setAlignment(QtCore.Qt.AlignTop)
self.park_btn_pkt.setContentsMargins(5,2,5,8)
self.wndw_layer_pkt.addLayout(self.park_btn_pkt, 0,0,1,1)
self.park_frame=QtGui.QFrame()
self.park_frame.setStyleSheet("background-color: #434343; border-style: solid; border-width: 2px; border-color:#434343;border-radius:8px;")
#widgets
self.drop_lbl_01=QLabel()
self.drop_lbl_01.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)
self.drop_lbl_01.setStyleSheet("color: #b1b1b1; background-color: rgba(255,255,255,0);")
self.window_layer_01.addWidget(self.drop_lbl_01, 0,0,1,1)
self.drop_01=QComboBox()
self.window_layer_01.addWidget(self.drop_01, 0,1,1,1)
QtCore.QObject.connect(self.drop_01, SIGNAL("currentIndexChanged(QString)"),
self.on_drop_01_changed)
self.drop_01.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.connect(self.drop_lbl_01, SIGNAL("customContextMenuRequested(QPoint)"), self.onRightClick)
self.drop_lbl_02=QLabel()
self.drop_lbl_02.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)
self.drop_lbl_02.setStyleSheet("color: #b1b1b1; background-color: rgba(255,255,255,0);")
self.window_layer_01.addWidget(self.drop_lbl_02, 0,2,1,1)
self.drop_02=QComboBox()
self.window_layer_01.addWidget(self.drop_02, 0,3,1,1)
QtCore.QObject.connect(self.drop_02, SIGNAL("currentIndexChanged(QString)"),
self.on_drop_01_changed)
self.drop_02.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.connect(self.drop_lbl_01, SIGNAL("customContextMenuRequested(QPoint)"), self.onRightClick)
self.button_01=QPushButton("Set")
self.button_01.setToolTip("set")
self.connect(self.button_01, SIGNAL('clicked()'), self.connectButton01)
self.window_layer_01.addWidget(self.button_01, 0,4,1,1)
self.button_02=QPushButton("Set2")
self.button_02.setToolTip("set2")
self.connect(self.button_02, SIGNAL('clicked()'), self.connectButton01)
self.window_layer_01.addWidget(self.button_02, 0,5,1,1)
self.drop_lbl_03=QLabel()
self.drop_lbl_03.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)
self.drop_lbl_03.setStyleSheet("color: #b1b1b1; background-color: rgba(255,255,255,0);")
self.window_layer_02.addWidget(self.drop_lbl_03, 0,0,1,1)
self.drop_03=QComboBox()
self.window_layer_02.addWidget(self.drop_03, 0,1,1,1)
QtCore.QObject.connect(self.drop_03, SIGNAL("currentIndexChanged(QString)"),
self.on_drop_01_changed)
self.drop_03.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.connect(self.drop_03, SIGNAL("customContextMenuRequested(QPoint)"), self.onRightClick)
self.button_03=QPushButton("button_03")
self.button_03.setToolTip("button_03")
self.connect(self.button_03, SIGNAL('clicked()'), self.connectButton01)
self.window_layer_02.addWidget(self.button_03, 0,2,1,1)
self.button_04=QPushButton("button_04")
self.button_04.setToolTip("button_04")
self.connect(self.button_04, SIGNAL('clicked()'), self.connectButton01)
self.window_layer_02.addWidget(self.button_04, 0,3,1,1)
self.button_05=QPushButton("button_05")
self.button_05.setToolTip("button_05")
self.connect(self.button_05, SIGNAL('clicked()'), self.connectButton01)
self.window_layer_02.addWidget(self.button_05, 0,4,1,1)
self.drop_04=QComboBox()
self.window_layer_04.addWidget(self.drop_04, 0,2,1,1)
QtCore.QObject.connect(self.drop_04, SIGNAL("currentIndexChanged(QString)"),
self.on_drop_01_changed)
self.drop_04.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.connect(self.drop_04, SIGNAL("customContextMenuRequested(QPoint)"), self.onRightClick)
self.list_frame=QFrame()
self.list_frame.setStyleSheet("color: rgb"+str(buttonColoursDict.get("red")))
self.list_layout=QHBoxLayout()
self.list_frame.setLayout(self.list_layout)
self.drop_list_builder_05=QComboBox()
self.drop_list_builder_05.addItems(alist)
QtCore.QObject.connect(self.drop_list_builder_05, SIGNAL("currentIndexChanged(QString)"),
self.build)
self.drop_list_builder_05.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.connect(self.drop_list_builder_05, SIGNAL("customContextMenuRequested(QPoint)"), self.onRightClick)
self.list_layout.addWidget(self.drop_list_builder_05)
self.window_layer_04.addWidget(self.list_frame, 0,3,1,1)
self.drop_list_06=QComboBox()
QtCore.QObject.connect(self.drop_list_06, SIGNAL("currentIndexChanged(QString)"),
self.load)
self.drop_list_06.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.connect(self.drop_list_06, SIGNAL("customContextMenuRequested(QPoint)"), self.onRightClick)
if len(pres)<1:
self.drop_list_06.setEnabled(0)
else:
self.drop_list_06.setEnabled(1)
self.drop_list_06.addItems(alist2)
self.list_layout.addWidget(self.drop_list_06)
self.type_list_drop=QComboBox()
self.type_list_drop.addItems(typesOfStuffInList)
QtCore.QObject.connect(self.type_list_drop, SIGNAL("currentIndexChanged(QString)"),
self.on_drop_01_changed)
self.window_layer_04.addWidget(self.type_list_drop, 0,5,1,1)
self.button_06=QPushButton("button_06")
self.button_06.setToolTip("button_06")
self.connect(self.button_06, SIGNAL('clicked()'), self.connectButton01)
self.window_layer_04.addWidget(self.button_06, 0,6,0,1)
self.listWidg=QtGui.QTableWidget()
self.listWidg.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.listWidg.customContextMenuRequested.connect(self.RightClick)
self.connect(self.listWidg, SIGNAL("itemClicked(QTableWidgetItem *)"), self.clicked)
self.connect(self.listWidg, SIGNAL("itemDoubleClicked(QTableWidgetItem *)"), self.dclicked)
self.window_layer_05.addWidget(self.listWidg, 0,2,1,1)
self.status_lbl=QLabel()
self.status_lbl.setStyleSheet('background-color:transparent')
self.status_lbl.setAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter)
self.frame_title_layout.addWidget(self.status_lbl, 0,2,1,1)
self.spaceHold=QLabel()
self.spaceHold.setStyleSheet("color: #b1b1b1; background-color: rgba(255,255,255,0);")
self.spaceHold.setAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter)
self.frame_title_layout.addWidget(self.spaceHold, 0,0,1,1)
self.checkbox=QCheckBox("add")
self.checkbox.setStyleSheet("color: #b1b1b1; background-color: rgba(255,255,255,0);")
self.checkbox.setContentsMargins(5,0,0,0)
self.checkbox.setChecked(1)
self.frame_title_layout.addWidget(self.checkbox, 0,1,1,1)
self.radiobox=QGridLayout()
self.radio=QRadioButton("radio")
self.radio.setStyleSheet("color: #b1b1b1; background-color: rgba(255,255,255,0);")
self.radio.setChecked(1)
self.radiobox.addWidget(self.radio, 0,0,1,1)
self.newradio=QRadioButton("newradio")
self.newradio.setStyleSheet("color: #b1b1b1; background-color: rgba(255,255,255,0);")
self.radiobox.addWidget(self.newradio, 0,1,1,1)
self.frame_len_layout=QGridLayout()
self.frame_len_layout.setAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter)
#self.frame_title_layout.addWidget(self.frame_len_layout, 1,3,1,1)
self.spaceHold=QLabel()
self.spaceHold.setStyleSheet("color: #b1b1b1; background-color: rgba(255,255,255,0);")
self.spaceHold.setAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter)
self.frame_title_layout.addWidget(self.spaceHold, 0,0,1,1)
self.over=QRadioButton("over")
self.over.setStyleSheet("color: #b1b1b1; background-color: rgba(255,255,255,0);")
self.radiobox.addWidget(self.over, 1,1,1,1)
self.head_lbl=QLabel("from")
self.head_lbl.setStyleSheet("color: #b1b1b1; background-color: rgba(255,255,255,0);")
self.radiobox.addWidget(self.head_lbl, 1, 4,1,1)
self.head_field=QTextEdit("")
self.head_field.setStyleSheet("color: #b1b1b1; background-color: rgba(255,255,255,0);")
self.radiobox.addWidget(self.head_field, 1, 5,1,1)
self.toe_lbl=QLabel("til")
self.toe_lbl.setStyleSheet("color: #b1b1b1; background-color: rgba(255,255,255,0);")
self.radiobox.addWidget(self.toe_lbl, 1, 6,1,1)
self.toe_field=QTextEdit("")
self.toe_field.setStyleSheet("color: #b1b1b1; background-color: rgba(255,255,255,0);")
self.radiobox.addWidget(self.toe_field, 1, 7,1,1)
self.fieldBox=QLineEdit()
self.fieldBox.setVisible(0)
self.fieldBox.setText(defaultText)
self.go_btn=QPushButton("go")
self.connect(self.go_btn, SIGNAL('clicked()'), self.go)
self.frame_btn_layout.addWidget(self.go_btn, 0,0,0,1)
self.look_btn=QPushButton("look")
self.connect(self.look_btn, SIGNAL('clicked()'), self.go)
self.frame_btn_layout.addWidget(self.look_btn, 0,1, 0,1)
self.link_btn=QPushButton("link")
self.connect(self.link_btn, SIGNAL('clicked()'), self.go)
self.frame_btn_layout.addWidget(self.link_btn, 0,2,1,1)
self.create_btn=QPushButton("create_btn")
self.connect(self.create_btn, SIGNAL('clicked()'), self.go)
self.frame_btn_layout.addWidget(self.create_btn, 0,3, 1,1)
self.pocketTitle=QPushButton("title")
self.pocketTitle.setObjectName('label')
self.pocketTitle.setStyleSheet("QPushButton#label{font-weight:500; color: rgb"str(buttonColorDict).get("yello"))+"; button-color: rgba(255,255,255,0); font-size: 10pt; border-width: 0px; font-style: bold;}")
self.connect(self.pocketTitle, SIGNAL('clicked()'), self.send)
self.connect(self.pocketTitle, SIGNAL('customContextMenuRequested(QPoint)'), lambda: self.send())
self.park_btn_pkt.addWidget(self.pocketTitle)
self.a_btn=QPushButton("a_btn")
self.a_btn.setStyleSheet("background-color: rgb"str(buttonColorDict).get("yello")))
self.connect(self.a_btn, SIGNAL('clicked()'), self.go)
self.park_btn_pkt.addWidget(self.a_btn)
self.card_menu=QMenu("card")
self.card_menuBar=self.menuBar()
self.card_menuBar.addMenu(self.card_menu)
self.park_btn_pkt.addWidget(self.card_menuBar)
buttonGrp.append(self.card_menuBar)
self.card_btn=QToolButton()
self.card_btn.setPopupMode(QToolButton.MenuButtonPopup)
self.card_btn.setMenu(self.card_menu)
self.card_special_btn=QPushButton("card special")
self.connect(self.card_special_btn, SIGNAL('clicked()'), self.card_special_callup)
action=QtGui.QWidgetAction(self.card_btn)
action.setDefaultWidget(self.card_special_btn)
self.card_btn.menu().addAction(action)
self.B_card_btn=QToolButton()
self.B_card_btn.setPopupMode(QToolButton.MenuButtonPopup)
self.B_card_btn.setMenu(self.card_menu)
self.B_card_special_btn=QPushButton("card special")
self.connect(self.B_card_special_btn, SIGNAL('clicked()'),self.B_card_special_callup)
action=QtGui.QWidgetAction(self.B_card_btn)
action.setDefaultWidget(self.B_card_special_btn)
self.B_card_btn.menu().addAction(action)
def buttonToggle(self):
get_a_layout=self.park_btn_pkt
get_size=get_a_layout.getContentsMargine()
if get_size==(0,0,0,0):
self.setvisible()
else:
self.setinvisible()
def setinvisible(self):
for each in buttonGrp:
each.setVisible(0)
self.park_btn_pkt.setContentsMargine(0,0,0,0)
def setvisible(self):
for each in buttonGrp:
each.setVisible(1)
self.park_btn_pkt.setContentsMargine(5,8,5,8)
def onRightClick(self):
path='//'
command="xdg-open '%s'"%path
subprocess.Popen(command, stdout=subprocess.PIPE, shell=True)
def on_drop_01_changed(self):
newcol1=self.listWidg.columnWidth(0)
newcol2=self.listWidg.columnWidth(1)
newcol3=self.listWidg.columnWidth(2)
if newcol1==0:
col1, col1, col1= 240, 160, 500
else:
col1, col1, col1= newcol1, newcol2, newcol3
getPath='//'
get_items=os.listdir(get_items)
self.listWidg.clear()
self.status_lbl.clear()
self.drop_03.addItems(get_items)
model, countdata, listArray =self.get_listStuff()
if self.on_drop_01=="item1":
buildListPath=pathList.get("listpathtype").replace(getUser, newUser)
self.makeList(listpath, newUser, self.listWidg, model, stat_lab, listtype)
elif self.on_drop_01=="item2":
buildListPath=pathList.get("listpathtype2").replace(getUser, newUser)
self.makeList(listpath, newUser, self.listWidg, model, stat_lab, listtype)
def clicked(self):
print "hi"
def dclicked(self):
print "hello"
def get_listStuff(self):
listArray=self.listWidg
countdata=listArray.rowCount()
model=listArray.model()
return model, countdata, listArray
def getListWidgetData(self):
model, countdata, listArray =self.get_listStuff()
dataInListWidget=[]
for row in range(model.rowCount()):
dataInListWidget.append([])
for column in range(model.columnCount()):
index = model.index(row, column)
dataInListWidet[row].append(str(model.data(index).toString()))
return dataInListWidget, countdata
def listCreate(self):
directory='//'
getUser='******'
(dataInListWidget, countdata)=self.getListWidgetData()
self.listWidg.setRowCount(0)
self.listWidg.setColumnCount(0)
try:
getFiles=[os.path.join(directory, o) for o in os.listdir(directory) if os.path.isdir(os.path.join(directory, o))]
pass
except:
print "nothing found"
return
getFile=[(each) for each in getFiles if getpwuid(stat(each).st_uid).pw_name==getUser]
getFiles.sort(key=lambda x: os.path.getmtime(x))
fileDict=[]
for each in getFiles:
statbuf=os.stat(each)
timeFormat=time.strftime('%m/%d/%Y', time.gmtime(os.path.getctime(each)))
getAccTime=time.ctime(os.path.getmtime(each))
if " " in str(getAccTime):
getAccTime=getAccTime.split(" ")
getAccTime=getAccTime[1].split(" ")[1]
else:
getAccTime=getAccTime.split(" ")[3]
timeFormat=timeFormat+" "+getAccTime
makeDict=(each, timeFormat)
fileDict.append(makeDict)
count=len(fileDict)
fileDict=reversed(fileDict)
dictItems=fileDict
col1, col1, col1= 240, 160, 500
headerLabels=["Name", "Date", "Path"]
self.listWidg.setRowCount(count)
self.listWidg.clear()
self.listWidg.setSortingEnabled(True)
self.listWidg.setColumnWidth(3)
self.listWidg.setColumnWidth(0, col1)
self.listWidg.setColumnWidth(1, col2)
self.listWidg.setColumnWidth(2, col3)
self.listWidg.setHorizontalHeaderLabels(headerLabels)
getVerticalHeader=self.listWidg.verticalHeader()
getVerticalHeader.setDefaultSelectionSize(20)
self.listWidg.setSelectionBehavior(QAbstractItemView.SelectRows)
self.listWidg.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.listWidg.horizontalHeaderItem(0).setTextAlignment(QtCore.Qt.AlignLeft)
self.listWidg.horizontalHeaderItem(1).setTextAlignment(QtCore.Qt.AlignLeft)
self.listWidg.horizontalHeaderItem(2).setTextAlignment(QtCore.Qt.AlignLeft)
for row, item in enumerate(dictItems):
key=item[0].split('/')[-1]
path='/'.join(item[0].split('/')[-1])
path="/"+path
value=item[1]
getTable=self.listWidg
name=QtGui.QTableWidgetItem(key)
name.setFlage(QtCore.Qt.ItemIsEnabled|QtCore.Qt.ItemIsSelectable)
self.listWidg.setItem(row, 0, name)
timeStamp=QtGui.QTableWidgetItem(value)
self.listWidg.setItem(row, 1, timeStamp)
location=QtGui.QTableWidgetItem(path)
self.listWidg.setItem(row, 2, location)
self.status_lbl.setText(grabText)
self.status_lbl.setObjectName('non_plan_label')
self.status_lbl.setStyleSheet('QLabel#non_plan_label{font-weight: 500; color: orange; background-color: rgba(255,255,255,0);font-size: 9pt}')
def is_listWid_item_selected(self):
listW=self.listWidg
(dataInListWidget, countdata)=self.getListWidgetData()
get_string_id=[]
for index in xrange(countdata):
get=listW.item(index, 0).isSelected()
if get==True:
getObj=listW.item(index, 2).text()
getObj=str(getObj)
get_string_id.append(getObj)
else:
get=listW.item(index, 1).isSelected()
if get==True:
getObj=listW.item(index, 2).text()
getObj=str(getObj)
get_string_id.append(getObj)
else:
get=listW.item(index, 2).isSelected()
if get==True:
getObj=listW.item(index, 2).text()
getObj=str(getObj)
get_string_id.append(getObj)
return get_string_id
def build(self):
list_build=self.drop_list_builder_05
list_build_function=list_build.currentText()
selected_in_list=self.is_listWid_item_selected()
allthePaths=('//', '//')
allthePathsDic={"firstPath":'//', "secondPath":'//'}
#drop_list_builder_05
getlisttype=self.type_list_drop
listtype=getlisttype.currentText()
if selected_in_list>1:
getItems=[(each) for each in selected_in_list]
nameToSave=' '.join(getItems)
if listtype=="firstPath":
suffixAppend="first"
path=allthePathsDic.get("firstPath")
if listtype=="secondPath":
suffixAppend="second"
path=allthePathsDic.get("secondPath")
compareBucket=[]
getitems=[(suffixAppend+":"+each.split("/")[-1]) for each in selected_in_list]
name_to_save=' '.join(getitems)
if list_build_function==list_build[1]:
prompt="name of list:"
getcomment=self.makeBody(prompt)
if getComment==None:
print "needs name"
return
else:
pass
getComment=getComment.replace(' ', '_')
shotList=suffixAppend+"_"+getComment+"storedText.txt"
fileBuild=path+shotList
copyfilemessage="creating in "+fileBuild
replay = QtGui.QMessageBox.question(None, 'Message' ,copyfilemessage, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
if os.path.isfile(fileBuild)==True:
cmessage="create over "+fileBuild
replay = QtGui.QMessageBox.question(None, 'Message', cmessage, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
inp=open(fileBuild, "w+")
inp.write(name_to_save)
inp.close()
print "created "+fileBuild
else:
print "cancelled"
return
else:
inp=open(fileBuild, "w+")
inp.write(name_to_save)
inp.close()
print "created "+fileBuild
else:
print "cancelled"
return
elif list_build_function==list_build[2]:
fileDict, list=self.getAllLists(allthePaths)
def getAllLists(self, stuff):
fileDict={}
for each in stuff:
getList, getnamesdic=self.obtain_presets(each)
getnames=getnamesdic.keys()
for eachp in eachn in map(None, getList, getnames):
dictlist={eachn:eachp}
fileDict.update(dictlist)
return fileDict, getList
def obtain_presets(self, morestuff):
preset=False
format=".txt"
getpreset=[os.path.join(dirpath, name) for dirpath, dirnames, files in os.walk(morestuff) for name in files if name.lower().endswith(format)]
preset=[(each) for each in getpreset if "storedText" in each]
getlistnames={}
for each in preset:
getName=each.split("/")[-1]
nam=getName.split("_")
getpletename='_'.join(nam[:-1])
diction={getpletename:nam[0]}
getlistnames.update(diction)
return preset, getlistnames
# def obtain_files(self, stuff):
# preset_name=[]
# if presetis!=False:
# for each in presetis:
# pathsplit=each.split("/")[-1]
# namefind=pathsplit.split("_")[0]
# preset_name.append(namefind)
# else:
# preset_name=False
# return preset_name
def makeBody(self, prompt):
text, ok=QtGui.QInputDialog.getText(None, 'Intput Dialog', prompt)
if ok:
project=(str(text))
else:
return
return project
def makeBodyFilled(self, prompt, message):
text, ok=QtGui.QInputDialog.getText(None, 'Intput Dialog', prompt, QtGui.QLineEdit.Normal, message)
if ok and text:
project=(str(text))
else:
return
return project
def load(self):
list_load=self.drop_list_06
list_load_function=list_build.currentText()
allthePaths=('//', '//')
allthePathsDic={"firstPath":'//', "secondPath":'//'}
# getlisttype=self.type_list_drop
# listtype=getlisttype.currentText()
# if selected_in_list>1:
# getItems=[(each) for each in selected_in_list]
# nameToSave=' '.join(getItems)
# if listtype=="firstPath"
# suffixAppend="first"
# path=allthePathsDic.get("firstPath")
# if listtype=="secondPath"
# suffixAppend="second"
# path=allthePathsDic.get("secondPath")
# compareBucket=[]
# getitems=[(suffixAppend+":"+each.split("/")[-1]) for each in selected_in_list]
# name_to_save=' '.join(getitems)
if list_load_function==presetlist[0]:
prompt="name of list:"
getcomment=self.makeBody(prompt)
if getComment==None:
print "needs name"
return
else:
pass
getComment=getComment.replace(' ', '_')
shotList=suffixAppend+"_"+getComment+"storedText.txt"
fileBuild=path+shotList
copyfilemessage="creating in "+fileBuild
replay = QtGui.QMessageBox.question(None, 'Message', copyfilemessage, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
if os.path.isfile(fileBuild)==True:
cmessage="create over "+fileBuild
replay = QtGui.QMessageBox.question(None, 'Message' ,cmessage, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
inp=open(fileBuild, "w+")
inp.write(name_to_save)
inp.close()
print "created "+fileBuild
else:
print "cancelled"
return
else:
inp=open(fileBuild, "w+")
inp.write(name_to_save)
inp.close()
print "created "+fileBuild
else:
print "cancelled"
return
elif list_build_function==list_build[2]:
fileDict, list=self.getAllLists(allthePaths)
def reset_callup(self):
allthePaths=('//', '//')
allthePathsDic={"firstPath":'//', "secondPath":'//'}
getlisttype=self.type_list_drop
listtype=getlisttype.currentText()
if listtype=="firstPath":
directory=allthePathsDic.get("firstPath")
getUser=getUser
self.directory_for_taking(getUser, directory)
def directory_for_taking(self, getUser, directory):
model, countdata, listArray =self.get_listStuff()
# self.status_lbl
def connectButton01(self):
print "hi"
def RightClick(self):
print "hello"
def go(self):
print "go"
def send(self):
print "end"
def card_special_callup(self):
print "card_special_callup"
def Bcard_special_callup(self):
print "B_card_special_callup"
def B_card_special_callup(self):
print "B_card_special_callup"
class Dialog(QDialog):
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self._info = None
self._text = ""
self._convertedtext = ""
self._encoding = None
self.fromVersionLabel = QLabel()
self.fromVersion = QLineEdit()
self.reason = QLabel()
self.toVersionLabel = QLabel()
self.toVersion = QLineEdit()
self.messages = QTextBrowser()
self.diff = QTextBrowser(lineWrapMode=QTextBrowser.NoWrap)
self.copyCheck = QCheckBox(checked=QSettings().value("convert_ly/copy_messages", True) not in (False, "false"))
self.tabw = QTabWidget()
self.tabw.addTab(self.messages, "")
self.tabw.addTab(self.diff, "")
self.buttons = QDialogButtonBox(QDialogButtonBox.Reset | QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
self.buttons.button(QDialogButtonBox.Reset).clicked.connect(self.run)
layout = QVBoxLayout()
self.setLayout(layout)
top = QHBoxLayout()
top.addWidget(self.fromVersionLabel)
top.addWidget(self.fromVersion)
top.addWidget(self.reason)
top.addStretch()
top.addWidget(self.toVersionLabel)
top.addWidget(self.toVersion)
layout.addLayout(top)
layout.addWidget(self.tabw)
layout.addWidget(self.copyCheck)
layout.addWidget(widgets.Separator())
layout.addWidget(self.buttons)
app.translateUI(self)
util.saveDialogSize(self, "convert_ly/dialog/size", QSize(600, 300))
app.settingsChanged.connect(self.readSettings)
self.readSettings()
self.finished.connect(self.saveCopyCheckSetting)
def translateUI(self):
self.fromVersionLabel.setText(_("From version:"))
self.toVersionLabel.setText(_("To version:"))
self.copyCheck.setText(_("Save convert-ly messages in document"))
self.copyCheck.setToolTip(
_("If checked, the messages of convert-ly are appended as a " "comment to the end of the document.")
)
self.tabw.setTabText(0, _("&Messages"))
self.tabw.setTabText(1, _("&Changes"))
self.buttons.button(QDialogButtonBox.Reset).setText(_("Run Again"))
self.setCaption()
def saveCopyCheckSetting(self):
QSettings().setValue("convert_ly/copy_messages", self.copyCheck.isChecked())
def readSettings(self):
font = textformats.formatData("editor").font
self.diff.setFont(font)
def setCaption(self):
version = self._info and self._info.versionString() or _("<unknown>")
title = _("Convert-ly from LilyPond {version}").format(version=version)
self.setWindowTitle(app.caption(title))
def setLilyPondInfo(self, info):
self._info = info
self.setCaption()
self.toVersion.setText(info.versionString())
self.setConvertedText()
def setConvertedText(self, text=""):
self._convertedtext = text
self.buttons.button(QDialogButtonBox.Ok).setEnabled(bool(text))
if text:
self.diff.setHtml(makeHtmlDiff(self._text, text))
else:
self.diff.clear()
def convertedText(self):
return self._convertedtext or ""
def setDocument(self, doc):
v = documentinfo.info(doc).versionString()
if v:
self.fromVersion.setText(v)
self.reason.setText(_("(set in document)"))
else:
self.reason.clear()
self._text = doc.toPlainText()
self._encoding = doc.encoding() or "UTF-8"
self.setConvertedText()
def run(self):
"""Runs convert-ly (again)."""
fromVersion = self.fromVersion.text()
toVersion = self.toVersion.text()
if not fromVersion or not toVersion:
self.messages.setPlainText(_("Both 'from' and 'to' versions need to be set."))
return
info = self._info
convert_ly = os.path.join(info.bindir(), info.convert_ly)
# on Windows the convert-ly command is not directly executable, but
# must be started using the LilyPond-provided Python interpreter
if os.name == "nt":
if not os.access(convert_ly, os.R_OK) and not convert_ly.endswith(".py"):
convert_ly += ".py"
command = [info.python(), convert_ly]
else:
command = [convert_ly]
command += ["-f", fromVersion, "-t", toVersion, "-"]
# if the user wants english messages, do it also here
env = None
if QSettings().value("lilypond_settings/no_translation", False) in (True, "true"):
env = dict(os.environ)
env["LANGUAGE"] = "C"
with util.busyCursor():
try:
proc = subprocess.Popen(
command, env=env, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE
)
out, err = proc.communicate(self._text.encode(self._encoding))
except OSError as e:
self.messages.setPlainText(
_("Could not start {convert_ly}:\n\n" "{message}\n").format(convert_ly=convert_ly, message=e)
)
return
self.messages.setPlainText(err.decode("UTF-8"))
self.setConvertedText(out.decode("UTF-8"))
if not out or self._convertedtext == self._text:
self.messages.append("\n" + _("The document has not been changed."))
class TplRow(QWidget):
def __init__(self, parent = None, _id = 0):
super(TplRow, self).__init__(parent)
self.id = _id
self.setLayout(QHBoxLayout())
self.idLabel = QLabel(self)
self.beginEdit = QDateTimeEdit(self)
self.beginEdit.setCalendarPopup(True)
self.endEdit = QDateTimeEdit(self)
self.endEdit.setCalendarPopup(True)
self.timeDiff = ClickLabel(self)
self.descriptionEdit = QLineEdit(self)
self.noteEdit = QLineEdit(self)
self.delButton = QPushButton(self)
self.delButton.setText('X')
self.layout().addWidget(self.idLabel)
self.layout().addWidget(self.beginEdit)
self.layout().addWidget(self.endEdit)
self.layout().addWidget(self.timeDiff)
self.layout().addWidget(self.descriptionEdit)
self.layout().addWidget(self.noteEdit)
self.layout().addWidget(self.delButton)
self.layout().setContentsMargins(2,2,2,2)
self.connect(self.descriptionEdit, SIGNAL('editingFinished ()'), self.notify)
self.connect(self.noteEdit, SIGNAL('editingFinished ()'), self.notify)
self.connect(self.beginEdit, SIGNAL('editingFinished ()'), self.notify)
self.connect(self.endEdit, SIGNAL('editingFinished ()'), self.notify)
self.connect(self.delButton, SIGNAL('clicked()'), self.delete)
self.connect(self.timeDiff, SIGNAL('clicked()'), self.onTimeDiff)
def set(self, tpl):
self.idLabel.setText(str(tpl[0]))
self.beginEdit.setDateTime(QDateTime.fromTime_t(tpl[1]))
self.endEdit.setDateTime(QDateTime.fromTime_t(tpl[2]))
self.timeDiff.setText( self.mkDiff( tpl[1], tpl[2] ) )
self.descriptionEdit.setText(str(tpl[3]))
self.noteEdit.setText(str(tpl[4]))
def get(self):
tpl = []
tpl.append(int(self.idLabel.text()))
tpl.append(self.beginEdit.dateTime().toTime_t())
tpl.append(self.endEdit.dateTime().toTime_t())
tpl.append(self.descriptionEdit.text())
tpl.append(self.noteEdit.text())
return tpl
def clear(self):
self.beginEdit.clear()
self.endEdit.clear()
self.timeDiff.clear()
self.descriptionEdit.clear()
self.noteEdit.clear()
self.idLabel.clear()
def mkDiff(self, begin, end):
return '%4d' % ceil( float( end - begin ) / 60 )
@pyqtSlot()
def onTimeDiff(self):
self.parent().parent().parent().statusBar.showMessage( '%s copied to clipboard.' % self.timeDiff.text() )
self.parent().clipboard.setText( str(self.timeDiff.text()).strip() )
@pyqtSlot()
def delete(self):
if self.idLabel.text():
if QMessageBox.question(self, 'delete ?', 'really delete id %s ?' % self.idLabel.text(), QMessageBox.Yes|QMessageBox.No, QMessageBox.No) == QMessageBox.Yes:
self.emit(SIGNAL('del(int)'), self.id)
@pyqtSlot()
def notify(self):
if self.idLabel.text():
self.timeDiff.setText( self.mkDiff( self.beginEdit.dateTime().toTime_t(), self.endEdit.dateTime().toTime_t() ) )
self.emit(SIGNAL('valueChanged(int)'), self.id)
class _QueuedMessageWidget(QWidget):
cleared = pyqtSignal()
finished = pyqtSignal()
shown = pyqtSignal()
closed = pyqtSignal()
linkActivated = pyqtSignal(unicode)
linkHovered= pyqtSignal(unicode)
buttonClicked = pyqtSignal(QAbstractButton)
def __init__(self, *args):
QWidget.__init__(self, *args)
self._messages = []
self._defaultTimeout = 0
self._defaultPixmap = QPixmap(":/enkiicons/infos.png" )
self._defaultBackground = QBrush( QColor( 250, 230, 147 ) )
self._defaultForeground = QBrush( QColor( 0, 0, 0 ) )
# pixmap
self.lPixmap = QLabel( self )
self.lPixmap.setAlignment( Qt.AlignCenter )
self.lPixmap.setSizePolicy( QSizePolicy( QSizePolicy.Maximum, QSizePolicy.Preferred ) )
# message
self.lMessage = QLabel( self )
self.lMessage.setAlignment( Qt.AlignVCenter | Qt.AlignLeft )
self.lMessage.setSizePolicy( QSizePolicy( QSizePolicy.Expanding, QSizePolicy.Preferred ) )
self.lMessage.setWordWrap( True )
self.lMessage.setOpenExternalLinks( True )
self.lMessage.setTextInteractionFlags( Qt.TextBrowserInteraction )
# button
self.dbbButtons = QDialogButtonBox( self )
# if false - buttons don't have neither text nor icons
self.dbbButtons.setStyleSheet("dialogbuttonbox-buttons-have-icons: true;")
self.dbbButtons.setSizePolicy( QSizePolicy( QSizePolicy.Maximum, QSizePolicy.Preferred ) )
self.setSizePolicy( QSizePolicy( QSizePolicy.Expanding, QSizePolicy.Maximum ) )
# layout
self.hbl = QHBoxLayout( self )
self.hbl.setMargin( 0 )
self.hbl.addWidget( self.lPixmap, 0, Qt.AlignCenter )
self.hbl.addWidget( self.lMessage )
self.hbl.addWidget( self.dbbButtons, 0, Qt.AlignCenter )
# connections
self.lMessage.linkActivated.connect(self.linkActivated)
self.lMessage.linkHovered.connect(self.linkHovered)
self.dbbButtons.clicked.connect(self.buttonClicked)
def sizeHint(self):
return QWidget.minimumSizeHint(self)
def openExternalLinks(self):
return self.lMessage.openExternalLinks()
def defaultTimeout(self):
return self._defaultTimeout
def defaultPixmap(self):
return self._defaultPixmap
def defaultBackground(self):
return self._defaultBackground
def defaultForeground(self):
return self._defaultForeground
def currentMessageInformations(self):
return self.currentMessagePixmap(), self.currentMessageBackground(), self.currentMessageForeground()
def pendingMessageCount(self):
return len(self._messages)
def currentMessage(self):
return self._messages[0]
def append(self, message, milliSeconds ):
msg = _QueuedMessage()
msg.message = message
if milliSeconds == -1:
msg.milliSeconds = self._defaultTimeout
else:
msg.milliSeconds = milliSeconds
msg.pixmap = self._defaultPixmap
msg.background = self._defaultBackground
msg.foreground = self._defaultForeground
self._messages.append(msg)
if len(self._messages) == 1 :
QTimer.singleShot( 0, self.showMessage)
def setOpenExternalLinks(self, open ):
self.lMessage.setOpenExternalLinks( open )
def setDefaultTimeout(self, timeout ):
self._defaultTimeout = timeout
def setDefaultPixmap(self, pixmap ):
self._defaultPixmap = pixmap
def setDefaultBackground(self, brush ):
self._defaultBackground = brush
def setDefaultForeground(self, brush ):
self._defaultForeground = brush
def remove(self, message ):
raise NotImplemented() # incorrect port from cpp fresh
if not self._messages or self._messages.first() == message:
return
self._messages.removeOne( message )
def clear(self):
self._messages.clear()
self.lPixmap.clear()
self.lMessage.clear()
self.dbbButtons.clear()
self.cleared.emit()
def currentMessagePixmap(self):
msg = self.currentMessage()
if msg.pixmap.isNull():
return self._defaultPixmap
else:
return msg.pixmap
def currentMessageBackground(self):
msg = self.currentMessage()
if msg.background == QBrush( Qt.NoBrush ):
return self._defaultBackground
else:
return msg.background
def currentMessageForeground(self):
msg = self.currentMessage()
if msg.foreground == QBrush( Qt.NoBrush ):
return self._defaultForeground
else:
return msg.foreground
def paintEvent(self, event ):
if self.pendingMessageCount() == 0 :
QWidget.paintEvent(self, event )
return
painter = QPainter( self )
painter.setPen( Qt.NoPen )
painter.setBrush( self.currentMessageBackground() )
painter.drawRect( self.contentsRect() )
def buttonClicked(self, button ):
msg = self.currentMessage()
standardButton = self.dbbButtons.standardButton( button )
if msg.slot is not None:
msg.slot(standardButton, msg)
self.closeMessage()
def showMessage(self):
# get message
msg = self.currentMessage()
# update palette
pal = self.lMessage.palette()
pal.setBrush( self.lMessage.foregroundRole(), self.currentMessageForeground() )
self.lMessage.setPalette( pal )
# format widget
self.lPixmap.setPixmap( self.currentMessagePixmap() )
self.lMessage.setText( msg.message )
self.lMessage.setToolTip( msg.message )
self.lMessage.setWhatsThis( msg.message )
# set buttons
if not msg.buttons:
msg.buttons[ QDialogButtonBox.Close ] = None
self.dbbButtons.clear()
for button in msg.buttons.keys():
pb = self.dbbButtons.addButton( button )
if button in msg.buttons:
pb.setText( msg.buttons[ button ] )
# auto close if needed
if msg.milliSeconds == -1:
timeout = self._defaultTimeout
else:
timeout = msg.milliSeconds
if timeout > 0:
QTimer.singleShot( timeout, self.closeMessage )
# signal.emit
self.shown.emit()
def closeMessage(self):
# message.emit
self.closed.emit()
# remove remove current message from hash
self._messages = self._messages[1:]
# process next if possible, clear gui
if self._messages:
QTimer.singleShot( 0, self.showMessage)
else:
QTimer.singleShot( 0, self.clearMessage)
# finished.emit message if needed
if not self._messages:
self.finished.emit()
def clearMessage(self):
self.lPixmap.clear()
self.lMessage.clear()
self.dbbButtons.clear()
class Dialog(QDialog):
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self._info = None
self._text = ''
self._convertedtext = ''
self._encoding = None
self.mainwindow = parent
self.fromVersionLabel = QLabel()
self.fromVersion = QLineEdit()
self.reason = QLabel()
self.toVersionLabel = QLabel()
self.toVersion = QLineEdit()
self.lilyChooser = lilychooser.LilyChooser()
self.messages = QTextBrowser()
self.diff = QTextBrowser(lineWrapMode=QTextBrowser.NoWrap)
self.uni_diff = QTextBrowser(lineWrapMode=QTextBrowser.NoWrap)
self.copyCheck = QCheckBox(checked=
QSettings().value('convert_ly/copy_messages', True, bool))
self.tabw = QTabWidget()
self.tabw.addTab(self.messages, '')
self.tabw.addTab(self.diff, '')
self.tabw.addTab(self.uni_diff, '')
self.buttons = QDialogButtonBox(
QDialogButtonBox.Reset | QDialogButtonBox.Save |
QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.buttons.button(QDialogButtonBox.Ok).clicked .connect(self.accept)
self.buttons.rejected.connect(self.reject)
self.buttons.button(QDialogButtonBox.Reset).clicked.connect(self.run)
self.buttons.button(QDialogButtonBox.Save).clicked.connect(self.saveFile)
layout = QVBoxLayout()
self.setLayout(layout)
grid = QGridLayout()
grid.addWidget(self.fromVersionLabel, 0, 0)
grid.addWidget(self.fromVersion, 0, 1)
grid.addWidget(self.reason, 0, 2, 1, 3)
grid.addWidget(self.toVersionLabel, 1, 0)
grid.addWidget(self.toVersion, 1, 1)
grid.addWidget(self.lilyChooser, 1, 3, 1, 2)
layout.addLayout(grid)
layout.addWidget(self.tabw)
layout.addWidget(self.copyCheck)
layout.addWidget(widgets.Separator())
layout.addWidget(self.buttons)
app.translateUI(self)
qutil.saveDialogSize(self, 'convert_ly/dialog/size', QSize(600, 300))
app.settingsChanged.connect(self.readSettings)
self.readSettings()
self.finished.connect(self.saveCopyCheckSetting)
self.lilyChooser.currentIndexChanged.connect(self.slotLilyPondVersionChanged)
self.slotLilyPondVersionChanged()
def translateUI(self):
self.fromVersionLabel.setText(_("From version:"))
self.toVersionLabel.setText(_("To version:"))
self.copyCheck.setText(_("Save convert-ly messages in document"))
self.copyCheck.setToolTip(_(
"If checked, the messages of convert-ly are appended as a "
"comment to the end of the document."))
self.tabw.setTabText(0, _("&Messages"))
self.tabw.setTabText(1, _("&Changes"))
self.tabw.setTabText(2, _("&Diff"))
self.buttons.button(QDialogButtonBox.Reset).setText(_("Run Again"))
self.buttons.button(QDialogButtonBox.Save).setText(_("Save as file"))
self.setCaption()
def saveCopyCheckSetting(self):
QSettings().setValue('convert_ly/copy_messages', self.copyCheck.isChecked())
def readSettings(self):
font = textformats.formatData('editor').font
self.diff.setFont(font)
diffFont = QFont("Monospace")
diffFont.setStyleHint(QFont.TypeWriter)
self.uni_diff.setFont(diffFont)
def slotLilyPondVersionChanged(self):
self.setLilyPondInfo(self.lilyChooser.lilyPondInfo())
def setCaption(self):
version = self._info and self._info.versionString() or _("<unknown>")
title = _("Convert-ly from LilyPond {version}").format(version=version)
self.setWindowTitle(app.caption(title))
def setLilyPondInfo(self, info):
self._info = info
self.setCaption()
self.toVersion.setText(info.versionString())
self.setConvertedText()
self.setDiffText()
self.messages.clear()
def setConvertedText(self, text=''):
self._convertedtext = text
self.buttons.button(QDialogButtonBox.Ok).setEnabled(bool(text))
if text:
self.diff.setHtml(htmldiff.htmldiff(
self._text, text,
_("Current Document"), _("Converted Document"),
wrapcolumn=100))
else:
self.diff.clear()
def setDiffText(self, text=''):
if text:
difflist = list(difflib.unified_diff(
self._text.split('\n'), text.split('\n'),
_("Current Document"), _("Converted Document")))
diffHLstr = self.diffHighl(difflist)
self.uni_diff.setHtml(diffHLstr)
else:
self.uni_diff.clear()
def convertedText(self):
return self._convertedtext or ''
def setDocument(self, doc):
v = documentinfo.docinfo(doc).version_string()
if v:
self.fromVersion.setText(v)
self.reason.setText(_("(set in document)"))
else:
self.reason.clear()
self._text = doc.toPlainText()
self._encoding = doc.encoding() or 'UTF-8'
self.setConvertedText()
self.setDiffText()
def run(self):
"""Runs convert-ly (again)."""
fromVersion = self.fromVersion.text()
toVersion = self.toVersion.text()
if not fromVersion or not toVersion:
self.messages.setPlainText(_(
"Both 'from' and 'to' versions need to be set."))
return
info = self._info
command = info.toolcommand(info.convert_ly)
command += ['-f', fromVersion, '-t', toVersion, '-']
# if the user wants english messages, do it also here: LANGUAGE=C
env = None
if QSettings().value("lilypond_settings/no_translation", False, bool):
if os.name == "nt":
# Python 2.7 subprocess on Windows chokes on unicode in env
env = util.bytes_environ()
env[b'LANGUAGE'] = b'C'
else:
env = dict(os.environ)
env['LANGUAGE'] = 'C'
with qutil.busyCursor():
try:
proc = subprocess.Popen(command,
universal_newlines = True,
env = env,
stdin = subprocess.PIPE,
stdout = subprocess.PIPE,
stderr = subprocess.PIPE)
out, err = proc.communicate(self._text.encode(self._encoding))
except OSError as e:
self.messages.setPlainText(_(
"Could not start {convert_ly}:\n\n"
"{message}\n").format(convert_ly = convert_ly, message = e))
return
self.messages.setPlainText(err.decode('UTF-8'))
self.setConvertedText(out.decode('UTF-8'))
self.setDiffText(out.decode('UTF-8'))
if not out or self._convertedtext == self._text:
self.messages.append('\n' + _("The document has not been changed."))
def saveFile(self):
"""Save content in tab as file"""
tabdata = self.getTabData(self.tabw.currentIndex())
doc = self.mainwindow.currentDocument()
orgname = doc.url().toLocalFile()
filename = os.path.splitext(orgname)[0] + '['+tabdata.filename+']'+'.'+tabdata.ext
caption = app.caption(_("dialog title", "Save File"))
filetypes = '{0} (*.txt);;{1} (*.htm);;{2} (*)'.format(_("Text Files"), _("HTML Files"), _("All Files"))
filename = QFileDialog.getSaveFileName(self.mainwindow, caption, filename, filetypes)
if not filename:
return False # cancelled
f = open(filename, 'w')
f.write(tabdata.text.encode('utf-8'))
f.close()
def getTabData(self, index):
"""Get content of current tab from current index"""
if index == 0:
return FileInfo('message', 'txt', self.messages.toPlainText())
elif index == 1:
return FileInfo('html-diff', 'html', self.diff.toHtml())
elif index == 2:
return FileInfo('uni-diff', 'diff', self.uni_diff.toPlainText())
def diffHighl(self, difflist):
"""Return highlighted version of input."""
result = []
for l in difflist:
if l.startswith('-'):
s = '<span style="color: red; white-space: pre-wrap;">'
elif l.startswith('+'):
s = '<span style="color: green; white-space: pre-wrap;">'
else:
s = '<span style="white-space: pre-wrap;">'
h = l.replace('&', '&').replace('<', '<').replace('>', '>')
result.append(s + h + '</span>')
return '<br>'.join(result)
class AddWordWidget(QDialog):
def __init__(self, parent=None):
super(AddWordWidget, self).__init__(parent=parent)
self.setWindowTitle('Add word')
self.create_layout()
self.create_connections()
def create_layout(self):
hbox = QHBoxLayout()
vbox = QVBoxLayout()
vbox.addWidget(QLabel("Dictionary"))
vbox.addWidget(QLabel("Original"))
vbox.addWidget(QLabel("Translation"))
vbox.addWidget(QLabel("Phoneme"))
vbox.addWidget(QLabel("Parts of Speech"))
vbox.addWidget(QLabel("Synonyms"))
vbox.addWidget(QLabel("Antonyms"))
hbox.addLayout(vbox)
vbox = QVBoxLayout()
self.dictionaries = Dictionary.objects.all()
self.dictionary = QComboBox()
self.dictionary.addItems([d.name for d in self.dictionaries])
vbox.addWidget(self.dictionary)
self.original = QLineEdit()
vbox.addWidget(self.original)
self.translation = QLineEdit()
vbox.addWidget(self.translation)
self.phoneme = QLineEdit()
vbox.addWidget(self.phoneme)
self.pos = QComboBox()
self.pos.addItems([p.strip() for p in
self.dictionaries[0].pos.split(',') if len(p) > 0])
vbox.addWidget(self.pos)
self.synonyms = QLineEdit()
vbox.addWidget(self.synonyms)
self.antonyms = QLineEdit()
vbox.addWidget(self.antonyms)
hbox.addLayout(vbox)
vbox = QVBoxLayout()
vbox.addLayout(hbox)
vbox.addWidget(QLabel("Description"))
self.description = QTextEdit()
vbox.addWidget(self.description)
self.add_button = QPushButton("&Add")
self.close_button = QPushButton("&Close")
hbox = QHBoxLayout()
hbox.addStretch()
hbox.addWidget(self.add_button)
hbox.addWidget(self.close_button)
vbox.addLayout(hbox)
self.status = QLabel('Add a new word to a dictionary.')
vbox.addWidget(self.status)
self.setLayout(vbox)
def create_connections(self):
self.connect(self.dictionary, SIGNAL("currentIndexChanged(int)"),
self.change_pos)
self.connect(self.close_button, SIGNAL("clicked()"), self.close)
self.connect(self.add_button, SIGNAL("clicked()"), self.add_word)
def change_pos(self, index):
current_dict = self.dictionaries[index]
self.pos.clear()
self.pos.addItems([p.strip() for p in
current_dict.pos.split(',') if len(p) > 0])
def get_texts(self):
current_dict = self.dictionaries[self.dictionary.currentIndex()].abbrev
original = unicode(self.original.text()).strip()
translation = unicode(self.translation.text()).strip()
phoneme = unicode(self.phoneme.text()).strip()
pos = unicode(self.pos.currentText()).strip()
synonyms = unicode(self.synonyms.text()).strip()
antonyms = unicode(self.antonyms.text()).strip()
description = unicode(self.description.toPlainText()).strip()
if not all([original, translation, pos]):
self.status.setText('There was an error inserting the word. Please'
' try again.')
QMessageBox.critical(self, "Error", "You must enter at least "
"'Original', 'Translation' and 'Parts of "
"Speech'.")
return None
return dict(dictionary=current_dict, original=original,
translation=translation, phoneme=phoneme, pos=pos,
synonyms=synonyms, antonyms=antonyms,
description=description)
def clear_texts(self):
self.translation.clear()
self.phoneme.clear()
self.synonyms.clear()
self.antonyms.clear()
self.description.clear()
self.original.setFocus()
def add_word(self):
self.status.clear()
texts = self.get_texts()
if not texts:
return
word = Word(**texts)
word.save()
self.clear_texts()
self.status.setText('Word %s has been added successfully.' %
word.original)
self.words_widget.load_words()
def save_word(self):
self.status.clear()
texts = self.get_texts()
if not texts:
return
word = self.word
word.dictionary = texts['dictionary']
word.original = texts['original']
word.translation = texts['translation']
word.phoneme = texts['phoneme']
word.pos = texts['pos']
word.synonyms = texts['synonyms']
word.antonyms = texts['antonyms']
word.description = texts['description']
word.save()
self.status.setText('Word %s has been saved successfully' %
word.original)
self.words_widget.load_words()
def get_word(self):
return self._word
def set_word(self, word):
self._word = word
self.setWindowTitle("Edit %s" % word.original)
self.add_button.setText("&Save")
self.disconnect(self.add_button, SIGNAL("clicked()"), self.add_word)
if word.exported:
self.add_button.setEnabled(False)
self.status.setText('This word has been exported already. '
'You cannot save the changes to it.')
else:
self.connect(self.add_button, SIGNAL("clicked()"), self.save_word)
self.status.setText('Edit this word and save to your dictionary.')
for i, d in enumerate(self.dictionaries):
if d.abbrev == word.dictionary:
self.dictionary.setCurrentIndex(i)
break
self.original.setText(word.original)
self.translation.setText(word. translation)
self.phoneme.setText(word.phoneme)
self.synonyms.setText(word.synonyms)
self.antonyms.setText(word.antonyms)
self.description.setText(word.description)
for i in range(self.pos.count()):
if self.pos.itemText(i) == word.pos:
self.pos.setCurrentIndex(i)
break
word = property(get_word, set_word)
class Dialog(QDialog):
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self._info = None
self._text = ''
self._convertedtext = ''
self._encoding = None
self.fromVersionLabel = QLabel()
self.fromVersion = QLineEdit()
self.reason = QLabel()
self.toVersionLabel = QLabel()
self.toVersion = QLineEdit()
self.lilyChooser = lilychooser.LilyChooser()
self.messages = QTextBrowser()
self.diff = QTextBrowser(lineWrapMode=QTextBrowser.NoWrap)
self.copyCheck = QCheckBox(
checked=QSettings().value('convert_ly/copy_messages', True, bool))
self.tabw = QTabWidget()
self.tabw.addTab(self.messages, '')
self.tabw.addTab(self.diff, '')
self.buttons = QDialogButtonBox(QDialogButtonBox.Reset
| QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
self.buttons.button(QDialogButtonBox.Reset).clicked.connect(self.run)
layout = QVBoxLayout()
self.setLayout(layout)
grid = QGridLayout()
grid.addWidget(self.fromVersionLabel, 0, 0)
grid.addWidget(self.fromVersion, 0, 1)
grid.addWidget(self.reason, 0, 2, 1, 3)
grid.addWidget(self.toVersionLabel, 1, 0)
grid.addWidget(self.toVersion, 1, 1)
grid.addWidget(self.lilyChooser, 1, 3, 1, 2)
layout.addLayout(grid)
layout.addWidget(self.tabw)
layout.addWidget(self.copyCheck)
layout.addWidget(widgets.Separator())
layout.addWidget(self.buttons)
app.translateUI(self)
qutil.saveDialogSize(self, 'convert_ly/dialog/size', QSize(600, 300))
app.settingsChanged.connect(self.readSettings)
self.readSettings()
self.finished.connect(self.saveCopyCheckSetting)
self.lilyChooser.currentIndexChanged.connect(
self.slotLilyPondVersionChanged)
self.slotLilyPondVersionChanged()
def translateUI(self):
self.fromVersionLabel.setText(_("From version:"))
self.toVersionLabel.setText(_("To version:"))
self.copyCheck.setText(_("Save convert-ly messages in document"))
self.copyCheck.setToolTip(
_("If checked, the messages of convert-ly are appended as a "
"comment to the end of the document."))
self.tabw.setTabText(0, _("&Messages"))
self.tabw.setTabText(1, _("&Changes"))
self.buttons.button(QDialogButtonBox.Reset).setText(_("Run Again"))
self.setCaption()
def saveCopyCheckSetting(self):
QSettings().setValue('convert_ly/copy_messages',
self.copyCheck.isChecked())
def readSettings(self):
font = textformats.formatData('editor').font
self.diff.setFont(font)
def slotLilyPondVersionChanged(self):
self.setLilyPondInfo(self.lilyChooser.lilyPondInfo())
def setCaption(self):
version = self._info and self._info.versionString() or _("<unknown>")
title = _("Convert-ly from LilyPond {version}").format(version=version)
self.setWindowTitle(app.caption(title))
def setLilyPondInfo(self, info):
self._info = info
self.setCaption()
self.toVersion.setText(info.versionString())
self.setConvertedText()
self.messages.clear()
def setConvertedText(self, text=''):
self._convertedtext = text
self.buttons.button(QDialogButtonBox.Ok).setEnabled(bool(text))
if text:
self.diff.setHtml(
htmldiff.htmldiff(self._text,
text,
_("Current Document"),
_("Converted Document"),
wrapcolumn=100))
else:
self.diff.clear()
def convertedText(self):
return self._convertedtext or ''
def setDocument(self, doc):
v = documentinfo.docinfo(doc).version_string()
if v:
self.fromVersion.setText(v)
self.reason.setText(_("(set in document)"))
else:
self.reason.clear()
self._text = doc.toPlainText()
self._encoding = doc.encoding() or 'UTF-8'
self.setConvertedText()
def run(self):
"""Runs convert-ly (again)."""
fromVersion = self.fromVersion.text()
toVersion = self.toVersion.text()
if not fromVersion or not toVersion:
self.messages.setPlainText(
_("Both 'from' and 'to' versions need to be set."))
return
info = self._info
command = info.toolcommand(info.convert_ly)
command += ['-f', fromVersion, '-t', toVersion, '-']
# if the user wants english messages, do it also here: LANGUAGE=C
env = None
if QSettings().value("lilypond_settings/no_translation", False, bool):
if os.name == "nt":
# Python 2.7 subprocess on Windows chokes on unicode in env
env = util.bytes_environ()
env[b'LANGUAGE'] = b'C'
else:
env = dict(os.environ)
env['LANGUAGE'] = 'C'
with qutil.busyCursor():
try:
proc = subprocess.Popen(command,
universal_newlines=True,
env=env,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
out, err = proc.communicate(self._text.encode(self._encoding))
except OSError as e:
self.messages.setPlainText(
_("Could not start {convert_ly}:\n\n"
"{message}\n").format(convert_ly=convert_ly, message=e))
return
self.messages.setPlainText(err.decode('UTF-8'))
self.setConvertedText(out.decode('UTF-8'))
if not out or self._convertedtext == self._text:
self.messages.append('\n' +
_("The document has not been changed."))
class HAConfigFrontend(FullFeaturedScrollArea):
COMPONENT = 'ha'
LABEL = tr('High Availability')
REQUIREMENTS = ('ha',)
ICON = ':/icons/picto_ha.png'
if EDENWALL:
LINK_STATE = {
NOT_REGISTERED: tr('Not registered'),
NOT_CONNECTED: tr('Not connected'),
CONNECTED: tr('Connected'),
}
NODE_STATE = {
NOT_REGISTERED: tr('Not registered'),
ACTIVE: tr('Active'),
INACTIVE: tr('Inactive'),
}
STATE_DESCRIPTIONS = {
ENOHA: span(tr('High availability is not configured.')),
PENDING_PRIMARY: span(tr('Primary; click "Join" to <br/>complete high availability configuration.')),
PRIMARY: span(tr('Primary, in function.')),
SECONDARY: span(tr('Secondary, in function.')),
PENDING_SECONDARY: span(tr('Secondary; connect EAS to the primary server to <br/>complete high availability configuration.')),
}
def __init__(self, client, parent):
self.auth_page = None
self.group_page = None
self.auth_configs = {}
self.group_configs = {}
self.mainwindow = parent
self.node_status_label = QLabel() # status of current node (active / inactive)
self.link_status_label = QLabel() # status of dedicaced link
self.interface_label = QLabel()
self.activity_label = QLabel()
self.last_error_text = QTextEdit()
self.last_error_text.setReadOnly(True)
self.last_error_text.setMaximumHeight(100)
self.type_label = QLabel()
self.join = None
self.link_state = None
self.ha_last_date = None
self.version = self.mainwindow.init_call('ha', 'getComponentVersion')
FullFeaturedScrollArea.__init__(self, client, parent)
self.missing_upgrades = []
# create timer only if HA activated
if self.__ha_type() != ENOHA:
self.timer = Timer(
self.setViewData,
REFRESH_INTERVAL_MILLISECONDS,
self.mainwindow.keep_alive.thread,
self
)
else:
self.timer = None
self.force_join = QAction(QIcon(":/icons/force_join"), tr("Force joining secondary"), self)
self.connect(self.force_join, SIGNAL('triggered(bool)'), self.joinSecondary)
self.force_takeover = QAction(QIcon(":/icons/ha_takeover"), tr("Force to become active"), self)
self.connect(self.force_takeover, SIGNAL('triggered(bool)'), self.takeover)
buttons = [self.force_join, self.force_takeover]
self.contextual_toolbar = ToolBar(buttons, name=tr("High Availability"))
@staticmethod
def get_calls():
"""
services called by initial multicall
"""
return (('ha', 'getState'), ('ha', 'getFullState'),
('ha', 'getComponentVersion'))
def __ha_type(self):
config = QHAObject.getInstance().cfg
if config is None:
return ENOHA
return config.ha_type
def buildInterface(self):
frame = QFrame()
self.setWidget(frame)
self.setWidgetResizable(True)
layout = QGridLayout(frame)
title = u'<h1>%s</h1>' % self.tr('High Availability Configuration')
layout.addWidget(QLabel(title), 0, 0, 1, -1)
configure = QPushButton(QIcon(":/icons/configurationha.png"), tr('Configure'))
self.mainwindow.writeAccessNeeded(configure)
layout.addWidget(configure, 1, 3)
self.join = QPushButton(QIcon(":/icons/joinha.png"), tr('Join Secondary'))
layout.addWidget(self.join, 2, 3)
if "1.1" == self.version:
layout.addWidget(QLabel(tr('Appliance status')), 3, 0)
layout.addWidget(self.node_status_label, 3, 1)
row = 4
else:
row = 3
self.last_error_title = QLabel(tr('Last error'))
self.missing_upgrade_text_label = QLabel()
self.missing_upgrade_nums_label = QLabel()
widgets = [
(QLabel(tr('Link status')), self.link_status_label),
(QLabel(tr('Type')),self.type_label),
(QLabel(tr('Interface')),self.interface_label),
(QLabel(tr('Last activity')), self.activity_label),
(self.last_error_title, self.last_error_text),
(self.missing_upgrade_text_label, self.missing_upgrade_nums_label),
]
for index, (label, widget) in enumerate(widgets):
layout.addWidget(label, row+index, 0)
layout.addWidget(widget, row+index, 1)
# syncUpgrades_button = QPushButton(tr('Synchronize upgrades'))
# layout.addWidget(syncUpgrades_button, 7, 2)
# self.connect(syncUpgrades_button, SIGNAL('clicked()'), self.syncUpgrades)
layout.setColumnStretch(0, 1)
layout.setColumnStretch(1, 5)
layout.setColumnStretch(2, 10)
layout.setColumnStretch(3, 1)
layout.setRowStretch(row+6, row+7)
self.connect(configure, SIGNAL("clicked()"), self.displayConfig)
self.connect(self.join, SIGNAL("clicked()"), self.joinSecondary)
def displayConfig(self):
config = QHAObject.getInstance().hacfg
if config.ha_type == PRIMARY:
QMessageBox.warning(
self,
tr('High availability already configured'),
tr('High availability status disallows editing the configuration'))
return
ha_wizard = ConfigWizard(self)
ret = ha_wizard.exec_()
if ret != QDialog.Accepted:
return False
qhaobject = QHAObject.getInstance()
qhaobject.pre_modify()
config = qhaobject.hacfg
qnetobject = QNetObject.getInstance()
qnetobject.pre_modify()
net_cfg = qnetobject.netcfg
old_type = config.ha_type
new_config = ha_wizard.getData()
config.ha_type = new_config.ha_type
config.interface_id = new_config.interface_id
config.interface_name = new_config.interface_name
if config.ha_type in (PENDING_PRIMARY, PENDING_SECONDARY):
iface = net_cfg.getIfaceByHardLabel(config.interface_id)
configureHA(net_cfg, iface)
network_modified = True
elif config.ha_type != old_type:
deconfigureHA(net_cfg)
network_modified = True
# XXX should not reconfigure now ?
else:
network_modified = False
valid = qnetobject.post_modify()
if not valid:
qhaobject.revert()
else:
# FIXME: use post_modify() result?
qhaobject.post_modify()
self.setModified(True)
if network_modified:
network = self.mainwindow.getPage('network')
network.setModified(True)
dhcp = self.mainwindow.getPage('dhcp')
dhcp.dhcp_widget.setModified(True)
dhcp.dhcp_widget.fillView()
self.setViewData()
return True
def hide_last_error(self):
self.last_error_text.clear()
self.last_error_text.hide()
self.last_error_title.hide()
def show_last_error(self, last_error):
if last_error:
self.last_error_text.setText(last_error)
self.last_error_title.show()
self.last_error_text.show()
else:
self.hide_last_error()
def syncUpgrades(self):
# First, update the list of missing upgrades:
defer = self.setViewData()
if defer:
defer.addCallback(self._syncUpgrades)
def _syncUpgrades(self):
pass
def fetchConfig(self):
# we use QHAObject
pass
def __disable(self):
self.close()
raise NuConfModuleDisabled("Disabling high availability interface")
def setViewData(self):
config = QHAObject.getInstance().hacfg
if "1.0" == self.version:
raw_state = self.mainwindow.init_call('ha', 'getState')
if raw_state is None:
self.__disable()
return
self.link_state, self.ha_last_date, last_error = raw_state
self.link_status_label.setText(self.LINK_STATE.get(self.link_state,
tr('(unknown)')))
else:
raw_state = self.mainwindow.init_call('ha', 'getFullState')
if raw_state is None:
self.__disable()
return
node_state = raw_state['node_state']
self.link_state = raw_state['link_state']
self.ha_last_date = raw_state['seen_other']
last_error = raw_state['last_error']
self.link_status_label.setText(self.LINK_STATE.get(self.link_state,
tr('(unknown)')))
self.node_status_label.setText(self.NODE_STATE.get(node_state,
tr('(unknown)')))
# TEMP : use compatibility instead
try:
try:
if raw_state.get('link_state', None) == CONNECTED:
self.join.setEnabled(False)
except Exception:
if isinstance(raw_state, list) and len(raw_state) > 0:
if raw_state[0] == CONNECTED:
self.join.setEnabled(False)
except TypeError:
pass
ha_type = self.__ha_type()
self.type_label.setText(
HAConfigFrontend.STATE_DESCRIPTIONS[ha_type]
)
if ha_type != ENOHA:
if self.ha_last_date not in (0, None):
fmt = '%Y-%m-%d %H:%M:%S'
seen = time.strftime(fmt, time.localtime(self.ha_last_date))
self.activity_label.setText(unicode(seen))
if config.interface_id is not None:
qnetobject = QNetObject.getInstance()
iface = qnetobject.netcfg.getIfaceByHardLabel(config.interface_id)
self.interface_label.setText(iface.fullName())
try:
last_error = self.client.call('ha', 'getLastError')
self.show_last_error(last_error)
except Exception:
self.hide_last_error()
else:
self.interface_label.clear()
self.activity_label.clear()
self.hide_last_error()
if ha_type == PRIMARY:
async = self.client.async()
async.call('ha', 'getMissingUpgradeNums',
callback=self._get_missing_upgrade_nums,
errback=self.writeError)
self.mainwindow.writeAccessNeeded(self.join)
if self.join.isEnabled():
self.join.setEnabled(PENDING_PRIMARY == ha_type)
def _get_missing_upgrade_nums(self, missing_upgrade_nums):
try:
self.missing_upgrade_nums = missing_upgrade_nums
if type(missing_upgrade_nums) != type([]):
self.missing_upgrade_nums_label.setText(tr('N/A'))
elif not missing_upgrade_nums:
self.missing_upgrade_nums_label.setText(tr('None '))
else:
sample = sorted(missing_upgrade_nums)
if len(sample) > MAX_MISSING_UPGRADE_NUMS:
sample = sample[:MAX_MISSING_UPGRADE_NUMS] + ['...']
self.missing_upgrade_nums_label.setText(
', '.join([unicode(num) for num in sample]))
self.missing_upgrade_text_label.setText(
tr('Missing upgrades on the secondary'))
except Exception:
pass
def sendConfig(self, message):
"""
Save HA config
"""
serialized = QHAObject.getInstance().hacfg.serialize()
self.client.call('ha', 'configureHA', serialized, message)
def joinSecondary(self):
self.mainwindow.addToInfoArea(
tr("Attempting to enslave the secondary, please wait...")
)
self.splash = SplashScreen()
self.splash.setText(tr("Attempting to enslave the secondary..."))
self.splash.show()
async = self.client.async()
async.call('ha', 'startHA',
callback = self.successJoin,
errback = self.errorJoin
)
def successJoin(self, ok):
self.splash.hide()
self.timer = Timer(
self.setViewData,
REFRESH_INTERVAL_MILLISECONDS,
self.mainwindow.keep_alive.thread,
self
)
self.join.setEnabled(False)
self.mainwindow.addToInfoArea(tr("Joining secondary: success"), category=COLOR_SUCCESS)
def errorJoin(self, error):
self.splash.hide()
self.mainwindow.addToInfoArea(tr('Joining secondary: fail'), category=COLOR_ERROR)
warning = QMessageBox(self)
warning.setWindowTitle(tr('Joining secondary: fail'))
warning.setText(tr('An error was encountered while joining secondary.'))
errmsg = exceptionAsUnicode(error)
if "current state=ENOHA" in errmsg:
errmsg = tr(
"Can not join yet: the appliance is still not configured for "
"high availability. Did you save and apply your changes?"
)
warning.setDetailedText(errmsg)
warning.setIcon(QMessageBox.Warning)
warning.exec_()
def takeover(self):
try:
self.client.call('ha', 'takeover')
except Exception, err:
self.mainwindow.exception(err)
return
self.mainwindow.addToInfoArea(tr('Take over request sent.'), category=COLOR_SUCCESS)
class LDSControls(QFrame):
STATIC_IMG = ('error_static.png','linz_static.png','busy_static.png','clean_static.png')
ANIM_IMG = ('error.gif','linz.gif','layer.gif','clean.gif')
IMG_SPEED = 100
IMG_WIDTH = 64
IMG_HEIGHT = 64
MAX_WD = 450
GD_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../../bin/gdal/gdal-data'))
STATUS = LU.enum('ERROR','IDLE','BUSY','CLEAN')
def __init__(self,parent):
super(LDSControls, self).__init__()
self.parent = parent
self.initConf()
self.initEPSG()
self.initUI()
def initConf(self):
'''Read files in conf dir ending in conf'''
self.cflist = ConfigInitialiser.getConfFiles()
#self.imgset = self.STATIC_IMG if ConfigWrapper().readDSProperty('Misc','indicator')=='static' else self.ANIM_IMG
#self.imgset = self.STATIC_IMG if self.parent.confconn.tp.src.confwrap.readDSProperty('Misc','indicator')=='static' else self.ANIM_IMG
sep = self.parent.confconn.reg.openEndPoint(self.parent.confconn.SRCNAME,self.parent.confconn.uconf)
self.imgset = self.STATIC_IMG if sep.confwrap.readDSProperty('Misc','indicator')=='static' else self.ANIM_IMG
self.parent.confconn.reg.closeEndPoint(self.parent.confconn.SRCNAME)
def initEPSG(self):
'''Read GDAL EPSG files, splitting by NZ(RSR) and RestOfTheWorld'''
gcsf = gdal.FindFile('gdal','gcs.csv')
if not gcsf:
gcsf = os.path.join(self.GD_PATH,'gcs.csv')
pcsf = gdal.FindFile('gdal','pcs.csv')
if not pcsf:
pcsf = os.path.join(self.GD_PATH,'pcs.csv')
gcs = ConfigInitialiser.readCSV(gcsf)
pcs = ConfigInitialiser.readCSV(pcsf)
self.nzlsr = [(e[0],e[0]+' - '+e[3]) for e in gcs if 'NZGD' in e[1] or 'RSRGD' in e[1]] \
+ [(e[0],e[0]+' - '+e[1]) for e in pcs if 'NZGD' in e[1] or 'RSRGD' in e[1]]
self.rowsr = [(e[0],e[0]+' - '+e[3]) for e in gcs if 'NZGD' not in e[1] and 'RSRGD' not in e[1]] \
+ [(e[0],e[0]+' - '+e[1]) for e in pcs if 'NZGD' not in e[1] and 'RSRGD' not in e[1]]
def initUI(self):
# 0 1 2 3 4 5 6 7 8
#'destname','lgselect','layer','uconf','group','epsg','fd','td','int'
#self.rdest,rlgselect,self.rlayer,ruconf,self.rgroup,repsg,rfd,rtd,rint = readlist
QToolTip.setFont(QFont('SansSerif', 10))
#labels
destLabel = QLabel('Destination')
lgLabel = QLabel('Group/Layer')
epsgLabel = QLabel('EPSG')
fromDateLabel = QLabel('From Date')
toDateLabel = QLabel('To Date')
confLabel = QLabel('User Config')
self.view = QLabel()
self.view.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.view.setAlignment(Qt.AlignCenter)
self.confcombo = QComboBox(self)
self.confcombo.setToolTip('Enter your user config name (file) here')
self.confcombo.addItems(self.cflist)
self.confcombo.setEditable(False)
#self.confcombo.currentIndexChanged.connect(self.doLGEditUpdate)
#combos
self.lgcombo = QComboBox(self)
self.lgcombo.setMaximumWidth(self.MAX_WD)
self.lgcombo.setDuplicatesEnabled(False)
#self.lgcombo.setInsertPolicy(QComboBox.InsertAlphabetically)#?doesnt seem to work
self.lgcombo.setToolTip('Select either Layer or Group entry')
self.lgcombo.setEditable(False)
self.sepindex = None
#self.updateLGValues()
self.epsgcombo = QComboBox(self)
self.epsgcombo.setMaximumWidth(self.MAX_WD)
self.epsgcombo.setToolTip('Setting an EPSG number here determines the output SR of the layer')
self.epsgcombo.addItems([i[1] for i in self.nzlsr])
self.epsgcombo.insertSeparator(len(self.nzlsr))
self.epsgcombo.addItems([i[1] for i in self.rowsr])
self.epsgcombo.setEditable(True)
self.epsgcombo.setEnabled(False)
self.destlist = self.getConfiguredDestinations()
self.destcombo = QComboBox(self)
self.destcombo.setToolTip('Choose the desired output type')
self.destcombo.setEditable(False)
self.destcombo.addItems(self.destlist)
#date selection
self.fromdateedit = QDateEdit()
self.fromdateedit.setCalendarPopup(True)
self.fromdateedit.setEnabled(False)
self.todateedit = QDateEdit()
self.todateedit.setCalendarPopup(True)
self.todateedit.setEnabled(False)
#check boxes
self.epsgenable = QCheckBox()
self.epsgenable.setCheckState(False)
self.epsgenable.clicked.connect(self.doEPSGEnable)
self.fromdateenable = QCheckBox()
self.fromdateenable.setCheckState(False)
self.fromdateenable.clicked.connect(self.doFromDateEnable)
self.todateenable = QCheckBox()
self.todateenable.setCheckState(False)
self.todateenable.clicked.connect(self.doToDateEnable)
self.progressbar = QProgressBar()
self.progressbar.setRange(0,100)
self.progressbar.setVisible(True)
self.progressbar.setMinimumWidth(self.MAX_WD)
#buttons
self.initbutton = QPushButton("waiting")
self.initbutton.setToolTip('Initialise the Layer Configuration')
self.initbutton.clicked.connect(self.doInitClickAction)
self.cleanbutton = QPushButton("Clean")
self.cleanbutton.setToolTip('Clean the selected layer/group from local storage')
self.cleanbutton.clicked.connect(self.doCleanClickAction)
self.replicatebutton = QPushButton("Replicate")
self.replicatebutton.setToolTip('Execute selected replication')
self.replicatebutton.clicked.connect(self.doReplicateClickAction)
self.cancelbutton = QPushButton("Close")
self.cancelbutton.setToolTip('Close the LDS Replicate application')
self.cancelbutton.clicked.connect(self.parent.close)
#set dialog values using GPR
self.updateGUIValues(self.parent.gvs)
#set onchange here otherwise we get circular initialisation
self.destcombo.currentIndexChanged.connect(self.doDestChanged)
self.confcombo.currentIndexChanged.connect(self.doConfChanged)
self.lgcombo.currentIndexChanged.connect(self.doLGComboChanged)
self.setStatus(self.STATUS.IDLE)
#grid
grid = QGridLayout()
grid.setSpacing(10)
#placement section ------------------------------------
#---------+---------+--------+---------+--------
# dest LB | | dest DD
# grp LB | | grp DD
# conf LB | | conf DD
# epsg L | epsg CB | epsg DD
# f dt L | f dt CB | f dt DD
# t td L | t td CB | t td DD
# icon | <- progress ->
# layer B | <- . -> |repl B | clean B | close B
#---------+---------+--------+---------+--------
grid.addWidget(destLabel, 1, 0)
grid.addWidget(self.destcombo, 1, 2)
#grid.addWidget(layerLabel, 2, 0)
grid.addWidget(lgLabel, 2, 0)
grid.addWidget(self.lgcombo, 2, 2)
grid.addWidget(confLabel, 3, 0)
grid.addWidget(self.confcombo, 3, 2)
#grid.addWidget(groupLabel, 4, 0)
#grid.addWidget(self.groupEdit, 4, 2)
grid.addWidget(epsgLabel, 5, 0)
grid.addWidget(self.epsgenable, 5, 1)
grid.addWidget(self.epsgcombo, 5, 2)
grid.addWidget(fromDateLabel, 6, 0)
grid.addWidget(self.fromdateenable, 6, 1)
grid.addWidget(self.fromdateedit, 6, 2)
grid.addWidget(toDateLabel, 7, 0)
grid.addWidget(self.todateenable, 7, 1)
grid.addWidget(self.todateedit, 7, 2)
hbox3 = QHBoxLayout()
hbox3.addWidget(self.view)
hbox3.addStretch(1)
hbox3.addWidget(self.progressbar)
#hbox3.addLayout(vbox2)
#hbox3.addLayout(vbox3)
hbox4 = QHBoxLayout()
hbox4.addWidget(self.initbutton)
hbox4.addStretch(1)
hbox4.addWidget(self.replicatebutton)
hbox4.addWidget(self.cleanbutton)
hbox4.addWidget(self.cancelbutton)
vbox = QVBoxLayout()
#vbox.addStretch(1)
vbox.addLayout(grid)
vbox.addLayout(hbox3)
vbox.addLayout(hbox4)
self.setLayout(vbox)
#def setProgress(self,pct):
# self.progressbar.setValue(pct)
def setStatus(self,status,message='',tooltip=None):
'''Sets indicator icon and statusbar message'''
self.parent.statusbar.showMessage(message)
self.parent.statusbar.setToolTip(tooltip if tooltip else '')
#progress
loc = os.path.abspath(os.path.join(IMG_LOC,self.imgset[status]))
#loc = os.path.abspath(os.path.join(os.path.dirname(__file__),self.parent.IMG_LOC,self.imgset[status]))
self.progressbar.setVisible(status in (self.STATUS.BUSY, self.STATUS.CLEAN))
#icon
anim = QMovie(loc, QByteArray(), self)
anim.setScaledSize(QSize(self.IMG_WIDTH,self.IMG_HEIGHT))
anim.setCacheMode(QMovie.CacheAll)
anim.setSpeed(self.IMG_SPEED)
self.view.clear()
self.view.setMovie(anim)
anim.start()
self.view.repaint()
QApplication.processEvents(QEventLoop.AllEvents)
def mainWindowEnable(self,enable=True):
cons = (self.lgcombo, self.confcombo, self.destcombo,
self.initbutton, self.replicatebutton, self.cleanbutton, self.cancelbutton,
self.epsgenable,self.fromdateenable,self.todateenable,
self.parent.menubar)
for c in cons:
c.setEnabled(enable)
if enable:
self.epsgcombo.setEnabled(self.epsgenable.checkState())
self.fromdateedit.setEnabled(self.fromdateenable.checkState())
self.todateedit.setEnabled(self.todateenable.checkState())
else:
self.epsgcombo.setEnabled(False)
self.fromdateedit.setEnabled(False)
self.todateedit.setEnabled(False)
QApplication.restoreOverrideCursor() if enable else QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
def refreshLGCombo(self):
'''Re index LG combobox since a refreshLG call (new dest?) will usually mean new groups'''
self.lgcombo.clear()
self.lgcombo.addItems([i[2] for i in self.parent.confconn.lglist])
#NOTE the separator consumes an index, if not clearing the combobox selectively remove the old sepindex (assumes g preceeds l)
#if self.sepindex:
# self.lgcombo.removeItem(self.sepindex)
self.sepindex = [i[0] for i in self.parent.confconn.lglist].count(LORG.GROUP)
self.lgcombo.insertSeparator(self.sepindex)
def updateLGValues(self,uconf,lgval,dest):
'''Sets the values displayed in the Layer/Group combo'''
#because we cant seem to sort combobox entries and want groups at the top, clear and re-add
#TRACE#
#pdb.set_trace()
sf = None
try:
self.parent.confconn.initConnections(uconf,lgval,dest)
except Exception as e:
sf=1
ldslog.error('Error Updating UC Values. '+str(e))
if sf:
self.setStatus(self.STATUS.ERROR,'Error Updating UC Values', str(e))
else:
self.setStatus(self.STATUS.IDLE)
self.refreshLGCombo()
def centre(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def gprParameters(self,rdest):
'''Zip default and GPR values'''
return [x if LU.assessNone(x) else y for x,y in zip(self.parent.gpr.readsec(rdest),self.parent.DEF_RVALS[1:])]
def getLCE(self,ln):
'''Read layer parameters'''
dep = self.parent.confconn.reg.openEndPoint(self.parent.confconn.destname,self.parent.confconn.uconf)
#sep = self.parent.confconn.reg.openEndPoint('WFS',self.parent.confconn.uconf)
self.parent.confconn.reg.setupLayerConfig(self.parent.confconn.tp,None,dep,initlc=False)
lce = dep.getLayerConf().readLayerParameters(ln)
#self.parent.confconn.reg.closeEndPoint('WFS')
self.parent.confconn.reg.closeEndPoint(self.parent.confconn.destname)
sep,dep = None,None
return lce
def doDestChanged(self):
'''Read the destname parameter and fill dialog with matching GPR values'''
rdest = str(self.destlist[self.destcombo.currentIndex()])
rvals = self.gprParameters(rdest)
self.updateGUIValues([rdest]+rvals)
def doConfChanged(self):
'''Read the user conf parameter and fill dialog with matching GPR values'''
rdest = str(self.destlist[self.destcombo.currentIndex()])
rlg,_,rep,rfd,rtd = self.gprParameters(rdest)
ruc = str(self.cflist[self.confcombo.currentIndex()])
self.updateGUIValues((rdest,rlg,ruc,rep,rfd,rtd))
def doLGComboChanged(self):
'''Read the layer/group value and change epsg to layer or gpr match'''
#get a matching LG entry and test whether its a layer or group
#lgi = self.parent.confconn.getLayerGroupIndex(self.lgcombo.currentText().toUtf8().data())
lgi = self.parent.confconn.getLayerGroupIndex(LQ.readWidgetText(self.lgcombo.currentText()))
#lgi can be none if we init a new group, in which case we use the GPR value
if lgi:
lge = self.parent.confconn.lglist[lgi]
lce = self.getLCE(lge[1]) if lge[0]==LORG.LAYER else None
else:
lce = None
#look for filled layer conf epsg OR use prefs stored in gpr
if lce and LU.assessNone(lce.epsg):
epsgval = lce.epsg
else:
rdest = str(self.destlist[self.destcombo.currentIndex()])
_,_,epsgval,_,_ = self.gprParameters(rdest)
epsgindex = [i[0] for i in self.nzlsr+[(0,0)]+self.rowsr].index(epsgval)
if self.epsgcombo.currentIndex() != epsgindex:
self.epsgcombo.setCurrentIndex(int(epsgindex))
def updateGUIValues(self,readlist):
'''Fill dialog values from provided list'''
#TODO. Remove circular references when setCurrentIndex() triggers do###Changed()
#Read user input
rdest,self.rlgval,ruconf,repsg,rfd,rtd = readlist
#--------------------------------------------------------------------
#Destination Menu
selecteddest = LU.standardiseDriverNames(rdest)
if selecteddest not in self.destlist:
self.destlist = self.getConfiguredDestinations()
self.destcombo.addItem(selecteddest)
destindex = self.destlist.index(selecteddest) if selecteddest else 0
if self.destcombo.currentIndex() != destindex:
self.destcombo.setCurrentIndex(destindex)
#InitButton
self.initbutton.setText('Layer Select')
#Config File
confindex = 0
if LU.assessNone(ruconf):
ruconf = ruconf.split('.')[0]
if ruconf not in self.cflist:
self.cflist += [ruconf,]
self.confcombo.addItem(ruconf)
confindex = self.cflist.index(ruconf)
if self.confcombo.currentIndex() != confindex:
self.confcombo.setCurrentIndex(confindex)
#self.confEdit.setText(ruconf if LU.assessNone(ruconf) else '')
#Layer/Group Selection
self.updateLGValues(ruconf,self.rlgval,rdest)
lgindex = None
if LU.assessNone(self.rlgval):
#index of list value
lgindex = self.parent.confconn.getLayerGroupIndex(self.rlgval,col=1)
if LU.assessNone(lgindex):
#advance by 1 for sep
lgindex += 1 if lgindex>self.sepindex else 0
else:
#using the separator index sets the combo to blank
lgindex = self.sepindex
if self.lgcombo.currentIndex() != lgindex:
self.lgcombo.setCurrentIndex(lgindex)
#self.doLGEditUpdate()
#EPSG
# user > layerconf
#useepsg = LU.precedence(repsg, lce.epsg if lce else None, None)
epsgindex = [i[0] for i in self.nzlsr+[(None,None)]+self.rowsr].index(repsg)
if self.epsgcombo.currentIndex() != epsgindex:
self.epsgcombo.setCurrentIndex(epsgindex)
#epsgedit = self.epsgcombo.lineEdit()
#epsgedit.setText([e[1] for e in self.nzlsr+self.rowsr if e[0]==repsg][0])
#epsgedit.setText([e for e in self.nzlsr+self.rowsr if re.match('^\s*(\d+).*',e).group(1)==repsg][0])
#To/From Dates
if LU.assessNone(rfd):
self.fromdateedit.setDate(QDate(int(rfd[0:4]),int(rfd[5:7]),int(rfd[8:10])))
else:
early = DataStore.EARLIEST_INIT_DATE
self.fromdateedit.setDate(QDate(int(early[0:4]),int(early[5:7]),int(early[8:10])))
if LU.assessNone(rtd):
self.todateedit.setDate(QDate(int(rtd[0:4]),int(rtd[5:7]),int(rtd[8:10])))
else:
today = DataStore.getCurrent()
self.todateedit.setDate(QDate(int(today[0:4]),int(today[5:7]),int(today[8:10])))
#Internal/External CheckBox
# if LU.assessNone(rint):
# self.internalTrigger.setChecked(rint.lower()==DataStore.CONF_INT)
# else:
# self.internalTrigger.setChecked(DataStore.DEFAULT_CONF==DataStore.CONF_INT)
def getConfiguredDestinations(self):
defml = ['',]+DataStore.DRIVER_NAMES.values()
return [d for d in self.parent.gpr.getDestinations() if d in defml]
def doEPSGEnable(self):
self.epsgcombo.setEnabled(self.epsgenable.isChecked())
def doFromDateEnable(self):
self.fromdateedit.setEnabled(self.fromdateenable.isChecked())
def doToDateEnable(self):
self.todateedit.setEnabled(self.todateenable.isChecked())
def readParameters(self):
'''Read values out of dialogs'''
destination = LU.assessNone(str(self.destlist[self.destcombo.currentIndex()]))
#lgindex = self.parent.confconn.getLayerGroupIndex(self.lgcombo.currentText().toUtf8().data())
lgindex = self.parent.confconn.getLayerGroupIndex(LQ.readWidgetText(self.lgcombo.currentText()))
#NB need to test for None explicitly since zero is a valid index
lgval = self.parent.confconn.lglist[lgindex][1] if LU.assessNone(lgindex) else None
#uconf = LU.standardiseUserConfigName(str(self.confcombo.lineEdit().text()))
#uconf = str(self.confcombo.lineEdit().text())
uconf = str(self.cflist[self.confcombo.currentIndex()])
ee = self.epsgenable.isChecked()
epsg = None if ee is False else re.match('^\s*(\d+).*',str(self.epsgcombo.lineEdit().text())).group(1)
fe = self.fromdateenable.isChecked()
te = self.todateenable.isChecked()
fd = None if fe is False else str(self.fromdateedit.date().toString('yyyy-MM-dd'))
td = None if te is False else str(self.todateedit.date().toString('yyyy-MM-dd'))
return destination,lgval,uconf,epsg,fe,te,fd,td
def doInitClickAction(self):
'''Initialise the LC on LC-button-click, action'''
try:
try:
self.setStatus(self.STATUS.BUSY,'Opening Layer-Config Editor')
self.progressbar.setValue(0)
self.parent.runLayerConfigAction()
finally:
self.setStatus(self.STATUS.IDLE,'Ready')
except Exception as e:
self.setStatus(self.STATUS.ERROR,'Error in Layer-Config',str(sys.exc_info()))#e))
def doCleanClickAction(self):
'''Set clean anim and run clean'''
#lgo = self.lgcombo.currentText().toUtf8().data()
lgo = LQ.readWidgetText(self.lgcombo.currentText())
try:
self.setStatus(self.STATUS.CLEAN,'Running Clean '+lgo)
self.progressbar.setValue(0)
self.runReplicationScript(True)
except Exception as e:
self.setStatus(self.STATUS.ERROR,'Failed Clean of '+lgo,str(sys.exc_info()))#e))
def doReplicateClickAction(self):
'''Set busy anim and run repl'''
lgo = self.lgcombo.currentText()#.toUtf8().data()#only used for error messages
try:
self.setStatus(self.STATUS.BUSY,'Running Replicate '+lgo)
self.progressbar.setValue(0)
self.runReplicationScript(False)
ldslog.debug('TRPfinish')
except Exception as e:
self.setStatus(self.STATUS.ERROR,'Failed Replication of '+lgo,str(sys.exc_info()))#e))
def runReplicationScript(self,clean=False):
'''Run the layer/group repliction script'''
destination,lgval,uconf,epsg,fe,te,fd,td = self.readParameters()
uconf_path = LU.standardiseUserConfigName(uconf)
destination_path = LU.standardiseLayerConfigName(destination)
destination_driver = LU.standardiseDriverNames(destination)
if not os.path.exists(uconf_path):
self.userConfMessage(uconf_path)
return
elif not MainFileReader(uconf_path).hasSection(destination_driver):
self.userConfMessage(uconf_path,destination_driver)
return
#-----------------------------------------------------
#'destname','layer','uconf','group','epsg','fd','td','int'
self.parent.gpr.write((destination_driver,lgval,uconf,epsg,fd,td))
ldslog.info(u'dest={0}, lg={1}, conf={2}, epsg={3}'.format(destination_driver,lgval,uconf,epsg))
ldslog.info('fd={0}, td={1}, fe={2}, te={3}'.format(fd,td,fe,te))
lgindex = self.parent.confconn.getLayerGroupIndex(lgval,col=1)
#lorg = self.parent.confconn.lglist[lgindex][0]
#----------don't need lorg in TP anymore but it is useful for sorting/counting groups
#self.parent.confconn.tp.setLayerOrGroup(lorg)
self.parent.confconn.tp.setLayerGroupValue(lgval)
if self.fromdateenable.isChecked(): self.parent.confconn.tp.setFromDate(fd)
if self.todateenable.isChecked(): self.parent.confconn.tp.setToDate(td)
self.parent.confconn.tp.setUserConf(uconf)
if self.epsgenable: self.parent.confconn.tp.setEPSG(epsg)
#because clean state persists in TP
if clean:
self.parent.confconn.tp.setCleanConfig()
else:
self.parent.confconn.tp.clearCleanConfig()
#(re)initialise the data source since uconf may have changed
#>>#self.parent.confconn.tp.src = self.parent.confconn.initSourceWrapper()
#--------------------------
###ep = self.parent.confconn.reg.openEndPoint(self.parent.confconn.destname,self.parent.confconn.uconf)
###self.parent.confconn.reg.closeEndPoint(self.parent.confconn.destname)
###ep = None
#Open ProcessRunner and run with TP(proc)/self(gui) instances
#HACK temp add of dest_drv to PR call
try:
#TODO. Test for valid LC first
self.tpr = ProcessRunner(self,destination_driver)
except Exception as e:
ldslog.error('Cannot create ProcessRunner {}. NB Possible missing Layer Config {}'.format(str(e),destination_path))
self.layerConfMessage(destination_path)
return
#If PR has been successfully created we must vave a valid dst
ldslog.debug('TRPstart')
self.tpr.start()
# def quitProcessRunner(self):
# self.tpr.join()
# self.tpr.quit()
# self.trp = None
def userConfMessage(self,uconf,secname=None):
ucans = QMessageBox.warning(self, 'User Config Missing/Incomplete',
'Specified User-Config file, '+str(uconf)+' does not exist' if secname is None else 'User-Config file does not contain '+str(secname)+' section',
'Back','Initialise User Config')
if not ucans:
#Retry
ldslog.warn('Retry specifying UC')
#self.confcombo.setCurrentIndex(0)
return
#Init
ldslog.warn('Reset User Config Wizard')
self.parent.runWizardAction()
def layerConfMessage(self,dest):
lcans = QMessageBox.warning(self, 'Layer Config Missing',
'Required Layer-Config file, '+str(dest)+' does not exist',
'Back','Run Layer Select')
if not lcans:
#Retry
ldslog.warn('Retry specifying LC')
#self.destcombo.setCurrentIndex(0)
return
#Init
ldslog.warn('Reset Layer Config')
self.doInitClickAction()
class MainWindow(QMainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setWindowTitle('Address Book')
self.resize(704, 459)
self.db_file = self.database_file()
self.db = database.Database(self.db_file)
dialog = dialogs.UserPanelDlg(self)
if dialog.exec_():
self.user = dialog.user
else:
self.close()
self.categComboBox = QComboBox()
self.cont_numLabel = QLabel()
self.contactsListWidget = QListWidget()
self.searchLineEdit = QLineEdit()
widgets = ((QLabel('Category:'), self.categComboBox),
(self.cont_numLabel, None),
(self.contactsListWidget,),
(QLabel('Search:'), self.searchLineEdit))
vlayout1 = QVBoxLayout()
for i in widgets:
hlayout = pyqttools.add_to_layout(QHBoxLayout(), i)
vlayout1.addLayout(hlayout)
addToolButton = QToolButton()
addToolButton.setIcon(QIcon(':addcontact.jpeg'))
addToolButton.setIconSize(QSize(45, 45))
self.showLabel = QLabel()
self.showLabel.setFrameShape(QFrame.StyledPanel)
self.showLabel.setAlignment(Qt.AlignLeading|Qt.AlignLeft|Qt.AlignTop)
self.editButton = QPushButton('Edit')
self.delButton = QPushButton('Delete')
widgets = ((None, addToolButton, None),
(self.showLabel,),
(None, self.editButton, self.delButton))
vlayout2 = QVBoxLayout()
for i in widgets:
hlayout = pyqttools.add_to_layout(QHBoxLayout(), i)
vlayout2.addLayout(hlayout)
f_layout = pyqttools.add_to_layout(QHBoxLayout(), (vlayout1, vlayout2))
Widget = QWidget()
Widget.setLayout(f_layout)
self.setCentralWidget(Widget)
self.statusBar = self.statusBar()
self.userLabel = QLabel()
self.statusBar.addPermanentWidget(self.userLabel)
c_action = pyqttools.create_action
panelAction = c_action(self, 'User panel', triggered=self.user_panel)
quitAction = c_action(self, 'Quit', 'Ctrl+Q',triggered=self.close)
add_contactAction = c_action(self, 'Add contact', 'Ctrl+N',
triggered=self.add_contact)
delete_allAction = c_action(self, 'Delete all contacts',
triggered=self.delete_all)
delete_categAction = c_action(self, 'Delete categories',
triggered=self.delete_categories)
backupAction = c_action(self, 'Backup', triggered=self.backup)
restoreAction = c_action(self, 'Restore', triggered=self.restore)
aboutAction = c_action(self, 'About', 'Ctrl+?', triggered=self.about)
fileMenu = self.menuBar().addMenu('File')
contactsMenu = self.menuBar().addMenu('Contacts')
deleteMenu = self.menuBar().addMenu(self.tr('Delete'))
backupMenu = self.menuBar().addMenu(self.tr('Backup'))
helpMenu = self.menuBar().addMenu('Help')
pyqttools.add_actions(fileMenu, [panelAction, None, quitAction])
pyqttools.add_actions(contactsMenu, [add_contactAction])
pyqttools.add_actions(deleteMenu,[delete_allAction,delete_categAction])
pyqttools.add_actions(backupMenu, [backupAction, restoreAction])
pyqttools.add_actions(helpMenu, [aboutAction])
addToolButton.clicked.connect(self.add_contact)
self.editButton.clicked.connect(self.edit_contact)
self.delButton.clicked.connect(self.delete_contact)
self.categComboBox.currentIndexChanged.connect(self.fill_ListWidget)
self.contactsListWidget.currentRowChanged.connect(self.show_contact)
self.searchLineEdit.textEdited.connect(self.search)
self.fill_categComboBox()
self.refresh_userLabel()
def fill_categComboBox(self):
categories = ['All']
categories.extend([i[1] for i in self.db.get_categories(self.user)])
self.categComboBox.currentIndexChanged.disconnect(self.fill_ListWidget)
self.categComboBox.clear()
self.categComboBox.addItems(categories)
self.categComboBox.currentIndexChanged.connect(self.fill_ListWidget)
self.fill_ListWidget()
def fill_ListWidget(self):
self.showLabel.clear()
self.contactsListWidget.clear()
if self.categComboBox.currentIndex() != 0: self.searchLineEdit.clear()
category = self.categComboBox.currentText()
if category == 'All':
contacts = self.db.get_all_contacts(self.user)
else:
categ_id = self.db.get_category_id(category, self.user)
if categ_id is None: return
contacts = self.db.get_contacts(categ_id)
for i in contacts:
self.contactsListWidget.addItem(MyListItem(i[1]+' '+i[2], i[0]))
self.contactsListWidget.setCurrentRow(0)
self.refresh_contacts_number()
self.set_buttons_enabled()
def refresh_userLabel(self):
self.userLabel.setText('User: '******'Contacts Numer: {0}'.format(self.contactsListWidget.count())
self.cont_numLabel.setText(text)
def set_buttons_enabled(self):
enable = bool(self.contactsListWidget)
self.editButton.setEnabled(enable)
self.delButton.setEnabled(enable)
def user_panel(self):
dialog = dialogs.UserPanelDlg(self)
if dialog.exec_():
self.user = dialog.user
self.fill_categComboBox()
self.refresh_userLabel()
def show_contact(self):
try:
_id = self.contactsListWidget.currentItem()._id
except AttributeError:
return
_id, name, surname, mail, address, tel, categ_id = \
self.db.get_contact_from_id(_id)[0]
category = self.db.get_category_from_id(categ_id)
text = ''
data = (name, surname, mail, address, tel, category)
labs = ('Name', 'Surname', 'e-mail', 'Address', 'Telephone', 'Category')
for i, y in zip(labs, data):
text += '''<p style=\' margin-top:0px; margin-bottom:0px; \'>
<span style=\' font-weight:600;\'>{0}:</span> {1} </p>\n'''\
.format(i, y)
self.showLabel.setText(text)
def add_contact(self):
categories = [i[1] for i in self.db.get_categories(self.user)]
dialog = dialogs.AddorEditContactDlg(categories)
if dialog.exec_():
data = dialog.values
if data[-1] not in categories:
self.db.addto_categories(data[-1], self.user)
categ_id = self.db.get_category_id(data[-1], self.user)
data[-1] = categ_id
self.db.addto_contacts(data)
self.fill_categComboBox()
def edit_contact(self):
_id = self.contactsListWidget.currentItem()._id
data = list(self.db.get_contact_from_id(_id)[0])
categ = self.db.get_category_from_id(data[-1])
data[-1] = categ
categories = [i[1] for i in self.db.get_categories(self.user)]
dialog = dialogs.AddorEditContactDlg(categories, True, data)
if dialog.exec_():
new_data = dialog.values
if new_data[-1] not in categories:
self.db.addto_categories(new_data[-1], self.user)
categ_id = self.db.get_category_id(new_data[-1], self.user)
new_data[-1] = categ_id
self.db.edit_contact(new_data, _id)
self.fill_categComboBox()
def delete_contact(self):
reply = QMessageBox.question(self, 'Address Book - Delete Contact',
'Are you sure that you want to delete this contact?',
QMessageBox.Yes|QMessageBox.Cancel)
if reply == QMessageBox.Yes:
_id = self.contactsListWidget.currentItem()._id
self.db.delete_contact(_id)
self.fill_ListWidget()
def delete_all(self):
reply = QMessageBox.question(self, 'Address Book - Delete Contact',
'Are you sure that you want to delete all contacts?',
QMessageBox.Yes|QMessageBox.Cancel)
if reply == QMessageBox.Yes:
self.db.delete_all_contacts()
self.fill_ListWidget()
def delete_categories(self):
categories = [i[1] for i in self.db.get_categories(self.user)]
dialogs.DelCategoriesDlg(categories, self).exec_()
self.fill_categComboBox()
def search(self):
self.categComboBox.setCurrentIndex(0)
self.showLabel.clear()
self.contactsListWidget.clear()
txt = self.searchLineEdit.text()
if all(i == ' ' for i in txt):
self.fill_ListWidget()
return
must_appear = []
contacts = self.db.get_all_contacts(self.user)
if not ' ' in txt:
for i in contacts:
if txt.lower() in i[1].lower() or txt.lower() in i[2].lower():
must_appear.append(i)
else:
try:
first, last = txt.split()
except ValueError:
return
for i in contacts:
_bool = bool(first.lower() in i[1].lower() or first.lower() in
i[2].lower() or last.lower() in i[1].lower() or
last.lower() in i[2].lower())
if _bool: must_appear.append(i)
for i in must_appear:
item = MyListItem(i[1] + ' ' + i[2], i[0])
self.contactsListWidget.addItem(item)
self.contactsListWidget.setCurrentRow(0)
self.refresh_contacts_number()
self.set_buttons_enabled()
def backup(self):
fname = QFileDialog.getSaveFileName(self,'Address Book - Backup','.db')
if fname:
try:
shutil.copy(self.db_file, fname)
except IOError:
pass
def restore(self):
reply = QMessageBox.question(self, 'Address Book - Restore',
'All current contacts will be deleted.\nAre you sure that you want'
' to continue?', QMessageBox.Yes|QMessageBox.Cancel)
if reply == QMessageBox.Yes:
fname = QFileDialog.getOpenFileName(self, 'Address Book - Restore')
if fname:
msg = 'Succesful restore!'
try:
os.remove(self.db_file)
shutil.copy(fname, self.db_file)
except (OSError, IOError):
msg = 'Restore failed!'
QMessageBox.information(self, 'Addess Book - Restore', msg)
self.db = database.Database(self.db_file)
self.fill_categComboBox()
def database_file(self):
_file = 'addressbook.db'
if not platform.platform().startswith('Windows'):
folder = os.getenv('HOME') + os.sep + '.addressbook'
if not os.path.exists(folder): os.mkdir(folder)
_file = folder + os.sep + _file
return _file
def about(self):
link = 'http://wiki.ubuntu-gr.org/Address%20Book'
QMessageBox.about(self, self.tr('About') + ' FF Multi Converter',
'''<b> Address Book {0} </b>
<p>Gui application to organize your contacts!
<p>Copyright © 2012 Ilias Stamatis
<br>License: GNU GPL3
<p><a href='{1}'>http://wiki.ubuntu-gr.org/Address Book</a>
<p>Python {2} - Qt {3} - PyQt {4} on {5}'''
.format(__version__, link, platform.python_version()[:5],
QT_VERSION_STR, PYQT_VERSION_STR, platform.system()))
def close(self):
self.db.close()
sys.exit()
class LDSControls(QFrame):
STATIC_IMG = ('error_static.png','linz_static.png','busy_static.png','clean_static.png')
ANIM_IMG = ('error.gif','linz.gif','layer.gif','clean.gif')
IMG_SPEED = 100
IMG_WIDTH = 64
IMG_HEIGHT = 64
MAX_WD = 450
GD_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../../bin/gdal/gdal-data'))
STATUS = LU.enum('ERROR','IDLE','BUSY','CLEAN')
def __init__(self,parent):
super(LDSControls, self).__init__()
self.parent = parent
self.initConf()
self.initEPSG()
self.initUI()
def initConf(self):
'''Read files in conf dir ending in conf'''
self.cflist = ConfigInitialiser.getConfFiles()
#self.imgset = self.STATIC_IMG if ConfigWrapper().readDSProperty('Misc','indicator')=='static' else self.ANIM_IMG
#self.imgset = self.STATIC_IMG if self.parent.confconn.tp.src.confwrap.readDSProperty('Misc','indicator')=='static' else self.ANIM_IMG
sep = self.parent.confconn.reg.openEndPoint(self.parent.confconn.SRCNAME,self.parent.confconn.uconf)
self.imgset = self.STATIC_IMG if sep.confwrap.readDSProperty('Misc','indicator')=='static' else self.ANIM_IMG
self.parent.confconn.reg.closeEndPoint(self.parent.confconn.SRCNAME)
def initEPSG(self):
'''Read GDAL EPSG files, splitting by NZ(RSR) and RestOfTheWorld'''
gcsf = gdal.FindFile('gdal','gcs.csv')
if not gcsf:
gcsf = os.path.join(self.GD_PATH,'gcs.csv')
pcsf = gdal.FindFile('gdal','pcs.csv')
if not pcsf:
pcsf = os.path.join(self.GD_PATH,'pcs.csv')
gcs = ConfigInitialiser.readCSV(gcsf)
pcs = ConfigInitialiser.readCSV(pcsf)
self.nzlsr = [(e[0],e[0]+' - '+e[3]) for e in gcs if 'NZGD' in e[1] or 'RSRGD' in e[1]] \
+ [(e[0],e[0]+' - '+e[1]) for e in pcs if 'NZGD' in e[1] or 'RSRGD' in e[1]]
self.rowsr = [(e[0],e[0]+' - '+e[3]) for e in gcs if 'NZGD' not in e[1] and 'RSRGD' not in e[1]] \
+ [(e[0],e[0]+' - '+e[1]) for e in pcs if 'NZGD' not in e[1] and 'RSRGD' not in e[1]]
def initUI(self):
# 0 1 2 3 4 5 6 7 8
#'destname','lgselect','layer','uconf','group','epsg','fd','td','int'
#self.rdest,rlgselect,self.rlayer,ruconf,self.rgroup,repsg,rfd,rtd,rint = readlist
QToolTip.setFont(QFont('SansSerif', 10))
#labels
destLabel = QLabel('Destination')
lgLabel = QLabel('Group/Layer')
epsgLabel = QLabel('EPSG')
fromDateLabel = QLabel('From Date')
toDateLabel = QLabel('To Date')
confLabel = QLabel('User Config')
self.view = QLabel()
self.view.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.view.setAlignment(Qt.AlignCenter)
self.confcombo = QComboBox(self)
self.confcombo.setToolTip('Enter your user config name (file) here')
self.confcombo.addItems(self.cflist)
self.confcombo.setEditable(False)
#self.confcombo.currentIndexChanged.connect(self.doLGEditUpdate)
#combos
self.lgcombo = QComboBox(self)
self.lgcombo.setMaximumWidth(self.MAX_WD)
self.lgcombo.setDuplicatesEnabled(False)
#self.lgcombo.setInsertPolicy(QComboBox.InsertAlphabetically)#?doesnt seem to work
self.lgcombo.setToolTip('Select either Layer or Group entry')
self.lgcombo.setEditable(False)
self.sepindex = None
#self.updateLGValues()
self.epsgcombo = QComboBox(self)
self.epsgcombo.setMaximumWidth(self.MAX_WD)
self.epsgcombo.setToolTip('Setting an EPSG number here determines the output SR of the layer')
self.epsgcombo.addItems([i[1] for i in self.nzlsr])
self.epsgcombo.insertSeparator(len(self.nzlsr))
self.epsgcombo.addItems([i[1] for i in self.rowsr])
self.epsgcombo.setEditable(True)
self.epsgcombo.setEnabled(False)
self.destlist = self.getConfiguredDestinations()
self.destcombo = QComboBox(self)
self.destcombo.setToolTip('Choose the desired output type')
self.destcombo.setEditable(False)
self.destcombo.addItems(self.destlist)
#date selection
self.fromdateedit = QDateEdit()
self.fromdateedit.setCalendarPopup(True)
self.fromdateedit.setEnabled(False)
self.todateedit = QDateEdit()
self.todateedit.setCalendarPopup(True)
self.todateedit.setEnabled(False)
#check boxes
self.epsgenable = QCheckBox()
self.epsgenable.setCheckState(False)
self.epsgenable.clicked.connect(self.doEPSGEnable)
self.fromdateenable = QCheckBox()
self.fromdateenable.setCheckState(False)
self.fromdateenable.clicked.connect(self.doFromDateEnable)
self.todateenable = QCheckBox()
self.todateenable.setCheckState(False)
self.todateenable.clicked.connect(self.doToDateEnable)
self.progressbar = QProgressBar()
self.progressbar.setRange(0,100)
self.progressbar.setVisible(True)
self.progressbar.setMinimumWidth(self.MAX_WD)
#buttons
self.initbutton = QPushButton("waiting")
self.initbutton.setToolTip('Initialise the Layer Configuration')
self.initbutton.clicked.connect(self.doInitClickAction)
self.cleanbutton = QPushButton("Clean")
self.cleanbutton.setToolTip('Clean the selected layer/group from local storage')
self.cleanbutton.clicked.connect(self.doCleanClickAction)
self.replicatebutton = QPushButton("Replicate")
self.replicatebutton.setToolTip('Execute selected replication')
self.replicatebutton.clicked.connect(self.doReplicateClickAction)
self.cancelbutton = QPushButton("Close")
self.cancelbutton.setToolTip('Close the LDS Replicate application')
self.cancelbutton.clicked.connect(self.parent.close)
#set dialog values using GPR
self.updateGUIValues(self.parent.gvs)
#set onchange here otherwise we get circular initialisation
self.destcombo.currentIndexChanged.connect(self.doDestChanged)
self.confcombo.currentIndexChanged.connect(self.doConfChanged)
self.lgcombo.currentIndexChanged.connect(self.doLGComboChanged)
self.setStatus(self.STATUS.IDLE)
#grid
grid = QGridLayout()
grid.setSpacing(10)
#placement section ------------------------------------
#---------+---------+--------+---------+--------
# dest LB | | dest DD
# grp LB | | grp DD
# conf LB | | conf DD
# epsg L | epsg CB | epsg DD
# f dt L | f dt CB | f dt DD
# t td L | t td CB | t td DD
# icon | <- progress ->
# layer B | <- . -> |repl B | clean B | close B
#---------+---------+--------+---------+--------
grid.addWidget(destLabel, 1, 0)
grid.addWidget(self.destcombo, 1, 2)
#grid.addWidget(layerLabel, 2, 0)
grid.addWidget(lgLabel, 2, 0)
grid.addWidget(self.lgcombo, 2, 2)
grid.addWidget(confLabel, 3, 0)
grid.addWidget(self.confcombo, 3, 2)
#grid.addWidget(groupLabel, 4, 0)
#grid.addWidget(self.groupEdit, 4, 2)
grid.addWidget(epsgLabel, 5, 0)
grid.addWidget(self.epsgenable, 5, 1)
grid.addWidget(self.epsgcombo, 5, 2)
grid.addWidget(fromDateLabel, 6, 0)
grid.addWidget(self.fromdateenable, 6, 1)
grid.addWidget(self.fromdateedit, 6, 2)
grid.addWidget(toDateLabel, 7, 0)
grid.addWidget(self.todateenable, 7, 1)
grid.addWidget(self.todateedit, 7, 2)
hbox3 = QHBoxLayout()
hbox3.addWidget(self.view)
hbox3.addStretch(1)
hbox3.addWidget(self.progressbar)
#hbox3.addLayout(vbox2)
#hbox3.addLayout(vbox3)
hbox4 = QHBoxLayout()
hbox4.addWidget(self.initbutton)
hbox4.addStretch(1)
hbox4.addWidget(self.replicatebutton)
hbox4.addWidget(self.cleanbutton)
hbox4.addWidget(self.cancelbutton)
vbox = QVBoxLayout()
#vbox.addStretch(1)
vbox.addLayout(grid)
vbox.addLayout(hbox3)
vbox.addLayout(hbox4)
self.setLayout(vbox)
#def setProgress(self,pct):
# self.progressbar.setValue(pct)
def setStatus(self,status,message='',tooltip=None):
'''Sets indicator icon and statusbar message'''
self.parent.statusbar.showMessage(message)
self.parent.statusbar.setToolTip(tooltip if tooltip else '')
#progress
loc = os.path.abspath(os.path.join(IMG_LOC,self.imgset[status]))
#loc = os.path.abspath(os.path.join(os.path.dirname(__file__),self.parent.IMG_LOC,self.imgset[status]))
self.progressbar.setVisible(status in (self.STATUS.BUSY, self.STATUS.CLEAN))
#icon
anim = QMovie(loc, QByteArray(), self)
anim.setScaledSize(QSize(self.IMG_WIDTH,self.IMG_HEIGHT))
anim.setCacheMode(QMovie.CacheAll)
anim.setSpeed(self.IMG_SPEED)
self.view.clear()
self.view.setMovie(anim)
anim.start()
self.view.repaint()
QApplication.processEvents(QEventLoop.AllEvents)
def mainWindowEnable(self,enable=True):
cons = (self.lgcombo, self.confcombo, self.destcombo,
self.initbutton, self.replicatebutton, self.cleanbutton, self.cancelbutton,
self.epsgenable,self.fromdateenable,self.todateenable,
self.parent.menubar)
for c in cons:
c.setEnabled(enable)
if enable:
self.epsgcombo.setEnabled(self.epsgenable.checkState())
self.fromdateedit.setEnabled(self.fromdateenable.checkState())
self.todateedit.setEnabled(self.todateenable.checkState())
else:
self.epsgcombo.setEnabled(False)
self.fromdateedit.setEnabled(False)
self.todateedit.setEnabled(False)
QApplication.restoreOverrideCursor() if enable else QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
def refreshLGCombo(self):
'''Re index LG combobox since a refreshLG call (new dest?) will usually mean new groups'''
self.lgcombo.clear()
self.lgcombo.addItems([i[2] for i in self.parent.confconn.lglist])
#NOTE the separator consumes an index, if not clearing the combobox selectively remove the old sepindex (assumes g preceeds l)
#if self.sepindex:
# self.lgcombo.removeItem(self.sepindex)
self.sepindex = [i[0] for i in self.parent.confconn.lglist].count(LORG.GROUP)
self.lgcombo.insertSeparator(self.sepindex)
def updateLGValues(self,uconf,lgval,dest):
'''Sets the values displayed in the Layer/Group combo'''
#because we cant seem to sort combobox entries and want groups at the top, clear and re-add
#TRACE#
#pdb.set_trace()
sf = None
try:
self.parent.confconn.initConnections(uconf,lgval,dest)
except Exception as e:
sf=1
ldslog.error('Error Updating UC Values. '+str(e))
if sf:
self.setStatus(self.STATUS.ERROR,'Error Updating UC Values', str(e))
else:
self.setStatus(self.STATUS.IDLE)
self.refreshLGCombo()
def centre(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def gprParameters(self,rdest):
'''Zip default and GPR values'''
return [x if LU.assessNone(x) else y for x,y in zip(self.parent.gpr.readsec(rdest),self.parent.DEF_RVALS[1:])]
def getLCE(self,ln):
'''Read layer parameters'''
dep = self.parent.confconn.reg.openEndPoint(self.parent.confconn.destname,self.parent.confconn.uconf)
#sep = self.parent.confconn.reg.openEndPoint('WFS',self.parent.confconn.uconf)
self.parent.confconn.reg.setupLayerConfig(self.parent.confconn.tp,None,dep,initlc=False)
lce = dep.getLayerConf().readLayerParameters(ln)
#self.parent.confconn.reg.closeEndPoint('WFS')
self.parent.confconn.reg.closeEndPoint(self.parent.confconn.destname)
sep,dep = None,None
return lce
def doDestChanged(self):
'''Read the destname parameter and fill dialog with matching GPR values'''
rdest = str(self.destlist[self.destcombo.currentIndex()])
rvals = self.gprParameters(rdest)
self.updateGUIValues([rdest]+rvals)
def doConfChanged(self):
'''Read the user conf parameter and fill dialog with matching GPR values'''
rdest = str(self.destlist[self.destcombo.currentIndex()])
rlg,_,rep,rfd,rtd = self.gprParameters(rdest)
ruc = str(self.cflist[self.confcombo.currentIndex()])
self.updateGUIValues((rdest,rlg,ruc,rep,rfd,rtd))
def doLGComboChanged(self):
'''Read the layer/group value and change epsg to layer or gpr match'''
#get a matching LG entry and test whether its a layer or group
#lgi = self.parent.confconn.getLayerGroupIndex(self.lgcombo.currentText().toUtf8().data())
lgi = self.parent.confconn.getLayerGroupIndex(LQ.readWidgetText(self.lgcombo.currentText()))
#lgi can be none if we init a new group, in which case we use the GPR value
if lgi:
lge = self.parent.confconn.lglist[lgi]
lce = self.getLCE(lge[1]) if lge[0]==LORG.LAYER else None
else:
lce = None
#look for filled layer conf epsg OR use prefs stored in gpr
if lce and LU.assessNone(lce.epsg):
epsgval = lce.epsg
else:
rdest = str(self.destlist[self.destcombo.currentIndex()])
_,_,epsgval,_,_ = self.gprParameters(rdest)
epsgindex = [i[0] for i in self.nzlsr+[(0,0)]+self.rowsr].index(epsgval)
if self.epsgcombo.currentIndex() != epsgindex:
self.epsgcombo.setCurrentIndex(int(epsgindex))
def updateGUIValues(self,readlist):
'''Fill dialog values from provided list'''
#TODO. Remove circular references when setCurrentIndex() triggers do###Changed()
#Read user input
rdest,self.rlgval,ruconf,repsg,rfd,rtd = readlist
#--------------------------------------------------------------------
#Destination Menu
selecteddest = LU.standardiseDriverNames(rdest)
if selecteddest not in self.destlist:
self.destlist = self.getConfiguredDestinations()
self.destcombo.addItem(selecteddest)
destindex = self.destlist.index(selecteddest) if selecteddest else 0
if self.destcombo.currentIndex() != destindex:
self.destcombo.setCurrentIndex(destindex)
#InitButton
self.initbutton.setText('Layer Select')
#Config File
confindex = 0
if LU.assessNone(ruconf):
ruconf = ruconf.split('.')[0]
if ruconf not in self.cflist:
self.cflist += [ruconf,]
self.confcombo.addItem(ruconf)
confindex = self.cflist.index(ruconf)
if self.confcombo.currentIndex() != confindex:
self.confcombo.setCurrentIndex(confindex)
#self.confEdit.setText(ruconf if LU.assessNone(ruconf) else '')
#Layer/Group Selection
self.updateLGValues(ruconf,self.rlgval,rdest)
lgindex = None
if LU.assessNone(self.rlgval):
#index of list value
lgindex = self.parent.confconn.getLayerGroupIndex(self.rlgval,col=1)
if LU.assessNone(lgindex):
#advance by 1 for sep
lgindex += 1 if lgindex>self.sepindex else 0
else:
#using the separator index sets the combo to blank
lgindex = self.sepindex
if self.lgcombo.currentIndex() != lgindex:
self.lgcombo.setCurrentIndex(lgindex)
#self.doLGEditUpdate()
#EPSG
# user > layerconf
#useepsg = LU.precedence(repsg, lce.epsg if lce else None, None)
epsgindex = [i[0] for i in self.nzlsr+[(None,None)]+self.rowsr].index(repsg)
if self.epsgcombo.currentIndex() != epsgindex:
self.epsgcombo.setCurrentIndex(epsgindex)
#epsgedit = self.epsgcombo.lineEdit()
#epsgedit.setText([e[1] for e in self.nzlsr+self.rowsr if e[0]==repsg][0])
#epsgedit.setText([e for e in self.nzlsr+self.rowsr if re.match('^\s*(\d+).*',e).group(1)==repsg][0])
#To/From Dates
if LU.assessNone(rfd):
self.fromdateedit.setDate(QDate(int(rfd[0:4]),int(rfd[5:7]),int(rfd[8:10])))
else:
early = DataStore.EARLIEST_INIT_DATE
self.fromdateedit.setDate(QDate(int(early[0:4]),int(early[5:7]),int(early[8:10])))
if LU.assessNone(rtd):
self.todateedit.setDate(QDate(int(rtd[0:4]),int(rtd[5:7]),int(rtd[8:10])))
else:
today = DataStore.getCurrent()
self.todateedit.setDate(QDate(int(today[0:4]),int(today[5:7]),int(today[8:10])))
#Internal/External CheckBox
# if LU.assessNone(rint):
# self.internalTrigger.setChecked(rint.lower()==DataStore.CONF_INT)
# else:
# self.internalTrigger.setChecked(DataStore.DEFAULT_CONF==DataStore.CONF_INT)
def getConfiguredDestinations(self):
defml = ['',]+DataStore.DRIVER_NAMES.values()
return [d for d in self.parent.gpr.getDestinations() if d in defml]
def doEPSGEnable(self):
self.epsgcombo.setEnabled(self.epsgenable.isChecked())
def doFromDateEnable(self):
self.fromdateedit.setEnabled(self.fromdateenable.isChecked())
def doToDateEnable(self):
self.todateedit.setEnabled(self.todateenable.isChecked())
def readParameters(self):
'''Read values out of dialogs'''
destination = LU.assessNone(str(self.destlist[self.destcombo.currentIndex()]))
#lgindex = self.parent.confconn.getLayerGroupIndex(self.lgcombo.currentText().toUtf8().data())
lgindex = self.parent.confconn.getLayerGroupIndex(LQ.readWidgetText(self.lgcombo.currentText()))
#NB need to test for None explicitly since zero is a valid index
lgval = self.parent.confconn.lglist[lgindex][1] if LU.assessNone(lgindex) else None
#uconf = LU.standardiseUserConfigName(str(self.confcombo.lineEdit().text()))
#uconf = str(self.confcombo.lineEdit().text())
uconf = str(self.cflist[self.confcombo.currentIndex()])
ee = self.epsgenable.isChecked()
epsg = None if ee is False else re.match('^\s*(\d+).*',str(self.epsgcombo.lineEdit().text())).group(1)
fe = self.fromdateenable.isChecked()
te = self.todateenable.isChecked()
fd = None if fe is False else str(self.fromdateedit.date().toString('yyyy-MM-dd'))
td = None if te is False else str(self.todateedit.date().toString('yyyy-MM-dd'))
return destination,lgval,uconf,epsg,fe,te,fd,td
def doInitClickAction(self):
'''Initialise the LC on LC-button-click, action'''
try:
try:
self.setStatus(self.STATUS.BUSY,'Opening Layer-Config Editor')
self.progressbar.setValue(0)
self.parent.runLayerConfigAction()
finally:
self.setStatus(self.STATUS.IDLE,'Ready')
except Exception as e:
self.setStatus(self.STATUS.ERROR,'Error in Layer-Config',str(sys.exc_info()))#e))
def doCleanClickAction(self):
'''Set clean anim and run clean'''
#lgo = self.lgcombo.currentText().toUtf8().data()
lgo = LQ.readWidgetText(self.lgcombo.currentText())
try:
self.setStatus(self.STATUS.CLEAN,'Running Clean '+lgo)
self.progressbar.setValue(0)
self.runReplicationScript(True)
except Exception as e:
self.setStatus(self.STATUS.ERROR,'Failed Clean of '+lgo,str(sys.exc_info()))#e))
def doReplicateClickAction(self):
'''Set busy anim and run repl'''
lgo = self.lgcombo.currentText()#.toUtf8().data()#only used for error messages
try:
self.setStatus(self.STATUS.BUSY,'Running Replicate '+lgo)
self.progressbar.setValue(0)
self.runReplicationScript(False)
except Exception as e:
self.setStatus(self.STATUS.ERROR,'Failed Replication of '+lgo,str(sys.exc_info()))#e))
def runReplicationScript(self,clean=False):
'''Run the layer/group repliction script'''
destination,lgval,uconf,epsg,fe,te,fd,td = self.readParameters()
uconf_path = LU.standardiseUserConfigName(uconf)
destination_path = LU.standardiseLayerConfigName(destination)
destination_driver = LU.standardiseDriverNames(destination)
if not os.path.exists(uconf_path):
self.userConfMessage(uconf_path)
return
elif not MainFileReader(uconf_path).hasSection(destination_driver):
self.userConfMessage(uconf_path,destination_driver)
return
#-----------------------------------------------------
#'destname','layer','uconf','group','epsg','fd','td','int'
self.parent.gpr.write((destination_driver,lgval,uconf,epsg,fd,td))
ldslog.info(u'dest={0}, lg={1}, conf={2}, epsg={3}'.format(destination_driver,lgval,uconf,epsg))
ldslog.info('fd={0}, td={1}, fe={2}, te={3}'.format(fd,td,fe,te))
lgindex = self.parent.confconn.getLayerGroupIndex(lgval,col=1)
#lorg = self.parent.confconn.lglist[lgindex][0]
#----------don't need lorg in TP anymore but it is useful for sorting/counting groups
#self.parent.confconn.tp.setLayerOrGroup(lorg)
self.parent.confconn.tp.setLayerGroupValue(lgval)
if self.fromdateenable.isChecked(): self.parent.confconn.tp.setFromDate(fd)
if self.todateenable.isChecked(): self.parent.confconn.tp.setToDate(td)
self.parent.confconn.tp.setUserConf(uconf)
if self.epsgenable: self.parent.confconn.tp.setEPSG(epsg)
#because clean state persists in TP
if clean:
self.parent.confconn.tp.setCleanConfig()
else:
self.parent.confconn.tp.clearCleanConfig()
#(re)initialise the data source since uconf may have changed
#>>#self.parent.confconn.tp.src = self.parent.confconn.initSourceWrapper()
#--------------------------
###ep = self.parent.confconn.reg.openEndPoint(self.parent.confconn.destname,self.parent.confconn.uconf)
###self.parent.confconn.reg.closeEndPoint(self.parent.confconn.destname)
###ep = None
#Open ProcessRunner and run with TP(proc)/self(gui) instances
#HACK temp add of dest_drv to PR call
try:
#TODO. Test for valid LC first
self.tpr = ProcessRunner(self,destination_driver)
except Exception as e:
ldslog.error('Cannot create ProcessRunner {}. NB Possible missing Layer Config {}'.format(str(e),destination_path))
self.layerConfMessage(destination_path)
return
#If PR has been successfully created we must vave a valid dst
self.tpr.start()
def quitProcessRunner(self):
self.tpr.join()
self.tpr.quit()
self.trp = None
def userConfMessage(self,uconf,secname=None):
ucans = QMessageBox.warning(self, 'User Config Missing/Incomplete',
'Specified User-Config file, '+str(uconf)+' does not exist' if secname is None else 'User-Config file does not contain '+str(secname)+' section',
'Back','Initialise User Config')
if not ucans:
#Retry
ldslog.warn('Retry specifying UC')
#self.confcombo.setCurrentIndex(0)
return
#Init
ldslog.warn('Reset User Config Wizard')
self.parent.runWizardAction()
def layerConfMessage(self,dest):
lcans = QMessageBox.warning(self, 'Layer Config Missing',
'Required Layer-Config file, '+str(dest)+' does not exist',
'Back','Run Layer Select')
if not lcans:
#Retry
ldslog.warn('Retry specifying LC')
#self.destcombo.setCurrentIndex(0)
return
#Init
ldslog.warn('Reset Layer Config')
self.doInitClickAction()
class Window(QtGui.QMainWindow):
def __init__(self):
super(Window, self).__init__()
self.setGeometry(50, 50, 900, 590)
self.setWindowTitle("CUBS FaceDemo Enroller")
self.home()
def home(self):
self.imgindex = 0
self.selectedname = ""
self.imglen = 0
self.delbtn = QtGui.QPushButton("Delete Entry", self)
self.delbtn.resize(100, 30)
self.delbtn.move(200, 125)
# self.delbtn.move(0, 0)
self.rightname = QLabel("", self)
self.rightname.move(350, 5)
self.rightname.resize(600, 20)
self.rightname.setAlignment(Qt.AlignCenter)
self.btn = QtGui.QPushButton("Enroll", self)
# self.btn.clicked.connect()
self.btn.resize(80, 30)
self.btn.move(10, 125)
self.nextbtn = QtGui.QPushButton("Next", self)
self.delimagebtn = QtGui.QPushButton("Delete Image", self)
self.previousbtn = QtGui.QPushButton("Previous", self)
self.nextbtn.move(750, 530)
self.delimagebtn.move(550, 530)
self.previousbtn.move(450, 530)
self.firstnametext = QLabel(self)
self.firstnametext.setText("First Name:")
self.firstnametext.move(10, 10)
self.firstnamefield = QLineEdit(self)
self.firstnamefield.setObjectName("First Name")
self.firstnamefield.resize(300, 30)
self.firstnamefield.move(100, 10)
lastnametext = QLabel(self)
lastnametext.setText("Last Name:")
lastnametext.move(10, 50)
self.lastnamefield = QLineEdit(self)
self.lastnamefield.setObjectName("First Name")
self.lastnamefield.resize(300, 30)
self.lastnamefield.move(100, 50)
self.dirbtn = QtGui.QPushButton("Choose Directory", self)
self.dirbtn.resize(140, 30)
self.dirbtn.move(10, 90)
self.dirfield = QLineEdit(self)
self.dirfield.setObjectName("Directory")
self.dirfield.resize(250, 30)
self.dirfield.move(150, 90)
self.status = QLabel(self)
self.status.move(10, 563)
self.status.resize(400, 20)
self.status.setText("Ready")
self.rebuild = QtGui.QPushButton("Add Image", self)
self.rebuild.move(650, 530)
self.rebuild.resize(100, 30)
self.listsize = QtGui.QLabel(self)
self.listsize.setText(" Persons Enrolled")
self.listsize.resize(200, 20)
self.listsize.move(10, 160)
self.list = QListWidget(self)
self.list.resize(389, 380)
self.list.move(10, 180)
self.stat("Pulling list")
refresh_list_elements(self.list, self.listsize)
self.stat("Ready")
self.image = QLabel(self)
self.image.resize(490, 490)
self.image.move(405, 30)
self.list.doubleClicked.connect(self.on_double_click)
self.connect(self, SIGNAL('triggered()'), self.closeEvent)
self.connect(self.rebuild, SIGNAL("clicked()"), self.add_image)
self.connect(self.nextbtn, SIGNAL("clicked()"), self.next_image)
self.connect(self.previousbtn, SIGNAL("clicked()"),
self.previous_image)
self.connect(self.delimagebtn, SIGNAL("clicked()"), self.delete_image)
self.connect(self.dirbtn, SIGNAL("clicked()"), self.opendir)
self.connect(self.delbtn, SIGNAL("clicked()"), self.button_delete)
self.connect(self.btn, SIGNAL("clicked()"), self.button_click)
self.show()
def closeEvent(self, event):
self.stat("Saving Changes")
save()
print "Changes saved"
print "Rebuilding Vectors"
self.rebuild_vector()
self.destroy()
def rebuild_vector(self):
# feature_build.generate_vectors()
pass
def stat(self, stat):
self.status.setText(stat)
def add_image(self):
self.dialog = QFileDialog(self)
directory = self.dialog.getOpenFileName(self, 'Select Directory')
if directory:
self.dirfield.setText(directory)
img_directory = str(self.dirfield.text())
picarray = test_create_image(img_directory, True)
# enroll_images.images_to_array(img_directory, True)
dict_personinfo[self.selectedname].append(picarray)
refresh_list_elements(self.list, self.listsize)
self.init_images()
self.dirfield.setText('')
def next_image(self):
check = self.imgindex + 1
if (check >= self.imglen):
self.display_image(0)
self.imgindex = 0
else:
self.display_image(check)
self.imgindex += 1
def previous_image(self):
check = self.imgindex - 1
if (check < 0):
self.display_image(self.imglen - 1)
self.imgindex = self.imglen - 1
else:
self.display_image(check)
self.imgindex -= 1
def delete_image(self):
# dict_personinfo = obtain_info()
dict_personinfo[self.selectedname].pop(self.imgindex)
if (len(dict_personinfo[self.selectedname]) == 0):
dict_personinfo.pop(self.selectedname, None)
# with open('data/gui_dict.pickle', 'wb') as handle:
# cPickle.dump(dict_personinfo, handle)
self.stat("Deleted " + self.selectedname)
refresh_list_elements(self.list, self.listsize)
self.image.clear()
self.rightname.setText("")
else:
# with open('data/gui_dict.pickle', 'wb') as handle:
# cPickle.dump(dict_personinfo, handle)
self.stat("Deleted image for " + self.selectedname)
refresh_list_elements(self.list, self.listsize)
self.init_images()
def display_image(self, index=0):
img = self.get_images()
self.imglen = len(img)
img = img[index]
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
height, width, channel = img.shape
bytesPerLine = 3 * width
qimg = QImage(img.data, width, height, bytesPerLine,
QImage.Format_RGB888)
pixmap = QtGui.QPixmap(qimg)
pixmap = pixmap.scaled(self.image.size())
self.image.setPixmap(pixmap)
def get_images(self):
# dict_personinfo = obtain_info()
arr_images = []
for i in range(len(dict_personinfo[self.selectedname])):
frame = dict_personinfo[self.selectedname][i][0]
rectangle = dict_personinfo[self.selectedname][i][1]
img = np.array(Image.fromarray(frame))
cv2.rectangle(img, (int(rectangle[0][0]), int(rectangle[0][3])),
(int(rectangle[0][2]), int(rectangle[0][1])),
(0, 255, 0), 40)
cv2.circle(img, (int(rectangle[0][5]), int(rectangle[0][6])), 10,
(0, 255, 0), 40)
cv2.circle(img, (int(rectangle[0][7]), int(rectangle[0][8])), 10,
(0, 255, 0), 40)
cv2.circle(img, (int(rectangle[0][9]), int(rectangle[0][10])), 10,
(0, 255, 0), 40)
cv2.circle(img, (int(rectangle[0][11]), int(rectangle[0][12])), 10,
(0, 255, 0), 40)
cv2.circle(img, (int(rectangle[0][13]), int(rectangle[0][14])), 10,
(0, 255, 0), 40)
print(rectangle)
arr_images.append(img)
self.imglen = len(arr_images)
return arr_images
def on_double_click(self):
self.selectedname = str(self.list.currentItem().text())
self.rightname.setText(self.selectedname)
self.init_images()
def init_images(self):
self.imgindex = 0
img = self.get_images()
img = img[0]
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
height, width, channel = img.shape
bytesPerLine = 3 * width
qimg = QImage(img.data, width, height, bytesPerLine,
QImage.Format_RGB888)
pixmap = QtGui.QPixmap(qimg)
pixmap = pixmap.scaled(self.image.size())
self.image.setPixmap(pixmap)
def opendir(self):
self.dialog = QFileDialog(self)
directory = self.dialog.getExistingDirectory(self, 'Select Directory')
if directory:
self.dirfield.setText(directory)
def button_delete(self):
if (str(self.list.currentItem().text()) != None):
# dict_personinfo = obtain_info()
dict_personinfo.pop(str(self.list.currentItem().text()), None)
# with open('data/gui_dict.pickle', 'wb') as handle:
# cPickle.dump(dict_personinfo, handle)
self.stat("Deleted " + str(self.list.currentItem().text()))
refresh_list_elements(self.list, self.listsize)
self.image.clear()
self.rightname.clear()
else:
pass
def button_click(self):
self.stat("Pulling list")
# dict_personinfo = obtain_info()
self.stat("Ready")
name = ['', '']
name[0] = str(self.firstnamefield.text())
name[1] = str(self.lastnamefield.text())
name[0] = name[0].replace(" ", "")
name[1] = name[1].replace(" ", "")
img_directory = str(self.dirfield.text())
self.stat("Detecting Face")
if img_directory == "" or len(name[0]) == 0:
picarray = []
else:
picarray = test_create_image(
img_directory, False) # Just a testing filler for now
# picarray = enroll_images.images_to_array(img_directory, False)
# feature_build.generate_vectors()
if len(picarray) != 0:
dict_personinfo[name[0] + " " + name[1]] = {}
dict_personinfo[name[0] + " " + name[1]] = picarray
if img_directory == "" or len(name[0]) == 0:
self.stat("Failed to add " + name[0] + " " + name[1])
else:
self.stat("Writing")
# with open('data/gui_dict.pickle', 'wb') as handle:
# cPickle.dump(dict_personinfo, handle)
self.stat("Added " + name[0] + " " + name[1] + " with " +
str(len(picarray)) + " images")
else:
self.stat("Failed to add " + name[0] + " " + name[1])
# feature_build.generate_vectors()
self.firstnamefield.setText('')
self.lastnamefield.setText('')
self.dirfield.setText('')
# self.list.addItem(name[0] + " " + name[1])
refresh_list_elements(self.list, self.listsize)
class Dialog(QDialog):
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self._info = None
self._text = ''
self._convertedtext = ''
self._encoding = None
self.mainwindow = parent
self.fromVersionLabel = QLabel()
self.fromVersion = QLineEdit()
self.reason = QLabel()
self.toVersionLabel = QLabel()
self.toVersion = QLineEdit()
self.lilyChooser = lilychooser.LilyChooser()
self.messages = QTextBrowser()
self.diff = QTextBrowser(lineWrapMode=QTextBrowser.NoWrap)
self.uni_diff = QTextBrowser(lineWrapMode=QTextBrowser.NoWrap)
self.copyCheck = QCheckBox(
checked=QSettings().value('convert_ly/copy_messages', True, bool))
self.tabw = QTabWidget()
self.tabw.addTab(self.messages, '')
self.tabw.addTab(self.diff, '')
self.tabw.addTab(self.uni_diff, '')
self.buttons = QDialogButtonBox(QDialogButtonBox.Reset
| QDialogButtonBox.Save
| QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.buttons.button(QDialogButtonBox.Ok).clicked.connect(self.accept)
self.buttons.rejected.connect(self.reject)
self.buttons.button(QDialogButtonBox.Reset).clicked.connect(self.run)
self.buttons.button(QDialogButtonBox.Save).clicked.connect(
self.saveFile)
layout = QVBoxLayout()
self.setLayout(layout)
grid = QGridLayout()
grid.addWidget(self.fromVersionLabel, 0, 0)
grid.addWidget(self.fromVersion, 0, 1)
grid.addWidget(self.reason, 0, 2, 1, 3)
grid.addWidget(self.toVersionLabel, 1, 0)
grid.addWidget(self.toVersion, 1, 1)
grid.addWidget(self.lilyChooser, 1, 3, 1, 2)
layout.addLayout(grid)
layout.addWidget(self.tabw)
layout.addWidget(self.copyCheck)
layout.addWidget(widgets.Separator())
layout.addWidget(self.buttons)
app.translateUI(self)
qutil.saveDialogSize(self, 'convert_ly/dialog/size', QSize(600, 300))
app.settingsChanged.connect(self.readSettings)
self.readSettings()
self.finished.connect(self.saveCopyCheckSetting)
self.lilyChooser.currentIndexChanged.connect(
self.slotLilyPondVersionChanged)
self.slotLilyPondVersionChanged()
def translateUI(self):
self.fromVersionLabel.setText(_("From version:"))
self.toVersionLabel.setText(_("To version:"))
self.copyCheck.setText(_("Save convert-ly messages in document"))
self.copyCheck.setToolTip(
_("If checked, the messages of convert-ly are appended as a "
"comment to the end of the document."))
self.tabw.setTabText(0, _("&Messages"))
self.tabw.setTabText(1, _("&Changes"))
self.tabw.setTabText(2, _("&Diff"))
self.buttons.button(QDialogButtonBox.Reset).setText(_("Run Again"))
self.buttons.button(QDialogButtonBox.Save).setText(_("Save as file"))
self.setCaption()
def saveCopyCheckSetting(self):
QSettings().setValue('convert_ly/copy_messages',
self.copyCheck.isChecked())
def readSettings(self):
font = textformats.formatData('editor').font
self.diff.setFont(font)
diffFont = QFont("Monospace")
diffFont.setStyleHint(QFont.TypeWriter)
self.uni_diff.setFont(diffFont)
def slotLilyPondVersionChanged(self):
self.setLilyPondInfo(self.lilyChooser.lilyPondInfo())
def setCaption(self):
version = self._info and self._info.versionString() or _("<unknown>")
title = _("Convert-ly from LilyPond {version}").format(version=version)
self.setWindowTitle(app.caption(title))
def setLilyPondInfo(self, info):
self._info = info
self.setCaption()
self.toVersion.setText(info.versionString())
self.setConvertedText()
self.setDiffText()
self.messages.clear()
def setConvertedText(self, text=''):
self._convertedtext = text
self.buttons.button(QDialogButtonBox.Ok).setEnabled(bool(text))
if text:
self.diff.setHtml(
htmldiff.htmldiff(self._text,
text,
_("Current Document"),
_("Converted Document"),
wrapcolumn=100))
else:
self.diff.clear()
def setDiffText(self, text=''):
if text:
difflist = list(
difflib.unified_diff(self._text.split('\n'), text.split('\n'),
_("Current Document"),
_("Converted Document")))
diffHLstr = self.diffHighl(difflist)
self.uni_diff.setHtml(diffHLstr)
else:
self.uni_diff.clear()
def convertedText(self):
return self._convertedtext or ''
def setDocument(self, doc):
v = documentinfo.docinfo(doc).version_string()
if v:
self.fromVersion.setText(v)
self.reason.setText(_("(set in document)"))
else:
self.reason.clear()
self._text = doc.toPlainText()
self._encoding = doc.encoding() or 'UTF-8'
self.setConvertedText()
self.setDiffText()
def run(self):
"""Runs convert-ly (again)."""
fromVersion = self.fromVersion.text()
toVersion = self.toVersion.text()
if not fromVersion or not toVersion:
self.messages.setPlainText(
_("Both 'from' and 'to' versions need to be set."))
return
info = self._info
command = info.toolcommand(info.ly_tool('convert-ly'))
command += ['-f', fromVersion, '-t', toVersion, '-']
# if the user wants english messages, do it also here: LANGUAGE=C
env = None
if os.name == "nt":
# Python 2.7 subprocess on Windows chokes on unicode in env
env = util.bytes_environ()
else:
env = dict(os.environ)
if sys.platform.startswith('darwin'):
try:
del env['PYTHONHOME']
except KeyError:
pass
try:
del env['PYTHONPATH']
except KeyError:
pass
if QSettings().value("lilypond_settings/no_translation", False, bool):
if os.name == "nt":
# Python 2.7 subprocess on Windows chokes on unicode in env
env[b'LANGUAGE'] = b'C'
else:
env['LANGUAGE'] = 'C'
with qutil.busyCursor():
try:
proc = subprocess.Popen(command,
env=env,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
out, err = proc.communicate(
util.platform_newlines(self._text).encode(self._encoding))
except OSError as e:
self.messages.setPlainText(
_("Could not start {convert_ly}:\n\n"
"{message}\n").format(convert_ly=command[0], message=e))
return
out = util.universal_newlines(out.decode('UTF-8'))
err = util.universal_newlines(err.decode('UTF-8'))
self.messages.setPlainText(err)
self.setConvertedText(out)
self.setDiffText(out)
if not out or self._convertedtext == self._text:
self.messages.append('\n' +
_("The document has not been changed."))
def saveFile(self):
"""Save content in tab as file"""
tabdata = self.getTabData(self.tabw.currentIndex())
doc = self.mainwindow.currentDocument()
orgname = doc.url().toLocalFile()
filename = os.path.splitext(
orgname)[0] + '[' + tabdata.filename + ']' + '.' + tabdata.ext
caption = app.caption(_("dialog title", "Save File"))
filetypes = '{0} (*.txt);;{1} (*.htm);;{2} (*)'.format(
_("Text Files"), _("HTML Files"), _("All Files"))
filename = QFileDialog.getSaveFileName(self.mainwindow, caption,
filename, filetypes)
if not filename:
return False # cancelled
with open(filename, 'wb') as f:
f.write(tabdata.text.encode('utf-8'))
def getTabData(self, index):
"""Get content of current tab from current index"""
if index == 0:
return FileInfo('message', 'txt', self.messages.toPlainText())
elif index == 1:
return FileInfo('html-diff', 'html', self.diff.toHtml())
elif index == 2:
return FileInfo('uni-diff', 'diff', self.uni_diff.toPlainText())
def diffHighl(self, difflist):
"""Return highlighted version of input."""
result = []
for l in difflist:
if l.startswith('-'):
s = '<span style="color: red; white-space: pre-wrap;">'
elif l.startswith('+'):
s = '<span style="color: green; white-space: pre-wrap;">'
else:
s = '<span style="white-space: pre-wrap;">'
h = l.replace('&', '&').replace('<',
'<').replace('>', '>')
result.append(s + h + '</span>')
return '<br>'.join(result)
class Dialog(QDialog):
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self._info = None
self._text = ''
self._convertedtext = ''
self._encoding = None
self.fromVersionLabel = QLabel()
self.fromVersion = QLineEdit()
self.reason = QLabel()
self.toVersionLabel = QLabel()
self.toVersion = QLineEdit()
self.messages = QTextBrowser()
self.diff = QTextBrowser(lineWrapMode=QTextBrowser.NoWrap)
self.copyCheck = QCheckBox(checked=
QSettings().value('convert_ly/copy_messages', True, bool))
self.tabw = QTabWidget()
self.tabw.addTab(self.messages, '')
self.tabw.addTab(self.diff, '')
self.buttons = QDialogButtonBox(
QDialogButtonBox.Reset |
QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
self.buttons.button(QDialogButtonBox.Reset).clicked.connect(self.run)
layout = QVBoxLayout()
self.setLayout(layout)
top = QHBoxLayout()
top.addWidget(self.fromVersionLabel)
top.addWidget(self.fromVersion)
top.addWidget(self.reason)
top.addStretch()
top.addWidget(self.toVersionLabel)
top.addWidget(self.toVersion)
layout.addLayout(top)
layout.addWidget(self.tabw)
layout.addWidget(self.copyCheck)
layout.addWidget(widgets.Separator())
layout.addWidget(self.buttons)
app.translateUI(self)
qutil.saveDialogSize(self, 'convert_ly/dialog/size', QSize(600, 300))
app.settingsChanged.connect(self.readSettings)
self.readSettings()
self.finished.connect(self.saveCopyCheckSetting)
def translateUI(self):
self.fromVersionLabel.setText(_("From version:"))
self.toVersionLabel.setText(_("To version:"))
self.copyCheck.setText(_("Save convert-ly messages in document"))
self.copyCheck.setToolTip(_(
"If checked, the messages of convert-ly are appended as a "
"comment to the end of the document."))
self.tabw.setTabText(0, _("&Messages"))
self.tabw.setTabText(1, _("&Changes"))
self.buttons.button(QDialogButtonBox.Reset).setText(_("Run Again"))
self.setCaption()
def saveCopyCheckSetting(self):
QSettings().setValue('convert_ly/copy_messages', self.copyCheck.isChecked())
def readSettings(self):
font = textformats.formatData('editor').font
self.diff.setFont(font)
def setCaption(self):
version = self._info and self._info.versionString() or _("<unknown>")
title = _("Convert-ly from LilyPond {version}").format(version=version)
self.setWindowTitle(app.caption(title))
def setLilyPondInfo(self, info):
self._info = info
self.setCaption()
self.toVersion.setText(info.versionString())
self.setConvertedText()
def setConvertedText(self, text=''):
self._convertedtext = text
self.buttons.button(QDialogButtonBox.Ok).setEnabled(bool(text))
if text:
self.diff.setHtml(htmldiff.htmldiff(
self._text, text,
_("Current Document"), _("Converted Document"),
wrapcolumn=100))
else:
self.diff.clear()
def convertedText(self):
return self._convertedtext or ''
def setDocument(self, doc):
v = documentinfo.docinfo(doc).version_string()
if v:
self.fromVersion.setText(v)
self.reason.setText(_("(set in document)"))
else:
self.reason.clear()
self._text = doc.toPlainText()
self._encoding = doc.encoding() or 'UTF-8'
self.setConvertedText()
def run(self):
"""Runs convert-ly (again)."""
fromVersion = self.fromVersion.text()
toVersion = self.toVersion.text()
if not fromVersion or not toVersion:
self.messages.setPlainText(_(
"Both 'from' and 'to' versions need to be set."))
return
info = self._info
command = info.toolcommand(info.convert_ly)
command += ['-f', fromVersion, '-t', toVersion, '-']
# if the user wants english messages, do it also here: LANGUAGE=C
env = None
if QSettings().value("lilypond_settings/no_translation", False, bool):
if os.name == "nt":
# Python 2.7 subprocess on Windows chokes on unicode in env
env = util.bytes_environ()
env[b'LANGUAGE'] = b'C'
else:
env = dict(os.environ)
env['LANGUAGE'] = 'C'
with qutil.busyCursor():
try:
proc = subprocess.Popen(command,
universal_newlines = True,
env = env,
stdin = subprocess.PIPE,
stdout = subprocess.PIPE,
stderr = subprocess.PIPE)
out, err = proc.communicate(self._text.encode(self._encoding))
except OSError as e:
self.messages.setPlainText(_(
"Could not start {convert_ly}:\n\n"
"{message}\n").format(convert_ly = convert_ly, message = e))
return
self.messages.setPlainText(err.decode('UTF-8'))
self.setConvertedText(out.decode('UTF-8'))
if not out or self._convertedtext == self._text:
self.messages.append('\n' + _("The document has not been changed."))
class MMGoogleClientLoginDialog(QDialog):
def __init__(self, parent):
QDialog.__init__(self, parent)
self.setupUi()
self.userNameLineEdit.setFocus()
self.settings = QSettings("cheungs", "MaeMoney")
settingUsername = self.settings.value("username")
settingPassword = self.settings.value("password")
if settingUsername is not "":
self.userNameLineEdit.setText(settingUsername.toString())
self.passwordLineEdit.setFocus()
if settingPassword is not "":
self.passwordLineEdit.setText(base64.decodestring(settingPassword.toString()))
self.loginButton.setFocus()
def setupUi(self):
self.setWindowModality(QtCore.Qt.WindowModal)
self.setWindowTitle(self.tr("Login to Google Finance"))
self.buttonBox = QtGui.QDialogButtonBox(QtCore.Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel | QDialogButtonBox.Ok)
self.gridLayout = QtGui.QGridLayout()
self.setLayout(self.gridLayout)
self.userNameLabel = QLabel(self.tr("User name"))
self.gridLayout.addWidget(self.userNameLabel, 0, 1, 1, 1)
self.userNameLineEdit = QLineEdit()
self.gridLayout.addWidget(self.userNameLineEdit, 0, 2, 1, 1)
self.passwordLabel = QLabel(self.tr("Password"))
self.gridLayout.addWidget(self.passwordLabel, 1, 1, 1, 1)
self.passwordLineEdit = QLineEdit()
self.passwordLineEdit.setEchoMode(QLineEdit.Password)
self.gridLayout.addWidget(self.passwordLineEdit, 1, 2, 1, 1)
self.loginButton = QPushButton(self.tr("Login"))
self.gridLayout.addWidget(self.loginButton, 2, 1, 1, 2)
self.loginErrorMsgLabel = QLabel("")
self.gridLayout.addWidget(self.loginErrorMsgLabel, 3, 1, 1, 2)
self.connect(self.buttonBox, SIGNAL("accepted()"), self.accept)
self.connect(self.buttonBox, SIGNAL("rejected()"), self.reject)
self.connect(self.loginButton, SIGNAL("clicked()"), self.credentialsEntered)
self.connect(self.passwordLineEdit, SIGNAL("returnPressed()"), self.loginButton.click)
def credentialsEntered(self):
userName = self.userNameLineEdit.text()
password = self.passwordLineEdit.text()
self.emit(SIGNAL("credentialsEntered(QString, QString)"), userName, password)
def acceptCredentials(self, userName, password):
self.loginErrorMsgLabel.clear()
self.accept()
self.settings.setValue("username", userName)
self.settings.setValue("password", base64.encodestring(password.toAscii()))
def rejectCredentials(self, reason):
self.passwordLineEdit.clear()
self.passwordLineEdit.setFocus()
self.loginErrorMsgLabel.setText(reason)
