def build_layout(self, model):
self.clear_layout(self.dicts_layout)
label1 = QLabel("")
label1.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
label2 = QLabel(_("DICTS"))
label2.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
label3 = QLabel(_("DICT_FIELDS"))
label3.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
self.dicts_layout.addWidget(label1, 0, 0)
self.dicts_layout.addWidget(label2, 0, 1)
self.dicts_layout.addWidget(label3, 0, 2)
maps = config.get_maps(model['id'])
for i, fld in enumerate(model['flds']):
ord = fld['ord']
name = fld['name']
if maps:
for j, each in enumerate(maps):
if each.get('fld_ord', -1) == ord:
self.add_dict_layout(j,
fld_name=name,
word_checked=each['word_checked'],
dict=each['dict'],
dict_field=each['dict_field'],
dict_path=each.get(
'dict_path', ''))
break
else:
self.add_dict_layout(i, fld_name=name)
else:
self.add_dict_layout(i, fld_name=name)
self.setLayout(self.main_layout)
def on_action_enable_share(self):
if not self.cap_screen:
return
self.ipc = Ipc(self.on_rpc_event)
ret, share_id = self.ipc.producer_init(config.REDIS_HOST, config.REDIS_PORT, config.REDIS_DB)
if not ret:
QtWidgets.QMessageBox.critical(
self, _(config.TITLE_ERROR),
_("Fail to connect redis server\n%s:%d" % (config.REDIS_HOST, config.REDIS_PORT)))
self.ipc = None
return
# 若定时器未初始化过，则先初始化并绑定信号槽
if self.frame_timer is None:
self.frame_timer = QtCore.QTimer()
self.frame_timer.timeout.connect(self.update_frame_in_timer)
self.frame_queue.clear()
self.frame_timer.start(10)
self.set_tip_message(_("Sharing with ID: %d") % share_id)
self.ipc.start()
self.ui.actionShare.setText(_("Disable share"))
def build(self):
layout = QVBoxLayout()
btn_layout = QHBoxLayout()
add_btn = QPushButton("+")
remove_btn = QPushButton("-")
btn_layout.addWidget(add_btn)
btn_layout.addWidget(remove_btn)
add_btn.clicked.connect(self.add_folder)
remove_btn.clicked.connect(self.remove_folder)
self.folders_lst = QListWidget()
self.folders_lst.addItems(config.get_dirs())
self.chk_use_filename = QCheckBox(_('CHECK_FILENAME_LABEL'))
self.chk_export_media = QCheckBox(_('EXPORT_MEDIA'))
self.chk_use_filename.setChecked(config.use_filename())
self.chk_export_media.setChecked(config.export_media())
chk_layout = QHBoxLayout()
chk_layout.addWidget(self.chk_use_filename)
chk_layout.addWidget(self.chk_export_media)
btnbox = QDialogButtonBox(QDialogButtonBox.Ok, Qt.Horizontal, self)
btnbox.accepted.connect(self.accept)
layout.addLayout(btn_layout)
layout.addWidget(self.folders_lst)
layout.addLayout(chk_layout)
layout.addWidget(btnbox)
self.setLayout(layout)
def on_action_start_recorder(self):
if len(self.record_frames) > 0:
QtWidgets.QMessageBox.critical(
self, _(config.TITLE_INFO),
_("Please try after current video been saved"))
return
self.record_timer.start(config.MAX_RECORD_MIN * 60 * 1000)
self.recording = True
self.set_tip_message(_("Recording (time limit %d min)...") % config.MAX_RECORD_MIN)
mp4file = os.path.join(config.VIDEO_DIR, time.strftime("%y-%m-%d/%H-%M-%S.mp4"))
_dir = os.path.dirname(mp4file)
if not os.path.exists(_dir):
try:
os.makedirs(_dir)
except OSError as err:
logger.error("fail to create video path: %s" % err)
mp4file = "tmp.mp4"
orientation = self.ui.screen.get_orientation()
if orientation == self.ui.screen.VERTICAL:
logger.debug("VERTICAL recorder")
width, height = self.mini_cap_head.virtual_width, self.mini_cap_head.virtual_height
else:
logger.debug("HORIZONTAL recorder")
width, height = self.mini_cap_head.virtual_height, self.mini_cap_head.virtual_width
recorder.init(mp4file, 40, width, height)
self.record_frames = []
self.ui.actionRecorder.setText(_("Stop video recorder ..."))
def query_from_menu():
browser = context['browser']
if not browser:
return
notes = [browser.mw.col.getNote(note_id)
for note_id in browser.selectedNotes()]
if len(notes) == 0:
return
if len(notes) == 1:
context['editor'] = browser.editor
query_from_editor()
if len(notes) > 1:
fields_number = 0
update_progress_label.kwargs = defaultdict(str)
mw.progress.start(immediate=True, label="Querying...")
for i, note in enumerate(notes):
word_ord, word, maps = inspect_note(note)
if not word:
continue
results = query_all_flds(word_ord, word, maps)
for j, q in results.items():
if not isinstance(q, QueryResult):
continue
update_note_field(note, j, q)
# note.flush()
fields_number += len(results)
update_progress_label(
{'words_number': i + 1, 'fields_number': fields_number})
browser.model.reset()
mw.progress.finish()
# browser.model.reset()
# browser.endReset()
tooltip(u'%s %d %s' % (_('UPDATED'), len(notes), _('CARDS')))
def on_action_send_text(self):
"""向设备发送文本"""
if not self.cap_screen:
return
text, ret = QtWidgets.QInputDialog.getText(self, _("Send text"), _("Please input the content"))
if not ret:
return
self.cap_screen.touch.send_text(text)
def on_rotation_changed(self, angle, virtual_width=config.DEFAULT_WIDTH):
logger.debug("on_rotation_changed. angle={}".format(angle))
self.angle = angle
if self.cap_screen:
self.cap_screen.stop()
adb_helper.restart_mini_cap(angle=angle, virtual_width=virtual_width)
self.ui.screen.set_orientation(angle)
self.show_starting_dialog(title=_("Rotating"), text=_("Adapting screen rotation, wait about 3 seconds"),
cap_start=True)
def on_start_result(self, ret):
if ret == 0:
self.update_ui_on_started()
else:
self.dismiss_starting_dialog()
QtWidgets.QMessageBox.critical(
self, _(config.TITLE_ERROR),
_("Connect failed, please retry after reset your USB line"))
self.close()
def update_progress_label(info):
update_progress_label.kwargs.update(info)
words_number, fields_number = update_progress_label.kwargs.get(
'words_number', 0), update_progress_label.kwargs.get('fields_number', 0)
number_info = '<br>%s %d %s, %d %s' % (_('QUERIED'), words_number, _(
'WORDS'), fields_number, _('FIELDS')) if words_number and fields_number else ""
mw.progress.update(label="Querying <b>%s</b>...<br>[%s] %s%s" % (
update_progress_label.kwargs[
'word'], update_progress_label.kwargs['service_name'],
update_progress_label.kwargs['field_name'], number_info))
def on_action_remote_screen(self):
if self.share_proc:
return self.on_disconnect_remote_screen()
share_id, ret = QtWidgets.QInputDialog.getInt(
self, _("Remote share"), _("Please input your share id"), value=Ipc.MIN_SHARE_ID)
if not ret:
return
frame_queue, tmp = Ipc.make_queue(share_id)
self.share_val.value = 0
self.share_proc = multiprocessing.Process(target=remote_screen.start, args=(self.share_val, frame_queue, ))
self.share_proc.start()
Toast.show_(self, _("Remote screen started, waiting frame ..."))
logger.debug("remote screen started, pid: %d" % self.share_proc.pid)
self.ui.actionRemote_screen.setText(_("Disconnect remote screen..."))
def __init__(self, parent=None):
QtWidgets.QMainWindow.__init__(self, parent)
self.ui = Ui_MainWindow()
self.setup_ui()
self.ui.screen.set_disconnect_callback(self.on_disconnected)
self.setup_signal()
self.cap_screen = None
self.queue = multiprocessing.Queue()
self.starting_dialog = None
self.timer = None
self.check_code = -1
self.recording = False
self.record_frames = []
self.record_timer = QtCore.QTimer()
self.record_timer.timeout.connect(self.on_record_timeout)
self.mini_cap_head = None
self.ipc = None
# 是否连接过本地手机
self.cap_used = False
self.is_first_start = True
self.customer_running = False
self.device_name = ""
self.angle = 0
self.virtual_width = config.DEFAULT_WIDTH
self.rotation_watcher = None
self.share_proc = None
self.share_val = multiprocessing.Value("i", 0)
self.frame_timer = None
self.frame_queue = deque()
self.donate_scene = QtWidgets.QGraphicsScene(self)
self.donate_view = QtWidgets.QGraphicsView(self.donate_scene)
self.donate_view.setWindowTitle(_("Donate"))
self.donate_scene.addItem(QtWidgets.QGraphicsPixmapItem(QtGui.QPixmap(":/app/icons/app/donate.jpg")))
def save_task(frames):
recorder.write_frames(frames)
mp4file = recorder.finish()
self.set_tip_message("%s" % mp4file.replace("\\", "/"))
self.record_frames = []
self.ui.actionRecorder.setEnabled(not self.recording)
self.ui.actionRecorder.setText(_("Start video recorder ..."))
def query_from_editor():
editor = context['editor']
if not editor:
return
word, word_ord = None, 0
fld_index = editor.currentField
word_ord, word, maps = inspect_note(editor.note)
if not word:
showInfo(_("NO_QUERY_WORD"))
return
mw.progress.start(immediate=True, label="Querying...")
update_progress_label.kwargs = defaultdict(str)
# if the focus falls into the word field, then query all note fields,
# else only query the current focused field.
if fld_index == word_ord:
results = query_all_flds(word_ord, word, maps)
# showText(str(results))
for i, q in results.items():
if not isinstance(q, QueryResult):
continue
update_note_field(editor.note, i, q)
else:
q = query_single_fld(word, fld_index, maps)
if not isinstance(q, QueryResult):
return
update_note_field(editor.note, fld_index, q)
# editor.note.flush()
# showText(str(editor.note.model()['tmpls']))
mw.progress.finish()
editor.setNote(editor.note, focus=True)
editor.saveNow()
def add_dict_layout(self, i, **kwargs):
"""
kwargs:
word_checked dict fld_name dict_field
"""
word_checked, dict_name, dict_path, fld_name, dict_field = kwargs.get(
'word_checked',
False), kwargs.get('dict', _('NOT_DICT_FIELD')), kwargs.get(
'dict_path', ''), kwargs.get('fld_name',
''), kwargs.get('dict_field', '')
fldname_label = QRadioButton(fld_name)
fldname_label.setMinimumSize(100, 0)
fldname_label.setMaximumSize(100, 30)
fldname_label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
fldname_label.setCheckable(True)
fldname_label.clicked.connect(self.radio_btn_checked)
fldname_label.setChecked(word_checked)
dict_combo = QComboBox()
dict_combo.setMinimumSize(130, 0)
dict_combo.setFocusPolicy(0x1 | 0x2 | 0x8 | 0x4)
dict_combo.setEnabled(not word_checked)
dict_combo.currentIndexChanged.connect(
self.dict_combobox_index_changed)
self.fill_dict_combo_options(dict_combo)
self.set_combo_options(dict_combo, dict_name)
# dict_combo.activated.connect(self.dict_combobox_activated)
field_combo = QComboBox()
field_combo.setMinimumSize(130, 0)
# field_combo.setMaximumSize(130, 30)
field_combo.setEnabled((not word_checked)
and (dict_name != _('NOT_DICT_FIELD')))
field_combo.setEditable(True)
field_combo.setEditText(dict_field)
self.fill_field_combo_options(field_combo, dict_name, dict_path)
# self.connect(dict_check, SIGNAL("clicked()"),
# self.signal_mapper_chk, SLOT("map()"))
# self.signal_mapper_chk.setMapping(dict_check, i)
# self.dicts_layout.addWidget(dict_check, i, 0)
self.dicts_layout.addWidget(fldname_label, i + 1, 0)
self.dicts_layout.addWidget(dict_combo, i + 1, 1)
self.dicts_layout.addWidget(field_combo, i + 1, 2)
self.setLayout(self.main_layout)
def radio_btn_checked(self):
rbs = self.findChildren(QRadioButton)
dict_cbs, fld_cbs = self._get_combos(2)
for i, rb in enumerate(rbs):
dict_cbs[i].setEnabled(not rb.isChecked())
fld_cbs[i].setEnabled(
(dict_cbs[i].currentText() != _('NOT_DICT_FIELD'))
and (not rb.isChecked()))
def __init__(self):
self.win = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.win.connect("destroy", lambda w : gtk.main_quit())
self.fixed = gtk.Fixed()
self.ok_btn = gtk.Button(_(0))
self.can_btn = gtk.Button(_(1))
self.en_btn = gtk.Button("替换英文")
self.en_btn.connect("clicked", self.en_btn_clicked)
self.cn_btn = gtk.Button("替换成中文")
self.cn_btn.connect("clicked", self.cn_btn_clicked)
self.fixed.put(self.ok_btn, 50, 50)
self.fixed.put(self.can_btn, 150, 50)
self.fixed.put(self.en_btn, 250, 50)
self.fixed.put(self.cn_btn, 380, 50)
self.win.add(self.fixed)
self.win.show_all()
def on_start_up_timer():
value = self.starting_dialog.value()
self.starting_dialog.setValue(value + 1)
pid = adb_helper.current_device().get_pid(config.MINICAP)
if pid:
logger.debug("minicap pid is %s" % pid)
if not cap_start:
self.dismiss_starting_dialog()
return
self.dismiss_starting_dialog()
self.on_action_start(ready=True)
mini_touch_pid = adb_helper.current_device().get_pid(config.MINITOUCH)
logger.debug("minitouch pid is %s" % mini_touch_pid)
elif value >= max_value - 1:
self.dismiss_starting_dialog()
QtWidgets.QMessageBox.critical(
self, _(config.TITLE_ERROR),
_("Fatal error occurred, please restart"))
self.close()
def on_action_disable_share(self):
if self.ipc is None:
logger.error("self.ipc is None")
return
self.frame_timer.stop()
self.ipc.stop()
self.ipc = None
self.set_tip_message("")
self.ui.actionShare.setText(_("Enable share"))
def fill_dict_combo_options(self, dict_combo):
dict_combo.clear()
dict_combo.addItem(_('NOT_DICT_FIELD'))
dict_combo.insertSeparator(dict_combo.count())
for each in mdx_service_manager.services:
# combo_data.insert("data", each.label)
dict_combo.addItem(each.title, userData=each.label)
dict_combo.insertSeparator(dict_combo.count())
for s in web_service_manager.services:
# combo_data.insert("data", "webservice")
dict_combo.addItem(s.label, userData="webservice")
def build(self):
self.main_layout = QVBoxLayout()
models_layout = QHBoxLayout()
# add buttons
mdx_button = QPushButton(_('DICTS_FOLDERS'))
mdx_button.clicked.connect(self.show_mdx_dialog)
self.models_button = QPushButton(_('CHOOSE_NOTE_TYPES'))
self.models_button.clicked.connect(self.btn_models_pressed)
models_layout.addWidget(mdx_button)
models_layout.addWidget(self.models_button)
self.main_layout.addLayout(models_layout)
# add dicts mapping
dicts_widget = QWidget()
self.dicts_layout = QGridLayout()
self.dicts_layout.setSizeConstraint(QLayout.SetMinAndMaxSize)
dicts_widget.setLayout(self.dicts_layout)
scroll_area = QScrollArea()
scroll_area.setWidgetResizable(True)
scroll_area.setWidget(dicts_widget)
self.main_layout.addWidget(scroll_area)
# add description of radio buttons AND ok button
bottom_layout = QHBoxLayout()
btnbox = QDialogButtonBox(QDialogButtonBox.Ok, Qt.Horizontal, self)
btnbox.accepted.connect(self.accept)
bottom_layout.addWidget(QLabel(_("RADIOS_DESC")))
bottom_layout.addWidget(btnbox)
self.main_layout.addLayout(bottom_layout)
# self.signal_mapper_chk.mapped.connect(self.chkbox_state_changed)
self.setLayout(self.main_layout)
# init saved data
if config.last_model_id:
model = get_model_byId(mw.col.models, config.last_model_id)
if model:
self.models_button.setText(
u'%s [%s]' % (_('CHOOSE_NOTE_TYPES'), model['name']))
# build fields -- dicts layout
self.build_layout(model)
def show_starting_dialog(self, title=_("First start"),
text=_("Init env, please wait(about 6 seconds)..."),
cap_start=False):
logger.debug("show starting dialog")
if self.timer:
return
max_value = 30
self.timer = QtCore.QTimer()
self.starting_dialog = QtWidgets.QProgressDialog(self)
self.starting_dialog.setWindowModality(QtCore.Qt.ApplicationModal)
self.starting_dialog.setWindowTitle(title)
self.starting_dialog.setLabelText(text)
self.starting_dialog.setMaximum(max_value)
self.starting_dialog.setCancelButton(None)
def on_start_up_timer():
value = self.starting_dialog.value()
self.starting_dialog.setValue(value + 1)
pid = adb_helper.current_device().get_pid(config.MINICAP)
if pid:
logger.debug("minicap pid is %s" % pid)
if not cap_start:
self.dismiss_starting_dialog()
return
self.dismiss_starting_dialog()
self.on_action_start(ready=True)
mini_touch_pid = adb_helper.current_device().get_pid(config.MINITOUCH)
logger.debug("minitouch pid is %s" % mini_touch_pid)
elif value >= max_value - 1:
self.dismiss_starting_dialog()
QtWidgets.QMessageBox.critical(
self, _(config.TITLE_ERROR),
_("Fatal error occurred, please restart"))
self.close()
self.timer.timeout.connect(on_start_up_timer)
self.timer.start(100)
self.starting_dialog.show()
def on_action_stop_recorder(self):
self.recording = False
if self.record_timer.isActive():
self.record_timer.stop()
if len(self.record_frames) < 1:
QtWidgets.QMessageBox.critical(self, _(config.TITLE_ERROR), _("No any frame, your screen didn't change!"))
self.set_tip_message("")
self.ui.actionRecorder.setText(_("Start video recorder ..."))
return
self.set_tip_message(_("Saving video ..."))
self.ui.actionRecorder.setEnabled(self.recording)
def save_task(frames):
recorder.write_frames(frames)
mp4file = recorder.finish()
self.set_tip_message("%s" % mp4file.replace("\\", "/"))
self.record_frames = []
self.ui.actionRecorder.setEnabled(not self.recording)
self.ui.actionRecorder.setText(_("Start video recorder ..."))
task = threading.Thread(target=save_task, args=(self.record_frames,))
task.start()
def show_models(self):
self.save()
edit = QPushButton(anki.lang._("Manage"),
clicked=lambda: aqt.models.Models(mw, self))
ret = StudyDeck(mw,
names=lambda: sorted(mw.col.models.allNames()),
accept=anki.lang._("Choose"),
title=anki.lang._("Choose Note Type"),
help="_notes",
parent=self,
buttons=[edit],
cancel=True,
geomKey="selectModel")
if ret.name:
model = mw.col.models.byName(ret.name)
config.last_model_id = model['id']
self.models_button.setText(u'%s [%s]' %
(_('CHOOSE_NOTE_TYPES'), ret.name))
return model
def on_mini_touch_connect_result(self, ret):
if not ret:
QtWidgets.QMessageBox.warning(
self, _(config.TITLE_WARNING),
_("Fail to connect minitouch\nThe screen is OK, but you couldn't control"))
def on_action_about(self):
QtWidgets.QMessageBox.information(self, _("About"), version.about)
def cn_btn_clicked(self, widget):
print "cn_btn_clicked.."
lang.set_lang("cn.ini")
self.ok_btn.set_label(_(0))
self.can_btn.set_label(_(1))
def on_screenshots_result(self, filename, show_toast=True):
if show_toast:
Toast.show_(self, _("Saved: %s") % filename)
def on_disconnect_remote_screen(self):
self.share_val.value = 1
self.share_proc = None
logger.debug("kill share process")
self.ui.actionRemote_screen.setText(_("Connect remote screen..."))
def en_btn_clicked(self, widget):
print "en_btn_clicked.."
lang.set_lang("en.ini")
print "_(0):", _(0)
self.ok_btn.set_label(_(0))
self.can_btn.set_label(_(1))
def on_disconnected(self):
self.on_action_stop()
self.setWindowTitle(version.app_name)
QtWidgets.QMessageBox.critical(
self, _("Disconnected"),
_("USB line pulled out or you closed USB-DEBUG mode"))
