A gtk version of printscript.py; A cups verion of printscript.py, final version of printerdeviceicon, allworking

7 files changed, 716 insertions, 19 deletions

diff --git a/.goutputstream-JNP5VU b/.goutputstream-JNP5VU
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/.goutputstream-JNP5VU
diff --git a/.goutputstream-ST50VU b/.goutputstream-ST50VU
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/.goutputstream-ST50VU
diff --git a/printactivity.py b/printactivity.py
index 8d93d58..d1211d3 100644
--- a/printactivity.py
+++ b/printactivity.py
@@ -38,7 +38,7 @@ from sugar.graphics.objectchooser import ObjectChooser
 
 from printscript import serverConnection
 from printtoolbar import PrintToolbar, \
-ReadToolbar, ViewToolbar
+ReadToolbar, ViewToolbar, PrintSetupToolbar
 
 from glib import GError
 import atexit
@@ -123,7 +123,11 @@ class ReadActivity(activity.Activity):
         self._view.set_screen_dpi(_get_screen_dpi())
 
         toolbox = activity.ActivityToolbox(self)
-
+        
+        self._print_setup_toolbar = PrintSetupToolbar(self._view)
+        toolbox.add_toolbar(_('Print Setup'), self._print_setup_toolbar)
+        self._print_setup_toolbar.show()
+        
         self._print_toolbar = PrintToolbar(self._view)
         self._print_toolbar._pdf.connect('clicked',self._save_pdf)
         self._print_toolbar._USB.props.sensitive = True
@@ -472,7 +476,7 @@ class ReadActivity(activity.Activity):
         self._read_toolbar.set_document(self._document)
 
         self._print_toolbar.setTitlePath(self._title,self._tempfile)
-
+        self._print_setup_toolbar.setTitlePath(self._title,self._tempfile)
 
         if not self.metadata['title_set_by_user'] == '1':
             info = self._document.get_info()
