[patch] introspection port attempt

pdfshuffler-introspection.patch (text/plain), 37.38 KB, created by Rafał Mużyło on 2011-11-18 03:29:16 UTC

--- pdfshuffler-test	2011-11-17 03:23:00.000000000 +0100
+++ pdfshuffler-gi-idle	2011-11-18 04:18:03.000000000 +0100
@@ -40,34 +40,14 @@
 import gettext
 gettext.install('pdfshuffler', unicode=1)
 
-try:
-    import pygtk
-    pygtk.require('2.0')
-    import gtk
-    assert gtk.gtk_version >= (2, 10, 0)
-    assert gtk.pygtk_version >= (2, 10, 0)
-except AssertionError:
-    print('You do not have the required versions of GTK+ and/or PyGTK ' +
-          'installed.\n\n' +
-          'Installed GTK+ version is ' + 
-          '.'.join([str(n) for n in gtk.gtk_version]) + '\n' +
-          'Required GTK+ version is 2.10.0 or higher\n\n'
-          'Installed PyGTK version is ' + 
-          '.'.join([str(n) for n in gtk.pygtk_version]) + '\n' +
-          'Required PyGTK version is 2.10.0 or higher')
-    sys.exit(1)
-except:
-    print('PyGTK version 2.10.0 or higher is required to run this program.')
-    print('No version of PyGTK was found on your system.')
-    sys.exit(1)
-
-gtk.gdk.threads_init()
-import gobject      #to use custom signals
-import pango        #to adjust the text alignment in CellRendererText
-import gio          #to inquire mime types information
-import cairo, array
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk, Gdk, GObject, Pango, Gio, GdkPixbuf, Poppler
+import cairo
+
+Gdk.threads_init()
+import array
 
-import poppler      #for the rendering of pdf pages
 from pyPdf import PdfFileWriter, PdfFileReader
 
 class PDFshuffler:
