def __init__(self, pixbuf, ocr_engines, reviewer):
self.configuration_manager = ConfigurationManager()
self.pixbuf = pixbuf
self.data_box = None
self.box = None
self.__connected_signal_handles_list = []
self.box_editor = BoxEditor(pixbuf.get_width(), pixbuf.get_height())
self.box_editor.connect('text-edited-by-user', self.checkHasText)
self.reviewer = reviewer
self.ocr_engines = ocr_engines
self.updateOcrEngines(self.ocr_engines)
self.box_editor.x_spin_button.connect('value-changed', self.__updateBoxX)
self.box_editor.y_spin_button.connect('value-changed', self.__updateBoxY)
self.box_editor.width_spin_button.connect('value-changed', self.__updateBoxWidth)
self.box_editor.height_spin_button.connect('value-changed', self.__updateBoxHeight)
self.box_editor.make_text_button.connect('toggled', self.__pressedTextContextButton)
self.box_editor.make_image_button.connect('toggled', self.__pressedImageContextButton)
self.box_editor.perform_ocr_button.connect('clicked', self.__pressedPerformOcrButton)
self.box_editor.detect_angle_button.connect('clicked', self.__pressedAngleDetectionButton)
self.box_editor.font_button.connect('font-set', self.__setDataBoxFont)
self.box_editor.align_left_button.connect('toggled', self.__setDataBoxAlign, ALIGN_LEFT)
self.box_editor.align_right_button.connect('toggled', self.__setDataBoxAlign, ALIGN_RIGHT)
self.box_editor.align_center_button.connect('toggled', self.__setDataBoxAlign, ALIGN_CENTER)
self.box_editor.align_fill_button.connect('toggled', self.__setDataBoxAlign, ALIGN_FILL)
self.box_editor.letter_spacing_spin.connect('value-changed', self.__setDataBoxLetterSpacing)
self.box_editor.line_spacing_spin.connect('value-changed', self.__setDataBoxLineSpacing)
self.box_editor.ocr_combo_box.connect('changed', self._onOCREngineChanged)
self.box_editor.languages_combo.connect('changed', self._onLanguageChanged)
self.box_editor.hide()
def __init__(self, main_window, page_data, ocr_engines):
super(ImageReviewer, self).__init__()
self.configuration_manager = ConfigurationManager()
self.main_window = main_window
self.path_to_image = page_data.image_path
self.text_box_fill_color = (94, 156, 235, 150)
self.box_stroke_color = (94, 156, 235, 250)
self.image_box_fill_color = (0, 183, 0, 150)
self.selectable_boxes_area = BoxesArea(self.path_to_image)
self.selectable_boxes_area.connect('selected_box', self.selectedBox)
self.selectable_boxes_area.connect('removed_box', self.removedBox)
self.selectable_boxes_area.connect('updated_box', self.updatedBox)
self.selectable_boxes_area.connect('dragged_box', self.updatedBoxBounds)
self.selectable_boxes_area.connect('deselected_box',
self.deselectedBoxCb)
self.image_pixbuf = GdkPixbuf.Pixbuf.new_from_file(self.path_to_image)
self.set_position(500)
self.show()
self.ocr_engines = ocr_engines
self.editor = Editor(self.image_pixbuf, self.ocr_engines, self)
self.boxes_dict = {}
selectable_boxes_scrolled_window = Gtk.ScrolledWindow()
selectable_boxes_scrolled_window.get_accessible().set_name(
_('Selectable areas'))
selectable_boxes_scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
selectable_boxes_scrolled_window.add(self.selectable_boxes_area)
self.selectable_boxes_area.show()
selectable_boxes_scrolled_window.show()
self.pack1(selectable_boxes_scrolled_window, True, False)
self.pack2(self.editor.box_editor, True, False)
self.page = page_data
self.updatePageData(self.page)
selectable_boxes_scrolled_window.connect_after("size-allocate", self.zoomFitCb)
def __init__(self):
# i18n
languages = []
lc, encoding = locale.getdefaultlocale()
if lc:
languages = [lc]
languages += DEFAULT_LANGUAGES
gettext.bindtextdomain(OCRFEEDER_COMPACT_NAME, LOCALE_DIR)
gettext.textdomain(OCRFEEDER_COMPACT_NAME)
language = gettext.translation(OCRFEEDER_COMPACT_NAME, LOCALE_DIR,
languages = languages, fallback = True)
_ = language.gettext
self.EXPORT_FORMATS = {0: ('ODT', _('ODT')),
1: ('HTML', _('HTML')),
2: ('PDF', _('PDF')),
3: ('TXT', _('Plain Text'))}
self.title = OCRFEEDER_STUDIO_NAME
self.main_window = widgetPresenter.MainWindow()
self.main_window.set_title(self.title)
self.document_generator_manager = DocumentGeneratorManager()
self.configuration_manager = ConfigurationManager()
self.ocr_engines_manager = OcrEnginesManager(self.configuration_manager)
self.configuration_manager.loadConfiguration()
user_engines_folder = self.configuration_manager.user_engines_folder
self.engines_needing_update = \
self.ocr_engines_manager.makeEnginesFromFolder(user_engines_folder)
self.ocr_engines = self.ocr_engines_manager.ocr_engines
self.pages_icon_view = PagesIconView()
self.pages_icon_view.setDeleteCurrentPageFunction(self.deleteCurrentPage)
self.pages_icon_view.get_model().connect('row-inserted',
self.__pagesUpdatedCallback)
self.pages_icon_view.get_model().connect('row-deleted',
self.__pagesUpdatedCallback)
self.pages_icon_view.show()
self.main_window.main_area_left.add_with_viewport(self.pages_icon_view)
self.images_selectable_area = {}
self.source_images_controler = ImageReviewer_Controler(self.main_window,
self.pages_icon_view,
self.ocr_engines,
self.configuration_manager)
self.project_name = None
toolbar_callback_dict = {'recognizePage': self.__recognizePageAction,
'recognizeDocument': self.__recognizeDocumentAction,
'export_to_odt': self.exportToOdt}
menubar_callback_dict = {'exit': self.quit, 'add_image': self.addImage, 'export_to_odt': self.exportToOdt, 'edit_page': self.choosePageSize,
'delete_page': self.deleteCurrentPage, 'export_dialog': self.exportDialog, 'add_folder': self.addFolder,
'import_pdf': self.importPdf, 'save_project': self.saveProject, 'save_project_as': self.saveProjectAs,
'open_project': self.openProject, 'append_project': self.appendProject,'clear': self.clear,
'unpaper': self.unpaper, 'preferences': self.preferences, 'about': self.about,
'ocr_engines': self.ocrEngines, 'zoom_in': self.zoomIn, 'zoom_out': self.zoomOut,
'zoom_fit': self.zoomFit, 'reset_zoom': self.resetZoom,
'recognize_areas': self.__recognizeSelectedAreas,
'import_from_scanner': self.importFromScanner,
'select_next_area': self.source_images_controler.selectNextArea,
'select_previous_area': self.source_images_controler.selectPreviousArea,
'select_all_areas': self.source_images_controler.selectAllAreas,
'delete_selected_areas': self.source_images_controler.deleteSelectedAreas,
'image_deskewer': self.source_images_controler.deskewCurrentImage,
'copy_to_clipboard': self.source_images_controler.copyRecognizedTextToClipboard,
'spell_checker': self.spellChecker,
'help_contents': self.showHelpContents,
'move_page_down': self.movePageDown,
'move_page_up': self.movePageUp,
'select_next_page': self.selectNextPage,
'select_previous_page': self.selectPreviousPage,
}
self.main_window.setHeader(menubar_callback_dict, toolbar_callback_dict)
self.main_window.setDestroyEvent(self.quit)
parser = ArgumentParser(description=OCRFEEDER_STUDIO_COMMENTS)
parser.add_argument('images', metavar='IMAGE',
nargs='*', help='images to be automatically added '
'on start-up')
parser.add_argument('-d', '--dir', help='directory with images to be '
'added automatically on start-up')
parser.add_argument('-v', '--version', action='version',
version='%(prog)s ' + OCRFEEDER_STUDIO_VERSION)
args = parser.parse_args()
imgs = args.images
if imgs:
self.__addImagesToReviewer(imgs)
if args.dir:
self.__addImagesToReviewer(lib.getImagesFromFolder(args.dir))
self.main_window.setHasSelectedBoxes(False)
self.main_window.setHasContentBoxes(False)
self.main_window.setNumberOfPages(
self.pages_icon_view.getNumberOfPages())
# Show dialog to choose system-wide OCR engines when no engine was found
if not self.ocr_engines:
engines = self.configuration_manager.getEnginesInSystem()
if engines:
add_engines_dialog = widgetPresenter.SystemEnginesDialog(engines)
response = add_engines_dialog.run()
if response == Gtk.ResponseType.ACCEPT:
for engine in add_engines_dialog.getChosenEngines():
self.ocr_engines_manager.addNewEngine(engine)
add_engines_dialog.destroy()
else:
self.__askForEnginesMigration()
self._last_images_dir = ''
if not self.ocr_engines:
self.warnNoOCREngines()
class Studio:
TARGET_TYPE_URI_LIST = 80
def __init__(self):
# i18n
languages = []
lc, encoding = locale.getdefaultlocale()
if lc:
languages = [lc]
languages += DEFAULT_LANGUAGES
gettext.bindtextdomain(OCRFEEDER_COMPACT_NAME, LOCALE_DIR)
gettext.textdomain(OCRFEEDER_COMPACT_NAME)
language = gettext.translation(OCRFEEDER_COMPACT_NAME, LOCALE_DIR,
languages = languages, fallback = True)
_ = language.gettext
self.EXPORT_FORMATS = {0: ('ODT', _('ODT')),
1: ('HTML', _('HTML')),
2: ('PDF', _('PDF')),
3: ('TXT', _('Plain Text'))}
self.title = OCRFEEDER_STUDIO_NAME
self.main_window = widgetPresenter.MainWindow()
self.main_window.set_title(self.title)
self.document_generator_manager = DocumentGeneratorManager()
self.configuration_manager = ConfigurationManager()
self.ocr_engines_manager = OcrEnginesManager(self.configuration_manager)
self.configuration_manager.loadConfiguration()
user_engines_folder = self.configuration_manager.user_engines_folder
self.engines_needing_update = \
self.ocr_engines_manager.makeEnginesFromFolder(user_engines_folder)
self.ocr_engines = self.ocr_engines_manager.ocr_engines
self.pages_icon_view = PagesIconView()
self.pages_icon_view.setDeleteCurrentPageFunction(self.deleteCurrentPage)
self.pages_icon_view.get_model().connect('row-inserted',
self.__pagesUpdatedCallback)
self.pages_icon_view.get_model().connect('row-deleted',
self.__pagesUpdatedCallback)
self.pages_icon_view.show()
self.main_window.main_area_left.add_with_viewport(self.pages_icon_view)
self.images_selectable_area = {}
self.source_images_controler = ImageReviewer_Controler(self.main_window,
self.pages_icon_view,
self.ocr_engines,
self.configuration_manager)
self.project_name = None
toolbar_callback_dict = {'recognizePage': self.__recognizePageAction,
'recognizeDocument': self.__recognizeDocumentAction,
'export_to_odt': self.exportToOdt}
menubar_callback_dict = {'exit': self.quit, 'add_image': self.addImage, 'export_to_odt': self.exportToOdt, 'edit_page': self.choosePageSize,
'delete_page': self.deleteCurrentPage, 'export_dialog': self.exportDialog, 'add_folder': self.addFolder,
'import_pdf': self.importPdf, 'save_project': self.saveProject, 'save_project_as': self.saveProjectAs,
'open_project': self.openProject, 'append_project': self.appendProject,'clear': self.clear,
'unpaper': self.unpaper, 'preferences': self.preferences, 'about': self.about,
'ocr_engines': self.ocrEngines, 'zoom_in': self.zoomIn, 'zoom_out': self.zoomOut,
'zoom_fit': self.zoomFit, 'reset_zoom': self.resetZoom,
'recognize_areas': self.__recognizeSelectedAreas,
'import_from_scanner': self.importFromScanner,
'select_next_area': self.source_images_controler.selectNextArea,
'select_previous_area': self.source_images_controler.selectPreviousArea,
'select_all_areas': self.source_images_controler.selectAllAreas,
'delete_selected_areas': self.source_images_controler.deleteSelectedAreas,
'image_deskewer': self.source_images_controler.deskewCurrentImage,
'copy_to_clipboard': self.source_images_controler.copyRecognizedTextToClipboard,
'spell_checker': self.spellChecker,
'help_contents': self.showHelpContents,
'move_page_down': self.movePageDown,
'move_page_up': self.movePageUp,
'select_next_page': self.selectNextPage,
'select_previous_page': self.selectPreviousPage,
}
self.main_window.setHeader(menubar_callback_dict, toolbar_callback_dict)
self.main_window.setDestroyEvent(self.quit)
parser = ArgumentParser(description=OCRFEEDER_STUDIO_COMMENTS)
parser.add_argument('images', metavar='IMAGE',
nargs='*', help='images to be automatically added '
'on start-up')
parser.add_argument('-d', '--dir', help='directory with images to be '
'added automatically on start-up')
parser.add_argument('-v', '--version', action='version',
version='%(prog)s ' + OCRFEEDER_STUDIO_VERSION)
args = parser.parse_args()
imgs = args.images
if imgs:
self.__addImagesToReviewer(imgs)
if args.dir:
self.__addImagesToReviewer(lib.getImagesFromFolder(args.dir))
self.main_window.setHasSelectedBoxes(False)
self.main_window.setHasContentBoxes(False)
self.main_window.setNumberOfPages(
self.pages_icon_view.getNumberOfPages())
# Show dialog to choose system-wide OCR engines when no engine was found
if not self.ocr_engines:
engines = self.configuration_manager.getEnginesInSystem()
if engines:
add_engines_dialog = widgetPresenter.SystemEnginesDialog(engines)
response = add_engines_dialog.run()
if response == Gtk.ResponseType.ACCEPT:
for engine in add_engines_dialog.getChosenEngines():
self.ocr_engines_manager.addNewEngine(engine)
add_engines_dialog.destroy()
else:
self.__askForEnginesMigration()
self._last_images_dir = ''
if not self.ocr_engines:
self.warnNoOCREngines()
def run(self):
Gdk.threads_init()
Gdk.threads_enter()
Gtk.main()
Gdk.threads_leave()
def addImage(self, widget):
file_open_dialog = widgetPresenter.FileDialog(self.main_window,
'open',
file_filters = [(_('Images'), ['image/*'], [])])
file_open_dialog.set_select_multiple(True)
if self._last_images_dir:
file_open_dialog.set_current_folder(self._last_images_dir)
response = file_open_dialog.run()
if response == Gtk.ResponseType.OK:
self.__addImagesToReviewer(file_open_dialog.get_filenames())
self._last_images_dir = file_open_dialog.get_current_folder()
file_open_dialog.destroy()
def importFromScanner(self, widget):
dialog = widgetPresenter.QueuedEventsProgressDialog(self.main_window)
item_obtain = AsyncItem(lib.obtainScanners,(),
self.__obtainScannersFinishedCb,(dialog,))
info_obtain = (_('Obtaining scanners'), _(u'Please wait…'))
dialog.setItemsList([(info_obtain, item_obtain)])
dialog.run()
def __obtainScannersFinishedCb(self, dialog, devices, error):
dialog.destroy()
device = None
if len(devices) > 1:
scanner_chooser_dialog = widgetPresenter.ScannerChooserDialog(\
self.main_window,
devices)
Gdk.threads_enter()
response = scanner_chooser_dialog.run()
Gdk.threads_leave()
scanner_chooser_dialog.destroy()
if response == Gtk.ResponseType.ACCEPT:
device = scanner_chooser_dialog.getSelectedDevice()
else:
return
elif len(devices) == 1:
device = devices[0][0]
if device:
dialog_scan = widgetPresenter.QueuedEventsProgressDialog(\
self.main_window)
item_scan = AsyncItem(lib.scan,(device,),
self.__scanFinishedCb,(dialog_scan,))
info_scan = (_('Scanning'), _(u'Please wait…'))
dialog_scan.setItemsList([(info_scan, item_scan)])
dialog_scan.run()
else:
error = widgetPresenter.SimpleDialog(self.main_window,
_("No scanner devices were found"),
_("Error"),
'warning')
Gdk.threads_enter()
error.run()
Gdk.threads_leave()
def __scanFinishedCb(self, dialog, image_path, error):
dialog.destroy()
if image_path:
Gdk.threads_enter()
self.__addImagesToReviewer([image_path])
Gdk.threads_leave()
else:
error = widgetPresenter.SimpleDialog(\
_("Error scanning page"),
_("Error"),
'warning')
Gdk.threads_enter()
error.run()
Gdk.threads_leave()
def importPdf(self, widget):
file_open_dialog = widgetPresenter.FileDialog(self.main_window,
'open',
file_filters = [(_('PDF'), ['application/pdf'], [])])
response = file_open_dialog.run()
files = []
if response == Gtk.ResponseType.OK:
files = file_open_dialog.get_filenames()
file_open_dialog.destroy()
for file_name in files:
dialog = widgetPresenter.QueuedEventsProgressDialog(
self.main_window)
item = AsyncItem(lib.convertPdfToImages,
(file_name,
self.configuration_manager.TEMPORARY_FOLDER),
self.__loadPdfFinishedCb,
(dialog,))
info = (_('Loading PDF'), _(u'Please wait…'))
dialog.setItemsList([(info, item)])
dialog.run()
def __loadPdfFinishedCb(self, dialog, folder, error):
self.__addImagesToReviewer(lib.getImagesFromFolder(folder))
dialog.destroy()
def addFolder(self, widget):
file_open_dialog = widgetPresenter.FileDialog(self.main_window,
'select-folder')
response = file_open_dialog.run()
if response == Gtk.ResponseType.OK:
filenames = file_open_dialog.get_filenames()
file_open_dialog.destroy()
for folder in filenames:
self.__addImagesToReviewer(lib.getImagesFromFolder(folder))
file_open_dialog.destroy()
def exportToFormat(self, format, name):
generator = self.document_generator_manager.get(format)
self.source_images_controler.exportPagesWithGenerator(generator,
name)
def exportToOdt(self, widget):
self.exportToFormat('ODT', 'ODT')
def exportDialog(self, widget):
format_names = [format[1] for format in self.EXPORT_FORMATS.values()]
export_dialog = widgetPresenter.ExportDialog(self.main_window,
_('Export pages'),
format_names)
response = export_dialog.run()
if response == Gtk.ResponseType.ACCEPT:
format = export_dialog.getSelectedFormat()
export_dialog.destroy()
if format != -1:
# Retrieve and run the exportation function
self.exportToFormat(self.EXPORT_FORMATS[format][0],
self.EXPORT_FORMATS[format][1])
return None
export_dialog.destroy()
return None
def choosePageSize(self, widget):
self.source_images_controler.choosePageSize()
def deleteCurrentPage(self, widget):
delete_dialog = widgetPresenter.QuestionDialog(self.main_window,
_('Are you sure you want to delete the current image?'))
response = delete_dialog.run()
if response == Gtk.ResponseType.YES:
self.source_images_controler.deleteCurrentPage()
self.pages_icon_view.deleteCurrentSelection()
delete_dialog.destroy()
def movePageDown(self, widget):
self.pages_icon_view.movePage(1)
def movePageUp(self, widget):
self.pages_icon_view.movePage(-1)
def selectNextPage(self, widget):
self.pages_icon_view.selectPageFromOffset(1)
def selectPreviousPage(self, widget):
self.pages_icon_view.selectPageFromOffset(-1)
def __addImagesToReviewer(self, images):
if not images:
return
self.source_images_controler.addImages(images)
def __recognizePageAction(self, widget):
if not self.ocr_engines_manager.ocr_engines:
self.warnNoOCREngines()
return
self.source_images_controler.recognizeCurrentPage()
def __recognizeDocumentAction(self, widget):
if not self.ocr_engines_manager.ocr_engines:
self.warnNoOCREngines()
return
self.source_images_controler.recognizeDocument()
def __recognizeSelectedAreas(self, widget):
if not self.ocr_engines_manager.ocr_engines:
self.warnNoOCREngines()
return
self.source_images_controler.recognizeSelectedAreas()
def setProjectName(self, project_name):
self.project_name = project_name
project_title = os.path.splitext(os.path.basename(self.project_name))[0]
self.main_window.set_title('%s - %s' % (self.title, project_title))
def saveProjectAs(self, widget = None):
file_name = self.source_images_controler.saveProjectAs()
if file_name:
self.setProjectName(file_name)
self.saveProject()
def saveProject(self, widget = None):
if self.project_name:
self.source_images_controler.saveProject(self.project_name)
else:
self.saveProjectAs()
def appendProject(self, widget = None):
self.__loadProject(False)
def openProject(self, widget = None):
self.__loadProject()
def __loadProject(self, clear_current = True):
project_title = self.source_images_controler.openProject(clear_current)
if project_title:
self.setProjectName(project_title)
def clear(self, widget = None):
dialog = widgetPresenter.QuestionDialog(self.main_window,
_('Are you sure you want '
'to clear the project?'))
response = dialog.run()
if response == Gtk.ResponseType.YES:
self.source_images_controler.clear()
dialog.destroy()
def unpaper(self, widget = None):
self.source_images_controler.unpaperTool()
def spellChecker(self, widget = None):
self.source_images_controler.spellCheck(locale.getdefaultlocale()[0])
def preferences(self, widget = None):
parent = self.main_window
preferences_dialog = widgetPresenter.PreferencesDialog(parent,
self.configuration_manager,
self.ocr_engines_manager.ocr_engines)
if preferences_dialog.run() == Gtk.ResponseType.ACCEPT:
preferences_dialog.saveToManager()
self.source_images_controler.updateFromConfiguration()
preferences_dialog.destroy()
def ocrEngines(self, widget = None):
ocr_dialog = widgetPresenter.OcrManagerDialog(self.main_window,
self.ocr_engines_manager)
ocr_dialog.run()
if ocr_dialog.modified:
ocr_engines = self.ocr_engines_manager.ocr_engines
self.source_images_controler.updateOcrEngines(ocr_engines)
ocr_dialog.destroy()
def warnNoOCREngines(self):
debug('No OCR engines found')
dialog = Gtk.MessageDialog(self.main_window,
Gtk.DialogFlags.MODAL |
Gtk.DialogFlags.DESTROY_WITH_PARENT,
Gtk.MessageType.INFO)
dialog.set_title(_('No OCR engines available'))
dialog.set_markup(_('No OCR engines were found in the system.\n'
'Please make sure you have OCR engines installed '
'and available.'))
dialog.add_buttons(_('_Ignore'),
Gtk.ResponseType.CANCEL,
_('_Open OCR Engines Manager Dialog'),
Gtk.ResponseType.OK)
response = dialog.run()
dialog.destroy()
if response == Gtk.ResponseType.OK:
self.ocrEngines()
def enginesTool(self, widget = None):
pass
def about(self, widget = None):
about_dialog = widgetPresenter.CustomAboutDialog(self.main_window)
if about_dialog.run():
about_dialog.destroy()
def showHelpContents(self, widget = None):
Gtk.show_uri(self.main_window.get_screen(),
'help:ocrfeeder',
Gtk.get_current_event_time())
def zoomIn(self, widget = None):
self.source_images_controler.zoomIn()
def zoomOut(self, widget = None):
self.source_images_controler.zoomOut()
def resetZoom(self, widget = None):
self.source_images_controler.resetZoom()
def zoomFit(self, widget = None):
self.source_images_controler.zoomFit()
def __pagesUpdatedCallback(self, model, path, iter = None):
self.main_window.setNumberOfPages(
self.pages_icon_view.getNumberOfPages())
def __askForEnginesMigration(self):
auto_update = self.engines_needing_update['auto']
if auto_update:
for migration in auto_update:
self.ocr_engines_manager.migrateEngine(migration['engine'],
migration['configuration'])
manual_update = self.engines_needing_update['manual']
if manual_update:
names = []
for migration in manual_update:
names.append(migration['engine'].name)
dialog = Gtk.MessageDialog(self.main_window,
Gtk.DialogFlags.MODAL |
Gtk.DialogFlags.DESTROY_WITH_PARENT,
Gtk.MessageType.WARNING)
dialog.add_buttons(_('_Keep Current Configuration') ,
Gtk.ResponseType.CANCEL,
_('_Open OCR Engines Manager Dialog'),
Gtk.ResponseType.OK)
message = _('The following OCR engines\' arguments '
'might need to be updated but it appears '
'you have changed their default configuration so '
'they need to be updated manually:\n '
'<b>%(engines)s</b>\n\n'
'If you do not want to keep your changes '
'you can just remove the current configuration '
'and have your OCR engines detected again.') % \
{'engines': '\n'.join(names)}
dialog.set_markup(message)
response = dialog.run()
dialog.destroy()
for migration in manual_update:
self.ocr_engines_manager.migrateEngine(migration['engine'],
migration['configuration'])
if response == Gtk.ResponseType.OK:
self.ocrEngines()
def quit(self, widget = None, data = None):
if not self.project_name and not self.pages_icon_view.isEmpty():
quit_dialog = widgetPresenter.QuestionDialog(self.main_window,
'<b>' + _("The project hasn't been saved.") + '</b>', Gtk.ButtonsType.NONE)
quit_dialog.format_secondary_text(_('Do you want to save it before closing?'))
quit_dialog.add_buttons(_('Close anyway'), Gtk.ResponseType.NO, Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_SAVE_AS, Gtk.ResponseType.YES)
response = quit_dialog.run()
quit_dialog.destroy()
if response == Gtk.ResponseType.YES:
self.saveProjectAs()
self.__main_quit()
elif response == Gtk.ResponseType.NO:
quit_dialog.destroy()
self.__main_quit()
else:
return True
else:
self.__main_quit()
return False
def __main_quit(self):
self.configuration_manager.configurationToXml()
self.configuration_manager.removeTemporaryFolder()
Gtk.main_quit()
def __init__(self):
# i18n
languages = []
lc, encoding = locale.getdefaultlocale()
if lc:
languages = [lc]
languages += DEFAULT_LANGUAGES
gettext.bindtextdomain(OCRFEEDER_COMPACT_NAME, LOCALE_DIR)
gettext.textdomain(OCRFEEDER_COMPACT_NAME)
language = gettext.translation(OCRFEEDER_COMPACT_NAME,
LOCALE_DIR,
languages=languages,
fallback=True)
_ = language.gettext
self.EXPORT_FORMATS = {
0: ('ODT', _('ODT')),
1: ('HTML', _('HTML')),
2: ('PDF', _('PDF')),
3: ('TXT', _('Plain Text'))
}
self.title = OCRFEEDER_STUDIO_NAME
self.main_window = widgetPresenter.MainWindow()
self.main_window.set_title(self.title)
self.document_generator_manager = DocumentGeneratorManager()
self.configuration_manager = ConfigurationManager()
self.ocr_engines_manager = OcrEnginesManager(
self.configuration_manager)
self.configuration_manager.loadConfiguration()
user_engines_folder = self.configuration_manager.user_engines_folder
self.engines_needing_update = \
self.ocr_engines_manager.makeEnginesFromFolder(user_engines_folder)
self.ocr_engines = self.ocr_engines_manager.ocr_engines
self.pages_icon_view = PagesIconView()
self.pages_icon_view.setDeleteCurrentPageFunction(
self.deleteCurrentPage)
self.pages_icon_view.get_model().connect('row-inserted',
self.__pagesUpdatedCallback)
self.pages_icon_view.get_model().connect('row-deleted',
self.__pagesUpdatedCallback)
self.pages_icon_view.show()
self.main_window.main_area_left.add_with_viewport(self.pages_icon_view)
self.images_selectable_area = {}
self.source_images_controler = ImageReviewer_Controler(
self.main_window, self.pages_icon_view, self.ocr_engines,
self.configuration_manager)
self.project_name = None
toolbar_callback_dict = {
'recognizePage': self.__recognizePageAction,
'recognizeDocument': self.__recognizeDocumentAction,
'export_to_odt': self.exportToOdt
}
menubar_callback_dict = {
'exit': self.quit,
'add_image': self.addImage,
'export_to_odt': self.exportToOdt,
'edit_page': self.choosePageSize,
'delete_page': self.deleteCurrentPage,
'export_dialog': self.exportDialog,
'add_folder': self.addFolder,
'import_pdf': self.importPdf,
'save_project': self.saveProject,
'save_project_as': self.saveProjectAs,
'open_project': self.openProject,
'append_project': self.appendProject,
'clear': self.clear,
'unpaper': self.unpaper,
'preferences': self.preferences,
'about': self.about,
'ocr_engines': self.ocrEngines,
'zoom_in': self.zoomIn,
'zoom_out': self.zoomOut,
'zoom_fit': self.zoomFit,
'reset_zoom': self.resetZoom,
'recognize_areas': self.__recognizeSelectedAreas,
'import_from_scanner': self.importFromScanner,
'select_next_area': self.source_images_controler.selectNextArea,
'select_previous_area':
self.source_images_controler.selectPreviousArea,
'select_all_areas': self.source_images_controler.selectAllAreas,
'delete_selected_areas':
self.source_images_controler.deleteSelectedAreas,
'image_deskewer': self.source_images_controler.deskewCurrentImage,
'copy_to_clipboard':
self.source_images_controler.copyRecognizedTextToClipboard,
'spell_checker': self.spellChecker,
'help_contents': self.showHelpContents,
'move_page_down': self.movePageDown,
'move_page_up': self.movePageUp,
'select_next_page': self.selectNextPage,
'select_previous_page': self.selectPreviousPage,
}
self.main_window.setHeader(menubar_callback_dict,
toolbar_callback_dict)
self.main_window.setDestroyEvent(self.quit)
parser = ArgumentParser(description=OCRFEEDER_STUDIO_COMMENTS)
parser.add_argument('images',
metavar='IMAGE',
nargs='*',
help='images to be automatically added '
'on start-up')
parser.add_argument('-d',
'--dir',
help='directory with images to be '
'added automatically on start-up')
parser.add_argument('-v',
'--version',
action='version',
version='%(prog)s ' + OCRFEEDER_STUDIO_VERSION)
args = parser.parse_args()
imgs = args.images
if imgs:
self.__addImagesToReviewer(imgs)
if args.dir:
self.__addImagesToReviewer(lib.getImagesFromFolder(args.dir))
self.main_window.setHasSelectedBoxes(False)
self.main_window.setHasContentBoxes(False)
self.main_window.setNumberOfPages(
self.pages_icon_view.getNumberOfPages())
# Show dialog to choose system-wide OCR engines when no engine was found
if not self.ocr_engines:
engines = self.configuration_manager.getEnginesInSystem()
if engines:
add_engines_dialog = widgetPresenter.SystemEnginesDialog(
engines)
response = add_engines_dialog.run()
if response == Gtk.ResponseType.ACCEPT:
for engine in add_engines_dialog.getChosenEngines():
self.ocr_engines_manager.addNewEngine(engine)
add_engines_dialog.destroy()
else:
self.__askForEnginesMigration()
self._last_images_dir = ''
if not self.ocr_engines:
self.warnNoOCREngines()
class Studio:
TARGET_TYPE_URI_LIST = 80
def __init__(self):
# i18n
languages = []
lc, encoding = locale.getdefaultlocale()
if lc:
languages = [lc]
languages += DEFAULT_LANGUAGES
gettext.bindtextdomain(OCRFEEDER_COMPACT_NAME, LOCALE_DIR)
gettext.textdomain(OCRFEEDER_COMPACT_NAME)
language = gettext.translation(OCRFEEDER_COMPACT_NAME,
LOCALE_DIR,
languages=languages,
fallback=True)
_ = language.gettext
self.EXPORT_FORMATS = {
0: ('ODT', _('ODT')),
1: ('HTML', _('HTML')),
2: ('PDF', _('PDF')),
3: ('TXT', _('Plain Text'))
}
self.title = OCRFEEDER_STUDIO_NAME
self.main_window = widgetPresenter.MainWindow()
self.main_window.set_title(self.title)
self.document_generator_manager = DocumentGeneratorManager()
self.configuration_manager = ConfigurationManager()
self.ocr_engines_manager = OcrEnginesManager(
self.configuration_manager)
self.configuration_manager.loadConfiguration()
user_engines_folder = self.configuration_manager.user_engines_folder
self.engines_needing_update = \
self.ocr_engines_manager.makeEnginesFromFolder(user_engines_folder)
self.ocr_engines = self.ocr_engines_manager.ocr_engines
self.pages_icon_view = PagesIconView()
self.pages_icon_view.setDeleteCurrentPageFunction(
self.deleteCurrentPage)
self.pages_icon_view.get_model().connect('row-inserted',
self.__pagesUpdatedCallback)
self.pages_icon_view.get_model().connect('row-deleted',
self.__pagesUpdatedCallback)
self.pages_icon_view.show()
self.main_window.main_area_left.add_with_viewport(self.pages_icon_view)
self.images_selectable_area = {}
self.source_images_controler = ImageReviewer_Controler(
self.main_window, self.pages_icon_view, self.ocr_engines,
self.configuration_manager)
self.project_name = None
toolbar_callback_dict = {
'recognizePage': self.__recognizePageAction,
'recognizeDocument': self.__recognizeDocumentAction,
'export_to_odt': self.exportToOdt
}
menubar_callback_dict = {
'exit': self.quit,
'add_image': self.addImage,
'export_to_odt': self.exportToOdt,
'edit_page': self.choosePageSize,
'delete_page': self.deleteCurrentPage,
'export_dialog': self.exportDialog,
'add_folder': self.addFolder,
'import_pdf': self.importPdf,
'save_project': self.saveProject,
'save_project_as': self.saveProjectAs,
'open_project': self.openProject,
'append_project': self.appendProject,
'clear': self.clear,
'unpaper': self.unpaper,
'preferences': self.preferences,
'about': self.about,
'ocr_engines': self.ocrEngines,
'zoom_in': self.zoomIn,
'zoom_out': self.zoomOut,
'zoom_fit': self.zoomFit,
'reset_zoom': self.resetZoom,
'recognize_areas': self.__recognizeSelectedAreas,
'import_from_scanner': self.importFromScanner,
'select_next_area': self.source_images_controler.selectNextArea,
'select_previous_area':
self.source_images_controler.selectPreviousArea,
'select_all_areas': self.source_images_controler.selectAllAreas,
'delete_selected_areas':
self.source_images_controler.deleteSelectedAreas,
'image_deskewer': self.source_images_controler.deskewCurrentImage,
'copy_to_clipboard':
self.source_images_controler.copyRecognizedTextToClipboard,
'spell_checker': self.spellChecker,
'help_contents': self.showHelpContents,
'move_page_down': self.movePageDown,
'move_page_up': self.movePageUp,
'select_next_page': self.selectNextPage,
'select_previous_page': self.selectPreviousPage,
}
self.main_window.setHeader(menubar_callback_dict,
toolbar_callback_dict)
self.main_window.setDestroyEvent(self.quit)
parser = ArgumentParser(description=OCRFEEDER_STUDIO_COMMENTS)
parser.add_argument('images',
metavar='IMAGE',
nargs='*',
help='images to be automatically added '
'on start-up')
parser.add_argument('-d',
'--dir',
help='directory with images to be '
'added automatically on start-up')
parser.add_argument('-v',
'--version',
action='version',
version='%(prog)s ' + OCRFEEDER_STUDIO_VERSION)
args = parser.parse_args()
imgs = args.images
if imgs:
self.__addImagesToReviewer(imgs)
if args.dir:
self.__addImagesToReviewer(lib.getImagesFromFolder(args.dir))
self.main_window.setHasSelectedBoxes(False)
self.main_window.setHasContentBoxes(False)
self.main_window.setNumberOfPages(
self.pages_icon_view.getNumberOfPages())
# Show dialog to choose system-wide OCR engines when no engine was found
if not self.ocr_engines:
engines = self.configuration_manager.getEnginesInSystem()
if engines:
add_engines_dialog = widgetPresenter.SystemEnginesDialog(
engines)
response = add_engines_dialog.run()
if response == Gtk.ResponseType.ACCEPT:
for engine in add_engines_dialog.getChosenEngines():
self.ocr_engines_manager.addNewEngine(engine)
add_engines_dialog.destroy()
else:
self.__askForEnginesMigration()
self._last_images_dir = ''
if not self.ocr_engines:
self.warnNoOCREngines()
def run(self):
Gdk.threads_init()
Gdk.threads_enter()
Gtk.main()
Gdk.threads_leave()
def addImage(self, widget):
file_open_dialog = widgetPresenter.FileDialog(self.main_window,
'open',
file_filters=[
(_('Images'),
['image/*'], [])
])
file_open_dialog.set_select_multiple(True)
if self._last_images_dir:
file_open_dialog.set_current_folder(self._last_images_dir)
response = file_open_dialog.run()
if response == Gtk.ResponseType.OK:
self.__addImagesToReviewer(file_open_dialog.get_filenames())
self._last_images_dir = file_open_dialog.get_current_folder()
file_open_dialog.destroy()
def importFromScanner(self, widget):
dialog = widgetPresenter.QueuedEventsProgressDialog(self.main_window)
item_obtain = AsyncItem(lib.obtainScanners, (),
self.__obtainScannersFinishedCb, (dialog, ))
info_obtain = (_('Obtaining scanners'), _('Please wait…'))
dialog.setItemsList([(info_obtain, item_obtain)])
dialog.run()
def __obtainScannersFinishedCb(self, dialog, devices, error):
dialog.destroy()
device = None
if len(devices) > 1:
scanner_chooser_dialog = widgetPresenter.ScannerChooserDialog(\
self.main_window,
devices)
Gdk.threads_enter()
response = scanner_chooser_dialog.run()
Gdk.threads_leave()
if response == Gtk.ResponseType.ACCEPT:
device = scanner_chooser_dialog.getSelectedDevice()
scanner_chooser_dialog.destroy()
if response != Gtk.ResponseType.ACCEPT:
return
elif len(devices) == 1:
device = devices[0][0]
if device:
dialog_scan = widgetPresenter.QueuedEventsProgressDialog(\
self.main_window)
item_scan = AsyncItem(lib.scan, (device, ), self.__scanFinishedCb,
(dialog_scan, ))
info_scan = (_('Scanning'), _('Please wait…'))
dialog_scan.setItemsList([(info_scan, item_scan)])
dialog_scan.run()
else:
error = widgetPresenter.SimpleDialog(
self.main_window, _("No scanner devices were found"),
_("Error"), 'warning')
Gdk.threads_enter()
error.run()
Gdk.threads_leave()
def __scanFinishedCb(self, dialog, image_path, error):
dialog.destroy()
if image_path:
Gdk.threads_enter()
self.__addImagesToReviewer([image_path])
Gdk.threads_leave()
else:
error = widgetPresenter.SimpleDialog(self.main_window,
_("Error scanning page"),
_("Error"), 'warning')
Gdk.threads_enter()
error.run()
Gdk.threads_leave()
def importPdf(self, widget):
file_open_dialog = widgetPresenter.FileDialog(
self.main_window,
'open',
file_filters=[(_('PDF'), ['application/pdf'], [])])
response = file_open_dialog.run()
files = []
if response == Gtk.ResponseType.OK:
files = file_open_dialog.get_filenames()
file_open_dialog.destroy()
for file_name in files:
dialog = widgetPresenter.QueuedEventsProgressDialog(
self.main_window)
item = AsyncItem(
lib.convertPdfToImages,
(file_name, self.configuration_manager.TEMPORARY_FOLDER),
self.__loadPdfFinishedCb, (dialog, ))
info = (_('Loading PDF'), _('Please wait…'))
dialog.setItemsList([(info, item)])
dialog.run()
def __loadPdfFinishedCb(self, dialog, folder, error):
self.__addImagesToReviewer(lib.getImagesFromFolder(folder))
dialog.destroy()
def addFolder(self, widget):
file_open_dialog = widgetPresenter.FileDialog(self.main_window,
'select-folder')
response = file_open_dialog.run()
if response == Gtk.ResponseType.OK:
filenames = file_open_dialog.get_filenames()
file_open_dialog.destroy()
for folder in filenames:
self.__addImagesToReviewer(lib.getImagesFromFolder(folder))
file_open_dialog.destroy()
def exportToFormat(self, format, name):
generator = self.document_generator_manager.get(format)
self.source_images_controler.exportPagesWithGenerator(generator, name)
def exportToOdt(self, widget):
self.exportToFormat('ODT', 'ODT')
def exportDialog(self, widget):
format_names = [format[1] for format in self.EXPORT_FORMATS.values()]
export_dialog = widgetPresenter.ExportDialog(self.main_window,
_('Export pages'),
format_names)
response = export_dialog.run()
if response == Gtk.ResponseType.ACCEPT:
format = export_dialog.getSelectedFormat()
export_dialog.destroy()
if format != -1:
# Retrieve and run the exportation function
self.exportToFormat(self.EXPORT_FORMATS[format][0],
self.EXPORT_FORMATS[format][1])
return None
export_dialog.destroy()
return None
def choosePageSize(self, widget):
self.source_images_controler.choosePageSize()
def deleteCurrentPage(self, widget):
delete_dialog = widgetPresenter.QuestionDialog(
self.main_window,
_('Are you sure you want to delete the current image?'))
response = delete_dialog.run()
if response == Gtk.ResponseType.YES:
self.source_images_controler.deleteCurrentPage()
self.pages_icon_view.deleteCurrentSelection()
delete_dialog.destroy()
def movePageDown(self, widget):
self.pages_icon_view.movePage(1)
def movePageUp(self, widget):
self.pages_icon_view.movePage(-1)
def selectNextPage(self, widget):
self.pages_icon_view.selectPageFromOffset(1)
def selectPreviousPage(self, widget):
self.pages_icon_view.selectPageFromOffset(-1)
def __addImagesToReviewer(self, images):
if not images:
return
self.source_images_controler.addImages(images)
def __recognizePageAction(self, widget):
if not self.ocr_engines_manager.ocr_engines:
self.warnNoOCREngines()
return
self.source_images_controler.recognizeCurrentPage()
def __recognizeDocumentAction(self, widget):
if not self.ocr_engines_manager.ocr_engines:
self.warnNoOCREngines()
return
self.source_images_controler.recognizeDocument()
def __recognizeSelectedAreas(self, widget):
if not self.ocr_engines_manager.ocr_engines:
self.warnNoOCREngines()
return
self.source_images_controler.recognizeSelectedAreas()
def setProjectName(self, project_name):
self.project_name = project_name
project_title = os.path.splitext(os.path.basename(
self.project_name))[0]
self.main_window.set_title('%s - %s' % (self.title, project_title))
def saveProjectAs(self, widget=None):
file_name = self.source_images_controler.saveProjectAs()
if file_name:
self.setProjectName(file_name)
self.saveProject()
def saveProject(self, widget=None):
if self.project_name:
self.source_images_controler.saveProject(self.project_name)
else:
self.saveProjectAs()
def appendProject(self, widget=None):
self.__loadProject(False)
def openProject(self, widget=None):
self.__loadProject()
def __loadProject(self, clear_current=True):
project_title = self.source_images_controler.openProject(clear_current)
if project_title:
self.setProjectName(project_title)
def clear(self, widget=None):
dialog = widgetPresenter.QuestionDialog(
self.main_window,
_('Are you sure you want '
'to clear the project?'))
response = dialog.run()
if response == Gtk.ResponseType.YES:
self.source_images_controler.clear()
dialog.destroy()
def unpaper(self, widget=None):
self.source_images_controler.unpaperTool()
def spellChecker(self, widget=None):
self.source_images_controler.spellCheck(locale.getdefaultlocale()[0])
def preferences(self, widget=None):
parent = self.main_window
preferences_dialog = widgetPresenter.PreferencesDialog(
parent, self.configuration_manager,
self.ocr_engines_manager.ocr_engines)
if preferences_dialog.run() == Gtk.ResponseType.ACCEPT:
preferences_dialog.saveToManager()
self.source_images_controler.updateFromConfiguration()
preferences_dialog.destroy()
def ocrEngines(self, widget=None):
ocr_dialog = widgetPresenter.OcrManagerDialog(self.main_window,
self.ocr_engines_manager)
ocr_dialog.run()
if ocr_dialog.modified:
ocr_engines = self.ocr_engines_manager.ocr_engines
self.source_images_controler.updateOcrEngines(ocr_engines)
ocr_dialog.destroy()
def warnNoOCREngines(self):
debug('No OCR engines found')
dialog = Gtk.MessageDialog(
self.main_window,
Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
Gtk.MessageType.INFO)
dialog.set_title(_('No OCR engines available'))
dialog.set_markup(
_('No OCR engines were found in the system.\n'
'Please make sure you have OCR engines installed '
'and available.'))
dialog.add_buttons(_('_Ignore'), Gtk.ResponseType.CANCEL,
_('_Open OCR Engines Manager Dialog'),
Gtk.ResponseType.OK)
response = dialog.run()
dialog.destroy()
if response == Gtk.ResponseType.OK:
self.ocrEngines()
def enginesTool(self, widget=None):
pass
def about(self, widget=None):
about_dialog = widgetPresenter.CustomAboutDialog(self.main_window)
if about_dialog.run():
about_dialog.destroy()
def showHelpContents(self, widget=None):
Gtk.show_uri(self.main_window.get_screen(), 'help:ocrfeeder',
Gtk.get_current_event_time())
def zoomIn(self, widget=None):
self.source_images_controler.zoomIn()
def zoomOut(self, widget=None):
self.source_images_controler.zoomOut()
def resetZoom(self, widget=None):
self.source_images_controler.resetZoom()
def zoomFit(self, widget=None):
self.source_images_controler.zoomFit()
def __pagesUpdatedCallback(self, model, path, iter=None):
self.main_window.setNumberOfPages(
self.pages_icon_view.getNumberOfPages())
def __askForEnginesMigration(self):
auto_update = self.engines_needing_update['auto']
if auto_update:
for migration in auto_update:
self.ocr_engines_manager.migrateEngine(
migration['engine'], migration['configuration'])
manual_update = self.engines_needing_update['manual']
if manual_update:
names = []
for migration in manual_update:
names.append(migration['engine'].name)
dialog = Gtk.MessageDialog(
self.main_window,
Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
Gtk.MessageType.WARNING)
dialog.add_buttons(_('_Keep Current Configuration'),
Gtk.ResponseType.CANCEL,
_('_Open OCR Engines Manager Dialog'),
Gtk.ResponseType.OK)
message = _('The following OCR engines\' arguments '
'might need to be updated but it appears '
'you have changed their default configuration so '
'they need to be updated manually:\n '
'<b>%(engines)s</b>\n\n'
'If you do not want to keep your changes '
'you can just remove the current configuration '
'and have your OCR engines detected again.') % \
{'engines': '\n'.join(names)}
dialog.set_markup(message)
response = dialog.run()
dialog.destroy()
for migration in manual_update:
self.ocr_engines_manager.migrateEngine(
migration['engine'], migration['configuration'])
if response == Gtk.ResponseType.OK:
self.ocrEngines()
def quit(self, widget=None, data=None):
if not self.project_name and not self.pages_icon_view.isEmpty():
quit_dialog = widgetPresenter.QuestionDialog(
self.main_window,
'<b>' + _("The project hasn't been saved.") + '</b>',
Gtk.ButtonsType.NONE)
quit_dialog.format_secondary_text(
_('Do you want to save it before closing?'))
quit_dialog.add_buttons(_('Close anyway'), Gtk.ResponseType.NO,
Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
Gtk.STOCK_SAVE_AS, Gtk.ResponseType.YES)
response = quit_dialog.run()
quit_dialog.destroy()
if response == Gtk.ResponseType.YES:
self.saveProjectAs()
self.__main_quit()
elif response == Gtk.ResponseType.NO:
quit_dialog.destroy()
self.__main_quit()
else:
return True
else:
self.__main_quit()
return False
def __main_quit(self):
self.configuration_manager.configurationToXml()
self.configuration_manager.removeTemporaryFolder()
Gtk.main_quit()
def __init__(self):
# i18n
languages = []
lc, encoding = locale.getdefaultlocale()
if lc:
languages = [lc]
languages += DEFAULT_LANGUAGES
gettext.bindtextdomain(OCRFEEDER_COMPACT_NAME, LOCALE_DIR)
gettext.textdomain(OCRFEEDER_COMPACT_NAME)
language = gettext.translation(OCRFEEDER_COMPACT_NAME, LOCALE_DIR,
languages = languages, fallback = True)
_ = language.gettext
self.EXPORT_FORMATS = {0: ('ODT', _('ODT')),
1: ('HTML', _('HTML')),
2: ('PDF', _('PDF')),
3: ('TXT', _('Plain Text'))}
self.title = OCRFEEDER_STUDIO_NAME
self.main_window = widgetPresenter.MainWindow()
self.main_window.setTitle(self.title)
self.document_generator_manager = DocumentGeneratorManager()
self.configuration_manager = ConfigurationManager()
self.ocr_engines_manager = OcrEnginesManager(self.configuration_manager)
self.configuration_manager.loadConfiguration()
user_engines_folder = self.configuration_manager.user_engines_folder
self.engines_needing_update = \
self.ocr_engines_manager.makeEnginesFromFolder(user_engines_folder)
self.ocr_engines = self.ocr_engines_manager.ocr_engines
self.source_images_list_store = SourceImagesListStore()
self.source_images_icon_view = SourceImagesSelectorIconView(self.source_images_list_store)
self.source_images_icon_view.setDeleteCurrentPageFunction(self.deleteCurrentPage)
self.source_images_icon_view.connect('drag_data_received', self.dragDataReceived)
self.source_images_icon_view.connect('drag_drop', self.dragDrop)
self.source_images_icon_view.get_model().connect('row-inserted',
self.__pagesUpdatedCallback)
self.source_images_icon_view.get_model().connect('row-deleted',
self.__pagesUpdatedCallback)
self.source_images_icon_view.drag_dest_set(gtk.DEST_DEFAULT_MOTION | gtk.DEST_DEFAULT_HIGHLIGHT,
[('text/uri-list', 0, self.TARGET_TYPE_URI_LIST)], gtk.gdk.ACTION_COPY)
self.source_images_icon_view.show()
self.main_window.main_area_left.add_with_viewport(self.source_images_icon_view)
self.images_selectable_area = {}
self.source_images_controler = ImageReviewer_Controler(self.main_window,
self.source_images_icon_view,
self.ocr_engines,
self.configuration_manager)
self.project_name = None
toolbar_callback_dict = {'recognizePage': self.__recognizePageAction,
'recognizeDocument': self.__recognizeDocumentAction,
'export_to_odt': self.exportToOdt}
menubar_callback_dict = {'exit': self.quit, 'add_image': self.addImage, 'export_to_odt': self.exportToOdt, 'edit_page': self.choosePageSize,
'delete_page': self.deleteCurrentPage, 'export_dialog': self.exportDialog, 'add_folder': self.addFolder,
'import_pdf': self.importPdf, 'save_project': self.saveProject, 'save_project_as': self.saveProjectAs,
'open_project': self.openProject, 'append_project': self.appendProject,'clear': self.clear,
'unpaper': self.unpaper, 'preferences': self.preferences, 'about': self.about,
'ocr_engines': self.ocrEngines, 'zoom_in': self.zoomIn, 'zoom_out': self.zoomOut,
'zoom_fit': self.zoomFit, 'reset_zoom': self.resetZoom,
'recognize_areas': self.source_images_controler.recognizeSelectedAreas,
'import_from_scanner': self.importFromScanner,
'select_next_area': self.source_images_controler.selectNextArea,
'select_previous_area': self.source_images_controler.selectPreviousArea,
'select_all_areas': self.source_images_controler.selectAllAreas,
'delete_selected_areas': self.source_images_controler.deleteSelectedAreas,
'image_deskewer': self.source_images_controler.deskewCurrentImage,
'copy_to_clipboard': self.source_images_controler.copyRecognizedTextToClipboard,
'spell_checker': self.spellChecker,
'help_contents': self.showHelpContents,
'move_page_down': self.movePageDown,
'move_page_up': self.movePageUp,
'select_next_page': self.selectNextPage,
'select_previous_page': self.selectPreviousPage,
}
self.main_window.setHeader(menubar_callback_dict, toolbar_callback_dict)
self.main_window.setDestroyEvent(self.quit)
parser = OptionParser(version = '%prog ' + OCRFEEDER_STUDIO_VERSION)
parser.add_option('-i', '--images', dest = 'images',
action = 'append', type = 'string',
metavar = 'IMAGE1 [IMAGE2, ...]', default = [],
help = 'images to be automatically added on start-up. '
'Use the option before every image path.')
parser.add_option('-d', '--dir', dest = 'directory',
action = 'store', type = 'string',
help = 'directory with images to be added'
' automatically on start-up')
options, args = parser.parse_args()
imgs = options.images
if imgs:
self.__addImagesToReviewer(imgs)
if options.directory:
self.__addImagesToReviewer(
lib.getImagesFromFolder(options.directory))
self.main_window.setHasSelectedBoxes(False)
self.main_window.setHasContentBoxes(False)
self.main_window.setNumberOfPages(
self.source_images_icon_view.getNumberOfPages())
# Show dialog to choose system-wide OCR engines when no engine was found
if not self.ocr_engines:
engines = self.configuration_manager.getEnginesInSystem()
if engines:
add_engines_dialog = widgetPresenter.SystemEnginesDialog(engines)
response = add_engines_dialog.run()
if response == gtk.RESPONSE_ACCEPT:
for engine in add_engines_dialog.getChosenEngines():
self.ocr_engines_manager.addNewEngine(engine)
add_engines_dialog.destroy()
else:
self.__askForEnginesMigration()
class Studio:
TARGET_TYPE_URI_LIST = 80
def __init__(self):
# i18n
languages = []
lc, encoding = locale.getdefaultlocale()
if lc:
languages = [lc]
languages += DEFAULT_LANGUAGES
gettext.bindtextdomain(OCRFEEDER_COMPACT_NAME, LOCALE_DIR)
gettext.textdomain(OCRFEEDER_COMPACT_NAME)
language = gettext.translation(OCRFEEDER_COMPACT_NAME, LOCALE_DIR,
languages = languages, fallback = True)
_ = language.gettext
self.EXPORT_FORMATS = {0: ('ODT', _('ODT')),
1: ('HTML', _('HTML')),
2: ('PDF', _('PDF')),
3: ('TXT', _('Plain Text'))}
self.title = OCRFEEDER_STUDIO_NAME
self.main_window = widgetPresenter.MainWindow()
self.main_window.setTitle(self.title)
self.document_generator_manager = DocumentGeneratorManager()
self.configuration_manager = ConfigurationManager()
self.ocr_engines_manager = OcrEnginesManager(self.configuration_manager)
self.configuration_manager.loadConfiguration()
user_engines_folder = self.configuration_manager.user_engines_folder
self.engines_needing_update = \
self.ocr_engines_manager.makeEnginesFromFolder(user_engines_folder)
self.ocr_engines = self.ocr_engines_manager.ocr_engines
self.source_images_list_store = SourceImagesListStore()
self.source_images_icon_view = SourceImagesSelectorIconView(self.source_images_list_store)
self.source_images_icon_view.setDeleteCurrentPageFunction(self.deleteCurrentPage)
self.source_images_icon_view.connect('drag_data_received', self.dragDataReceived)
self.source_images_icon_view.connect('drag_drop', self.dragDrop)
self.source_images_icon_view.get_model().connect('row-inserted',
self.__pagesUpdatedCallback)
self.source_images_icon_view.get_model().connect('row-deleted',
self.__pagesUpdatedCallback)
self.source_images_icon_view.drag_dest_set(gtk.DEST_DEFAULT_MOTION | gtk.DEST_DEFAULT_HIGHLIGHT,
[('text/uri-list', 0, self.TARGET_TYPE_URI_LIST)], gtk.gdk.ACTION_COPY)
self.source_images_icon_view.show()
self.main_window.main_area_left.add_with_viewport(self.source_images_icon_view)
self.images_selectable_area = {}
self.source_images_controler = ImageReviewer_Controler(self.main_window,
self.source_images_icon_view,
self.ocr_engines,
self.configuration_manager)
self.project_name = None
toolbar_callback_dict = {'recognizePage': self.__recognizePageAction,
'recognizeDocument': self.__recognizeDocumentAction,
'export_to_odt': self.exportToOdt}
menubar_callback_dict = {'exit': self.quit, 'add_image': self.addImage, 'export_to_odt': self.exportToOdt, 'edit_page': self.choosePageSize,
'delete_page': self.deleteCurrentPage, 'export_dialog': self.exportDialog, 'add_folder': self.addFolder,
'import_pdf': self.importPdf, 'save_project': self.saveProject, 'save_project_as': self.saveProjectAs,
'open_project': self.openProject, 'append_project': self.appendProject,'clear': self.clear,
'unpaper': self.unpaper, 'preferences': self.preferences, 'about': self.about,
'ocr_engines': self.ocrEngines, 'zoom_in': self.zoomIn, 'zoom_out': self.zoomOut,
'zoom_fit': self.zoomFit, 'reset_zoom': self.resetZoom,
'recognize_areas': self.source_images_controler.recognizeSelectedAreas,
'import_from_scanner': self.importFromScanner,
'select_next_area': self.source_images_controler.selectNextArea,
'select_previous_area': self.source_images_controler.selectPreviousArea,
'select_all_areas': self.source_images_controler.selectAllAreas,
'delete_selected_areas': self.source_images_controler.deleteSelectedAreas,
'image_deskewer': self.source_images_controler.deskewCurrentImage,
'copy_to_clipboard': self.source_images_controler.copyRecognizedTextToClipboard,
'spell_checker': self.spellChecker,
'help_contents': self.showHelpContents,
'move_page_down': self.movePageDown,
'move_page_up': self.movePageUp,
'select_next_page': self.selectNextPage,
'select_previous_page': self.selectPreviousPage,
}
self.main_window.setHeader(menubar_callback_dict, toolbar_callback_dict)
self.main_window.setDestroyEvent(self.quit)
parser = OptionParser(version = '%prog ' + OCRFEEDER_STUDIO_VERSION)
parser.add_option('-i', '--images', dest = 'images',
action = 'append', type = 'string',
metavar = 'IMAGE1 [IMAGE2, ...]', default = [],
help = 'images to be automatically added on start-up. '
'Use the option before every image path.')
parser.add_option('-d', '--dir', dest = 'directory',
action = 'store', type = 'string',
help = 'directory with images to be added'
' automatically on start-up')
options, args = parser.parse_args()
imgs = options.images
if imgs:
self.__addImagesToReviewer(imgs)
if options.directory:
self.__addImagesToReviewer(
lib.getImagesFromFolder(options.directory))
self.main_window.setHasSelectedBoxes(False)
self.main_window.setHasContentBoxes(False)
self.main_window.setNumberOfPages(
self.source_images_icon_view.getNumberOfPages())
# Show dialog to choose system-wide OCR engines when no engine was found
if not self.ocr_engines:
engines = self.configuration_manager.getEnginesInSystem()
if engines:
add_engines_dialog = widgetPresenter.SystemEnginesDialog(engines)
response = add_engines_dialog.run()
if response == gtk.RESPONSE_ACCEPT:
for engine in add_engines_dialog.getChosenEngines():
self.ocr_engines_manager.addNewEngine(engine)
add_engines_dialog.destroy()
else:
self.__askForEnginesMigration()
def run(self):
gtk.gdk.threads_init()
gtk.main()
def dragDataReceived(self, widget, context, x, y, selection, target_type, timestamp):
if target_type == self.TARGET_TYPE_URI_LIST:
uris = selection.data.strip('\r\n\x00').split()
paths = []
for uri in uris:
path = ""
if uri.startswith('file:\\\\\\'): # windows
path = uri[8:]
elif uri.startswith('file://'): # nautilus, rox
path = uri[7:]
elif uri.startswith('file:'): # xffm
path = uri[5:]
path = urllib.url2pathname(path).strip('\r\n\x00')
if os.path.isfile(path):
paths.append(path)
for path in paths:
if os.path.splitext(path)[1] == '.pdf':
folder = lib.convertPdfToImages(path,
self.configuration_manager.TEMPORARY_FOLDER)
self.__addImagesToReviewer(lib.getImagesFromFolder(folder))
else:
try:
self.__addImagesToReviewer([path])
except:
pass
def dragDrop(self, widget, context, x, y, timestamp):
target_atom = widget.drag_dest_find_target(context, widget.drag_dest_get_target_list())
if target_atom != None:
widget.drag_get_data(context, target_atom, timestamp)
context.finish(True, False, timestamp)
return True
def addImage(self, widget):
file_open_dialog = widgetPresenter.FileDialog('open', file_filters = [(_('Images'), ['image/*'], [])])
file_open_dialog.set_select_multiple(True)
response = file_open_dialog.run()
if response == gtk.RESPONSE_OK:
self.__addImagesToReviewer(file_open_dialog.get_filenames())
file_open_dialog.destroy()
def importFromScanner(self, widget):
dialog = widgetPresenter.QueuedEventsProgressDialog(\
self.main_window.window)
item_obtain = AsyncItem(lib.obtainScanners,(),
self.__obtainScannersFinishedCb,(dialog,))
info_obtain = (_('Obtaining scanners'), _(u'Please wait…'))
dialog.setItemsList([(info_obtain, item_obtain)])
dialog.run()
def __obtainScannersFinishedCb(self, dialog, devices, error):
dialog.destroy()
device = None
if len(devices) > 1:
scanner_chooser_dialog = widgetPresenter.ScannerChooserDialog(\
self.main_window.window,
devices)
gtk.gdk.threads_enter()
response = scanner_chooser_dialog.run()
gtk.gdk.threads_leave()
scanner_chooser_dialog.destroy()
if response == gtk.RESPONSE_ACCEPT:
device = scanner_chooser_dialog.getSelectedDevice()
else:
return
elif len(devices) == 1:
device = devices[0][0]
if device:
dialog_scan = widgetPresenter.QueuedEventsProgressDialog(\
self.main_window.window)
item_scan = AsyncItem(lib.scan,(device,),
self.__scanFinishedCb,(dialog_scan,))
info_scan = (_('Scanning'), _(u'Please wait…'))
dialog_scan.setItemsList([(info_scan, item_scan)])
dialog_scan.run()
else:
error = widgetPresenter.SimpleDialog(\
_("No scanner devices were found"),
_("Error"),
'warning')
gtk.gdk.threads_enter()
error.run()
gtk.gdk.threads_leave()
def __scanFinishedCb(self, dialog, image_path, error):
dialog.destroy()
if image_path:
gtk.gdk.threads_enter()
self.__addImagesToReviewer([image_path])
gtk.gdk.threads_leave()
else:
error = widgetPresenter.SimpleDialog(\
_("Error scanning page"),
_("Error"),
'warning')
gtk.gdk.threads_enter()
error.run()
gtk.gdk.threads_leave()
def importPdf(self, widget):
file_open_dialog = widgetPresenter.FileDialog('open', file_filters = [(_('PDF'), ['application/pdf'], [])])
response = file_open_dialog.run()
files = []
if response == gtk.RESPONSE_OK:
files = file_open_dialog.get_filenames()
file_open_dialog.destroy()
for file_name in files:
dialog = widgetPresenter.QueuedEventsProgressDialog(
self.main_window.window)
item = AsyncItem(lib.convertPdfToImages,
(file_name,
self.configuration_manager.TEMPORARY_FOLDER),
self.__loadPdfFinishedCb,
(dialog,))
info = (_('Loading PDF'), _(u'Please wait…'))
dialog.setItemsList([(info, item)])
dialog.run()
def __loadPdfFinishedCb(self, dialog, folder, error):
self.__addImagesToReviewer(lib.getImagesFromFolder(folder))
dialog.destroy()
def addFolder(self, widget):
file_open_dialog = widgetPresenter.FileDialog('select-folder')
response = file_open_dialog.run()
if response == gtk.RESPONSE_OK:
filenames = file_open_dialog.get_filenames()
file_open_dialog.destroy()
for folder in filenames:
self.__addImagesToReviewer(lib.getImagesFromFolder(folder))
file_open_dialog.destroy()
def exportToFormat(self, format, name):
generator = self.document_generator_manager.get(format)
self.source_images_controler.exportPagesWithGenerator(generator,
name)
def exportToOdt(self, widget):
self.exportToFormat('ODT', 'ODT')
def exportDialog(self, widget):
format_names = [format[1] for format in self.EXPORT_FORMATS.values()]
export_dialog = widgetPresenter.ExportDialog(_('Export pages'),
format_names)
response = export_dialog.run()
if response == gtk.RESPONSE_ACCEPT:
format = export_dialog.getSelectedFormat()
export_dialog.destroy()
if format != -1:
# Retrieve and run the exportation function
self.exportToFormat(self.EXPORT_FORMATS[format][0],
self.EXPORT_FORMATS[format][1])
return None
export_dialog.destroy()
return None
def choosePageSize(self, widget):
self.source_images_controler.choosePageSize()
def deleteCurrentPage(self, widget):
delete_dialog = widgetPresenter.QuestionDialog(_('Are you sure you want to delete the current image?'))
response = delete_dialog.run()
if response == gtk.RESPONSE_YES:
self.source_images_controler.deleteCurrentPage()
self.source_images_icon_view.deleteCurrentSelection()
delete_dialog.destroy()
def movePageDown(self, widget):
self.source_images_icon_view.movePage(1)
def movePageUp(self, widget):
self.source_images_icon_view.movePage(-1)
def selectNextPage(self, widget):
self.source_images_icon_view.selectPageFromOffset(1)
def selectPreviousPage(self, widget):
self.source_images_icon_view.selectPageFromOffset(-1)
def __addImagesToReviewer(self, images):
if not images:
return
self.source_images_controler.addImages(images)
def __recognizePageAction(self, widget):
self.source_images_controler.recognizeCurrentPage()
def __recognizeDocumentAction(self, widget):
self.source_images_controler.recognizeDocument()
def setProjectName(self, project_name):
self.project_name = project_name
project_title = os.path.splitext(os.path.basename(self.project_name))[0]
self.main_window.setTitle('%s - %s' % (self.title, project_title))
def saveProjectAs(self, widget = None):
file_name = self.source_images_controler.saveProjectAs()
if file_name:
self.setProjectName(file_name)
self.saveProject()
def saveProject(self, widget = None):
if self.project_name:
self.source_images_controler.saveProject(self.project_name)
else:
self.saveProjectAs()
def appendProject(self, widget = None):
self.__loadProject(False)
def openProject(self, widget = None):
self.__loadProject()
def __loadProject(self, clear_current = True):
project_title = self.source_images_controler.openProject(clear_current)
if project_title:
self.setProjectName(project_title)
def clear(self, widget = None):
dialog = widgetPresenter.QuestionDialog(_('Are you sure you want '
'to clear the project?'))
response = dialog.run()
if response == gtk.RESPONSE_YES:
self.source_images_controler.clear()
dialog.destroy()
def unpaper(self, widget = None):
self.source_images_controler.unpaperTool()
def spellChecker(self, widget = None):
self.source_images_controler.spellCheck(locale.getdefaultlocale()[0])
def preferences(self, widget = None):
preferences_dialog = widgetPresenter.PreferencesDialog(self.configuration_manager, self.ocr_engines_manager.ocr_engines)
if preferences_dialog.run() == gtk.RESPONSE_ACCEPT:
preferences_dialog.saveToManager()
self.source_images_controler.updateFromConfiguration()
preferences_dialog.destroy()
def ocrEngines(self, widget = None):
ocr_dialog = widgetPresenter.OcrManagerDialog(self.ocr_engines_manager)
ocr_dialog.run()
ocr_dialog.destroy()
def enginesTool(self, widget = None):
pass
def about(self, widget = None):
about_dialog = widgetPresenter.CustomAboutDialog()
if about_dialog.run():
about_dialog.destroy()
def showHelpContents(self, widget = None):
gtk.show_uri(self.main_window.window.get_screen(),
'ghelp:ocrfeeder',
gtk.get_current_event_time())
def zoomIn(self, widget = None):
self.source_images_controler.zoomIn()
def zoomOut(self, widget = None):
self.source_images_controler.zoomOut()
def resetZoom(self, widget = None):
self.source_images_controler.resetZoom()
def zoomFit(self, widget = None):
self.source_images_controler.zoomFit()
def __pagesUpdatedCallback(self, model, path, iter):
self.main_window.setNumberOfPages(
self.source_images_icon_view.getNumberOfPages())
def __askForEnginesMigration(self):
auto_update = self.engines_needing_update['auto']
if auto_update:
for migration in auto_update:
self.ocr_engines_manager.migrateEngine(migration['engine'],
migration['configuration'])
manual_update = self.engines_needing_update['manual']
if manual_update:
names = []
for migration in manual_update:
names.append(migration['engine'].name)
dialog = gtk.MessageDialog(self.main_window.window,
gtk.DIALOG_MODAL |
gtk.DIALOG_DESTROY_WITH_PARENT,
gtk.MESSAGE_WARNING)
dialog.add_buttons(_('_Keep Current Configuration') ,
gtk.RESPONSE_CANCEL,
_('_Open OCR Engines Manager Dialog'),
gtk.RESPONSE_OK)
message = _('The following OCR engines\' arguments '
'might need to be updated but it appears '
'you have changed their default configuration so '
'they need to be updated manually:\n '
'<b>%(engines)s</b>\n\n'
'If you do not want to keep your changes '
'you can just remove the current configuration '
'and have your OCR engines detected again.') % \
{'engines': '\n'.join(names)}
dialog.set_markup(message)
response = dialog.run()
dialog.destroy()
for migration in manual_update:
self.ocr_engines_manager.migrateEngine(migration['engine'],
migration['configuration'])
if response == gtk.RESPONSE_OK:
self.ocrEngines()
def quit(self, widget = None, data = None):
if not self.project_name and not self.source_images_list_store.isEmpty():
quit_dialog = widgetPresenter.QuestionDialog('<b>' + _("The project hasn't been saved.") + '</b>', gtk.BUTTONS_NONE)
quit_dialog.format_secondary_text(_('Do you want to save it before closing?'))
quit_dialog.add_buttons(_('Close anyway'), gtk.RESPONSE_NO, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE_AS, gtk.RESPONSE_YES)
response = quit_dialog.run()
quit_dialog.destroy()
if response == gtk.RESPONSE_YES:
self.saveProjectAs()
self.__main_quit()
elif response == gtk.RESPONSE_NO:
quit_dialog.destroy()
self.__main_quit()
else:
return True
else:
self.__main_quit()
return False
def __main_quit(self):
self.configuration_manager.configurationToXml()
self.configuration_manager.removeTemporaryFolder()
gtk.main_quit()