Attachment #292961 for bug #390607

View | Details | Raw Unified | Return to bug 390607 | Differences between
Collapse All | Expand All




import gettext
gettext.install('pdfshuffler', unicode=1)

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
    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 poppler      #for the rendering of pdf pages
from pyPdf import PdfFileWriter, PdfFileReader

class PDFshuffler:

    # All the preferences are stored here.
    # =======================================================
    prefs = {
        '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,

    MODEL_ROW_EXTERN = 1002
    TEXT_URI_LIST = 1003
    MODEL_ROW_MOTION = 1004
    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


        pixmap = os.path.join(sys.prefix,'share','pixmaps','pdfshuffler.png')
        try:
            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.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'])

        self.window.show()

        # Create a vbox to hold the thumnails-container
        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.set_border_width(0)
        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,
                              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.add(self.sw)

        # Create an alignment to keep the thumbnails center-aligned
        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
                                   GdkPixbuf.Pixbuf,  # 1.Thumbnail image
                                   int,             # 2.Document number
                                   int,             # 3.Page number
                                   int,             # 4.Thumbnail width

        self.zoom_scale = self.prefs['initial zoom scale']
        self.iv_col_width = self.prefs['initial thumbnail size']

        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.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.celltxt.set_property('width', self.iv_col_width)
        self.celltxt.set_property('wrap-width', self.iv_col_width)
        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_selection_mode(Gtk.SelectionMode.MULTIPLE)
        self.iconview.enable_model_drag_source(Gdk.ModifierType.BUTTON1_MASK,
                                               self.TARGETS_IV,
                                               Gdk.DragAction.COPY |
                                               Gdk.DragAction.MOVE )
        self.iconview.enable_model_drag_dest(self.TARGETS_IV,
                                             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)


        style = self.iconview.get_style().copy()
        style_sw = self.sw.get_style()
        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.Grid()
        hbox.set_column_homogeneous(True)
        vbox.add(hbox)

        # Create buttons
        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.add(self.button_exit)

        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.add(self.button_del)

        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.add(self.button_import)

        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.add(self.button_export)

        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.add(self.button_export)

        # Define window callback function and show window
        self.window.connect('size_allocate', self.on_window_size_request)        # resize

        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)'))
        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)

        self.iv_auto_scroll_timer = None
        self.pdfqueue = []

        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()
        GObject.idle_add(self.rendering_thread.run)

    # =======================================================
    def on_window_size_request(self, window, event):

    def on_keypress_event(self, widget, event):
        """Keypress events in Main Window"""

        #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"""

        #Gdk.threads_leave()
        self.rendering_thread.quit = True
        #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()
        else:
            sys.exit(0)
        return False

        for npage in range(n_start, n_end + 1):
            descriptor = ''.join([pdfdoc.shortname, '\n', _('page'), ' ', str(npage)])
            width = self.iv_col_width
            thumbnail = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, False,
                                       8, width, width)
            self.model.append((descriptor,              # 0
                               thumbnail,               # 1

    def choose_export_pdf_name(self, widget=None):
        """Handles choosing a name for exporting """

        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.set_name(_('PDF files'))
        filter_pdf.add_mime_type('application/pdf')
        chooser.add_filter(filter_pdf)

        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.ResponseType.OK:
                file_out = chooser.get_filename()
                (path, shortname) = os.path.split(file_out)
                (shortname, ext) = os.path.splitext(shortname)

                    self.export_to_file(file_out)
                    self.export_directory = path
                except IOError:
                    error_msg_win = Gtk.MessageDialog(flags=Gtk.DialogFlags.MODAL,
                                                      type=Gtk.MessageType.ERROR,
                       message_format=_("Error writing file: %s") % file_out,
                                                      buttons=Gtk.ButtonsType.OK)
                    response = error_msg_win.run()
                    if response == Gtk.ResponseType.OK:
                        error_msg_win.destroy()
                    continue
            break

    def on_action_add_doc_activate(self, widget, data=None):
        """Import doc"""

        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.set_name(_('All files'))
        filter_all.add_pattern('*')
        chooser.add_filter(filter_all)

        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.ResponseType.OK:
            for filename in chooser.get_filenames():
                if os.path.isfile(filename):
                    # FIXME
                    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)

                        print(_('File type not supported!'))
                else:
                    print(_('File %s does not exist') % filename)
        elif response == Gtk.ResponseType.CANCEL:
            print(_('Closed, no files selected'))
        chooser.destroy()



        if len(iconview.get_selected_items()) > 1:
            iconview.stop_emission('drag_begin')
            context.set_icon_stock(Gtk.STOCK_DND_MULTIPLE, 0, 0)

    # =======================================================
    def iv_dnd_get_data(self, iconview, context, 

            iter_to = None
            if drop_info:
                path, position = drop_info
                ref_to = Gtk.TreeRowReference(model,path)
            else:
                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)
            if ref_to:
                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)
                                     for path in data]
                    for ref_from in ref_from_list:
                        path = ref_to.get_path()

                            model.insert_before(iter_to, row)
                        else:
                            model.insert_after(iter_to, row)
                    if context.action == Gdk.DragAction.MOVE:
                        for ref_from in ref_from_list:
                            path = ref_from.get_path()
                            iter_from = model.get_iter(path)

                                    model.move_before(iter_from, iter_to)
                                else:
                                    model.move_after(iter_from, iter_to)
                                if context.action == Gdk.DragAction.MOVE:
                                    context.finish(True, True, etime)

    # =======================================================


        model = self.iconview.get_model()
        selection = self.iconview.get_selected_items()
        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)

        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)
        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)
        elif self.iv_auto_scroll_timer:
            GObject.source_remove(self.iv_auto_scroll_timer)
            self.iv_auto_scroll_timer = None

    # =======================================================

        """Ends the auto-scroll during DND"""

        if self.iv_auto_scroll_timer:
            GObject.source_remove(self.iv_auto_scroll_timer)
            self.iv_auto_scroll_timer = None

    # =======================================================


        sw_vadj = self.sw.get_vadjustment()
        sw_vpos = sw_vadj.get_value()
        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:
            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

                    iconview.unselect_all()
                iconview.select_path(path)
                iconview.grab_focus()
                self.popup.popup( None, None, None, None, event.button, time)
            return 1

    # =======================================================

                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 == Gdk.DragAction.MOVE:
                        context.finish(True, True, etime)
        elif target_id == self.TEXT_URI_LIST:
            uri = data.strip()

            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)')),
                            parent=self.window,
                            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.ResponseType.OK)

        frame = Gtk.Frame.new(_('Crop Margins'))
        dialog.vbox.pack_start(frame, False, False, 20)

        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)
            vbox.pack_start(hbox, False, False, 5)

            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.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(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.ResponseType.OK:
            crop = []
            for spin in spin_list:
                crop.append( spin.get_value()/100. )

                    model.set_value(pos, 8 + it, crop[it])
                model.set_value(pos, 6, False) #rendering request
            self.render()
        elif result == Gtk.ResponseType.CANCEL:
            print(_('Dialog closed'))
        dialog.destroy()

    # =======================================================
    def about_dialog(self, widget, data=None):
        about_dialog = Gtk.AboutDialog()
        try:
            about_dialog.set_transient_for(self.window)
            about_dialog.set_modal(True)

        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.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.npage = self.document.get_n_pages()
        else:
            self.nfile = 0


# =======================================================
class PDF_Renderer(threading.Thread,GObject.GObject):

    def __init__(self, model, pdfqueue, scale=1., width=100):
        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
                    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"""


            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)

                 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 = 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)

                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 = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, True,
                                               8, width, height)
                thumbnail.copy_area(src_x, src_y, width, height,
                                    new_thumbnail, 0, 0)

            traceback.print_exc()
            pix_w = self.default_width
            pix_h = pix_w
            thumbnail = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, False,
                                       8, pix_w, pix_h)
            thumbnail.fill(0xffffffff)

        #add border
        thickness = 3
        color = 0x000000FF
        canvas = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, True, 8,
                                pix_w + thickness + 1,
                                pix_h + thickness + 1)
        canvas.fill(color)

# =======================================================
if __name__ == '__main__':
    PDFshuffler()
    Gdk.threads_enter()
    Gtk.main()
    Gdk.threads_leave()


Return to bug 390607