@@ -75,8 +55,8 @@
     # All the preferences are stored here.
     # =======================================================
     prefs = {
-        'window width': min (700, gtk.gdk.screen_get_default().get_width() / 2 ),
-        'window height': min(600, gtk.gdk.screen_get_default().get_height() - 50 ),
+        'window width': min (700, Gdk.Screen.get_default().get_width() / 2 ),
+        'window height': min(600, Gdk.Screen.get_default().get_height() - 50 ),
         'window x': 0,
         'window y': 0,
         'initial thumbnail size': 530,
@@ -87,11 +67,11 @@
     MODEL_ROW_EXTERN = 1002
     TEXT_URI_LIST = 1003
     MODEL_ROW_MOTION = 1004
-    TARGETS_IV = [('MODEL_ROW_INTERN', gtk.TARGET_SAME_WIDGET, MODEL_ROW_INTERN),
-                  ('MODEL_ROW_EXTERN', gtk.TARGET_OTHER_APP, MODEL_ROW_EXTERN),
-                  ('MODEL_ROW_MOTION', 0, MODEL_ROW_MOTION)]
-    TARGETS_SW = [('text/uri-list', 0, TEXT_URI_LIST),
-                  ('MODEL_ROW_EXTERN', gtk.TARGET_OTHER_APP, MODEL_ROW_EXTERN)]
+    TARGETS_IV = [Gtk.TargetEntry.new('MODEL_ROW_INTERN', Gtk.TargetFlags.SAME_WIDGET, MODEL_ROW_INTERN),
+                  Gtk.TargetEntry.new('MODEL_ROW_EXTERN', Gtk.TargetFlags.OTHER_APP, MODEL_ROW_EXTERN),
+                  Gtk.TargetEntry.new('MODEL_ROW_MOTION', 0, MODEL_ROW_MOTION)]
+    TARGETS_SW = [Gtk.TargetEntry.new('text/uri-list', 0, TEXT_URI_LIST),
+                  Gtk.TargetEntry.new('MODEL_ROW_EXTERN', Gtk.TargetFlags.OTHER_APP, MODEL_ROW_EXTERN)]
 
     def __init__(self):
         # Create the temporary directory
@@ -100,13 +80,13 @@
 
         pixmap = os.path.join(sys.prefix,'share','pixmaps','pdfshuffler.png')
         try:
-            gtk.window_set_default_icon_from_file(pixmap)
+            Gtk.Window.set_default_icon_from_file(pixmap)
         except:
             print(_('File %s does not exist') % pixmap)
 
         # Create the main window, and attach delete_event signal to terminating
         # the application
-        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
+        self.window = Gtk.Window.new(Gtk.WindowType.TOPLEVEL)
         self.window.set_title('PDF-Shuffler')
         self.window.set_border_width(0)
         self.window.move(self.prefs['window x'], self.prefs['window y'])
@@ -116,31 +96,32 @@
         self.window.show()
 
         # Create a vbox to hold the thumnails-container
-        vbox = gtk.VBox()
+        vbox = Gtk.Grid()
+        vbox.set_orientation(Gtk.Orientation.VERTICAL)
         self.window.add(vbox)
 
         # Create a scrolled window to hold the thumbnails-container
-        self.sw = gtk.ScrolledWindow()
+        self.sw = Gtk.ScrolledWindow()
         self.sw.set_border_width(0)
-        self.sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
-        self.sw.drag_dest_set(gtk.DEST_DEFAULT_MOTION |
-                              gtk.DEST_DEFAULT_HIGHLIGHT |
-                              gtk.DEST_DEFAULT_DROP |
-                              gtk.DEST_DEFAULT_MOTION,
+        self.sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+        self.sw.drag_dest_set(Gtk.DestDefaults.MOTION |
+                              Gtk.DestDefaults.HIGHLIGHT |
+                              Gtk.DestDefaults.DROP |
+                              Gtk.DestDefaults.MOTION,
                               self.TARGETS_SW,
-                              gtk.gdk.ACTION_COPY |
-                              gtk.gdk.ACTION_MOVE )
+                              Gdk.DragAction.COPY |
+                              Gdk.DragAction.MOVE )
         self.sw.connect('drag_data_received', self.sw_dnd_received_data)
         self.sw.connect('button_press_event', self.sw_button_press_event)
-        vbox.pack_start(self.sw)
+        vbox.add(self.sw)
 
         # Create an alignment to keep the thumbnails center-aligned
-        align = gtk.Alignment(0.5, 0.5, 0, 0)
+        align = Gtk.Alignment.new(0.5, 0.5, 0, 0)
         self.sw.add_with_viewport(align)
 
         # Create ListStore model and IconView
-        self.model = gtk.ListStore(str,             # 0.Text descriptor
-                                   gtk.gdk.Pixbuf,  # 1.Thumbnail image
+        self.model = Gtk.ListStore(str,             # 0.Text descriptor
+                                   GdkPixbuf.Pixbuf,  # 1.Thumbnail image
                                    int,             # 2.Document number
                                    int,             # 3.Page number
                                    int,             # 4.Thumbnail width
@@ -155,30 +136,32 @@
         self.zoom_scale = self.prefs['initial zoom scale']
         self.iv_col_width = self.prefs['initial thumbnail size']
 
-        self.iconview = gtk.IconView(self.model)
+        self.iconview = Gtk.IconView(model=self.model)
+        self.iconview.set_hexpand(True)
+        self.iconview.set_vexpand(True)
         self.iconview.set_item_width(self.iv_col_width + 12)
 
         self.iconview.set_pixbuf_column(1)
-#        self.cellpb = gtk.CellRendererPixbuf()
+#        self.cellpb = Gtk.CellRendererPixbuf()
 #        self.cellpb.set_property('follow-state', True)
 #        self.iconview.pack_start(self.cellpb, False)
 #        self.iconview.set_attributes(self.cellpb, pixbuf=1)
 
-#        self.iconview.set_text_column(0)
-        self.celltxt = gtk.CellRendererText()
+        self.iconview.set_text_column(0)
+        self.celltxt = Gtk.CellRendererText()
         self.celltxt.set_property('width', self.iv_col_width)
         self.celltxt.set_property('wrap-width', self.iv_col_width)
-        self.celltxt.set_property('alignment', pango.ALIGN_CENTER)
+        self.celltxt.set_property('alignment', Pango.Alignment.CENTER)
         self.iconview.pack_start(self.celltxt, False)
-        self.iconview.set_attributes(self.celltxt, text=0)
+        #self.iconview.set_attributes(self.celltxt, text=0)
 
-        self.iconview.set_selection_mode(gtk.SELECTION_MULTIPLE)
-        self.iconview.enable_model_drag_source(gtk.gdk.BUTTON1_MASK,
+        self.iconview.set_selection_mode(Gtk.SelectionMode.MULTIPLE)
+        self.iconview.enable_model_drag_source(Gdk.ModifierType.BUTTON1_MASK,
                                                self.TARGETS_IV,
-                                               gtk.gdk.ACTION_COPY |
-                                               gtk.gdk.ACTION_MOVE )
+                                               Gdk.DragAction.COPY |
+                                               Gdk.DragAction.MOVE )
         self.iconview.enable_model_drag_dest(self.TARGETS_IV,
-                                             gtk.gdk.ACTION_DEFAULT)
+                                             Gdk.DragAction.DEFAULT)
         self.iconview.connect('drag_begin', self.iv_drag_begin)
         self.iconview.connect('drag_data_get', self.iv_dnd_get_data)
         self.iconview.connect('drag_data_received', self.iv_dnd_received_data)
@@ -191,48 +174,54 @@
 
         style = self.iconview.get_style().copy()
         style_sw = self.sw.get_style()
-        for state in (gtk.STATE_NORMAL, gtk.STATE_PRELIGHT, gtk.STATE_ACTIVE):
-            style.base[state] = style_sw.bg[gtk.STATE_NORMAL]
+        for state in (Gtk.StateType.NORMAL, Gtk.StateType.PRELIGHT, Gtk.StateType.ACTIVE):
+            style.base[state] = style_sw.bg[Gtk.StateType.NORMAL]
         self.iconview.set_style(style)
 
         align.add(self.iconview)
 
         # Create a horizontal box to hold the buttons
-        hbox = gtk.HBox()
-        vbox.pack_start(hbox, expand=False, fill=False)
+        hbox = Gtk.Grid()
+        hbox.set_column_homogeneous(True)
+        vbox.add(hbox)
 
         # Create buttons
-        self.button_exit = gtk.Button(stock=gtk.STOCK_QUIT)
+        self.button_exit = Gtk.Button(stock=Gtk.STOCK_QUIT)
+        self.button_exit.set_halign(Gtk.Align.CENTER)
         self.button_exit.connect('clicked', self.close_application)
-        hbox.pack_start(self.button_exit, expand=True, fill=False, padding=20)
+        hbox.add(self.button_exit)
 
-        self.button_del = gtk.Button(_('Delete Page(s)'))
-        image = gtk.Image()
-        image.set_from_stock(gtk.STOCK_DELETE, gtk.ICON_SIZE_BUTTON)
+        self.button_del = Gtk.Button(_('Delete Page(s)'))
+        self.button_del.set_halign(Gtk.Align.CENTER)
+        image = Gtk.Image()
+        image.set_from_stock(Gtk.STOCK_DELETE, Gtk.IconSize.BUTTON)
         self.button_del.set_image(image)
         self.button_del.connect('clicked', self.clear_selected)
-        hbox.pack_start(self.button_del, expand=True, fill=False, padding=20)
+        hbox.add(self.button_del)
 
-        self.button_import = gtk.Button(_('Import pdf'))
-        image = gtk.Image()
-        image.set_from_stock(gtk.STOCK_OPEN, gtk.ICON_SIZE_BUTTON)
+        self.button_import = Gtk.Button(_('Import pdf'))
+        self.button_import.set_halign(Gtk.Align.CENTER)
+        image = Gtk.Image()
+        image.set_from_stock(Gtk.STOCK_OPEN, Gtk.IconSize.BUTTON)
         self.button_import.set_image(image)
         self.button_import.connect('clicked', self.on_action_add_doc_activate)
-        hbox.pack_start(self.button_import, expand=True, fill=False, padding=20)
+        hbox.add(self.button_import)
 
-        self.button_export = gtk.Button(_('Export pdf'))
-        image = gtk.Image()
-        image.set_from_stock(gtk.STOCK_SAVE_AS, gtk.ICON_SIZE_BUTTON)
+        self.button_export = Gtk.Button(_('Export pdf'))
+        self.button_export.set_halign(Gtk.Align.CENTER)
+        image = Gtk.Image()
+        image.set_from_stock(Gtk.STOCK_SAVE_AS, Gtk.IconSize.BUTTON)
         self.button_export.set_image(image)
         self.button_export.connect('clicked', self.choose_export_pdf_name)
-        hbox.pack_start(self.button_export, expand=True, fill=False, padding=20)
+        hbox.add(self.button_export)
 
-        self.button_export = gtk.Button(_('About'))
-        image = gtk.Image()
-        image.set_from_stock(gtk.STOCK_ABOUT, gtk.ICON_SIZE_BUTTON)
+        self.button_export = Gtk.Button(_('About'))
+        self.button_export.set_halign(Gtk.Align.CENTER)
+        image = Gtk.Image()
+        image.set_from_stock(Gtk.STOCK_ABOUT, Gtk.IconSize.BUTTON)
         self.button_export.set_image(image)
         self.button_export.connect('clicked', self.about_dialog)
-        hbox.pack_start(self.button_export, expand=True, fill=False, padding=20)
+        hbox.add(self.button_export)
 
         # Define window callback function and show window
         self.window.connect('size_allocate', self.on_window_size_request)        # resize
@@ -240,11 +229,11 @@
         self.window.show_all()
 
         #Creating the popup menu
-        self.popup = gtk.Menu()
-        popup_rotate_right = gtk.MenuItem(_('Rotate Page(s) Clockwise'))
-        popup_rotate_left = gtk.MenuItem(_('Rotate Page(s) Counterclockwise'))
-        popup_crop = gtk.MenuItem(_('Crop Page(s)'))
-        popup_delete = gtk.MenuItem(_('Delete Page(s)'))
+        self.popup = Gtk.Menu()
+        popup_rotate_right = Gtk.MenuItem(_('Rotate Page(s) Clockwise'))
+        popup_rotate_left = Gtk.MenuItem(_('Rotate Page(s) Counterclockwise'))
+        popup_crop = Gtk.MenuItem(_('Crop Page(s)'))
+        popup_delete = Gtk.MenuItem(_('Delete Page(s)'))
         popup_rotate_right.connect('activate', self.rotate_page_right)
         popup_rotate_left.connect('activate', self.rotate_page_left)
         popup_crop.connect('activate', self.crop_page_dialog)
@@ -265,24 +254,25 @@
         self.iv_auto_scroll_timer = None
         self.pdfqueue = []
 
-        gobject.type_register(PDF_Renderer)
-        gobject.signal_new('reset_iv_width', PDF_Renderer,
-                           gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ())
+        GObject.type_register(PDF_Renderer)
+        GObject.signal_new('reset_iv_width', PDF_Renderer,
+                           GObject.SignalFlags.RUN_FIRST, None, ())
         self.rendering_thread = PDF_Renderer(self.model, self.pdfqueue,
                                              self.zoom_scale, self.iv_col_width)
         self.rendering_thread.connect('reset_iv_width', self.reset_iv_width)
-        self.rendering_thread.start()
 
         # Importing documents passed as command line arguments
         for filename in sys.argv[1:]:
             self.add_pdf_pages(filename)
+        #GObject.idle_add(self.rendering_thread.run)
 
     # =======================================================
     def render(self):
-        if self.rendering_thread.paused:
-            self.rendering_thread.paused = False
-            self.rendering_thread.evnt.set()
-            self.rendering_thread.evnt.clear()
+#        if self.rendering_thread.paused:
+#            self.rendering_thread.paused = False
+#            self.rendering_thread.evnt.set()
+#            self.rendering_thread.evnt.clear()
+        GObject.idle_add(self.rendering_thread.run)
 
     # =======================================================
     def on_window_size_request(self, window, event):
@@ -309,24 +299,24 @@
     def on_keypress_event(self, widget, event):
         """Keypress events in Main Window"""
 
-        #keyname = gtk.gdk.keyval_name(event.keyval)
-        if event.keyval == 65535:   # Delete keystroke
+        #keyname = Gdk.keyval_name(event.keyval)
+        if event.keyval == Gdk.KEY_Delete:   # Delete keystroke
             self.clear_selected()
 
     # =======================================================
     def close_application(self, widget, event=None, data=None):
         """Termination"""
 
-        #gtk.gdk.threads_leave()
+        #Gdk.threads_leave()
         self.rendering_thread.quit = True
-        #gtk.gdk.threads_enter()
-        if self.rendering_thread.paused == True:
-             self.rendering_thread.evnt.set()
-             self.rendering_thread.evnt.clear()
+        #Gdk.threads_enter()
+        #if self.rendering_thread.paused == True:
+        #     self.rendering_thread.evnt.set()
+        #     self.rendering_thread.evnt.clear()
         if os.path.isdir(self.tmp_dir):
             shutil.rmtree(self.tmp_dir)
-        if gtk.main_level():
-            gtk.main_quit()
+        if Gtk.main_level():
+            Gtk.main_quit()
         else:
             sys.exit(0)
         return False
@@ -367,7 +357,7 @@
         for npage in range(n_start, n_end + 1):
             descriptor = ''.join([pdfdoc.shortname, '\n', _('page'), ' ', str(npage)])
             width = self.iv_col_width
-            thumbnail = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False,
+            thumbnail = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, False,
                                        8, width, width)
             self.model.append((descriptor,              # 0
                                thumbnail,               # 1
@@ -389,27 +379,27 @@
     def choose_export_pdf_name(self, widget=None):
         """Handles choosing a name for exporting """
 
-        chooser = gtk.FileChooserDialog(title=_('Export ...'),
-                                        action=gtk.FILE_CHOOSER_ACTION_SAVE,
-                                        buttons=(gtk.STOCK_CANCEL,
-                                                 gtk.RESPONSE_CANCEL,
-                                                 gtk.STOCK_SAVE,
-                                                 gtk.RESPONSE_OK))
+        chooser = Gtk.FileChooserDialog(title=_('Export ...'),
+                                        action=Gtk.FileChooserAction.SAVE,
+                                        buttons=(Gtk.STOCK_CANCEL,
+                                                 Gtk.ResponseType.CANCEL,
+                                                 Gtk.STOCK_SAVE,
+                                                 Gtk.ResponseType.OK))
         chooser.set_do_overwrite_confirmation(True)
         chooser.set_current_folder(self.export_directory)
-        filter_pdf = gtk.FileFilter()
+        filter_pdf = Gtk.FileFilter()
         filter_pdf.set_name(_('PDF files'))
         filter_pdf.add_mime_type('application/pdf')
         chooser.add_filter(filter_pdf)
 
-        filter_all = gtk.FileFilter()
+        filter_all = Gtk.FileFilter()
         filter_all.set_name(_('All files'))
         filter_all.add_pattern('*')
         chooser.add_filter(filter_all)
 
         while True:
             response = chooser.run()
-            if response == gtk.RESPONSE_OK:
+            if response == Gtk.ResponseType.OK:
                 file_out = chooser.get_filename()
                 (path, shortname) = os.path.split(file_out)
                 (shortname, ext) = os.path.splitext(shortname)
@@ -419,12 +409,12 @@
                     self.export_to_file(file_out)
                     self.export_directory = path
                 except IOError:
-                    error_msg_win = gtk.MessageDialog(flags=gtk.DIALOG_MODAL,
-                                                      type=gtk.MESSAGE_ERROR,
+                    error_msg_win = Gtk.MessageDialog(flags=Gtk.DialogFlags.MODAL,
+                                                      type=Gtk.MessageType.ERROR,
                        message_format=_("Error writing file: %s") % file_out,
-                                                      buttons=gtk.BUTTONS_OK)
+                                                      buttons=Gtk.ButtonsType.OK)
                     response = error_msg_win.run()
-                    if response == gtk.RESPONSE_OK:
+                    if response == Gtk.ResponseType.OK:
                         error_msg_win.destroy()
                     continue
             break
@@ -491,33 +481,33 @@
     def on_action_add_doc_activate(self, widget, data=None):
         """Import doc"""
 
-        chooser = gtk.FileChooserDialog(title=_('Import...'),
-                                        action=gtk.FILE_CHOOSER_ACTION_OPEN,
-                                        buttons=(gtk.STOCK_CANCEL,
-                                                  gtk.RESPONSE_CANCEL,
-                                                  gtk.STOCK_OPEN,
-                                                  gtk.RESPONSE_OK))
+        chooser = Gtk.FileChooserDialog(title=_('Import...'),
+                                        action=Gtk.FileChooserAction.OPEN,
+                                        buttons=(Gtk.STOCK_CANCEL,
+                                                  Gtk.ResponseType.CANCEL,
+                                                  Gtk.STOCK_OPEN,
+                                                  Gtk.ResponseType.OK))
         chooser.set_current_folder(self.import_directory)
         chooser.set_select_multiple(True)
 
-        filter_all = gtk.FileFilter()
+        filter_all = Gtk.FileFilter()
         filter_all.set_name(_('All files'))
         filter_all.add_pattern('*')
         chooser.add_filter(filter_all)
 
-        filter_pdf = gtk.FileFilter()
+        filter_pdf = Gtk.FileFilter()
         filter_pdf.set_name(_('PDF files'))
         filter_pdf.add_mime_type('application/pdf')
         chooser.add_filter(filter_pdf)
         chooser.set_filter(filter_pdf)
 
         response = chooser.run()
-        if response == gtk.RESPONSE_OK:
+        if response == Gtk.ResponseType.OK:
             for filename in chooser.get_filenames():
                 if os.path.isfile(filename):
                     # FIXME
-                    f = gio.File(filename)
-                    f_info = f.query_info('standard::content-type')
+                    f = Gio.File.new_for_path(filename)
+                    f_info = f.query_info('standard::content-type', 0, None)
                     mime_type = f_info.get_content_type()
                     if mime_type == 'application/pdf':
                         self.add_pdf_pages(filename)
@@ -529,7 +519,7 @@
                         print(_('File type not supported!'))
                 else:
                     print(_('File %s does not exist') % filename)
-        elif response == gtk.RESPONSE_CANCEL:
+        elif response == Gtk.ResponseType.CANCEL:
             print(_('Closed, no files selected'))
         chooser.destroy()
 
@@ -559,7 +549,7 @@
 
         if len(iconview.get_selected_items()) > 1:
             iconview.stop_emission('drag_begin')
-            context.set_icon_stock(gtk.STOCK_DND_MULTIPLE, 0, 0)
+            context.set_icon_stock(Gtk.STOCK_DND_MULTIPLE, 0, 0)
 
     # =======================================================
     def iv_dnd_get_data(self, iconview, context, 
@@ -599,23 +589,23 @@
             iter_to = None
             if drop_info:
                 path, position = drop_info
-                ref_to = gtk.TreeRowReference(model,path)
+                ref_to = Gtk.TreeRowReference(model,path)
             else:
-                position = gtk.ICON_VIEW_DROP_RIGHT
+                position = Gtk.ICON_VIEW_DROP_RIGHT
                 if len(model) > 0:  #find the iterator of the last row
                     row = model[-1]
                     path = row.path
-                    ref_to = gtk.TreeRowReference(model,path)
+                    ref_to = Gtk.TreeRowReference(model,path)
             if ref_to:
-                before = (   position == gtk.ICON_VIEW_DROP_LEFT
-                          or position == gtk.ICON_VIEW_DROP_ABOVE)
+                before = (   position == Gtk.ICON_VIEW_DROP_LEFT
+                          or position == Gtk.ICON_VIEW_DROP_ABOVE)
                 #if target_id == self.MODEL_ROW_INTERN:
                 if selection_data.target == 'MODEL_ROW_INTERN':
                     if before:
                         data.sort(key=int)
                     else:
                         data.sort(key=int,reverse=True)
-                    ref_from_list = [gtk.TreeRowReference(model,path)
+                    ref_from_list = [Gtk.TreeRowReference(model,path)
                                      for path in data]
                     for ref_from in ref_from_list:
                         path = ref_to.get_path()
@@ -627,7 +617,7 @@
                             model.insert_before(iter_to, row)
                         else:
                             model.insert_after(iter_to, row)
-                    if context.action == gtk.gdk.ACTION_MOVE:
+                    if context.action == Gdk.DragAction.MOVE:
                         for ref_from in ref_from_list:
                             path = ref_from.get_path()
                             iter_from = model.get_iter(path)
@@ -654,7 +644,7 @@
                                     model.move_before(iter_from, iter_to)
                                 else:
                                     model.move_after(iter_from, iter_to)
-                                if context.action == gtk.gdk.ACTION_MOVE:
+                                if context.action == Gdk.DragAction.MOVE:
                                     context.finish(True, True, etime)
 
     # =======================================================
@@ -663,7 +653,7 @@
 
         model = self.iconview.get_model()
         selection = self.iconview.get_selected_items()
-        ref_del_list = [gtk.TreeRowReference(model,path) for path in selection]
+        ref_del_list = [Gtk.TreeRowReference(model,path) for path in selection]
         for ref_del in ref_del_list:
             path = ref_del.get_path()
             iter = model.get_iter(path)
@@ -678,16 +668,16 @@
         sw_height = self.sw.get_allocation().height
         if y -sw_vadj.get_value() < autoscroll_area:
             if not self.iv_auto_scroll_timer:
-                self.iv_auto_scroll_direction = gtk.DIR_UP
-                self.iv_auto_scroll_timer = gobject.timeout_add(150,
+                self.iv_auto_scroll_direction = Gtk.DIR_UP
+                self.iv_auto_scroll_timer = GObject.timeout_add(150,
                                                                 self.iv_auto_scroll)
         elif y -sw_vadj.get_value() > sw_height - autoscroll_area:
             if not self.iv_auto_scroll_timer:
-                self.iv_auto_scroll_direction = gtk.DIR_DOWN
-                self.iv_auto_scroll_timer = gobject.timeout_add(150,
+                self.iv_auto_scroll_direction = Gtk.DIR_DOWN
+                self.iv_auto_scroll_timer = GObject.timeout_add(150,
                                                                 self.iv_auto_scroll)
         elif self.iv_auto_scroll_timer:
-            gobject.source_remove(self.iv_auto_scroll_timer)
+            GObject.source_remove(self.iv_auto_scroll_timer)
             self.iv_auto_scroll_timer = None
 
     # =======================================================
@@ -695,7 +685,7 @@
         """Ends the auto-scroll during DND"""
 
         if self.iv_auto_scroll_timer:
-            gobject.source_remove(self.iv_auto_scroll_timer)
+            GObject.source_remove(self.iv_auto_scroll_timer)
             self.iv_auto_scroll_timer = None
 
     # =======================================================
@@ -704,10 +694,10 @@
 
         sw_vadj = self.sw.get_vadjustment()
         sw_vpos = sw_vadj.get_value()
-        if self.iv_auto_scroll_direction == gtk.DIR_UP:
+        if self.iv_auto_scroll_direction == Gtk.DIR_UP:
             sw_vpos -= sw_vadj.step_increment
             sw_vadj.set_value( max(sw_vpos, sw_vadj.lower) )
-        elif self.iv_auto_scroll_direction == gtk.DIR_DOWN:
+        elif self.iv_auto_scroll_direction == Gtk.DIR_DOWN:
             sw_vpos += sw_vadj.step_increment
             sw_vadj.set_value( min(sw_vpos, sw_vadj.upper - sw_vadj.page_size) )
         return True  #call me again
@@ -727,7 +717,7 @@
                     iconview.unselect_all()
                 iconview.select_path(path)
                 iconview.grab_focus()
-                self.popup.popup( None, None, None, event.button, time)
+                self.popup.popup( None, None, None, None, event.button, time)
             return 1
 
     # =======================================================
@@ -746,7 +736,7 @@
                 npage, angle = [int(k) for k in tmp[1:3]]
                 crop = [float(side) for side in tmp[3:7]]
                 if self.add_pdf_pages(filename, npage, npage, angle, crop):
-                    if context.action == gtk.gdk.ACTION_MOVE:
+                    if context.action == Gdk.DragAction.MOVE:
                         context.finish(True, True, etime)
         elif target_id == self.TEXT_URI_LIST:
             uri = data.strip()
@@ -837,45 +827,45 @@
             pos = model.get_iter(path)
             crop = [model.get_value(pos, 8 + side) for side in range(4)]
 
-        dialog = gtk.Dialog(title=(_('Crop Selected Page(s)')),
+        dialog = Gtk.Dialog(title=(_('Crop Selected Page(s)')),
                             parent=self.window,
-                            flags=gtk.DIALOG_MODAL,
-                            buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
-                                     gtk.STOCK_OK, gtk.RESPONSE_OK))
+                            flags=Gtk.DialogFlags.MODAL,
+                            buttons=(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
+                                     Gtk.STOCK_OK, Gtk.ResponseType.OK))
         dialog.set_size_request(340, 250)
-        dialog.set_default_response(gtk.RESPONSE_OK)
+        dialog.set_default_response(Gtk.ResponseType.OK)
 
-        frame = gtk.Frame(_('Crop Margins'))
+        frame = Gtk.Frame.new(_('Crop Margins'))
         dialog.vbox.pack_start(frame, False, False, 20)
 
-        vbox = gtk.VBox(False, 0)
+        vbox = Gtk.VBox(False, 0)
         frame.add(vbox)
 
         spin_list = []
         units = 2 * [_('% of width')] + 2 * [_('% of height')] 
         for side in sides:
-            hbox = gtk.HBox(True, 0)
+            hbox = Gtk.HBox(True, 0)
             vbox.pack_start(hbox, False, False, 5)
 
-            label = gtk.Label(side_names[side])
+            label = Gtk.Label(label=side_names[side])
             label.set_alignment(0, 0.0)
             hbox.pack_start(label, True, True, 20)
 
-            adj = gtk.Adjustment(100.*crop.pop(0), 0.0, 99.0, 1.0, 5.0, 0.0)
-            spin = gtk.SpinButton(adj, 0, 1)
+            adj = Gtk.Adjustment(100.*crop.pop(0), 0.0, 99.0, 1.0, 5.0, 0.0)
+            spin = Gtk.SpinButton.new(adj, 0, 1)
             spin.set_activates_default(True)
             spin.connect('value-changed', set_crop_value, side)
             spin_list.append(spin)
             hbox.pack_start(spin, False, False, 30)
 
-            label = gtk.Label(units.pop(0))
+            label = Gtk.Label(label=units.pop(0))
             label.set_alignment(0, 0.0)
             hbox.pack_start(label, True, True, 0)
 
         dialog.show_all()
         result = dialog.run()
 
-        if result == gtk.RESPONSE_OK:
+        if result == Gtk.ResponseType.OK:
             crop = []
             for spin in spin_list:
                 crop.append( spin.get_value()/100. )
@@ -885,13 +875,13 @@
                     model.set_value(pos, 8 + it, crop[it])
                 model.set_value(pos, 6, False) #rendering request
             self.render()
-        elif result == gtk.RESPONSE_CANCEL:
+        elif result == Gtk.ResponseType.CANCEL:
             print(_('Dialog closed'))
         dialog.destroy()
 
     # =======================================================
     def about_dialog(self, widget, data=None):
-        about_dialog = gtk.AboutDialog()
+        about_dialog = Gtk.AboutDialog()
         try:
             about_dialog.set_transient_for(self.window)
             about_dialog.set_modal(True)
@@ -920,62 +910,62 @@
         self.filename = os.path.abspath(filename)
         (self.path, self.shortname) = os.path.split(self.filename)
         (self.shortname, self.ext) = os.path.splitext(self.shortname)
-        f = gio.File(filename)
-        mime_type = f.query_info('standard::content-type').get_content_type()
+        f = Gio.File.new_for_path(filename)
+        mime_type = f.query_info('standard::content-type', 0, None).get_content_type()
         if mime_type == 'application/pdf':
             self.nfile = nfile + 1
             self.mtime = os.path.getmtime(filename)
             self.copyname = os.path.join(tmp_dir, '%02d_' % self.nfile +
                                                   self.shortname + '.pdf')
             shutil.copy(self.filename, self.copyname)
-            self.document = poppler.document_new_from_file("file://" + self.copyname, None)
+            self.document = Poppler.Document.new_from_file("file://" + self.copyname, None)
             self.npage = self.document.get_n_pages()
         else:
             self.nfile = 0
 
 
 # =======================================================
-class PDF_Renderer(threading.Thread,gobject.GObject):
+class PDF_Renderer(threading.Thread,GObject.GObject):
 
     def __init__(self, model, pdfqueue, scale=1., width=100):
-        threading.Thread.__init__(self)
-        gobject.GObject.__init__(self)
+        GObject.GObject.__init__(self)
         self.model = model
         self.scale = scale
         self.default_width = width
         self.pdfqueue = pdfqueue
         self.quit = False
-        self.evnt = threading.Event()
-        self.paused = False
 
     def run(self):
-       while not self.quit:
-           rendered_all = True
-           for row in self.model:
-               if self.quit:
-                   break
-               if not row[6]:
-                   rendered_all = False
-                   gtk.gdk.threads_enter()
-                   try:
-                       nfile = row[2]
-                       npage = row[3]
-                       angle = row[7]
-                       crop = [row[8],row[9],row[10],row[11]]
-                       pdfdoc = self.pdfqueue[nfile - 1]
-                       thumbnail = self.load_pdf_thumbnail(pdfdoc, npage, angle, crop)
-                       row[6] = True
-                       row[4] = thumbnail.get_width()
-                       row[1] = thumbnail
-                   finally:
-                       gtk.gdk.threads_leave()
-           if rendered_all:
-               if self.model.get_iter_first(): #just checking if model isn't empty
-                   self.emit('reset_iv_width')
-               self.paused = True
-               self.evnt.wait()
+        while not self.quit:
+            rendered_all = True
+            for row in self.model:
+                if self.quit:
+                    break
+                if not row[6]:
+                    rendered_all = False
+                    try:
+                        nfile = row[2]
+                        npage = row[3]
+                        angle = row[7]
+                        crop = [row[8],row[9],row[10],row[11]]
+                        pdfdoc = self.pdfqueue[nfile - 1]
+                        thumbnail = self.load_pdf_thumbnail(pdfdoc, npage, angle, crop)
+                        row[6] = True
+                        row[4] = thumbnail.get_width()
+                        row[1] = thumbnail
+                    finally:
+                        pass #Gdk.threads_leave()
+            if rendered_all:
+                self.quit = True
+                if self.model.get_iter_first(): #just checking if model isn't empty
+                    self.emit('reset_iv_width')
+        self.quit = False
+        return False
 
     # =======================================================
+    def pixbuf_destroy_fn(self, pixbuf, data):
+        pass #del pixbuf
+
     def load_pdf_thumbnail(self, pdfdoc, npage, rotation=0, crop=[0.,0.,0.,0.]):
         """Create pdf pixbuf"""
 
@@ -988,6 +978,8 @@
             data = array.array('c', '\x00' * stride * pix_h)
             pix_surface = cairo.ImageSurface.create_for_data(data, cairo.FORMAT_ARGB32,
                           pix_w, pix_h, stride)
+            #thumbnail = GdkPixbuf.Pixbuf(GdkPixbuf.Colorspace.RGB, False,
+            #                           8, pix_w , pix_h)
             ctx = cairo.Context(pix_surface)
             ctx.scale(self.scale, self.scale)
             page.render(ctx)
@@ -996,10 +988,12 @@
                  data[1::4], data[2::4], data[3::4], data[0::4]
             else:
                 data[0::4], data[2::4] = data[2::4], data[0::4]
-            thumbnail = gtk.gdk.pixbuf_new_from_data(data,
-                                                 gtk.gdk.COLORSPACE_RGB,
-                                                 True, 8, pix_w , pix_h,
-                                                 stride)
+            thumbnail = GdkPixbuf.Pixbuf.new_from_data(data,
+                                                 GdkPixbuf.Colorspace.RGB,
+                                                 True, 8, pix_w, pix_h,
+                                                 stride, self.pixbuf_destroy_fn,
+                                                 None)
+            #page.render_to_pixbuf(0,0,pix_w,pix_h,self.scale,0,thumbnail)
             rotation = (-rotation) % 360
             rotation = ((rotation + 45) / 90) * 90
             thumbnail = thumbnail.rotate_simple(rotation)
@@ -1010,7 +1004,7 @@
                 src_y = int( crop[2] * pix_h )
                 width = int( (1. - crop[0] - crop[1]) * pix_w )
                 height = int( (1. - crop[2] - crop[3]) * pix_h )
-                new_thumbnail = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True,
+                new_thumbnail = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, True,
                                                8, width, height)
                 thumbnail.copy_area(src_x, src_y, width, height,
                                     new_thumbnail, 0, 0)
@@ -1022,14 +1016,14 @@
             traceback.print_exc()
             pix_w = self.default_width
             pix_h = pix_w
-            thumbnail = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False,
+            thumbnail = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, False,
                                        8, pix_w, pix_h)
             thumbnail.fill(0xffffffff)
 
         #add border
         thickness = 3
         color = 0x000000FF
-        canvas = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8,
+        canvas = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, True, 8,
                                 pix_w + thickness + 1,
                                 pix_h + thickness + 1)
         canvas.fill(color)
@@ -1042,7 +1036,7 @@
 # =======================================================
 if __name__ == '__main__':
     PDFshuffler()
-    gtk.gdk.threads_enter()
-    gtk.main()
-    gtk.gdk.threads_leave()
+    Gdk.threads_enter()
+    Gtk.main()
+    Gdk.threads_leave()