diff --git a/printerDeviceIcon.py b/printerDeviceIcon.py
new file mode 100644
index 0000000..c48a2cd
--- /dev/null
+++ b/printerDeviceIcon.py
@@ -0,0 +1,268 @@
+from gettext import gettext as _
+import logging
+import sha
+import socket
+import struct
+
+import gtk
+import gobject
+import gconf
+import dbus
+import time
+from datetime import date
+
+from sugar.graphics.icon import get_icon_state, Icon
+from sugar.graphics import style
+from sugar.graphics.palette import Palette
+from sugar.graphics.toolbutton import ToolButton
+from sugar.graphics.tray import TrayIcon
+from sugar.graphics import xocolor
+from sugar.util import unique_id
+from sugar.graphics.menuitem import MenuItem
+from sugar import profile
+from jarabe.frame.frameinvoker import FrameWidgetInvoker
+
+from printscript import *
+
+_HAL_SERVICE = 'org.freedesktop.Hal'
+_HAL_IFACE = 'org.freedesktop.Hal.Manager'
+_HAL_PATH = '/org/freedesktop/Hal/Manager'
+_PRINTER_SERVICE = 'org.freedesktop.Hal'
+_PRINTER_PATH = ''
+_PRINTER_IFACE = 'org.freedesktop.Hal.Device'
+_SPOOLER_PATH="/com/redhat/PrinterSpooler"
+_SPOOLER_IFACE="com.redhat.PrinterSpooler"
+#_PRINTER_DEVICE_IFACE = 'org.freedesktop.NetworkManager.Device'
+_ICON_NAME = 'printer'
+
+
+class PrinterPalette(Palette):
+
+
+    def __init__(self,name,):
+
+        self._name = name
+        Palette.__init__(self, label=_('Printer'))
+       
+        self._model = DeviceModel()
+        
+        logging.debug("hey this is 1" )
+
+        self._hbars = {}
+        self._indexToidmapper = []
+        self.tryJobs()
+        self.props.secondary_text = name   
+        self.connectEvents()
+
+    def connectEvents(self):
+
+        for key in self._hbars.keys():
+            self._hbars[key].connect('activate',self.cancel,key)
+            #logging.debug("hey this got deleted %s",key)                 
+    
+    def clearMenu(self):
+
+        for key in self._hbars.keys():
+            self.menu.remove(self._hbars[key])
+            del self._hbars[key]
+
+    def tryJobs(self):
+
+        self.clearMenu()
+        self._jobids = self._model.getLiveJobs()[0]
+        self._jobids.sort()
+
+        try:
+            for jobid in self._jobids:
+                logging.debug(self._model.getJobStatus(jobid))
+                status = self._model.getJobStatus(jobid)
+                title = self._model.getJobTitle(jobid)
+                self.createHBars(status,title,jobid)
+                self._indexToidmapper.append(jobid)
+        except TypeError:
+            pass   
+
+    def cancel(self,widget,key):
+
+        self._model.cancelAJob(key)
+        self.menu.remove(self._hbars[key])
+        #self.connectEvents(self)
+        del self._hbars[key]
+        
+    def createHBars(self,status,title,jobid):
+
+        self._cancel = MenuItem('')
+        self._icon = Icon(icon_size=gtk.ICON_SIZE_MENU)
+        self._cancel.set_image(self._icon)
+        self._icon.props.icon_name = _('dialog-cancel')
+        if len(title) > 10:
+            logging.debug('the length is %s',len(title))
+            title = title.rsplit(title[10:],1)[0] + '...'
+        self._cancel.get_child().set_text(_(title + '\n' + \
+                                            status))
+        self.menu.append(self._cancel)
+      
+        self._cancel.show()
+        self._hbars[jobid]= self._cancel     
+
+    def redraw(self):
+
+        logging.debug("I come from class 1")
+        self._model.update()
+        self.tryJobs()
+        self.connectEvents()
+
+class DeviceModel():
+
+    def __init__(self):
+   
+        self._cups = serverConnection()
+        self.update()
+           
+    def getLiveJobs(self,):
+
+        return [self.livejobsKeys, self.livejobsDict]
+   
+    def getJobStatus(self,jobkey):
+
+        if self.livejobsDict[jobkey]["job-state"] == 5:
+            return _("Processing")
+        elif self.livejobsDict[jobkey]["job-state"] == 3:
+            return _("Pending")
+        else:
+            return _("Cancelled")
+   
+    def getJobTitle(self,jobkey):
+
+        return self.livejobsDict[jobkey]["job-name"]
+
+    def cancelAJob(self,jobkey):
+
+        logging.debug("lololol")
+        logging.debug(jobkey)
+        self._cups._cancelAJob(jobkey)
+    
+    def update(self,):
+
+        self.livejobsDict = self._cups._getLiveJobQueue()
+        self.livejobsKeys = self.livejobsDict.keys()
+
+class PrinterDeviceView(TrayIcon):
+
+    
+    FRAME_POSITION_RELATIVE = 301
+
+    def __init__(self,name):
+
+        client = gconf.client_get_default()
+
+        sh = sha.new()
+        data = profile.get_nick_name()
+        sh.update(data)
+        h = hash(sh.digest())
+        idx = h % len(xocolor.colors)
+
+        color = xocolor.XoColor('%s,%s' % (xocolor.colors[idx][0],
+                                                 xocolor.colors[idx][1]))
+        
+        TrayIcon.__init__(self, icon_name=_ICON_NAME, xo_color=color)
+
+        self.set_palette_invoker(FrameWidgetInvoker(self))
+        self._palette = PrinterPalette(name)
+        self.set_palette(self._palette)
+        self._palette.set_group_id('frame')
+        logging.debug('I come from PrinterDeviceView')
+
+    def updateQueue(self):
+
+        logging.debug("I come from class 2")
+        try:
+            gobject.source_remove(self.timer)
+        except AttributeError:
+            pass
+
+        self.timer = gobject.timeout_add(500,self._palette.redraw)
+        #self._palette.redraw()
+
+class PrinterManagerObserver(object):
+
+
+    def __init__(self, tray):
+
+        self._bus = dbus.SystemBus()
+        self._halmgr = None
+        self._tray = tray
+        self._devices = {}
+       
+
+        try:
+            obj = self._bus.get_object(_HAL_SERVICE, _HAL_PATH)
+            self._halmgr = dbus.Interface(obj, _HAL_IFACE)
+        except dbus.DBusException:
+            logging.error('%s service not available', _HAL_SERVICE)
+            return
+
+        self.findPrinters()
+       
+        self._halmgr.connect_to_signal('DeviceAdded',
+                                       self.deviceAdded)
+        self._halmgr.connect_to_signal('DeviceRemoved',
+                                       self.deviceRemoved,)
+
+        self._bus.add_signal_receiver(self.updateLists,
+                                      path=_SPOOLER_PATH,
+                                      dbus_interface=_SPOOLER_IFACE)
+    def updateLists(self,*agrs):
+
+        logging.debug("I come from class 3")
+        try:
+            gobject.source_remove(self._timer)
+        except AttributeError:
+            pass
+        #self._device_view.update_queue()
+        self._timer = gobject.timeout_add(200,self._device_view.updateQueue)
+        
+   
+    def findPrinters(self):
+
+        try:
+            printerLocation = self._halmgr.FindDeviceByCapability('printer')
+                   
+        except AttributeError and IndexError:
+            logging.debug('No Print Device found')
+        else:
+            for printerLoc in printerLocation:
+                self.deviceAdded(printerLoc)    
+             
+        
+
+    def deviceAdded(self, printerLoc):    
+        
+        self._PrinterObj = self._bus.get_object(_PRINTER_SERVICE,printerLoc)

