Пример #1
0
class UPDF(Gtk.Window):
    def __init__(self, afile=None):
        Gtk.Window.__init__(self)
        self.set_position(Gtk.WindowPosition.CENTER_ALWAYS)
        self.set_title("uPdf")
        self.set_default_size(750, 600)
        self.set_icon_from_file(comun.ICON)
        self.connect("destroy", self.on_close_application)
        self.connect("key-press-event", self.on_view_key_pressed)
        self.connect("check-resize", self.on_resize, None)
        self.set_events(Gdk.EventMask.ALL_EVENTS_MASK)
        """
		win_style_context = self.get_style_context()
		print win_style_context
		print win_style_context.lookup_color('bg_color')
		bg = win_style_context.lookup_color('bg_color')[1].to_string()
		# Then we set that as the background for GtkToolbar
		# We also make the boarder transparent
		css_provider = Gtk.CssProvider()
		toolbar_css = "GtkToolbar,VBox { background-color: transparent}"
		css_provider.load_from_data(toolbar_css.encode('UTF-8'))
		screen = Gdk.Screen.get_default()
		win_style_context.add_provider_for_screen(screen, css_provider,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)			
"""

        # background = Gtk.Frame()
        # background.get_style_context().add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)
        # self.add(background)
        #
        vbox = Gtk.VBox()
        self.add(vbox)
        #
        #
        self.menubar = Gtk.MenuBar.new()
        vbox.pack_start(self.menubar, False, False, 0)
        ################################################################
        self.filemenu = Gtk.Menu.new()
        self.filem = Gtk.MenuItem.new_with_label(_("File"))
        self.filem.set_submenu(self.filemenu)
        #
        self.menus = {}
        #
        self.menus["open"] = Gtk.MenuItem.new_with_label(_("Open"))
        self.menus["open"].connect("activate", self.on_button1_clicked)
        self.filemenu.append(self.menus["open"])
        #
        self.menus["close"] = Gtk.MenuItem.new_with_label(_("Close"))
        self.menus["close"].connect("activate", self.on_toolbar_clicked, "close")
        self.filemenu.append(self.menus["close"])
        #
        self.filemenu.append(Gtk.SeparatorMenuItem())
        #
        self.menus["save_as"] = Gtk.MenuItem.new_with_label(_("Save as"))
        self.menus["save_as"].connect("activate", self.on_button0_clicked)
        self.filemenu.append(self.menus["save_as"])
        #
        self.filemenu.append(Gtk.SeparatorMenuItem())
        #
        self.menus["exit"] = Gtk.MenuItem.new_with_label(_("Exit"))
        self.menus["exit"].connect("activate", self.on_close_application)
        self.filemenu.append(self.menus["exit"])
        #
        self.menubar.append(self.filem)
        ################################################################
        self.fileedit = Gtk.Menu.new()
        self.filee = Gtk.MenuItem.new_with_label(_("Edit"))
        self.filee.set_submenu(self.fileedit)
        #
        self.menus["copy"] = Gtk.MenuItem.new_with_label(_("Copy"))
        self.menus["copy"].connect("activate", self.on_toolbar_clicked, "copy")
        self.fileedit.append(self.menus["copy"])
        #
        self.menus["paste"] = Gtk.MenuItem.new_with_label(_("Paste"))
        self.menus["paste"].connect("activate", self.on_toolbar_clicked, "paste")
        self.fileedit.append(self.menus["paste"])
        #
        """
		self.pref = Gtk.ImageMenuItem.new_with_label(_('Preferences'))
		self.pref.set_image(Gtk.Image.new_from_stock(Gtk.STOCK_PREFERENCES, Gtk.IconSize.MENU))		
		#self.pref.connect('activate',self.on_preferences_activate)
		self.pref.set_always_show_image(True)
		self.fileedit.append(self.pref)
		"""

        #
        self.menubar.append(self.filee)
        ################################################################
        filetool = Gtk.Menu.new()
        filet = Gtk.MenuItem.new_with_label(_("Tools"))
        filet.set_submenu(filetool)
        #
        self.menus["first"] = Gtk.MenuItem.new_with_label(_("Go to first"))
        self.menus["first"].connect("activate", self.on_toolbar_clicked, "goto_first")
        filetool.append(self.menus["first"])
        #
        self.menus["back"] = Gtk.MenuItem.new_with_label(_("Go to back"))
        self.menus["back"].connect("activate", self.on_toolbar_clicked, "goto_back")
        filetool.append(self.menus["back"])
        #
        self.menus["forward"] = Gtk.MenuItem.new_with_label(_("Go to forward"))
        self.menus["forward"].connect("activate", self.on_toolbar_clicked, "goto_fordward")
        filetool.append(self.menus["forward"])
        #
        self.menus["last"] = Gtk.MenuItem.new_with_label(_("Go to last"))
        self.menus["last"].connect("activate", self.on_toolbar_clicked, "goto_last")
        filetool.append(self.menus["last"])
        #
        filetool.append(Gtk.SeparatorMenuItem())
        #
        self.menus["zoom_in"] = Gtk.MenuItem.new_with_label(_("Zoom in"))
        self.menus["zoom_in"].connect("activate", self.on_toolbar_clicked, "zoom_in")
        filetool.append(self.menus["zoom_in"])
        #
        self.menus["zoom_out"] = Gtk.MenuItem.new_with_label(_("Zoom out"))
        self.menus["zoom_out"].connect("activate", self.on_toolbar_clicked, "zoom_out")
        filetool.append(self.menus["zoom_out"])
        #
        self.menus["zoom_reset"] = Gtk.MenuItem.new_with_label(_("Reset zoom"))
        self.menus["zoom_reset"].connect("activate", self.on_toolbar_clicked, "zoom_reset")
        filetool.append(self.menus["zoom_reset"])
        #
        self.menus["zoom_fit"] = Gtk.MenuItem.new_with_label(_("Fit zoom"))
        self.menus["zoom_fit"].connect("activate", self.on_toolbar_clicked, "zoom_fit")
        filetool.append(self.menus["zoom_fit"])
        #
        filetool.append(Gtk.SeparatorMenuItem())
        #
        self.menus["rotate_pages"] = Gtk.MenuItem.new_with_label(_("Rotate pages"))
        self.menus["rotate_pages"].connect("activate", self.on_toolbar_clicked, "rotate_pages")
        filetool.append(self.menus["rotate_pages"])
        #
        filetool.append(Gtk.SeparatorMenuItem())
        #
        self.menus["insert_pages"] = Gtk.MenuItem.new_with_label(_("Insert pages"))
        self.menus["insert_pages"].connect("activate", self.on_toolbar_clicked, "insert_pages")
        filetool.append(self.menus["insert_pages"])
        #
        self.menus["insert_blank_pages"] = Gtk.MenuItem.new_with_label(_("Insert blank pages"))
        self.menus["insert_blank_pages"].connect("activate", self.on_toolbar_clicked, "insert_blank_pages")
        filetool.append(self.menus["insert_blank_pages"])
        #
        self.menus["remove_pages"] = Gtk.MenuItem.new_with_label(_("Remove pages"))
        self.menus["remove_pages"].connect("activate", self.on_toolbar_clicked, "remove_pages")
        filetool.append(self.menus["remove_pages"])
        #
        self.menus["extract_pages"] = Gtk.MenuItem.new_with_label(_("Extract pages"))
        self.menus["extract_pages"].connect("activate", self.on_toolbar_clicked, "extract_pages")
        filetool.append(self.menus["extract_pages"])
        #
        self.menubar.append(filet)
        ################################################################
        self.filehelp = Gtk.Menu.new()
        self.fileh = Gtk.MenuItem.new_with_label(_("Help"))
        self.fileh.set_submenu(self.get_help_menu())
        #
        self.menubar.append(self.fileh)
        ################################################################
        #
        toolbar = Gtk.Toolbar()
        toolbar.set_property("visible", False)
        toolbar.set_property("can_focus", False)
        toolbar.set_property("toolbar_style", "icons")
        toolbar.set_property("icon_size", 4)
        # toolbar.get_style_context().add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)
        """
		color = Gdk.RGBA(0.242,0.242,0.242,1)
		toolbar.override_background_color(Gtk.StateFlags.NORMAL,color)		
		toolbar.override_background_color(Gtk.StateFlags.SELECTED, color)
		toolbar.override_background_color(Gtk.StateFlags.FOCUSED, color)
		"""
        vbox.pack_start(toolbar, False, False, 0)
        #
        self.buttons = {}
        self.buttons["open"] = widgets.ImageToolButton(
            os.path.join(comun.ICONDIR, "new_active.svg"), os.path.join(comun.ICONDIR, "new_inactive.svg")
        )
        self.buttons["open"].set_can_focus(False)
        self.buttons["open"].set_tooltip_text(_("Open"))
        self.buttons["open"].connect("clicked", self.on_button1_clicked)
        toolbar.add(self.buttons["open"])
        #
        self.buttons["save_as"] = widgets.ImageToolButton(
            os.path.join(comun.ICONDIR, "save_active.svg"), os.path.join(comun.ICONDIR, "save_inactive.svg")
        )
        self.buttons["save_as"].set_can_focus(False)
        self.buttons["save_as"].set_tooltip_text(_("Save As"))
        self.buttons["save_as"].connect("clicked", self.on_button0_clicked)
        toolbar.add(self.buttons["save_as"])
        #
        self.buttons["close"] = widgets.ImageToolButton(
            os.path.join(comun.ICONDIR, "close_active.svg"), os.path.join(comun.ICONDIR, "close_inactive.svg")
        )
        self.buttons["close"].set_can_focus(False)
        self.buttons["close"].set_tooltip_text(_("Close"))
        self.buttons["close"].connect("clicked", self.on_toolbar_clicked, "close")
        toolbar.add(self.buttons["close"])
        #
        toolbar.add(widgets.SeparatorToolButton())
        #
        self.buttons["first"] = widgets.ImageToolButton(
            os.path.join(comun.ICONDIR, "goto_first.svg"), os.path.join(comun.ICONDIR, "goto_first_inactive.svg")
        )
        self.buttons["first"].set_can_focus(False)
        self.buttons["first"].set_tooltip_text(_("Go to first"))
        self.buttons["first"].connect("clicked", self.on_toolbar_clicked, "goto_first")
        toolbar.add(self.buttons["first"])
        #
        self.buttons["back"] = widgets.ImageToolButton(
            os.path.join(comun.ICONDIR, "goto_back.svg"), os.path.join(comun.ICONDIR, "goto_back_inactive.svg")
        )
        self.buttons["back"].set_can_focus(False)
        self.buttons["back"].set_tooltip_text(_("Go to back"))
        self.buttons["back"].connect("clicked", self.on_toolbar_clicked, "goto_back")
        toolbar.add(self.buttons["back"])
        #
        self.entry1 = widgets.ToolEntry()
        self.entry1.entry.set_width_chars(6)
        self.entry1.entry.connect("key-press-event", self.on_entry1_key_pressed)
        toolbar.add(self.entry1)
        #
        self.label1 = widgets.ToolLabel()
        toolbar.add(self.label1)
        #
        self.buttons["forward"] = widgets.ImageToolButton(
            os.path.join(comun.ICONDIR, "goto_fordward.svg"), os.path.join(comun.ICONDIR, "goto_fordward_inactive.svg")
        )
        self.buttons["forward"].set_can_focus(False)
        self.buttons["forward"].set_tooltip_text(_("Go to forward"))
        self.buttons["forward"].connect("clicked", self.on_toolbar_clicked, "goto_fordward")
        toolbar.add(self.buttons["forward"])
        #
        self.buttons["last"] = widgets.ImageToolButton(
            os.path.join(comun.ICONDIR, "goto_last.svg"), os.path.join(comun.ICONDIR, "goto_last_inactive.svg")
        )
        self.buttons["last"].set_can_focus(False)
        self.buttons["last"].set_tooltip_text(_("Go to last"))
        self.buttons["last"].connect("clicked", self.on_toolbar_clicked, "goto_last")
        toolbar.add(self.buttons["last"])
        #
        toolbar.add(widgets.SeparatorToolButton())
        #
        self.buttons["zoom_in"] = widgets.ImageToolButton(
            os.path.join(comun.ICONDIR, "zoom_in.svg"), os.path.join(comun.ICONDIR, "zoom_in_inactive.svg")
        )
        self.buttons["zoom_in"].set_can_focus(False)
        self.buttons["zoom_in"].set_tooltip_text(_("Zoom in"))
        self.buttons["zoom_in"].connect("clicked", self.on_toolbar_clicked, "zoom_in")
        toolbar.add(self.buttons["zoom_in"])
        #
        self.buttons["zoom_out"] = widgets.ImageToolButton(
            os.path.join(comun.ICONDIR, "zoom_out.svg"), os.path.join(comun.ICONDIR, "zoom_out_inactive.svg")
        )
        self.buttons["zoom_out"].set_can_focus(False)
        self.buttons["zoom_out"].set_tooltip_text(_("Zoom out"))
        self.buttons["zoom_out"].connect("clicked", self.on_toolbar_clicked, "zoom_out")
        toolbar.add(self.buttons["zoom_out"])
        #
        self.buttons["zoom_reset"] = widgets.ImageToolButton(
            os.path.join(comun.ICONDIR, "zoom_reset.svg"), os.path.join(comun.ICONDIR, "zoom_reset_inactive.svg")
        )
        self.buttons["zoom_reset"].set_can_focus(False)
        self.buttons["zoom_reset"].set_tooltip_text(_("Reset zoom"))
        self.buttons["zoom_reset"].connect("clicked", self.on_toolbar_clicked, "zoom_reset")
        toolbar.add(self.buttons["zoom_reset"])
        #
        self.buttons["zoom_fit"] = widgets.ImageToolButton(
            os.path.join(comun.ICONDIR, "zoom_fit.svg"), os.path.join(comun.ICONDIR, "zoom_fit_inactive.svg")
        )
        self.buttons["zoom_fit"].set_can_focus(False)
        self.buttons["zoom_fit"].set_tooltip_text(_("Fit zoom"))
        self.buttons["zoom_fit"].connect("clicked", self.on_toolbar_clicked, "zoom_fit")
        toolbar.add(self.buttons["zoom_fit"])
        #
        self.buttons["rotate_clockwise"] = widgets.ImageToolButton(
            os.path.join(comun.ICONDIR, "rotate_clockwise.svg"),
            os.path.join(comun.ICONDIR, "rotate_clockwise_inactive.svg"),
        )
        self.buttons["rotate_clockwise"].set_can_focus(False)
        self.buttons["rotate_clockwise"].set_tooltip_text(_("Rotate"))
        self.buttons["rotate_clockwise"].connect("clicked", self.on_toolbar_clicked, "rotate_clockwise")
        toolbar.add(self.buttons["rotate_clockwise"])
        #
        self.buttons["rotate_counter_clockwise"] = widgets.ImageToolButton(
            os.path.join(comun.ICONDIR, "rotate_counter_clockwise.svg"),
            os.path.join(comun.ICONDIR, "rotate_counter_clockwise_inactive.svg"),
        )
        self.buttons["rotate_counter_clockwise"].set_can_focus(False)
        self.buttons["rotate_counter_clockwise"].set_tooltip_text(_("Rotate"))
        self.buttons["rotate_counter_clockwise"].connect("clicked", self.on_toolbar_clicked, "rotate_counter_clockwise")
        toolbar.add(self.buttons["rotate_counter_clockwise"])
        #
        self.buttons["insert_pages"] = widgets.ImageToolButton(
            os.path.join(comun.ICONDIR, "insert_pages.svg"), os.path.join(comun.ICONDIR, "insert_pages_inactive.svg")
        )
        self.buttons["insert_pages"].set_can_focus(False)
        self.buttons["insert_pages"].set_tooltip_text(_("Insert pages"))
        self.buttons["insert_pages"].connect("clicked", self.on_toolbar_clicked, "insert_pages")
        toolbar.add(self.buttons["insert_pages"])
        #
        self.buttons["remove_pages"] = widgets.ImageToolButton(
            os.path.join(comun.ICONDIR, "extract_pages.svg"), os.path.join(comun.ICONDIR, "extract_pages_inactive.svg")
        )
        self.buttons["remove_pages"].set_can_focus(False)
        self.buttons["remove_pages"].set_tooltip_text(_("Remove pages"))
        self.buttons["remove_pages"].connect("clicked", self.on_toolbar_clicked, "remove_pages")
        toolbar.add(self.buttons["remove_pages"])
        #
        toolbar2 = Gtk.Toolbar()
        toolbar2.set_property("visible", True)
        toolbar2.set_property("can_focus", False)
        toolbar2.set_property("toolbar_style", "icons")
        toolbar2.set_property("icon_size", 4)
        vbox.pack_start(toolbar2, False, False, 0)
        #
        self.buttons["bordercolor"] = widgets.ToolButtonColor()
        self.buttons["bordercolor"].set_can_focus(False)
        self.buttons["bordercolor"].set_tooltip_text(_("Border color"))
        toolbar2.add(self.buttons["bordercolor"])
        #
        self.buttons["fillcolor"] = widgets.ToolButtonColor()
        self.buttons["fillcolor"].set_can_focus(False)
        self.buttons["fillcolor"].set_tooltip_text(_("Fill color"))
        toolbar2.add(self.buttons["fillcolor"])
        #
        self.buttons["font"] = widgets.ToolButtonFont()
        self.buttons["font"].set_can_focus(False)
        self.buttons["font"].set_tooltip_text(_("Font"))
        toolbar2.add(self.buttons["font"])
        #
        self.buttons["size"] = widgets.ToolScaleButton()
        self.buttons["size"].set_can_focus(False)
        self.buttons["size"].set_tooltip_text(_("Size"))
        toolbar2.add(self.buttons["size"])
        #
        self.tools = {}
        self.tools["arrow"] = widgets.ImageToggleToolButton(
            os.path.join(comun.ICONDIR, "arrow_active.svg"), os.path.join(comun.ICONDIR, "arrow_inactive.svg")
        )
        self.tools["arrow"].set_tooltip_text(_("Select"))
        self.tools["arrow"].connect("clicked", self.on_buttontool_clicked, "arrow")
        toolbar2.add(self.tools["arrow"])
        #
        self.tools["remove"] = widgets.ImageToggleToolButton(
            os.path.join(comun.ICONDIR, "remove_active.svg"), os.path.join(comun.ICONDIR, "remove_inactive.svg")
        )
        self.tools["remove"].set_tooltip_text(_("Remove"))
        self.tools["remove"].connect("clicked", self.on_buttontool_clicked, "remove")
        toolbar2.add(self.tools["remove"])
        #
        self.tools["line"] = widgets.ImageToggleToolButton(
            os.path.join(comun.ICONDIR, "line.svg"), os.path.join(comun.ICONDIR, "line_inactive.svg")
        )
        self.tools["line"].set_tooltip_text(_("Draw a line"))
        self.tools["line"].connect("clicked", self.on_buttontool_clicked, "line")
        toolbar2.add(self.tools["line"])
        #
        self.tools["rectangle"] = widgets.ImageToggleToolButton(
            os.path.join(comun.ICONDIR, "rectangle.svg"), os.path.join(comun.ICONDIR, "rectangle_inactive.svg")
        )
        self.tools["rectangle"].set_tooltip_text(_("Draw a rectangle"))
        self.tools["rectangle"].connect("clicked", self.on_buttontool_clicked, "rectangle")
        toolbar2.add(self.tools["rectangle"])
        #
        self.tools["circle"] = widgets.ImageToggleToolButton(
            os.path.join(comun.ICONDIR, "circle.svg"), os.path.join(comun.ICONDIR, "circle_inactive.svg")
        )
        self.tools["circle"].set_tooltip_text(_("Draw a circle"))
        self.tools["circle"].connect("clicked", self.on_buttontool_clicked, "circle")
        toolbar2.add(self.tools["circle"])
        #
        self.tools["ellipse"] = widgets.ImageToggleToolButton(
            os.path.join(comun.ICONDIR, "ellipse_active.svg"), os.path.join(comun.ICONDIR, "ellipse_inactive.svg")
        )
        self.tools["ellipse"].set_tooltip_text(_("Draw an ellipse"))
        self.tools["ellipse"].connect("clicked", self.on_buttontool_clicked, "ellipse")
        toolbar2.add(self.tools["ellipse"])
        #
        self.tools["text"] = widgets.ImageToggleToolButton(
            os.path.join(comun.ICONDIR, "text.svg"), os.path.join(comun.ICONDIR, "text_inactive.svg")
        )
        self.tools["text"].set_tooltip_text(_("Write some text"))
        self.tools["text"].connect("clicked", self.on_buttontool_clicked, "text")
        toolbar2.add(self.tools["text"])
        #
        self.tools["image"] = widgets.ImageToggleToolButton(
            os.path.join(comun.ICONDIR, "image.svg"), os.path.join(comun.ICONDIR, "image_inactive.svg")
        )
        self.tools["image"].set_tooltip_text(_("Add an image"))
        self.tools["image"].connect("clicked", self.on_buttontool_clicked, "image")
        toolbar2.add(self.tools["image"])
        #
        self.tools["highlight"] = widgets.ImageToggleToolButton(
            os.path.join(comun.ICONDIR, "highlight_active.svg"), os.path.join(comun.ICONDIR, "highlight_inactive.svg")
        )
        self.tools["highlight"].set_tooltip_text(_("Highlight document"))
        self.tools["highlight"].connect("clicked", self.on_buttontool_clicked, "highlight")
        toolbar2.add(self.tools["highlight"])
        #
        #
        panel1 = Gtk.Paned()
        vbox.pack_start(panel1, True, True, 0)
        self.scrolledwindow1 = Gtk.ScrolledWindow()
        self.scrolledwindow1.set_size_request(200, 200)
        self.scrolledwindow1.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
        self.scrolledwindow1.set_shadow_type(Gtk.ShadowType.ETCHED_OUT)
        self.scrolledwindow1.connect("scroll-event", self.scroll)
        panel1.add(self.scrolledwindow1)
        self.viewport0 = Gtk.Viewport()
        self.miniview = PdfView(width=200, height=HEIGHT)
        self.miniview.connect("selected", self.on_page_selected)
        self.miniview.connect("unselected", self.on_page_unselected)
        self.viewport0.add(self.miniview)
        self.scrolledwindow1.add(self.viewport0)
        #
        self.scrolledwindow2 = Gtk.ScrolledWindow()
        self.scrolledwindow2.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
        self.scrolledwindow2.set_shadow_type(Gtk.ShadowType.ETCHED_OUT)
        panel1.add(self.scrolledwindow2)
        self.viewport = Gtk.Viewport()
        self.viewport.set_shadow_type(Gtk.ShadowType.ETCHED_OUT)
        self.scrolledwindow2.add(self.viewport)
        self.view = View(self.viewport, self)
        self.viewport.add(self.view)
        #

        #
        self.show_all()
        #
        self.set_focus(self.scrolledwindow2)
        self.text = ""
        self.miniview.reset()
        self.entry1.set_text("")
        self.label1.set_text("")
        self.set_tools_sensistive(sensitive=False)
        self.view.set_page(None, None, None, None, None)

    def set_tools_sensistive(self, sensitive=False, all_elements=False):
        for key in self.menus.keys():
            self.menus[key].set_sensitive(sensitive)
        for key in self.buttons.keys():
            self.buttons[key].set_sensitive(sensitive)
        for key in self.tools.keys():
            self.tools[key].set_sensitive(sensitive)
        self.entry1.set_sensitive(sensitive)
        if all_elements == False:
            self.buttons["open"].set_sensitive(True)
            self.menus["open"].set_sensitive(True)
            self.menus["exit"].set_sensitive(True)

    def get_help_menu(self):
        help_menu = Gtk.Menu()
        #
        add2menu(help_menu, text=_("Web..."), conector_event="activate", conector_action=self.on_menu_project_clicked)
        add2menu(
            help_menu,
            text=_("Get help online..."),
            conector_event="activate",
            conector_action=self.on_menu_help_online_clicked,
        )
        add2menu(
            help_menu,
            text=_("Translate this application..."),
            conector_event="activate",
            conector_action=self.on_menu_translations_clicked,
        )
        add2menu(
            help_menu, text=_("Report a bug..."), conector_event="activate", conector_action=self.on_menu_bugs_clicked
        )
        add2menu(help_menu)
        add2menu(help_menu, text=_("About"), conector_event="activate", conector_action=self.on_about_activate)
        #
        help_menu.show()
        #
        return help_menu

    def on_menu_project_clicked(self, widget):
        webbrowser.open("https://launchpad.net/updf")

    def on_menu_help_online_clicked(self, widget):
        webbrowser.open("https://answers.launchpad.net/updf")

    def on_menu_translations_clicked(self, widget):
        webbrowser.open("https://translations.launchpad.net/updf")

    def on_menu_bugs_clicked(self, widget):
        webbrowser.open("https://bugs.launchpad.net/updf")

    def on_about_activate(self, widget):
        ad = Gtk.AboutDialog()
        ad.set_name(comun.APPNAME)
        ad.set_version(comun.VERSION)
        ad.set_copyright("Copyright (c) 2012\nLorenzo Carbonell")
        ad.set_comments(_("An application to modify pdf files"))
        ad.set_license(
            ""
            + "This program is free software: you can redistribute it and/or modify it\n"
            + "under the terms of the GNU General Public License as published by the\n"
            + "Free Software Foundation, either version 3 of the License, or (at your option)\n"
            + "any later version.\n\n"
            + "This program is distributed in the hope that it will be useful, but\n"
            + "WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n"
            + "or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\n"
            + "more details.\n\n"
            + "You should have received a copy of the GNU General Public License along with\n"
            + "this program.  If not, see <http://www.gnu.org/licenses/>."
        )
        ad.set_website("http://www.atareao.es")
        ad.set_website_label("http://www.atareao.es")
        ad.set_authors(["Lorenzo Carbonell <*****@*****.**>"])
        ad.set_documenters(["Lorenzo Carbonell <*****@*****.**>"])
        ad.set_translator_credits("" + "Lorenzo Carbonell <*****@*****.**>\n")
        ad.set_program_name("uPdf")
        ad.set_logo(GdkPixbuf.Pixbuf.new_from_file(comun.ICON))
        ad.run()
        ad.destroy()

    def on_toolbar_clicked(self, widget, option):
        # self.miniview.update_current_page()
        if option == "close":
            self.close_file()
        elif option == "goto_first":
            self.goto_page(0)
        elif option == "goto_back":
            self.goto_page(self.miniview.get_number_of_selected_page() - 1)
        elif option == "goto_fordward":
            self.goto_page(self.miniview.get_number_of_selected_page() + 1)
        elif option == "goto_last":
            self.goto_page(self.miniview.get_number_of_pages() - 1)
        elif option == "zoom_in":
            self.view.zoom_in()
        elif option == "zoom_out":
            self.view.zoom_out()
        elif option == "zoom_reset":
            self.view.zoom_reset()
        elif option == "zoom_fit":
            self.view.zoom_fit()
        elif option == "rotate_pages":
            spd = SelectPagesToRotateDialog(self)
            if spd.run() == Gtk.ResponseType.ACCEPT:
                clockwise = spd.get_clockwise()
                pages = spd.get_pages()
                spd.destroy()
                p = Progreso(_("Rotate pages"), self, len(pages))
                for number_of_page in pages:
                    if number_of_page > 0 and number_of_page < (self.miniview.get_number_of_pages() - 1):
                        if clockwise:
                            self.miniview.get_page(number_of_page - 1).rotate_clockwise()
                        else:
                            self.miniview.get_page(number_of_page - 1).rotate_counter_clockwise()
                    p.increase()
                self.goto_page(self.miniview.get_number_of_selected_page())
            spd.destroy()
        elif option == "rotate_clockwise":
            self.view.rotate_clockwise()
            sp = self.miniview.get_selected_page().rotate_clockwise()
            if sp:
                sp.rotate_clockwise()
        elif option == "rotate_counter_clockwise":
            self.view.rotate_counter_clockwise()
            sp = self.miniview.get_selected_page()
            if sp:
                sp.rotate_counter_clockwise()
        elif option == "insert_pages":
            ipd = InsertPagesDialog(self)
            if ipd.run() == Gtk.ResponseType.ACCEPT:
                filename = ipd.get_filename()
                is_before = ipd.get_before()
                pages = ipd.get_pages()
                ipd.destroy()
                if filename:
                    uri = "file://" + filename
                    document = Poppler.Document.new_from_file(uri, None)
                    total_pages = document.get_n_pages()
                    p = Progreso(_("Load pdf"), self, len(pages))
                    if is_before:
                        insert_in = self.miniview.get_number_of_selected_page()
                    else:
                        insert_in = self.miniview.get_number_of_selected_page() + 1
                    old_selected_page = self.miniview.get_number_of_selected_page()
                    self.unselect()
                    for num_page in pages:
                        if num_page - 1 < total_pages:
                            page = document.get_page(num_page - 1)
                            self.miniview.insert_page(page, insert_in)
                            p.increase()
                    self.label1.set_text(_(" / %s ") % (str(self.miniview.get_number_of_pages())))
                    self.goto_page(old_selected_page + 1)
            ipd.destroy()
        elif option == "insert_blank_pages":
            ibpd = InsertBlankPagesDialog()
            if ibpd.run() == Gtk.ResponseType.ACCEPT:
                number_of_pages = int(ibpd.get_number_of_pages())
                size = ibpd.get_paper_size()
                is_before = ibpd.get_before()
                ibpd.destroy()
                if number_of_pages > 0:
                    p = Progreso(_("Load pdf"), self, number_of_pages)
                    if is_before:
                        insert_in = self.miniview.get_number_of_selected_page()
                    else:
                        insert_in = self.miniview.get_number_of_selected_page() + 1
                    old_selected_page = self.miniview.get_number_of_selected_page()
                    self.unselect()
                    for num_page in range(number_of_pages):
                        self.miniview.insert_blank_page(size[0], size[1], insert_in)
                        p.increase()
                    self.label1.set_text(_(" / %s ") % (str(self.miniview.get_number_of_pages())))
                    self.goto_page(old_selected_page + 1)
            ibpd.destroy()
        elif option == "remove_pages":
            spd = RemovePagesDialog(self)
            if spd.run() == Gtk.ResponseType.ACCEPT:
                pages = spd.get_pages()
                spd.destroy()
                pages = sorted(pages, reverse=True)
                for num_page in pages:
                    self.miniview.remove_page(num_page - 1)
                    self.label1.set_text(_(" / %s ") % (str(self.miniview.get_number_of_pages())))
            spd.destroy()
        elif option == "extract_pages":
            spd = ExtractPagesDialog(self)
            if spd.run() == Gtk.ResponseType.ACCEPT:
                pages = spd.get_pages()
                option_remove = spd.get_remove()
                spd.destroy()
                pages = sorted(pages, reverse=False)
                self.save_pages_as_pdf(pages)
                if option_remove:
                    pages = sorted(pages, reverse=True)
                    for num_page in pages:
                        self.miniview.remove_page(num_page - 1)
                        self.label1.set_text(_(" / %s ") % (str(self.miniview.get_number_of_pages())))
            spd.destroy()
        elif option == "copy":
            if (
                self.view.tool == "arrow"
                and self.view.mouse_down == None
                and self.view.selection_end
                and self.view.selection_start
            ):
                self.view.copy_to_pixbuf()
        elif option == "paste":
            if self.view.tool == "arrow":
                self.view.paste_from_pixbuf()

    def on_resize(self, widget, data):
        self.view.is_plotted = False
        self.view.queue_draw()

    def on_view_key_pressed(self, widget, event):
        if self.view.tool and self.view.tool == "text":
            if event.keyval >= 32 and event.keyval <= 126 or event.keyval >= 127 and event.keyval <= 255:
                if event.keyval == 32:
                    self.view.text += " "
                else:
                    self.view.text += unichr(Gdk.keyval_to_unicode(event.keyval))
                self.view.queue_draw()
            elif event.keyval == 65288:  # backspace
                self.view.text = self.view.text[:-1]
                self.view.queue_draw()
            elif event.keyval == 65293 or event.keyval == 65421:  # return
                self.view.write()
            elif event.keyval in range(65456, 65466):
                self.view.text += str(event.keyval - 65456)
                self.view.queue_draw()
            else:
                print(event.keyval)
                print(Gdk.keyval_name(event.keyval))
        else:
            if event.keyval == 65361:
                self.goto_page(0)
            elif event.keyval == 65362 or event.keyval == 65360:
                self.goto_page(self.miniview.get_number_of_selected_page() - 1)
            elif event.keyval == 65363:
                self.goto_page(self.miniview.get_number_of_pages() - 1)
            elif event.keyval == 65364 or event.keyval == 65367:

                self.goto_page(self.miniview.get_number_of_selected_page() + 1)
            elif event.keyval == 65451 or event.keyval == 43:
                self.view.zoom_in()
            elif event.keyval == 65453 or event.keyval == 45:
                self.view.zoom_out()
            else:
                print(event.keyval)
                print(Gdk.keyval_name(event.keyval))

    def toInt(self, valor):
        try:
            if len(valor) > 0:
                return int(float(valor))
            else:
                return 0
        except:
            return self.miniview.get_selected_page() + 1

    def on_entry1_key_pressed(self, widget, event):
        if event.keyval == 65293 or event.keyval == 65421:
            if self.miniview.get_number_of_pages() > 0:
                page_to_go = self.toInt(self.entry1.get_text()) - 1
            else:
                page_to_go = 0
            self.goto_page(page_to_go)

    def on_button0_clicked(self, widget):
        dialog = Gtk.FileChooserDialog(
            _("Select a pdf file"),
            self,
            Gtk.FileChooserAction.SAVE,
            (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, Gtk.ResponseType.OK),
        )
        dialog.set_default_response(Gtk.ResponseType.OK)
        filter = Gtk.FileFilter()
        filter.set_name(_("Pdf files"))
        filter.add_mime_type("application/pdf")
        filter.add_pattern("*.pdf")
        dialog.add_filter(filter)
        preview = MiniView(200)
        dialog.set_use_preview_label(False)
        dialog.set_preview_widget(preview)
        dialog.connect("update-preview", self.update_preview_cb, preview)
        response = dialog.run()
        if response == Gtk.ResponseType.OK:
            self.unselect()
            filename = dialog.get_filename()
            dialog.destroy()
            if not filename.endswith(".pdf"):
                filename += ".pdf"
            pdfsurface = cairo.PDFSurface(filename, 200, 200)
            context = cairo.Context(pdfsurface)
            progressdialog = Progreso(_("Save pdf"), self, len(self.miniview.get_children()))
            for page in self.miniview.get_children():
                context.save()
                if page.rotation_angle == 0.0 or page.rotation_angle == 2.0:
                    width, height = page.get_size()
                else:
                    height, width = page.get_size()
                pdfsurface.set_size(width, height)
                mtr = cairo.Matrix()
                mtr.rotate(page.rotation_angle * math.pi / 2.0)
                context.transform(mtr)
                if page.rotation_angle == 1.0:
                    context.translate(0.0, -width)
                elif page.rotation_angle == 2.0:
                    context.translate(-width, -height)
                elif page.rotation_angle == 3.0:
                    context.translate(-height, 0.0)
                if page.page:
                    page.page.render(context)
                context.restore()
                context.save()
                mtr = cairo.Matrix()
                mtr.rotate(page.rotation_angle * math.pi / 2.0)
                mtr.scale(1.0 / comun.RESOLUTION, 1.0 / comun.RESOLUTION)
                context.transform(mtr)
                if page.rotation_angle == 1.0:
                    context.translate(0.0, -width * comun.RESOLUTION)
                elif page.rotation_angle == 2.0:
                    context.translate(-width * comun.RESOLUTION, -height * comun.RESOLUTION)
                elif page.rotation_angle == 3.0:
                    context.translate(-height * comun.RESOLUTION, 0.0)
                for drawing in page.drawings:
                    drawing.draw(context)
                context.restore()
                context.show_page()
                progressdialog.increase()
        dialog.destroy()

    def on_button1_clicked(self, widget):
        self.close_file()
        dialog = Gtk.FileChooserDialog(
            _("Select a pdf file"),
            self,
            Gtk.FileChooserAction.OPEN,
            (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, Gtk.ResponseType.OK),
        )
        dialog.set_default_response(Gtk.ResponseType.OK)
        filter = Gtk.FileFilter()
        filter.set_name(_("Pdf files"))
        filter.add_mime_type("application/pdf")
        filter.add_pattern("*.pdf")
        dialog.add_filter(filter)
        preview = MiniView(200, force=True)
        dialog.set_use_preview_label(False)
        dialog.set_preview_widget(preview)
        dialog.connect("update-preview", self.update_preview_cb, preview)
        response = dialog.run()
        if response == Gtk.ResponseType.OK:
            filename = dialog.get_filename()
            self.load_file(filename)
        dialog.destroy()

    def update_preview_cb(self, file_chooser, preview):
        filename = file_chooser.get_preview_filename()
        have_preview = False
        try:
            if os.path.isfile(filename):
                uri = "file://" + filename
                document = Poppler.Document.new_from_file(uri, None)
                if document.get_n_pages() > 0:
                    preview.set_page(document.get_page(0))
                    have_preview = True
        except Exception as e:
            print(e)
        file_chooser.set_preview_widget_active(have_preview)
        return

    def close_file(self):
        self.miniview.reset()
        self.entry1.set_text("")
        self.label1.set_text("")
        self.set_tools_sensistive(sensitive=False)
        self.view.set_page(None, None, None, None, None)

    def on_buttontool_clicked(self, widget, tool):
        self.view.mouse_down = None
        self.view.selection_end = None
        self.view.selection_start = None
        if tool == "text":
            self.view.text = ""
        if self.tools[tool].get_active():
            for atool in self.tools.keys():
                if atool != tool:
                    self.tools[atool].set_active(False)
            self.view.set_tool(tool)
        else:
            self.view.set_tool(None)

    def on_close_application(self, widget):
        exit(0)

    def load_file(self, afile):
        uri = "file://" + afile
        try:
            document = Poppler.Document.new_from_file(uri, None)
            number_of_pages = document.get_n_pages()
            if number_of_pages > 0:
                p = Progreso(_("Load pdf"), self, number_of_pages)
                for number_of_page in range(number_of_pages):
                    page = document.get_page(number_of_page)
                    self.miniview.insert_page(page)
                    p.increase()
            self.goto_page(0)
            can_do_anything = self.miniview.get_number_of_pages() > 0
            self.set_tools_sensistive(sensitive=can_do_anything)
        except (Exception, e):
            print(e)

    def on_page_unselected(self, widget, n):
        if self.view.drawings and n > -1:
            self.miniview.get_page(n).drawings = clone_list(self.view.drawings)
            self.miniview.get_page(n).render()
            self.view.drawings = []

    def on_page_selected(self, widget, n):
        if n < 0:
            n = 0
        if n >= self.miniview.get_number_of_pages():
            n = self.miniview.get_number_of_pages() - 1
        if self.miniview.get_number_of_pages() > 0:
            self.entry1.set_text(str(n + 1))
            self.label1.set_text(_(" / %s ") % (str(self.miniview.get_number_of_pages())))
            rotation_angle = self.miniview.get_selected_page().rotation_angle
            width, height = self.miniview.get_selected_page().get_size()
            width = int(width * comun.RESOLUTION)
            height = int(height * comun.RESOLUTION)
            self.view.set_page(self.miniview.get_selected_page().get_image(), n, rotation_angle, width, height)
            self.view.drawings = clone_list(self.miniview.get_selected_page().drawings)
            self.scrolledwindow1.get_vadjustment().set_value(n * self.miniview.height)
            #
            rect = self.scrolledwindow1.get_allocation()
            after = rect.height / HEIGHT
            number_of_page = int(self.scrolledwindow1.get_vadjustment().get_value() / HEIGHT)
            for i in range(-1, after + 1):
                n = number_of_page + i
                if n > 0 and n < self.miniview.get_number_of_pages():
                    self.miniview.get_page(number_of_page + 1).render()

    def save_pages_as_pdf(self, pages):
        dialog = Gtk.FileChooserDialog(
            _("Select a pdf file"),
            self,
            Gtk.FileChooserAction.SAVE,
            (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, Gtk.ResponseType.OK),
        )
        dialog.set_default_response(Gtk.ResponseType.OK)
        filter = Gtk.FileFilter()
        filter.set_name(_("Pdf files"))
        filter.add_mime_type("application/pdf")
        filter.add_pattern("*.pdf")
        dialog.add_filter(filter)
        preview = MiniView(200)
        dialog.set_use_preview_label(False)
        dialog.set_preview_widget(preview)
        dialog.connect("update-preview", self.update_preview_cb, preview)
        response = dialog.run()
        if response == Gtk.ResponseType.OK:
            filename = dialog.get_filename()
            dialog.destroy()
            if not filename.endswith(".pdf"):
                filename += ".pdf"
            pdfsurface = cairo.PDFSurface(filename, 200, 200)
            context = cairo.Context(pdfsurface)
            progressdialog = Progreso(_("Save pdf"), self, len(pages))
            for number_of_page in pages:
                if number_of_page > 0 and number_of_page < len(self.miniview.get_children()):
                    page = self.miniview.get_children()[number_of_page - 1]
                    context.save()
                    if page.rotation_angle == 0.0 or page.rotation_angle == 2.0:
                        width, height = page.get_size()
                    else:
                        height, width = page.get_size()
                    pdfsurface.set_size(width, height)
                    mtr = cairo.Matrix()
                    mtr.rotate(page.rotation_angle * math.pi / 2.0)
                    context.transform(mtr)
                    if page.rotation_angle == 1.0:
                        context.translate(0.0, -width)
                    elif page.rotation_angle == 2.0:
                        context.translate(-width, -height)
                    elif page.rotation_angle == 3.0:
                        context.translate(-height, 0.0)
                    if page.page:
                        page.page.render(context)
                    context.restore()
                    context.save()
                    mtr = cairo.Matrix()
                    mtr.rotate(page.rotation_angle * math.pi / 2.0)
                    mtr.scale(1.0 / comun.RESOLUTION, 1.0 / comun.RESOLUTION)
                    context.transform(mtr)
                    if page.rotation_angle == 1.0:
                        context.translate(0.0, -width * comun.RESOLUTION)
                    elif page.rotation_angle == 2.0:
                        context.translate(-width * comun.RESOLUTION, -height * comun.RESOLUTION)
                    elif page.rotation_angle == 3.0:
                        context.translate(-height * comun.RESOLUTION, 0.0)
                    for drawing in page.drawings:
                        drawing.draw(context)
                    context.restore()
                    context.show_page()
                progressdialog.increase()
        dialog.destroy()

    def scroll(self, widget, data):
        rect = self.scrolledwindow1.get_allocation()
        after = rect.height / HEIGHT
        number_of_page = int(self.scrolledwindow1.get_vadjustment().get_value() / HEIGHT)
        self.entry1.set_text(str(number_of_page + 1))
        for i in range(-1, after + 1):
            n = number_of_page + i
            if n > 0 and n < self.miniview.get_number_of_pages():
                self.miniview.get_page(number_of_page + 1).render()

    def goto_page(self, n):
        if n < 0:
            n = 0
        if n >= self.miniview.get_number_of_pages():
            n = self.miniview.get_number_of_pages() - 1
        if self.miniview.get_number_of_pages() > 0:
            self.entry1.set_text(str(n + 1))
            self.label1.set_text(_(" / %s ") % (str(self.miniview.get_number_of_pages())))
            self.miniview.select_page(n)
            rotation_angle = self.miniview.get_selected_page().rotation_angle
            width, height = self.miniview.get_selected_page().get_size()
            width = int(width * comun.RESOLUTION)
            height = int(height * comun.RESOLUTION)
            self.view.set_page(self.miniview.get_selected_page().get_image(), n, rotation_angle, width, height)
            self.view.drawings = clone_list(self.miniview.get_selected_page().drawings)
            self.scrolledwindow1.get_vadjustment().set_value(n * self.miniview.height)
            #
            rect = self.scrolledwindow1.get_allocation()
            after = rect.height / HEIGHT
            number_of_page = int(self.scrolledwindow1.get_vadjustment().get_value() / HEIGHT)
            for i in range(-1, after + 1):
                n = number_of_page + i
                if n > 0 and n < self.miniview.get_number_of_pages():
                    self.miniview.get_page(number_of_page + 1).render()

    def unselect(self):
        if self.view.drawings and self.miniview.get_selected_page():
            self.miniview.get_selected_page().drawings = clone_list(self.view.drawings)
            self.miniview.get_selected_page().render()
            self.view.drawings = []
            self.miniview.unselect()
