path: root/printscriptCupsVersion.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
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()[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):
        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 "hello"
                           try:
                               f1 = open(desktop, 'r')
                           except IOError:

                                _logger.debug("$DESKTOP isn't defined,\
                                              so going to home directory")
                                self._location = os.getenv("HOME") 
                                _logger.debug('this is location 1 %s',self._location)
                           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"))
                                       _logger.debug('this is location2 %s',self._location)
                                       break     
                                         
                                          
                               f1.close()
                               #print self._location 
                                 
                       else:        
                           self._location = self._location.replace('${USER}', 
                                                              os.getenv("USER"))
                       break #break to end 2nd for loop
               _logger.debug('this is location3 %s',self._location)
        _title = _title.replace(")","_")
        _title = _title.replace("(","_")
        _title = _title.replace(" ","_")
        self._connection.printFile (_printer, _filename, _title, {})
        
        
        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:
            _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 + '\''