+        self._printeriface = dbus.Interface(self._PrinterObj, _PRINTER_IFACE)
+        try:
+            print self._printeriface.GetProperty('info.capabilities')[0]
+        except dbus.DBusException, IndexError:
+            return 
+        self._properties = self._printeriface.GetAllProperties()
+        self._headerString = self._properties[u'info.vendor']+ \
+                            ' '+self._properties[u'info.product']
+        logging.debug('Print Device found %s',self._headerString)
+        self._device_view = PrinterDeviceView(self._headerString)
+        self._tray.add_device(self._device_view)          
+        self._devices[printerLoc] = self._device_view
+        
+    def deviceRemoved(self, printerLoc):
+
+        logging.debug('No Print Device found, so Disconnecting Device')
+        #self._device_view.disconnect()
+        self._tray.remove_device(self._devices[printerLoc])
+        del self._devices[printerLoc]
+        self._devices[printerLoc] = None
+
+
+
+        
+def setup(tray):
+
+    device_observer = PrinterManagerObserver(tray)
diff --git a/printscript.py b/printscript.py
index 303aed2..eb7f064 100644
--- a/printscript.py
+++ b/printscript.py
@@ -30,9 +30,44 @@ class PageSetup(gtk.Dialog):
         return _PAGE_SETUP       
     
 
+
+class JustPrint:
+
+    def __init__(self, title, filepath):
+        self.printSettings = gtk.PrintSettings()
+        #self.printSettings.
+        self.pgSetup = gtk.PageSetup()
+        printerEnumerationObj = EnumeratePrinters()
+        self.printerObj = printerEnumerationObj.getPrinter()[1]
+        self._title = title
+        self._filepath = filepath        
+    
+    def printIt(self,):
+        cups = serverConnection()
+        cups._connect()
+        cups._print_Printer(self._filepath, self._title, self.printerObj)
+        #cups.close()
+    def setRange(self, textstring):
+        start, end = textstring.split('-',1)
+        self.printSettings.set_page_ranges([(int(start),int(end)),])
+
+    def setPrinter(self, printer):
+        self.printerObj = printer
+
+class EnumeratePrinters:
+
+    def __init__(self,):
+        self.cups = serverConnection()
+        self.cups._connect()
+        self.printerList = self.cups._getPrintersList()
+        #self.cups.close()    
+        
+    def getPrinter(self,):
+        return self.printerList
+
 class PrinterSetup(gtk.Dialog):
    
-    def __init__(self,title, filepath):
+    def __init__(self, title, filepath):
         printDialog = gtkunixprint.PrintUnixDialog('Printer Settings',
                                                    gtk.Window())       
         printDialog.show_all()
@@ -41,7 +76,7 @@ class PrinterSetup(gtk.Dialog):
     def processResponse(self, widget, settings,title,filepath):
         _PRINT_SETTINGS = widget.get_settings()
         _PRINTER = widget.get_selected_printer()
