def image_import(self):
"""
Take the path(s) of one or more images and import them to the application.
:return: Nothing
"""
file_dialog = QFileDialog() # Create QFileDialog
# Open the file dialog as Open File Names dialog (for image choice)
f_path = file_dialog.getOpenFileNames(parent=None,
caption="Open Image(s)",
directory=QDir.homePath(),
filter=self.IMG_FILTER,
options=self.DIALOG_FLAG)[0]
if f_path: # If user chose at least one image
img_id_counter = 0 # Set a counter for id
for file in f_path: # For all paths in f_paths
image_tmp = Image() # Create an Image object
success = image_tmp.img_open(file) # Set image parameters
if success: # If image exists
image_tmp.img_set_image_id(img_id_counter) # Set image counter
img_id_counter += 1 # increase the counter by 1
# image_tmp.img_print_info() # print image info for debugging
self.image_list.append(image_tmp) # Append image to list
item_name = "../" + image_tmp.info.dir_name + "/" + image_tmp.info.name # Set name for view
item_widget = QListWidgetItem(item_name) # Append item to window image list
item_widget.setFlags(item_widget.flags() | QtCore.Qt.ItemIsUserCheckable) # Set it checkable
item_widget.setCheckState(QtCore.Qt.Checked) # Set it checked
self.ui_main_win.listImage.addItem(item_widget) # Add item to list
self.ui_main_win.menuCamera_Settings.setEnabled(self.UP) # Enable Camera menu
self.ui_main_win.actionCrabSFM.setEnabled(self.UP) # Enable SFM action
def getOpenFileNames(self, name, parent=None, caption='', dir_='',
filter_='', selectedFilter='', options=QFileDialog.Options()):
'''
@param: name QString
@param: parent QWidget
@param: caption QString
@param: dir_ QString
@param: filter_ QString
@param: selectedFilter QString TODO: this is an output parameter
@param: options QFileDialog::Options
@return: QStringList
'''
settings = Settings()
settings.beginGroup('FileDialogPaths')
lastDir = settings.value(name, '')
fileName = self.getFileName(dir_)
if not lastDir:
lastDir = dir_
else:
lastDir = pathjoin(lastDir, fileName)
paths, selectedFilter = QFileDialog.getOpenFileNames(parent, caption,
lastDir, filter_, selectedFilter, options)
if paths:
settings.setValue(name, QFileInfo(paths[0]).absolutePath())
settings.endGroup()
return paths
def select_batch_files(self):
"""
Selection of .xml pyIMD project files for batch calculation.
"""
filter_ext = "XML (*.xml);;, All files (*.*) "
file_name = QFileDialog()
file_name.setFileMode(QFileDialog.ExistingFiles)
ret = file_name.getOpenFileNames(
self, "Select the pyIMD project files for batch processing",
self.last_selected_path, filter_ext)
files = ret[0]
for i in range(0, len(files)):
self.batchFileListWidget.addItem(str(files[i]))
def buttonExportClicked(self):
(filePaths, filter) = QFileDialog.getOpenFileNames(
parent=self,
caption="转换数据库文件为文本格式",
directory=QApplication.applicationDirPath() + "/../data",
filter="Database file (*.db * mdb)",
)
if not filePaths:
return
#
if DatabaseMgr().convertToText(filePaths):
QMessageBox.information(self, "格式转换", "转换成功！")
else:
QMessageBox.warning(self, "格式转换", "转换失败！")
def load_file_dialog(parent, filters, multiple_files=False):
dlg = QFileDialog()
options = dlg.Options()
options |= QFileDialog.DontUseNativeDialog
if multiple_files:
file_name, _ = dlg.getOpenFileNames(parent,
"Load a model",
"",
filters,
"File WRML (*.wrl)",
options=options)
else:
file_name, _ = dlg.getOpenFileName(parent,
"Load a model",
"",
filters,
"File WRML (*.wrl)",
options=options)
if file_name == "":
return None
return file_name
def select_data_files(self):
"""
Select data files to create a new pyIMD project
"""
try:
filter_ext = "All files (*.*);; Txt (*.txt);; TDMS (*.tdms);; All files " \
"without file endings (*)"
file_name = QFileDialog()
file_name.setFileMode(QFileDialog.ExistingFiles)
ret = file_name.getOpenFileNames(self, "Pick relevant data files",
self.last_selected_path,
filter_ext)
names = ret[0]
if len(names) > 0:
# Clear previous file list
self.file_list = []
# Setting the file list
self.file_list = names
sorted_file_list = self.file_list
self.last_selected_path = os.path.dirname(sorted_file_list[0])
self.show_data()
self.print_to_console("Selected %d files." %
(len(sorted_file_list)))
# Populate drop down list with selected items.
self.noCellDataBox.clear()
self.withCellDataBox.clear()
self.measuredDataBox.clear()
self.noCellDataBox.addItems(self.file_list)
self.withCellDataBox.addItems(self.file_list)
self.measuredDataBox.addItems(self.file_list)
# Create new pyimd project
self.imd.create_pyimd_project(self.file_list[0],
self.file_list[0],
self.file_list[0], '\t', 23,
'PLL')
except Exception as e:
self.print_to_console("Error could not select files." + str(e))
def video_import(self):
"""
Take the path(s) of one or more videos and import them to the application.
:return:
"""
file_dialog = QFileDialog()
f_path = file_dialog.getOpenFileNames(parent=None,
caption="Open Video(s)",
directory=QDir.homePath(),
filter=self.VID_FILTER,
options=self.DIALOG_FLAG)[0]
if f_path:
for file in f_path:
video_tmp = Video()
success = video_tmp.vid_open(file)
if success:
self.video_list.append(video_tmp)
item_name = "../" + video_tmp.info.dir_name + "/" + video_tmp.info.name
item_widget = QListWidgetItem(item_name)
item_widget.setFlags(item_widget.flags() | QtCore.Qt.ItemIsUserCheckable)
item_widget.setCheckState(QtCore.Qt.Checked)
self.ui_main_win.listVideo.addItem(item_widget)
self.video_list_info()
def __init__(
self, title=_('Choose Files'),
filters=[],
add_all_files_filter=True,
parent=None,
modal=True,
name='',
mode=QFileDialog.ExistingFiles,
default_dir=u'~',
no_save_dir=False,
combine_file_and_saved_dir=False
):
from calibre.gui2 import dynamic, sanitize_env_vars
from calibre.gui2.ui import get_gui
gui = get_gui()
adapt_menubar = gui.bars_manager.adapt_menu_bar_for_dialog if gui is not None else Dummy()
QObject.__init__(self)
ftext = ''
if filters:
for filter in filters:
text, extensions = filter
extensions = ['*'+(i if i.startswith('.') else '.'+i) for i in
extensions]
ftext += '%s (%s);;'%(text, ' '.join(extensions))
if add_all_files_filter or not ftext:
ftext += 'All files (*)'
if ftext.endswith(';;'):
ftext = ftext[:-2]
self.dialog_name = dialog_name(name, title)
self.selected_files = None
self.fd = None
if combine_file_and_saved_dir:
bn = os.path.basename(default_dir)
prev = dynamic.get(self.dialog_name,
os.path.expanduser(u'~'))
if os.path.exists(prev):
if os.path.isfile(prev):
prev = os.path.dirname(prev)
else:
prev = os.path.expanduser(u'~')
initial_dir = os.path.join(prev, bn)
elif no_save_dir:
initial_dir = os.path.expanduser(default_dir)
else:
initial_dir = dynamic.get(self.dialog_name,
os.path.expanduser(default_dir))
if not isinstance(initial_dir, string_or_bytes):
initial_dir = os.path.expanduser(default_dir)
if not initial_dir or (not os.path.exists(initial_dir) and not (
mode == QFileDialog.AnyFile and (no_save_dir or combine_file_and_saved_dir))):
initial_dir = select_initial_dir(initial_dir)
self.selected_files = []
use_native_dialog = 'CALIBRE_NO_NATIVE_FILEDIALOGS' not in os.environ
with sanitize_env_vars():
opts = QFileDialog.Option()
if not use_native_dialog:
opts |= QFileDialog.DontUseNativeDialog
if mode == QFileDialog.AnyFile:
with adapt_menubar:
f = QFileDialog.getSaveFileName(parent, title,
initial_dir, ftext, "", opts)
if f and f[0]:
self.selected_files.append(f[0])
elif mode == QFileDialog.ExistingFile:
with adapt_menubar:
f = QFileDialog.getOpenFileName(parent, title,
initial_dir, ftext, "", opts)
if f and f[0] and os.path.exists(f[0]):
self.selected_files.append(f[0])
elif mode == QFileDialog.ExistingFiles:
with adapt_menubar:
fs = QFileDialog.getOpenFileNames(parent, title, initial_dir,
ftext, "", opts)
if fs and fs[0]:
for f in fs[0]:
f = unicode_type(f)
if not f:
continue
if not os.path.exists(f):
# QFileDialog for some reason quotes spaces
# on linux if there is more than one space in a row
f = unquote(f)
if f and os.path.exists(f):
self.selected_files.append(f)
else:
if mode == QFileDialog.Directory:
opts |= QFileDialog.ShowDirsOnly
with adapt_menubar:
f = unicode_type(QFileDialog.getExistingDirectory(parent, title, initial_dir, opts))
if os.path.exists(f):
self.selected_files.append(f)
if self.selected_files:
self.selected_files = [unicode_type(q) for q in self.selected_files]
saved_loc = self.selected_files[0]
if os.path.isfile(saved_loc):
saved_loc = os.path.dirname(saved_loc)
if not no_save_dir:
dynamic[self.dialog_name] = saved_loc
self.accepted = bool(self.selected_files)
def __init__(self, title=_('Choose Files'),
filters=[],
add_all_files_filter=True,
parent=None,
modal=True,
name='',
mode=QFileDialog.ExistingFiles,
default_dir=u'~',
no_save_dir=False,
combine_file_and_saved_dir=False
):
QObject.__init__(self)
ftext = ''
if filters:
for filter in filters:
text, extensions = filter
extensions = ['*'+(i if i.startswith('.') else '.'+i) for i in
extensions]
ftext += '%s (%s);;'%(text, ' '.join(extensions))
if add_all_files_filter or not ftext:
ftext += 'All files (*)'
if ftext.endswith(';;'):
ftext = ftext[:-2]
self.dialog_name = name if name else 'dialog_' + title
self.selected_files = None
self.fd = None
if combine_file_and_saved_dir:
bn = os.path.basename(default_dir)
prev = dynamic.get(self.dialog_name,
expanduser(u'~'))
if os.path.exists(prev):
if os.path.isfile(prev):
prev = os.path.dirname(prev)
else:
prev = expanduser(u'~')
initial_dir = os.path.join(prev, bn)
elif no_save_dir:
initial_dir = expanduser(default_dir)
else:
initial_dir = dynamic.get(self.dialog_name,
expanduser(default_dir))
if not isinstance(initial_dir, basestring):
initial_dir = expanduser(default_dir)
if not initial_dir or (not os.path.exists(initial_dir) and not (
mode == QFileDialog.AnyFile and (no_save_dir or combine_file_and_saved_dir))):
initial_dir = select_initial_dir(initial_dir)
self.selected_files = []
use_native_dialog = 'CALIBRE_NO_NATIVE_FILEDIALOGS' not in os.environ
with sanitize_env_vars():
opts = QFileDialog.Option()
if not use_native_dialog:
opts |= QFileDialog.DontUseNativeDialog
if mode == QFileDialog.AnyFile:
f = QFileDialog.getSaveFileName(parent, title,
initial_dir, ftext, "", opts)
if f and f[0]:
self.selected_files.append(f[0])
elif mode == QFileDialog.ExistingFile:
f = QFileDialog.getOpenFileName(parent, title,
initial_dir, ftext, "", opts)
if f and f[0] and os.path.exists(f[0]):
self.selected_files.append(f[0])
elif mode == QFileDialog.ExistingFiles:
fs = QFileDialog.getOpenFileNames(parent, title, initial_dir,
ftext, "", opts)
if fs and fs[0]:
for f in fs[0]:
f = unicode(f)
if not f:
continue
if not os.path.exists(f):
# QFileDialog for some reason quotes spaces
# on linux if there is more than one space in a row
f = unquote(f)
if f and os.path.exists(f):
self.selected_files.append(f)
else:
if mode == QFileDialog.Directory:
opts |= QFileDialog.ShowDirsOnly
f = unicode(QFileDialog.getExistingDirectory(parent, title, initial_dir, opts))
if os.path.exists(f):
self.selected_files.append(f)
if self.selected_files:
self.selected_files = [unicode(q) for q in self.selected_files]
saved_loc = self.selected_files[0]
if os.path.isfile(saved_loc):
saved_loc = os.path.dirname(saved_loc)
if not no_save_dir:
dynamic[self.dialog_name] = saved_loc
self.accepted = bool(self.selected_files)
def load_media_subs():
import_dir = mw.pm.profile.get("importDirectory", "")
myfilter = "Subtitles (*.lrc *.srt);;All Files (*.*)"
open_file_dialog = QFileDialog()
open_file_dialog.setFileMode(QFileDialog.ExistingFiles)
load_media_subs_paths = open_file_dialog.getOpenFileNames(mw,
"Select Sub to Import",
import_dir,
myfilter)[0]
if not load_media_subs_paths:
return
mw.addon_RTMD.loading_media_subs = True
# thread to get feed data
class LoadSubsThreadSignals(QObject):
error_message = pyqtSignal(str)
class LoadSubsThread(QRunnable):
def __init__(self, parent, sub_path):
super(LoadSubsThread, self).__init__()
self.parent = parent
self.sub_path = sub_path
self.signals = LoadSubsThreadSignals()
def run(self):
if self.parent.loading_media_subs_need_abort \
or (not self.sub_path.endswith(".lrc")
and not self.sub_path.endswith(".srt")):
self.signals.error_message.emit("")
return
media_path_no_ext = self.sub_path[:-4]
if not os.path.split(media_path_no_ext)[1]:
self.signals.error_message.emit("Bad file name: %s" % self.sub_path)
return
folder_name = os.path.split(os.path.split(media_path_no_ext)[1])[1]
if self.sub_path.endswith(".lrc"):
media_ext = ".mp3"
if not os.path.isfile(media_path_no_ext + ".mp3"):
self.signals.error_message.emit("File not found: %s" % media_path_no_ext + ".mp3")
return
else:
video_ext = (".mp4", ".mkv", ".avi", ".flv", ".m4v", ".f4v", ".rmvb")
media_ext = ""
for ext in video_ext:
if os.path.isfile(media_path_no_ext + ext):
media_ext = ext
break
if not media_ext:
self.signals.error_message.emit("Can found media file for: %s" % self.sub_path)
return
# try to open the sub file
is_ok, sub_data = get_file_data(self.sub_path)
if not is_ok:
self.signals.error_message.emit("Encoding should be utf-8: %s" % self.sub_path)
# save sub_text as <<<start=23,end=43||say something>>>
# pattern = r"<<<id=(\d+),start=(\d+),end=(\d+)\|\|(.*?)>>>"
struct_sub = ""
# parse lrc text
if self.sub_path.endswith(".lrc"):
lrc_dict = {}
re_lrc_line = re.compile(r"(\[\d+:\d+\.\d+\])")
re_lrc_time = re.compile(r"\[(\d+):(\d+)\.\d+\]")
for line_text in sub_data.splitlines():
line_text = line_text.strip()
if not line_text or not re_lrc_time.match(line_text):
continue
line_time_points = []
line_sub_text = ""
for element in re_lrc_line.split(line_text):
if element:
if re_lrc_line.match(element):
minute, second = re_lrc_time.match(element).groups()
line_time_points.append(int(minute) * 60 + int(second))
else:
line_sub_text += element.strip()
if line_sub_text:
for second in line_time_points:
if second in lrc_dict:
lrc_dict[second] += line_sub_text
else:
lrc_dict[second] = line_sub_text
if lrc_dict:
struct_master = "<<<start=%d,end=0||%s>>>"
for second in sorted(lrc_dict.keys()):
struct_sub += struct_master % (second, lrc_dict[second])
# parse srt text
else:
sub_data = sub_data.replace("\r", "").split("\n\n")
re_srt = re.compile(r"\d+\s*\n(\d+):(\d+):(\d+),\d+ --> (\d+):(\d+):(\d+),\d+\s*\n(.*)", re.DOTALL)
struct_master = "<<<start=%d,end=%d||%s>>>"
for data_block in sub_data:
if re_srt.match(data_block):
# ('00', '00', '10', '00', '00', '11', "想不出来了\nI'm out.")
mg = re_srt.match(data_block).groups()
if len(mg) < 7:
continue
struct_sub += struct_master % \
(int(mg[0]) * 3600 + int(mg[1]) * 60 + int(mg[2]),
int(mg[3]) * 3600 + int(mg[4]) * 60 + int(mg[5]),
mg[6].strip())
# write to db
conn = sqlite3.connect(get_path("user_files", "doc.db"))
conn.execute("insert or replace into subs "
+ "(media_path_no_ext, media_ext, folder_name, sub_text, create_date) values "
+ "(?, ?, ?, ?, current_timestamp)",
(media_path_no_ext, media_ext, folder_name, struct_sub))
conn.commit()
conn.close()
self.signals.error_message.emit("")
class LoadMediaDialog(QDialog):
def __init__(self, parent, load_media_subs_paths):
super().__init__(parent)
self.parent = parent
self.load_media_subs_paths = load_media_subs_paths
self.verticalLayout =QVBoxLayout(self)
self.progress_bar = QProgressBar(self)
self.progress_bar.setProperty("value", 0)
self.progress_bar.setObjectName("progress_bar")
self.verticalLayout.addWidget(self.progress_bar)
self.status_label = QLabel(self)
self.status_label.setText("")
self.status_label.setObjectName("")
self.verticalLayout.addWidget(self.status_label)
self.abort_button = QPushButton(self)
self.abort_button.setText("Abort The Loading")
self.abort_button.clicked.connect(self.abort)
self.verticalLayout.addWidget(self.abort_button)
# start the work
self.load_subs_error_message = ""
self.loading_media_subs_need_abort = False
self.load_subs_completed_thread_count = 0
for sub_path in self.load_media_subs_paths:
load_thread = LoadSubsThread(self, sub_path)
load_thread.signals.error_message.connect(self.load_error_msg_slot)
thread_pool = QThreadPool.globalInstance()
thread_pool.start(load_thread)
def load_error_msg_slot(self, signal_error_msg):
self.load_subs_completed_thread_count += 1
if signal_error_msg:
self.load_subs_error_message += signal_error_msg + "<p>"
self.progress_bar.setValue(int(self.load_subs_completed_thread_count * 100
/ len(self.load_media_subs_paths)))
self.status_label.setText("Completed Subs %s / %s"
% (self.load_subs_completed_thread_count,
len(self.load_media_subs_paths)))
if self.load_subs_completed_thread_count == len(self.load_media_subs_paths):
if not self.loading_media_subs_need_abort:
self.status_label.setText("Completed loading.")
if self.load_subs_error_message:
show_text(self.load_subs_error_message)
if mw.addon_RTMD.loading_media_subs:
mw.addon_RTMD.loading_media_subs = False
self.abort_button.setEnabled(False)
def abort(self):
self.loading_media_subs_need_abort = True
def closeEvent(self, event):
if not mw.addon_RTMD.loading_media_subs:
event.accept()
else:
event.ignore()
LoadMediaDialog(mw, load_media_subs_paths).show()
def load_from_text_file(self):
import_dir = mw.pm.profile.get("importDirectory", "")
myfilter = "TXT/HTML (*.txt *.html);;All Files (*.*)"
open_file_dialog = QFileDialog()
open_file_dialog.setFileMode(QFileDialog.ExistingFiles)
self.load_text_file_paths = open_file_dialog.getOpenFileNames(self,
"Select Files to Import",
import_dir,
myfilter)[0]
if not self.load_text_file_paths:
return
# disable buttons
self.manual_input_button.setEnabled(False)
self.load_text_button.setEnabled(False)
self.clean_aged_button.setEnabled(False)
self.add_feed_button.setEnabled(False)
self.remove_feed_button.setEnabled(False)
self.load_feed_button.setEnabled(False)
if "load_from_text_file" not in self.hard_work:
self.hard_work.append("load_from_text_file")
self.existing_doc_id_list_part = []
# thread to get feed data
class LoadTextThreadSignals(QObject):
exit_signal = pyqtSignal(str)
class LoadTextThread(QRunnable):
def __init__(self, parent, file_path):
super(LoadTextThread, self).__init__()
self.parent = parent
self.file_path = file_path
self.signals = LoadTextThreadSignals()
def run(self):
if self.parent.need_abort:
self.signals.exit_signal.emit("")
return
desc = ""
is_ok, desc = get_file_data(self.file_path)
if not is_ok:
self.signals.exit_signal.emit("Need UTF-8 Encoding: %s" % self.file_path)
return
if desc:
link_to_set = '<p><p><a href="%s">%s</a>' % (self.file_path, self.file_path)
if "</body>" in desc:
desc = desc.replace("</body>", link_to_set + "</body>")
else:
desc = desc + link_to_set
title = os.path.basename(self.file_path)
conn = sqlite3.connect(get_path("user_files", "doc.db"),
detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES)
cur = conn.cursor()
cur.execute("select feed_id from doc where feed_id between ? and ?",
(int(time.time()*1000), int(time.time()*1000)+10000))
while True:
doc_id = int(time.time()*1000)
if doc_id not in self.parent.existing_doc_id_list_part:
break
self.parent.existing_doc_id_list_part.append(doc_id)
cur.execute("""insert into doc
(doc_id, link, title, descr, doc_type)
values (?, ?, ?, ?, 'tf')""",
(doc_id, self.file_path, title, desc))
conn.commit()
conn.close()
self.signals.exit_signal.emit("")
def load_exit_msg_slot(signal_error_msg):
self.load_text_completed_thread_count += 1
if signal_error_msg:
self.load_text_file_error_message += signal_error_msg + "<p>"
self.status_label.setText("Completed files %s / %s"
% (self.load_text_completed_thread_count,
len(self.load_text_file_paths)))
if self.load_text_completed_thread_count == len(self.load_text_file_paths):
if self.hard_work:
self.hard_work.remove("load_from_text_file")
if not self.need_abort:
self.status_label.setText("Completed loading.")
if not self.hard_work and self.need_abort:
self.need_abort = False
if self.load_text_file_error_message:
QMessageBox(QMessageBox.Warning, "Warning", self.load_text_file_error_message).exec()
self.load_text_file_error_message = ""
# enable buttons
self.manual_input_button.setEnabled(True)
self.load_text_button.setEnabled(True)
self.clean_aged_button.setEnabled(True)
self.add_feed_button.setEnabled(True)
self.remove_feed_button.setEnabled(True)
self.load_feed_button.setEnabled(True)
self.load_text_completed_thread_count = 0
self.load_text_file_error_message = ""
for file_path in self.load_text_file_paths:
load_thread = LoadTextThread(self, file_path)
load_thread.signals.exit_signal.connect(load_exit_msg_slot)
thread_pool = QThreadPool.globalInstance()
thread_pool.start(load_thread)