Пример #2
0
class MainWindow(object):
    UI_XML = './ui.xml'
    
    def __init__(self):
        self.view = View()
        
        self.builder = gtk.Builder()
        self.builder.add_from_file(self.UI_XML)
        self.builder.connect_signals(self)
        
        self.wnd = self.builder.get_object('main')
        container = self.builder.get_object('container')
        container.add(self.view)

        self.wnd.connect('delete-event', gtk.main_quit, None)
        
    def show(self):
        self.wnd.show_all()

    def quit(self, *args):
        gtk.main_quit()

    def open(self, *args):
        dlg = self.builder.get_object('open_dlg')
        dlg.parent = self.wnd

        if dlg.run() == 1:
            uri = dlg.get_uri()
            self.load_document(poppler.Document.new_from_file(uri, None))
            
        dlg.hide()

    def load_file(self, filename):
        self.load_document(poppler.Document.new_from_file('file://' + filename,
                                                          None))

    def load_document(self, doc):
        if not doc:
            return
        self.doc = doc
        self.current_page = 0

        self.builder.get_object('next').set_sensitive(doc.get_n_pages() > 1)
        self.builder.get_object('prev').set_sensitive(False)
        self.view.set_page(self.doc, 0)

    def next(self, action):
        self.current_page += 1
        self.view.set_page(self.doc, self.current_page)
        action.set_sensitive(self.doc.get_n_pages() > (self.current_page + 1))
        self.builder.get_object('prev').set_sensitive(self.current_page > 0)
            
    def prev(self, action):
        self.current_page -= 1
        self.view.set_page(self.doc, self.current_page)
        action.set_sensitive(self.current_page > 0)
        self.builder.get_object('next').set_sensitive(
            self.doc.get_n_pages() > (self.current_page + 1))
        
    def zoom_in(self, *args):
        self.view.zoom_in()

    def zoom_out(self, *args):
        self.view.zoom_out()

    def zoom_reset(self, *args):
        self.view.zoom_reset()

    def toggle_snap_to_grid(self, *args):
        self.view.snap_to_grid = not self.view.snap_to_grid

    def clip(self, *args):
        if hasattr(self.view, 'selection_start') and hasattr(self.view, 'selection_end') and self.view.page:
            dlg = self.builder.get_object('clip_save_dlg')
            dlg.parent = self.wnd
            if dlg.run() == 1:
                filename = dlg.get_filename()
                if not filename.endswith(".pdf"):
                    filename = filename + '.pdf'
                if os.path.exists(filename):
                    os.remove(filename)
                self.clip_pdf_page(self.view.page, self.view.selection_start,
                               self.view.selection_end, filename)
            dlg.hide()

    def clip_pdf_page(self, page, start, end, output):
        x = min(end[0], start[0])
        y = min(end[1], start[1])
        width = abs(end[0] - start[0])
        height = abs(end[1] - start[1])
        surface = cairo.PDFSurface(output, width, height)
        ctx = cairo.Context(surface)
        ctx.rectangle(0, 0, width, height)
        ctx.clip()
        ctx.translate(-x, -y)
        page.render(ctx)
        surface.flush()
        surface.finish()