-        print _PRINTER.get_name()
+        #print _PRINTER.get_name()
         widget.destroy()
         pgSetup = self.getDefaultPageLayout()
         
@@ -148,9 +183,10 @@ class serverConnection:
 # we require our script to not look up the editable names of the printing devices,
 # but look up the unchangeable URI of the printer, so we do this:        
 
-        theprinters = self._getPrintersList ()
+        theprinters = self._getPrintersList()
         self._location = ''
         for printer in theprinters:
+           #print printer
            if self._getPrinterURI(printer) == u'cups-pdf:/':
                _printer = printer 
                
@@ -174,7 +210,8 @@ class serverConnection:
                                f1 = open(desktop, 'r')
                            except IOError:
 
-                                _logger.debug("$DESKTOP isn't defined, so going to home directory")
+                                _logger.debug("$DESKTOP isn't defined,\
+                                              so going to home directory")
                                 self._location = os.getenv("HOME") 
                                 f1.close() 
                            else:
@@ -182,8 +219,10 @@ class serverConnection:
                                for line in f1:
                                   # print line[0:15]     
                                    if line[0:15] == 'XDG_'+folder+'_DIR':
-                                       self._location = line[15:].rsplit('\n',1)[0].strip('= "')
-                                       self._location = self._location.replace('$HOME',os.getenv("HOME"))
+                                       self._location = line[15:].rsplit('\n',
+                                                         1)[0].strip('= "')
+                                       self._location = self._location.replace('$HOME',
+                                                       os.getenv("HOME"))
                                        break     
                                          
                                           
@@ -191,15 +230,17 @@ class serverConnection:
                                #print self._location 
                                  
                        else:        
-                           self._location = self._location.replace('${USER}', os.getenv("USER"))
+                           self._location = self._location.replace('${USER}', 
+                                                              os.getenv("USER"))
                        break #break to end 2nd for loop
 
-           #print _printer 
-           #print _filename
-           #print _title
-           self._connection.printFile (_printer, _filename, _title, {})
-           break            # break to end 1st for loop
-        return self._location+'/'+_title+'.pdf'
+               self._connection.printFile (_printer, _filename, _title, {})
+                       # break to end 1st for loop
+               return self._location+'/'+_title+'.pdf'
+
+
+    def _print_Printer(self, filename, title, printer):
+        self._connection.printFile (printer, filename, title, {})
 
     def _printtoPrinter (self,_filename, _title=None):
         if _title == None:
@@ -209,6 +250,7 @@ class serverConnection:
             self._connection.printFile (printer, _filename, _title, {})
             return True
         return False
+    
     def _selectDefaultPrinter (self,_printer):
         self._connection.setDefault(_printer)
 
@@ -252,6 +294,7 @@ class serverConnection:
 
 
 
+#printer = JustPrint('lolmax','/home/iwikiwi/lolmax.odt')
 
 #hello = serverConnection()
 #lol = hello._printPDF('Cups-PDF','/home/iwikiwi/lolmax.odt','lolmax')
