def enableQuickAddButton(self, name=None, fax=None):
if name is None:
name = to_unicode(self.quickAddNameLineEdit.text())
if fax is None:
fax = to_unicode(self.quickAddFaxLineEdit.text())
existing_name = False
if name:
existing_name = name in self.db.get_all_names()
if existing_name:
try:
self.quickAddNameLineEdit.setPaletteBackgroundColor(QColor("yellow"))
except AttributeError:
pass
else:
try:
self.quickAddNameLineEdit.setPaletteBackgroundColor(QColor("white"))
except AttributeError:
pass
if name and not existing_name and fax:
self.quickAddPushButton.setEnabled(True)
else:
self.quickAddPushButton.setEnabled(False)
def AddToGroupAction_triggered(self):
selected_names = [to_unicode(n.text()) for n in self.NameTableWidget.selectedItems()]
if selected_names:
ok = False
all_groups = self.db.get_all_groups()
if all_groups:
all_groups = [g for g in all_groups if g != to_unicode("All")]
all_groups.sort()
dlg = JoinDialog(self, all_groups)
if dlg.exec_() == QDialog.Accepted:
group = dlg.group
if group:
self.db.add_to_group(group, selected_names)
self.group = group
log.debug("Adding %s to group %s" % (",".join(selected_names), self.group))
self.emit(SIGNAL("databaseChanged"), FAB_GROUP_MEMBERSHIP_CHANGED, self.group)
self.updateGroupList()
else:
FailureUI(
self,
self.__tr(
"<b>There are no groups to join.</b><p>Use <i>New Group from Selection</i> to create a new group using these name(s)."
),
)
def setOKButton(self, toggle=None):
if toggle is not None:
self.pushButtonOK.setEnabled(bool(toggle))
else:
name = to_unicode(self.nameEdit.text())
fax_num = to_unicode(self.faxEdit.text())
self.pushButtonOK.setEnabled(bool(name and fax_num))
def enableQuickAddButton(self, name=None, fax=None):
if name is None:
name = to_unicode(self.QuickAddNameEdit.text())
if fax is None:
fax = to_unicode(self.QuickAddFaxEdit.text())
existing_name = False
if name:
existing_name = name in self.db.get_all_names()
if existing_name:
try:
self.QuickAddNameEdit.setStyleSheet("background-color: yellow")
except AttributeError:
pass
else:
try:
self.QuickAddNameEdit.setStyleSheet("")
except AttributeError:
pass
if name and not existing_name and fax:
self.QuickAddButton.setEnabled(True)
else:
self.QuickAddButton.setEnabled(False)
def NameTableWidget_itemSelectionChanged(self):
if not self.updating_name:
selected_items = self.NameTableWidget.selectedItems()
num_selected_items = len(selected_items)
if num_selected_items == 0:
self.name = None
self.RemoveNameAction.setEnabled(False)
self.NewGroupFromSelectionAction.setEnabled(False)
self.RemoveFromGroupAction.setEnabled(False)
self.AddToGroupAction.setEnabled(False)
elif num_selected_items == 1:
self.name = to_unicode(selected_items[0].text())
self.RemoveNameAction.setEnabled(True)
self.NewGroupFromSelectionAction.setEnabled(True)
self.RemoveFromGroupAction.setEnabled(self.group != to_unicode("All"))
self.AddToGroupAction.setEnabled(True) # self.group != u'All')
else: # > 1
self.RemoveNameAction.setEnabled(True)
self.NewGroupFromSelectionAction.setEnabled(True)
self.RemoveFromGroupAction.setEnabled(self.group != to_unicode("All"))
self.AddToGroupAction.setEnabled(True) # self.group != u'All')
self.name = None
self.updateDetailsFrame()
def NextButton_clicked(self):
p = self.StackedWidget.currentIndex()
if p == PAGE_INTRO:
self.showDevicesPage()
elif p == PAGE_DEVICES:
row = self.DevicesTableWidget.currentRow()
if row != -1:
self.device_uri = self.DevicesTableWidget.item(row, 0).device_uri
self.mq = device.queryModelByURI(self.device_uri)
self.getWifiObject(self.mq['wifi-config'])
back_end, is_hp, bus, model, serial, dev_file, host, zc, port = device.parseDeviceURI(self.device_uri)
self.model = models.normalizeModelName(model).lower()
self.showNetworkPage()
elif p == PAGE_NETWORK:
self.security = 'None'
self.mode = 'Infrastructure'
self.ss = 0
row = self.NetworksTableWidget.currentRow()
if row != -1:
i = self.NetworksTableWidget.item(row, 0)
if i is not None:
self.network = to_unicode(i.text())
log.debug("Selected network SSID: %s" % self.network)
self.n, ok = value_int(i.data(Qt.UserRole))
if ok:
self.security = self.networks['encryptiontype-%d' % self.n]
log.debug("Security: %s" % self.security)
self.mode = self.networks['communicationmode-%d' % self.n]
log.debug("Mode: %s" % self.mode)
self.ss = self.networks['signalstrength-%d' % self.n]
log.debug("Signal strength: %s" % self.ss)
if self.security.lower() != 'none':
self.showConfigWifiPage()
else:
# Skip config page if no security to setup
self.associate()
self.showAssociateProgressDialog()
self.showExitPage()
elif p == PAGE_CONFIGURE_WIFI:
key = to_unicode(self.KeyLineEdit.text())
self.associate(key)
self.showAssociateProgressDialog()
self.showExitPage()
elif p == PAGE_EXIT:
if self.dev is not None:
self.dev.close()
self.close()
else:
log.error("Invalid page!") # shouldn't happen!
def RenameGroupAction_triggered(self):
selected_items = self.GroupTableWidget.selectedItems()
if selected_items:
old_group = to_unicode(selected_items[0].text())
ok = False
new_group, ok = QInputDialog.getText(
self, self.__tr("Rename Group"), "New Name for Group '%s':" % old_group
)
new_group = to_unicode(new_group)
groups = self.db.get_all_groups()
if new_group in groups:
FailureUI(
self,
self.__tr(
"<b>Sorry, the group name cannot be the same as an existing group (or 'All').</b><p>Please choose a different name."
),
)
ok = False
if ok:
self.db.rename_group(old_group, new_group)
log.debug("Rename group %s to %s" % (old_group, new_group))
self.emit(SIGNAL("databaseChanged"), FAB_GROUP_RENAME, old_group, new_group)
self.group = new_group
self.updateGroupList()
def quickAddPushButton_clicked(self):
name = to_unicode(self.quickAddNameLineEdit.text())
self.db.set(name, '', '', '', to_unicode(self.quickAddFaxLineEdit.text()), [], self.__tr('Added with Quick Add'))
self.db.save()
self.addRecipient(name)
self.quickAddNameLineEdit.setText("")
self.quickAddFaxLineEdit.setText("")
def QuickAddButton_clicked(self):
name = to_unicode(self.QuickAddNameEdit.text())
fax = to_unicode(self.QuickAddFaxEdit.text())
self.fab.addName(name, fax)
self.addRecipient(name)
self.updateRecipientTable()
self.QuickAddNameEdit.clear()
self.QuickAddFaxEdit.clear()
self.enableQuickAddButton('', '')
def update_groups(self, group, members):
for e, v in list(self._data.items()):
if v['name'] in members: # membership indicated
if not group in v['groups']:
v['groups'].append(to_unicode(group))
else:
if group in v['groups']:
v['groups'].remove(to_unicode(group))
self.save()
def addName(self, name, fax=""):
if self.group == to_unicode("All"):
g = [to_unicode("All")]
else:
g = [to_unicode("All"), self.group]
self.db.set(name, "", "", "", fax, g, "")
self.name = name
log.debug("New name %s" % self.name)
self.emit(SIGNAL("databaseChanged"), FAB_NAME_ADD, self.name)
self.updateNameList()
def initDB(self):
self.db = fax.FaxAddressBook()
# Fixup data from old-style database
data = self.db.get_all_records()
for d in data:
if to_unicode('All') not in data[d]['groups']:
data[d]['groups'].append(to_unicode('All'))
if not data:
self.db.set('__' + utils.gen_random_uuid(), '', '', '', '', [to_unicode('All')], '')
def initDB(self):
self.db = fax.FaxAddressBook()
# Fixup data from old-style database
data = self.db.get_all_records()
for d in data:
if to_unicode("All") not in data[d]["groups"]:
data[d]["groups"].append(to_unicode("All"))
if not data:
self.db.set("__" + utils.gen_random_uuid(), "", "", "", "", [to_unicode("All")], "")
def validate(self, input_data, pos):
returnCode = QValidator.Invalid
input_data = to_unicode(input_data)
if not input_data:
returnCode = QValidator.Acceptable
elif input_data[pos-1] not in to_unicode('0123456789-(+).,#* '):
returnCode = QValidator.Invalid
else:
returnCode = QValidator.Acceptable
return returnCode, input_data, pos
def load(self):
log.debug("Loading user settings...")
self.sync()
self.beginGroup("settings")
self.systray_visible = value_int(self.value("systray_visible"))[0]
self.systray_messages = value_int(self.value("systray_messages"))[0]
self.endGroup()
self.beginGroup("last_used")
self.last_used_device_uri = value_str(self.value("device_uri")) or self.last_used_device_uri
self.last_used_printer = value_str(self.value("printer_name")) or self.last_used_printer
self.working_dir = value_str(self.value("working_dir")) or self.working_dir
self.endGroup()
self.beginGroup("commands")
self.cmd_scan = value_str(self.value("scan")) or self.cmd_scan
self.endGroup()
self.beginGroup("refresh")
self.auto_refresh_rate = value_int(self.value("rate"))[0] or int(self.auto_refresh_rate)
self.auto_refresh = value_bool(self.value("enable"))
self.auto_refresh_type = value_int(self.value("type"))[0] or int(self.auto_refresh_type)
self.endGroup()
self.beginGroup("installation")
self.version = value_str(self.value("version"))
self.date_time = value_str(self.value("date_time"))
self.endGroup()
self.beginGroup("polling")
self.polling = value_bool(self.value("enable"))
self.polling_interval = value_int(self.value("interval"))[0] or int(self.polling_interval)
self.polling_device_list = to_unicode(value_str(self.value("device_list"))).split(to_unicode(','))
self.endGroup()
self.beginGroup("fax")
self.voice_phone = value_str(self.value("voice_phone"))
self.email_address = to_unicode(value_str(self.value("email_address")))
self.endGroup()
self.beginGroup("upgrade")
self.upgrade_notify= value_bool(self.value("notify_upgrade"))
self.latest_available_version=value_str(self.value("latest_available_version"))
self.upgrade_last_update_time = value_int(self.value("last_upgraded_time"))[0]
self.upgrade_pending_update_time = value_int(self.value("pending_upgrade_time"))[0]
self.endGroup()
def GroupTableWidget_itemSelectionChanged(self):
if not self.updating_group:
selected_items = self.GroupTableWidget.selectedItems()
if selected_items:
self.group = to_unicode(selected_items[0].text())
self.RemoveGroupAction.setEnabled(self.group != to_unicode("All"))
self.RenameGroupAction.setEnabled(self.group != to_unicode("All"))
else: # shouldn't happen?!
self.RemoveGroupAction.setEnabled(False)
self.RenameGroupAction.setEnabled(False)
self.group = None
self.updateNameList()
def getDlgData(self):
group_name = to_unicode(self.groupnameEdit.text())
entries = []
i = self.entriesListView.firstChild()
while i is not None:
if i.isOn():
entries.append(to_unicode(i.text()))
i = i.itemBelow()
return group_name, entries
def validate(self, input_data, pos):
returnCode = QValidator.Invalid
input_data = to_unicode(input_data)
if not input_data:
returnCode = QValidator.Acceptable
elif input_data in self.db.get_all_names():
returnCode = QValidator.Invalid
elif input_data[pos-1] in to_unicode('''|\\/"'''): # | is the drag 'n drop separator
returnCode = QValidator.Invalid
else:
returnCode = QValidator.Acceptable
return returnCode, input_data, pos
def jobStorageUsernameButtonGroup_clicked(self, a):
if a == 0: # Automatic
self.jobStorageUsernameDefaultPushButton.setEnabled(False)
self.jobStorageUsernameEdit.setEnabled(False)
self.job_storage_auto_username = True
self.job_storage_username = to_unicode(prop.username[:16])
self.setPrinterOptionUsername()
else: # Custom
self.jobStorageUsernameDefaultPushButton.setEnabled(True)
self.jobStorageUsernameEdit.setEnabled(True)
self.job_storage_auto_username = False
self.job_storage_username = to_unicode(self.jobStorageUsernameEdit.text())
self.setPrinterOptionUsername()
def showCoverPageDlg(self):
dlg = CoverpageForm(self.cover_page_name, self.preserve_formatting, parent=self)
dlg.messageTextEdit.setText(self.cover_page_message)
dlg.regardingTextEdit.setText(self.cover_page_re)
if dlg.exec_loop() == QDialog.Accepted:
self.cover_page_func, cover_page_png = dlg.data
self.cover_page_message = to_unicode(dlg.messageTextEdit.text())
self.cover_page_re = to_unicode(dlg.regardingTextEdit.text())
self.cover_page_name = dlg.coverpage_name
self.preserve_formatting = dlg.preserve_formatting
return True
return False
def addFile_clicked(self):
dlg = QFileDialog(user_conf.workingDirectory(), QString.null, None, None, True)
dlg.setCaption("openfile")
dlg.setMode(QFileDialog.ExistingFile)
dlg.show()
if dlg.exec_loop() == QDialog.Accepted:
results = dlg.selectedFile()
working_directory = to_unicode(dlg.dir().absPath())
# log.debug("results: %s" % unicode(results))
user_conf.setWorkingDirectory(working_directory)
if results:
self.addFile(to_unicode(results))
def NewGroupAction_triggered(self):
ok = False
g, ok = QInputDialog.getText(self, self.__tr("Enter New Group Name"), self.__tr("Name for New Group:"))
g = to_unicode(g)
if g == to_unicode('All'):
FailureUI(self, self.__tr("<b>Sorry, the group name cannot be 'All'.</b><p>Please choose a different name."))
ok = False
if ok:
self.db.set('__' + utils.gen_random_uuid(), '', '', '', '', [to_unicode('All'), g], '')
self.group = g
log.debug("New empty group %s" % self.group)
self.emit(SIGNAL("databaseChanged"), FAB_GROUP_ADD, self.group)
self.updateGroupList()
def UnloadDirectoryEdit_textChanged(self, dir):
self.unload_dir = to_unicode(dir)
if not os.path.exists(self.unload_dir):
self.UnloadDirectoryEdit.setPaletteBackgroundColor(QColor(0xff, 0x99, 0x99))
else:
self.UnloadDirectoryEdit.setPaletteBackgroundColor(self.bg)
def CheckOKButton(self, nickname=None, fax=None):
if nickname is None:
nickname = to_unicode(self.nicknameEdit.text())
if fax is None:
fax = to_unicode(self.faxEdit.text())
ok = bool(len(nickname) and len(fax))
if nickname:
all_entries = db.get_all_records()
for e, v in list(all_entries.items()):
if nickname == e and nickname != self.initial_nickname:
ok = False
self.OKButton.setEnabled(ok)
def onPrinterChange(self, printer_name):
if printer_name == self.cur_printer or printer_name is None:
return
self.cur_printer = to_unicode(printer_name)
if self.cur_device is not None and self.cur_device.supported:
#self.isFax()
QApplication.setOverrideCursor(QApplication.waitCursor)
try:
if 1:
#try:
self.fillControls()
#except Exception, e:
# log.exception()
finally:
QApplication.restoreOverrideCursor()
if self.cur_printer is not None:
try:
self.printerComboBox.setCurrentText(self.cur_printer)
except AttributeError:
pass
else:
self.y = 0
self.clear()
def addGroupHeading(self, group, heading, read_only=False):
widget = self.getWidget()
widget.setMinimumHeight(30)
layout = QGridLayout(widget, 0, 0, 5, 0, "layout")
textLabel2 = QLabel(widget, "textLabel2")
textLabel2.setSizePolicy(QSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum, 0, 0,
textLabel2.sizePolicy().hasHeightForWidth()))
if log.is_debug():
textLabel2.setFrameShape(self.frame_shape)
elif heading:
textLabel2.setFrameShape(QFrame.TabWidgetPanel)
textLabel2.setPaletteBackgroundColor(self.heading_color)
if read_only:
s = self.__tr("<b>%1 (read only)</b>").arg(heading) # <nobr>
else:
s = QString("<b>%1</b>").arg(heading)
# If label is kinda long, provide a tooltip to allow reading the whole thing
if s.length() > 32:
QToolTip.add(textLabel2, s)
textLabel2.setText(s)
textLabel2.setAlignment(QLabel.AlignLeft | QLabel.AlignVCenter | Qt.SingleLine)
layout.addWidget(textLabel2, 0, 0)
self.addWidget(widget, "g:"+to_unicode(group))
def ImportAction_triggered(self):
result = str(
QFileDialog.getOpenFileName(
self,
self.__tr("Import fax addresses from LDIF or vCard"),
# user_conf.workingDirectory(),
self.user_settings.working_dir,
"vCard (*.vcf);;LDIF (*.ldif *.ldi)",
)
)
if result:
working_directory = to_unicode(os.path.dirname(result))
log.debug("result: %s" % result)
# user_conf.setWorkingDirectory(working_directory)
self.user_settings.working_dir = working_directory
self.user_settings.save()
if result:
if result.endswith(".vcf"):
ok, error_str = self.db.import_vcard(result)
else:
ok, error_str = self.db.import_ldif(result)
if not ok:
FailureUI(self, error_str)
else:
self.updateUi()
def DevicesButtonGroup_clicked(self,a0):
for p in self.printer_index:
pp = self.printer_index[p]
if to_unicode(self.radio_buttons[a0].text()).startswith(pp[0]):
self.device_uri = pp[1]
self.printer_name = pp[0]
break
def faxNameLineEdit_textChanged(self, a0):
self.fax_name = to_unicode(a0)
self.defaultFaxNamePushButton.setEnabled(True)
self.fax_name_ok = True
if not self.fax_name:
QToolTip.add(self.faxNameLineEdit, self.__tr("You must enter a fax name."))
self.fax_name_ok = False
elif self.fax_name == self.printer_name:
s = self.__tr("The printer name and fax name must be different. Please choose different names.")
QToolTip.add(self.faxNameLineEdit, s)
QToolTip.add(self.printerNameLineEdit, s)
self.printer_name_ok = False
self.fax_name_ok = False
self.printer_fax_names_same = True
elif self.fax_name in self.installed_queues:
QToolTip.add(
self.faxNameLineEdit, self.__tr("A fax already exists with this name. Please choose a different name.")
)
self.fax_name_ok = False
elif self.printer_fax_names_same:
if self.fax_name != self.printer_name:
self.printer_fax_names_same = False
self.fax_name_ok = True
self.printerNameLineEdit.emit(SIGNAL("textChanged(const QString&)"), (self.printerNameLineEdit.text(),))
self.setEditErrors()
def updateUi(self):
if self.devices is None:
num_devices = self.setDevices()
self.device_index = {}
if self.devices:
if self.initial_device is None:
#self.initial_device = user_conf.get('last_used', 'device_uri')
self.initial_device = self.user_settings.last_used_device_uri
self.updating = True
try:
k = 0
str_devices = list(self.devices.keys())
d = to_unicode(str_devices[0])
for i in range(0, num_devices):
self.ComboBox.insertItem(str_devices[i], i)
if self.initial_device is not None and d == self.initial_device:
self.initial_device = None
k = i
self.ComboBox.setCurrentItem(-1)
finally:
self.updating = False
self.ComboBox.setCurrentItem(k)
else:
self.parent.DeviceUriComboBox_noDevices()
def associate(self, key=to_unicode('')):
beginWaitCursor()
try:
try:
alg, mode, secretid = self.wifiObj.getCryptoSuite(self.dev, self.adapterName)
except Error as e:
self.showIOError(e)
return
log.debug("Crypto algorithm: %s" % alg)
log.debug("Crypto mode: %s" % mode)
finally:
endWaitCursor()
beginWaitCursor()
try:
try:
self.wifiObj.associate(self.dev, self.adapterName, self.network, self.mode, self.security, key)
except Error as e:
self.showIOError(e)
return
finally:
endWaitCursor()
def ComboBox_indexChanged(self, currentItem):
sender = self.sender()
currentItem = to_unicode(currentItem)
# Checking for summary control
labelPQValaue = getattr(self, 'PQValueLabel', None)
labelPQColorInput = getattr(self, 'PQColorInputLabel', None)
# When output mode combo item is changed, we need to update the summary information
if currentItem is not None and sender.option == 'OutputMode' and labelPQValaue is not None and labelPQColorInput is not None:
# Setting output mode
self.PQValueLabel.setText(currentItem)
# Getting DPI custom attributefrom the PPD
# Setting color input
quality_attr_name = "OutputModeDPI"
cups.openPPD(self.cur_printer)
outputmode_dpi = cups.findPPDAttribute(quality_attr_name,
currentItem)
log.debug("Outputmode changed, setting outputmode_dpi: %s" %
outputmode_dpi)
cups.closePPD()
self.PQColorInputLabel.setText(outputmode_dpi)
log.debug("Outputmode changed, setting value outputmode: %s" %
currentItem)
def FaxNumberLineEdit_editingFinished(self):
if self.name is not None:
self.db.set_key_value(self.name, 'fax',
to_unicode(self.FaxNumberLineEdit.text()))
self.databaseChanged.emit(FAB_NAME_DETAILS_CHANGED, self.name)
def delete_group(self, group):
for e, v in list(self._data.items()):
if group in v['groups']:
v['groups'].remove(to_unicode(group))
self.save()
def mimeData(self, items):
data = QMimeData()
data.setText(
to_unicode('|').join([to_unicode(i.text()) for i in items]))
return data
def VoiceNumberLineEdit_editingFinished(self):
self.saveVoiceNumber(to_unicode(self.VoiceNumberLineEdit.text()))
def MessageEdit_textChanged(self):
self.cover_page_message = to_unicode(self.MessageEdit.toPlainText())
def load(self):
log.debug("Loading user settings...")
self.sync()
self.beginGroup("settings")
self.systray_visible = value_int(self.value("systray_visible"))[0]
self.systray_messages = value_int(self.value("systray_messages"))[0]
self.endGroup()
self.beginGroup("last_used")
self.last_used_device_uri = value_str(
self.value("device_uri")) or self.last_used_device_uri
self.last_used_printer = value_str(
self.value("printer_name")) or self.last_used_printer
self.working_dir = value_str(
self.value("working_dir")) or self.working_dir
self.endGroup()
self.beginGroup("commands")
self.cmd_scan = value_str(self.value("scan")) or self.cmd_scan
self.endGroup()
self.beginGroup("refresh")
self.auto_refresh_rate = value_int(self.value("rate"))[0] or int(
self.auto_refresh_rate)
self.auto_refresh = value_bool(self.value("enable"))
self.auto_refresh_type = value_int(self.value("type"))[0] or int(
self.auto_refresh_type)
self.endGroup()
self.beginGroup("installation")
self.version = value_str(self.value("version"))
self.date_time = value_str(self.value("date_time"))
self.endGroup()
self.beginGroup("polling")
self.polling = value_bool(self.value("enable"))
self.polling_interval = value_int(self.value("interval"))[0] or int(
self.polling_interval)
self.polling_device_list = to_unicode(
value_str(self.value("device_list"))).split(to_unicode(','))
self.endGroup()
self.beginGroup("fax")
self.voice_phone = value_str(self.value("voice_phone"))
self.email_address = to_unicode(value_str(self.value("email_address")))
self.endGroup()
self.beginGroup("upgrade")
self.upgrade_notify = value_bool(self.value("notify_upgrade"))
self.latest_available_version = value_str(
self.value("latest_available_version"))
self.upgrade_last_update_time = value_int(
self.value("last_upgraded_time"))[0]
self.upgrade_pending_update_time = value_int(
self.value("pending_upgrade_time"))[0]
self.endGroup()
for a in all_entries:
aa = db.get(a)
log.info("%s (fax number: %s)" % (a, aa['fax']))
print()
sys.exit(1)
for p in recipient_list:
a = db.get(p)
if a['fax']:
phone_num_list.append(a)
log.debug("Name=%s Number=%s" % (a['name'], a['fax']))
for p in faxnum_list:
phone_num_list.append({'fax': p, 'name': to_unicode('Unknown')})
log.debug("Number=%s" % p)
log.debug("Phone num list = %s" % phone_num_list)
if not phone_num_list:
mod.usage(error_msg=["No recipients specified. Please use -f, -r, and/or -g to specify recipients."])
allowable_mime_types = cups.getAllowableMIMETypes()
# stat = ''
# try :
# p = subprocess.Popen('getenforce', stdout=subprocess.PIPE, stderr=subprocess.PIPE)
# stat, err = p.communicate()
# stat = to_string_utf8(stat)
# except OSError :
def getCurrentRecipient(self):
item = self.RecipientsTable.item(self.RecipientsTable.currentRow(), 0)
if item is not None:
return to_unicode(item.text())
else:
return to_unicode('')
def AddGroupButton_clicked(self):
self.addGroup(to_unicode(self.AddGroupComboBox.currentText()))
def AddIndividualButton_clicked(self):
self.addRecipient(to_unicode(self.AddIndividualComboBox.currentText()))
def QuickAddNameEdit_textChanged(self, name):
self.enableQuickAddButton(to_unicode(name))
def QuickAddFaxEdit_textChanged(self, fax):
self.enableQuickAddButton(None, to_unicode(fax))
def RegardingEdit_textChanged(self, t):
self.cover_page_re = to_unicode(t)
def NotesTextEdit_textChanged(self):
if self.name is not None:
self.db.set_key_value(
self.name, 'notes',
to_unicode(self.NotesTextEdit.document().toPlainText()))
def GroupJoinComboBox_currentIndexChanged(self, i):
self.group = to_unicode(self.GroupJoinComboBox.currentText())
def loadNetworksTable(self):
self.n, self.network = 0, to_unicode('')
if self.num_networks:
beginWaitCursor()
try:
if self.show_extended:
for n in range(self.num_networks):
bssid = self.networks['bssid-%d' % n]
ss = self.networks['signalstrength-%d' % n]
try:
self.location_cache[bssid]
except KeyError:
location = wifi.getLocation(bssid, ss)
lat = self.networks['latitude-%d' % n] = location.get('latitude', 'Unknown')
lng = self.networks['longitude-%d' % n] = location.get('longitude', 'Unknown')
address = self.networks['address-%d' % n] = location.get('address', 'Unknown')
self.location_cache[bssid] = (lat, lng, address)
else:
self.networks['latitude-%d' % n], self.networks['longitude-%d' % n], self.networks['address-%d' % n] = \
self.location_cache[bssid]
self.NetworksTableWidget.setSortingEnabled(False)
self.NetworksTableWidget.setRowCount(self.num_networks)
headers = [self.__tr('Network Name (SSID)'), self.__tr('Signal Strength'),
self.__tr("Security"), self.__tr("Mode")]
if self.show_extended:
headers.extend([self.__tr('Channel'),
self.__tr("Address (BSSID)"), self.__tr("Location"),
self.__tr("Lat/Long")])
self.NetworksTableWidget.setColumnCount(len(headers))
self.NetworksTableWidget.setHorizontalHeaderLabels(headers)
enabled_flags = Qt.ItemIsSelectable | Qt.ItemIsEnabled
for n in range(self.num_networks):
name = self.networks['ssid-%d' % n]
if name == '(unknown)':
flags = None
else:
flags = enabled_flags
ss = self.networks['signalstrength-%d' % n]
sec = self.networks['encryptiontype-%d' % n]
mode = self.networks['communicationmode-%d' % n]
log.debug("%d: Name=%s, strength=%s, security=%s, mode=%s" % #, channel=%d bssid=%s" %
(n, name, ss, sec, mode))
if self.show_extended:
chn = self.networks['channel-%d' % n]
dbm = self.networks['dbm-%d' % n]
bssid = self.networks['bssid-%d' % n]
address = self.networks['address-%d' % n]
lat = self.networks['latitude-%d' % n]
lng = self.networks['longitude-%d' % n]
log.debug("%d: channel=%d bssid=%s dbm=%s lat=%s long=%s address=%s" %
(n, chn, bssid, dbm, lat, lng, address))
i = QTableWidgetItem(str(name))
if flags is not None: i.setFlags(flags)
i.setData(Qt.UserRole, n)
self.NetworksTableWidget.setItem(n, 0, i)
pixmap = load_pixmap('signal%d' % ss, 'other')
if self.show_extended:
i = QTableWidgetItem(QIcon(pixmap), self.__tr("%s/5 (%s dBm)" %(ss, dbm)))
else:
i = QTableWidgetItem(QIcon(pixmap), self.__tr("%s/5" % ss))
if flags is not None: i.setFlags(flags)
self.NetworksTableWidget.setItem(n, 1, i)
i = QTableWidgetItem(str(sec))
if flags is not None: i.setFlags(flags)
self.NetworksTableWidget.setItem(n, 2, i)
i = QTableWidgetItem(str(mode))
if flags is not None: i.setFlags(flags)
self.NetworksTableWidget.setItem(n, 3, i)
if self.show_extended:
i = QTableWidgetItem(str(str(chn)))
if flags is not None: i.setFlags(flags)
self.NetworksTableWidget.setItem(n, 4, i)
i = QTableWidgetItem(str(bssid))
if flags is not None: i.setFlags(flags)
self.NetworksTableWidget.setItem(n, 5, i)
i = QTableWidgetItem(str(address))
if flags is not None: i.setFlags(flags)
self.NetworksTableWidget.setItem(n, 6, i)
i = QTableWidgetItem(str("%s/%s" % (lat, lng)))
if flags is not None: i.setFlags(flags)
self.NetworksTableWidget.setItem(n, 7, i)
self.NetworksTableWidget.resizeColumnsToContents()
self.NetworksTableWidget.setSortingEnabled(True)
self.NetworksTableWidget.sortItems(1, Qt.DescendingOrder)
self.NetworksTableWidget.selectRow(0)
# itemSelectionChanged = pyqtSignal()
# self.NetworksTableWidget.emit(SIGNAL("itemSelectionChanged()"))
self.NetworksTableWidget.itemSelectionChanged.emit()
finally:
endWaitCursor()
self.NextButton.setEnabled(True)
else:
self.NextButton.setEnabled(False)
def endDeskjet450Page(self):
self.value = int(to_unicode(self.Deskjet450ComboBox.currentText()))
def NameCompanyLineEdit_editingFinished(self):
self.saveNameCompany(to_unicode(self.NameCompanyLineEdit.text()))
def getStationName(self):
return to_unicode(
self.readAttributeFromXml(
"/DevMgmt/FaxConfigDyn.xml",
'faxcfgdyn:faxconfigdyn-faxcfgdyn:systemsettings-dd:companyname'
))
def updateInfoTable(self):
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
self.DynamicTableWidget.clear()
self.DynamicTableWidget.setRowCount(0)
self.DynamicTableWidget.setColumnCount(0)
flags = Qt.ItemIsSelectable | Qt.ItemIsEnabled
while self.TabWidget.count() > 3:
self.TabWidget.removeTab(3)
self.DynamicTableWidget.clear()
self.DynamicTableWidget.setRowCount(0)
self.DynamicTableWidget.setColumnCount(len(self.headers))
self.DynamicTableWidget.setHorizontalHeaderLabels(self.headers)
#
# Static Data
#
try:
d = device.Device(self.device_uri, None)
except Error:
QApplication.restoreOverrideCursor()
FailureUI(
self,
self.__tr("<b>Unable to open device %s.</b>" %
(self.device_uri)))
#self.close()
return
self.StaticTableWidget.clear()
self.StaticTableWidget.setColumnCount(len(self.headers))
self.StaticTableWidget.setHorizontalHeaderLabels(self.headers)
mq_keys = list(d.mq.keys())
mq_keys.sort()
self.StaticTableWidget.setRowCount(len(mq_keys))
for row, key in enumerate(mq_keys):
i = QTableWidgetItem(str(key))
i.setFlags(flags)
self.StaticTableWidget.setItem(row, 0, i)
i = QTableWidgetItem(str(d.mq[key]))
i.setFlags(flags)
self.StaticTableWidget.setItem(row, 1, i)
self.StaticTableWidget.resizeColumnToContents(0)
self.StaticTableWidget.resizeColumnToContents(1)
self.StaticTableWidget.setSortingEnabled(True)
self.StaticTableWidget.sortItems(0)
#
# Dynamic Data
#
try:
try:
d.open()
d.queryDevice()
except Error as e:
QApplication.restoreOverrideCursor()
FailureUI(
self,
self.__tr("<b>Unable to open device %s.</b>" %
(self.device_uri)))
#self.close()
return
dq_keys = list(d.dq.keys())
dq_keys.sort()
self.DynamicTableWidget.setRowCount(len(dq_keys))
for row, key in enumerate(dq_keys):
i = QTableWidgetItem(str(key))
i.setFlags(flags)
self.DynamicTableWidget.setItem(row, 0, i)
i = QTableWidgetItem(str(d.dq[key]))
i.setFlags(flags)
self.DynamicTableWidget.setItem(row, 1, i)
self.DynamicTableWidget.resizeColumnToContents(0)
self.DynamicTableWidget.resizeColumnToContents(1)
self.DynamicTableWidget.setSortingEnabled(True)
self.DynamicTableWidget.sortItems(0)
finally:
d.close()
#
# History Table
#
self.HistoryTableWidget.clear()
self.HistoryTableWidget.setRowCount(0)
if d.device_type == DEVICE_TYPE_FAX:
self.history_headers[1] = self.__tr("Fax")
else:
self.history_headers[1] = self.__tr("Printer")
self.HistoryTableWidget.setColumnCount(len(self.history_headers))
self.HistoryTableWidget.setHorizontalHeaderLabels(self.history_headers)
history = d.queryHistory()
history.reverse()
self.HistoryTableWidget.setRowCount(len(history))
for row, h in enumerate(history):
dt = QDateTime()
dt.setTime_t(int(h.timedate))
dt = value_str(dt)
ess = device.queryString(h.event_code, 0)
for col, t in enumerate([
dt, h.printer_name,
to_unicode(h.event_code), ess, h.username,
to_unicode(h.job_id), h.title
]):
i = QTableWidgetItem(str(t))
i.setFlags(flags)
self.HistoryTableWidget.setItem(row, col, i)
self.HistoryTableWidget.resizeColumnToContents(0)
self.HistoryTableWidget.resizeColumnToContents(1)
self.HistoryTableWidget.setSortingEnabled(True)
self.HistoryTableWidget.sortItems(0)
#
# Printer Data
#
printers = cups.getPrinters()
for p in printers:
if p.device_uri == self.device_uri:
Tab = QWidget()
Tab.setObjectName(str(p.name))
GridLayout = QGridLayout(Tab)
GridLayout.setObjectName(str("GridLayout-%s" % p.name))
Table = QTableWidget(Tab)
Table.setAlternatingRowColors(True)
Table.setSelectionMode(QAbstractItemView.SingleSelection)
Table.setSelectionBehavior(QAbstractItemView.SelectRows)
Table.setVerticalScrollMode(QAbstractItemView.ScrollPerItem)
Table.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
Table.setGridStyle(Qt.DotLine)
Table.setObjectName(str("Table-%s" % p.name))
GridLayout.addWidget(Table, 0, 0, 1, 1)
self.TabWidget.addTab(Tab, str(p.name))
Table.setColumnCount(len(self.headers))
Table.setHorizontalHeaderLabels(self.headers)
cups.resetOptions()
cups.openPPD(p.name)
current_options = dict(cups.getOptions())
#current_options['cups_error_log_level'] = cups.getErrorLogLevel()
try:
f = open(os.path.expanduser('~/.cups/lpoptions'))
except IOError as e:
log.debug(str(e))
current_options['lpoptions_file_data'] = str("(%s)" %
str(e))
else:
text = f.read()
for d in text.splitlines():
if p.name in d:
current_options['lpoptions_file_data'] = d
break
else:
current_options['lpoptions_file_data'] = self.__tr(
"(no data)")
keys = list(current_options.keys())
keys.sort()
Table.setRowCount(len(keys))
for row, key in enumerate(keys):
i = QTableWidgetItem(str(key))
i.setFlags(flags)
Table.setItem(row, 0, i)
if key == 'printer-state':
state = int(current_options[key])
if state == cups.IPP_PRINTER_STATE_IDLE:
i = QTableWidgetItem(self.__tr("idle (%s)" %
state))
elif state == cups.IPP_PRINTER_STATE_PROCESSING:
i = QTableWidgetItem(
self.__tr("busy/printing (%s)" % state))
elif state == cups.IPP_PRINTER_STATE_STOPPED:
i = QTableWidgetItem(
self.__tr("stopped (%s)" % state))
else:
i = QTableWidgetItem(str(state))
else:
i = QTableWidgetItem(str(current_options[key]))
i.setFlags(flags)
Table.setItem(row, 1, i)
Table.resizeColumnToContents(0)
Table.resizeColumnToContents(1)
Table.setSortingEnabled(True)
Table.sortItems(0)
cups.closePPD()
self.TabWidget.setCurrentIndex(0)
QApplication.restoreOverrideCursor()
def CopyRadioButton_toggled(self, b):
if b:
self.PathLineEdit.setEnabled(True)
self.BrowseToolButton.setEnabled(True)
self.plugin_path = to_unicode(self.PathLineEdit.text())
self.setPathIndicators()
def PathLineEdit_textChanged(self, t):
self.plugin_path = to_unicode(t)
self.setPathIndicators()
def FaxNumberLineEdit_editingFinished(self):
self.saveFaxNumber(to_unicode(self.FaxNumberLineEdit.text()))
def updateUi(self, show_add_file_if_empty=True):
self.FileTable.clear()
self.FileTable.setRowCount(len(self.file_list))
self.FileTable.setColumnCount(0)
if self.file_list:
self.emit(SIGNAL("isNotEmpty"))
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
try:
selected = None
self.FileTable.setColumnCount(len(self.headers))
self.FileTable.setHorizontalHeaderLabels(self.headers)
flags = Qt.ItemIsSelectable | Qt.ItemIsEnabled
for row, f in enumerate(self.file_list):
filename, mime_type, mime_type_desc, title, num_pages = f
col = 0
if self.typ == FILETABLE_TYPE_FAX:
if title:
i = QTableWidgetItem(title)
else:
i = QTableWidgetItem(os.path.basename(filename))
else: # FILETABLE_TYPE_PRINT
# Filename (basename)
i = QTableWidgetItem(os.path.basename(filename))
i.setData(Qt.UserRole, to_unicode(filename))
i.setFlags(flags)
if self.selected_filename is not None and \
self.selected_filename == filename:
selected = i
self.FileTable.setItem(row, col, i)
col += 1
# MIME type
i = QTableWidgetItem(mime_type_desc)
i.setFlags(flags)
self.FileTable.setItem(row, col, i)
col += 1
if self.typ == FILETABLE_TYPE_PRINT:
# path/folder
i = QTableWidgetItem(os.path.dirname(filename))
i.setFlags(flags)
self.FileTable.setItem(row, col, i)
col += 1
if self.typ == FILETABLE_TYPE_FAX:
# num pages
if num_pages < 1:
i = QTableWidgetItem(self.__tr("(unknown)"))
else:
i = QTableWidgetItem(to_unicode(num_pages))
i.setFlags(flags)
self.FileTable.setItem(row, col, i)
col += 1
if self.typ == FILETABLE_TYPE_FAX and log.is_debug():
i = QTableWidgetItem(filename)
i.setFlags(flags)
self.FileTable.setItem(row, col, i)
self.FileTable.resizeColumnsToContents()
if selected is None:
selected = self.FileTable.item(0, 0)
selected.setSelected(True)
self.FileTable.setCurrentItem(selected)
finally:
QApplication.restoreOverrideCursor()
self.RemoveFileButton.setEnabled(True)
self.RemoveFileButton.setIcon(
QIcon(load_pixmap('list_remove', '16x16')))
self.setUpDownButtons()
else:
self.emit(SIGNAL("isEmpty"))
self.RemoveFileButton.setEnabled(False)
self.setUpDownButtons()
if show_add_file_if_empty:
self.AddFileButton.emit(SIGNAL("clicked()"))
def EmailLineEdit_editingFinished(self):
self.saveEmail(to_unicode(self.EmailLineEdit.text()))
def selectByName(self, name):
rows = self.NameTableWidget.rowCount()
for r in range(rows):
i = self.NameTableWidget.item(r, 0)
i.setSelected(name == to_unicode(i.text()))
try:
d.open()
except Error:
log.error("Unable to communicate with the device. Please check the device and try again.")
else:
try:
tries = 0
ok = True
while True:
tries += 1
try:
current_phone_num = str(d.getPhoneNum())
current_station_name = to_unicode(d.getStationName())
except Error:
log.error("Could not communicate with device. Device may be busy. Please wait for retry...")
time.sleep(5)
ok = False
if tries > 12:
break
else:
ok = True
break
if ok:
while True:
if current_phone_num:
def set_key_value(self, name, key, value):
self._data[to_unicode(name)][key] = value
self.save()