diff --git a/printscriptGtkVersion.py b/printscriptGtkVersion.py
new file mode 100644
index 0000000..8e0b853
--- /dev/null
+++ b/printscriptGtkVersion.py
@@ -0,0 +1,302 @@
+#!/usr/bin/env python
+import gtk 
+import gtkunixprint
+import logging
+import threading
+import cups
+import sys
+#import cupspk
+from gettext import gettext as _
+import gobject
+import gtk
+import os
+import tempfile
+import time
+import pygtk
+_logger = logging.getLogger('print-activity:printscript')
+
+
+class PageSetup(gtk.Dialog):
+
+    def __init__(self, title=None,):
+        printDialog = gtkunixprint.PageSetupUnixDialog('Page Setup',
+                                                        gtk.Window())
+        printDialog.show_all()
+        printDialog.connect('response',self.processResponse)
+   
+    def processResponse(self, widget, settings):
+        _PAGE_SETUP = widget.get_page_setup()
+        widget.destroy()
+        return _PAGE_SETUP       
+    
+
+
+class JustPrint:
+
+    def __init__(self, title, filepath):
+        self.printSettings = gtk.PrintSettings()
+        #self.printSettings.
+        self.pgSetup = gtk.PageSetup()
+        printerEnumerationObj = EnumeratePrinters()
+        self.printerObj = printerEnumerationObj.getPrinter()[0]
+        self._title = title
+        self._filepath = filepath        
+    
+    def printIt(self,):
+        printJob = PrintJob(self._title, self.printerObj, 
+                           self.printSettings, 
+                           self.pgSetup, self._filepath)
+
+    def setRange(self, textstring):
+        start, end = textstring.split('-',1)
+        self.printSettings.set_page_ranges([(int(start),int(end)),])
+
+    def setPrinter(self, printer):
+        self.printerObj = printer
+
+class EnumeratePrinters:
+
+    def __init__(self,):
+        self.printerList = []
+        self.count = 0
+            
+        loop = gtkunixprint.enumerate_printers(self.function, 
+                                               data=None, wait=True)
+       
+    def function(self, printer, data):
+        #if printer.get_name() != _('Cups-PDF'):
+        _logger.debug(printer.get_name())
+        self.printerList.append(printer)
+        
+    def getPrinter(self,):
+        return self.printerList
+
+class PrinterSetup(gtk.Dialog):
+   
+    def __init__(self, title, filepath):
+        printDialog = gtkunixprint.PrintUnixDialog('Printer Settings',
+                                                   gtk.Window())       
+        printDialog.show_all()
+        printDialog.connect('response',self.processResponse,title,filepath)
+        
+    def processResponse(self, widget, settings,title,filepath):
+        _PRINT_SETTINGS = widget.get_settings()
+        _PRINTER = widget.get_selected_printer()
+        #print _PRINTER.get_name()
+        widget.destroy()
+        pgSetup = self.getDefaultPageLayout()
+        
+        if settings == -5:
+           PrintJobObj = PrintJob(title, _PRINTER, 
+                                  _PRINT_SETTINGS,
+                                  pgSetup, filepath)
+   
+    def getDefaultPageLayout(self,):
+        pgSetup = gtk.PageSetup()
+        return pgSetup
+       
+        
+           
+        
+class PrintJob:
+    def __init__(self, title=None,
+                 printer=None, 
+                 settings=None, 
+                 page_setup=None,
+                 file_path=None):
+
+        printJob = gtkunixprint.PrintJob(title,printer,
+                                         settings, page_setup)         
+        printJob.set_source_file(file_path)
+        printJob.send(self.printDone)
+
+    def printDone(self, arg1, arg2, arg3):
+        pass
+
+class serverConnection:
+    
+    def __init__ (self, host=None, port=None, encryption=None, lock=False):
+        
+        if host != None:
+            cups.setServer (host)
+        if port != None:
+            cups.setPort (port)
+        if encryption != None:
+            cups.setEncryption (encryption)    
+  
+
+        self._use_password = ''
+        self._use_user = cups.getUser ()
+        self._server = cups.getServer ()
+        self._port = cups.getPort()
+        self._encryption = cups.getEncryption ()
+        if self._connect () == 1:
+           sys.exit()  
+        self._prompt_allowed = True
+        self._operation_stack = []
+        self._lock = lock
+        self._gui_event = threading.Event ()
+        self.jobid = []
+        #print self._server
+
+    def _connect (self,):
+        cups.setUser (self._use_user)
+        create_object = cups.Connection
+        try:
+            self._connection = create_object (host=self._server,
+                                                port=self._port,
+                                                encryption=self._encryption)
+        except RuntimeError:
+            _logger.debug("check if cups server is functioning properly")
+           # print ('hey i messed up')
+            return 1  
+
+    def _getTitle(self,_filepath):
+          title = os.path.split(_filepath)[1].rsplit('.',1)[0]
+          return title
+  
+    def _getPrintersList (self,):
+        self._dictPrinters = self._connection.getPrinters()
+        _thePrinters = self._dictPrinters.keys()
+        return _thePrinters
+
+    def _getPrinterURI (self, name):
+        self._dictPrinters = self._connection.getPrinters ()
+        _printerURI = self._dictPrinters[name]['device-uri']
+        return _printerURI
+        
+    def _getDefaultPrinter (self,):
+        self._defaultPrinter = self._connection.getDefault ()
+        return self._defaultPrinter
+
+    def _setPrintDevice (self, device = None, uri = None ):
+        if device != None:
+            self._ourDevice = device
+        else: 
+            self._ourDevice = _getDefaultPrinter () 
+                 
+        if uri != None:
+            self._ourURI = _getPrinterURI (self._ourDevice)
+        
+        setPrinterDevice (self, self._ourDevice, self._ourURI)   
+        
+  
+    def _printPDF (self, _printer, _filename, _title = None):
+    
+        if _title == None:
+            _title = self._getTitle(_filename)
+          
+# we require our script to not look up the editable names of the printing devices,
+# but look up the unchangeable URI of the printer, so we do this:        
+
+        theprinters = self._getPrintersList()
+        self._location = ''
+        for printer in theprinters:
+           #print printer
+           if self._getPrinterURI(printer) == u'cups-pdf:/':
+               _printer = printer 
+               
+# Now we have the printer at hand
+#lets open the config files and check the paths, and if user Directories are enabled
+#Check for the paths, if a default $USER path exists, skip the condition and just use
+#that if not go to user.dir, and also, that particular definition does not exist, use
+#home dir, as it defaults to that 
+
+              # print _printer 
+               f = open('/etc/cups/cups-pdf.conf', 'r')
+               for line in f:
+                   if line[0:3] == 'Out':
+                       folder = self._location = line[4:].rsplit('\n',1)[0]
+                       folder = folder.strip(' $ { } ')
+                       
+                       if self._location.find('${USER}') == -1:           #Special Fedora case
+                           desktop = os.getenv("HOME")+'/.config/user-dirs.dirs'
+                           #print desktop
+                           try:
+                               f1 = open(desktop, 'r')
+                           except IOError:
+
+                                _logger.debug("$DESKTOP isn't defined,\
+                                              so going to home directory")
+                                self._location = os.getenv("HOME") 
+                                f1.close() 
+                           else:
+                               self._location = os.getenv("HOME") 
+                               for line in f1:
+                                  # print line[0:15]     
+                                   if line[0:15] == 'XDG_'+folder+'_DIR':
+                                       self._location = line[15:].rsplit('\n',
+                                                         1)[0].strip('= "')
+                                       self._location = self._location.replace('$HOME',
+                                                       os.getenv("HOME"))
+                                       break     
+                                         
+                                          
+                               f1.close()
+                               #print self._location 
+                                 
+                       else:        
+                           self._location = self._location.replace('${USER}', 
+                                                              os.getenv("USER"))
+                       break #break to end 2nd for loop
+
+               self._connection.printFile (_printer, _filename, _title, {})
+                       # break to end 1st for loop
+               return self._location+'/'+_title+'.pdf'
+
+    def _printtoPrinter (self,_filename, _title=None):
+        if _title == None:
+            _title = self._getTitle(_filename)
+        printer = self._getDefaultPrinter()
+        if self._getPrinterURI(printer) != u'cups-pdf:/':
+            self._connection.printFile (printer, _filename, _title, {})
+            return True
+        return False
+    def _selectDefaultPrinter (self,_printer):
+        self._connection.setDefault(_printer)
+
+    def _getLiveJobQueue (self,noOfJobs=None):
+        if noOfJobs == None:
+            limit = -1
+        else:
+            limit = noOfJobs
+        return self._connection.getJobs('not-completed', True, limit, -1)
+    
+    def _getCompletedJobQueue (self, noOfJobs = None):
+        if noOfJobs == None:
+            limit = -1
+        else:
+            limit = noOfJobs
+        return self._connection.getJobs('completed', True, limit, -1)
+           
+    def _clearJobQueue (self,):
+        printers = self._getPrintersList()
+        for printer in printers:
+            printeruri = self._getPrinterURI(printer)
+            self._connection.cancelAllJobs(printeruri,False,True)
+        return True
+
+    def _clearPrinterQueue(self,printer):
+        printeruri = self._getPrinterURI(printer)
+        self._connection.cancelAllJobs(printeruri,False,True)
+
+    def _cancelAJob(self,jobid):
+       self._connection.cancelJob(jobid)
+       return True
+   
+
+
+
+
+
+
+
+
+
+
+
+#printer = JustPrint('lolmax','/home/iwikiwi/lolmax.odt')
+
+#hello = serverConnection()
+#lol = hello._printPDF('Cups-PDF','/home/iwikiwi/lolmax.odt','lolmax')
+#print '\''+ lol + '\''
diff --git a/printtoolbar.py b/printtoolbar.py
index 2132b16..386042b 100644
--- a/printtoolbar.py
+++ b/printtoolbar.py
@@ -41,7 +41,8 @@ class PrintToolbar(gtk.Toolbar):
         
         self._evince_view = evince_view
         self._document = None
-        
+        self._title = title
+        self._path = tempfile
         
         self._pdf = ToolButton('document-save')
         self._pdf.set_tooltip(_('save-PDF'))
@@ -64,12 +65,91 @@ class PrintToolbar(gtk.Toolbar):
         self._USB.connect('clicked', self.printing)
 
     def printing(self, widget):
-        printdialog = PrinterSetup(self._title, self._path)
+        justPrint = JustPrint(self._title, self._path)
+        justPrint.Printit()
+
+    def setTitlePath(self, title, path):
+        self._title = title
+        self._path = path
+
+class PrintSetupToolbar(gtk.Toolbar):
+    __gtype_name__= 'PrintSetupToolbar'
+
+
+    def __init__(self, evince_view, title=None, tempfile=None):
+        gtk.Toolbar.__init__(self)
+        
+        self._evince_view = evince_view
+        self._document = None
+        self._title = title
+        self._path = tempfile
+
+        total_page_item = gtk.ToolItem()
+
+        self._noOfPagesL = gtk.Label('Select Pages ')
+        self._noOfPagesL.show()
+        total_page_item.add(self._noOfPagesL)
+        total_page_item.show()
+        self.insert(total_page_item, -1)
+        self._noOfPagesTB = gtk.Entry()
+        self._noOfPagesTB.connect("activate", self.TBfunction, 
+                                  gtk.RESPONSE_OK)  
+        self._noOfPagesTB.set_editable(True)
+        self._noOfPagesTB.show()
+        total_page_item1 = gtk.ToolItem()
+
+        total_page_item1.add(self._noOfPagesTB)
+        total_page_item1.show()
+        self.insert(total_page_item1, -1)
+        printerEnumerationObj = EnumeratePrinters()
+        printerObjList = printerEnumerationObj.getPrinter()
+        self._printerComboBox = gtk.combo_box_new_text()
+        self._printerComboBox.append_text('Printer:')
+        
+        for printer in printerObjList:
+      
+            self._printerComboBox.append_text(printer)
+ 
+        self._printerComboBox.connect('changed', self.changed_cb)
+        self._printerComboBox.set_active(0)
+        self._printerComboBox.show()
+        total_page_item2 = gtk.ToolItem()
+        total_page_item2.add(self._printerComboBox)
+        total_page_item2.show()
+        self.insert(total_page_item2, -1)
+
+        self._USB = ToolButton('printer')
+        self._USB.set_tooltip(_('printer'))
+        self._USB.props.sensitive = True
+        self.insert(self._USB, -1)
+        self._USB.show()
+        
+        self._USB.connect('clicked', self.printing)
+
+    def TBfunction(self, widget, entry):
+
+        entry_text = widget.get_text()
+        self.justPrint = JustPrint(self._title, self._path)
+        self.justPrint.setRange(entry_text)
+
+    def changed_cb(self, combobox):
+
+        model = combobox.get_model()
+        index = combobox.get_active()
+        if index:
+             self._printerToSet = model[index][0]
+             self.justPrint.setPrinter(self._printerToSet)
+        return
+
+
+    def printing(self, widget):
+
+        self.justPrint.printIt()
     
     def setTitlePath(self, title, path):
+
         self._title = title
         self._path = path
-       
     
 class ReadToolbar(gtk.Toolbar):
     __gtype_name__ = 'ReadToolbar'