createaptoncd.py

Progra,, das sehr viele Medien formate spielt und sehr bekannt ist.

        for uri in uri_splitted:
            #path = self._get_file_path_from_dnd_dropped_uri(uri)
            #print 'path to open', path
            if uri.endswith(".deb"):
                self.cursorManager.setBusy(self.frmCreateCD,True)
                while gtk.events_pending(): gtk.main_iteration()        
                ipath = self.util.getFilePathFromUrl(uri)
                path,filename = os.path.split(ipath)
                
                if not metaPackage.itemExistSearch(self.packageList,ipath):
                    metaPackage.addNewListItem(self.packageList,metaPackage.createNewItem(filename,True,path),True,self.packageView)
                    ret = metaPackage.updatePackageCount(self.packageList)
                    self.updateCountView(ret)
                else:
                    from messageBox import MessageBox
                    MessageBox().ShowError(msg.MESSAGE_0005 %filename,self.frmCreateCD)

                self.cursorManager.setBusy(self.frmCreateCD,False)
                
                
    def on_btnAddDeb_clicked(self,widget):
        
        self.cmdAddDeb.set_sensitive(False)
        
        result, files = self.util.openSelectDialog (msg.MESSAGE_0006,msg.MESSAGE_0007,"*.deb",True)
        if result == gtk.RESPONSE_OK:
            for nFile in files:
                path,filename = os.path.split(nFile)
                if not metaPackage.itemExistSearch(self.packageList,filename,path):
                        metaPackage.addNewListItem(self.packageList,metaPackage.createNewItem(filename,True,path),True, self.packageView)
                        ret = metaPackage.updatePackageCount(self.packageList)
                        self.updateCountView(ret)
                else:
                    from messageBox import MessageBox
                    MessageBox().ShowError(msg.MESSAGE_0005 % (filename),self.frmCreateCD)
        
        self.cmdAddDeb.set_sensitive(True)
        return

    def on_button_press_event(self, widget, event):
        if event.button == 3 and event.type == gtk.gdk.BUTTON_PRESS:
            c = utils.ContextMenu(self)
            c.addMenuItem(msg.MESSAGE_0009, self.on_checkAll)
            c.addMenuItem(msg.MESSAGE_0010, self.on_uncheckAll)
            c.addMenuItem("-")
            c.addMenuItem(msg.MESSAGE_0011, self.on_removePackage)
            c.addMenuItem("-")
            c.addMenuItem(msg.MESSAGE_0012, self.on_invertcheckAll)
            c.popup(None, None, None, event.button, event.get_time())
        return
    
    def checkUncheck(self,iType,path = None, model = None):
        self.cursorManager.setBusy(self.frmCreateCD,True)
        
        if iType == 0:
            metaPackage.removePackage(self.packageView)
        elif iType == 1:
            metaPackage.checkAll(self.packageList,self.checkOld)
        elif iType == 2:
            metaPackage.uncheckAll(self.packageList)
        elif iType == 3:
            metaPackage.invertcheckAll(self.packageList,self.checkOld)
        elif iType == 4:
            metaPackage.Column_toggled(path,model,self.checkOld)
            # if user wants, aptoncd will check dependets packages 
            if self.ckbtnAutoSelectDepends.get_active():
                if model[path][config.C_CHECKED]:
                    metaPackage.checkDepends(self.packageList,model[path][config.C_PKG].get_pkg_depends())
            
        ret =metaPackage.updatePackageCount(self.packageList)    
        self.updateCountView(ret)
        self.cursorManager.setBusy(self.frmCreateCD,False)
        
    def on_removePackage(self, *args):
        self.checkUncheck(0)
        return
    
    def on_checkAll(self,*args):
        self.checkUncheck(1)
        return
    
    def on_uncheckAll(self,*args):
        self.checkUncheck(2)
        return
    
    def on_invertcheckAll(self,*args):
        self.checkUncheck(3)
        return
    
    def on_Column_toggled(self, cell, path, model):
        self.checkUncheck(4, path, model)
        
        return
    
        
    # Create APTonCD
    def on_btnCreateGo_clicked(self,widget, *args):
        self.isError = False
        self.entryIsoFilename = self.gladeFile.get_widget("entryIsoFilename").get_text()
        
	nbrSelectedPackages = metaPackage.countChecked(self.packageList)[2]
		
	if nbrSelectedPackages == 0:
	   mReturn = MessageBox().ShowError((msg.MESSAGE_0069),self.frmCreateCD)
           self.isError = True
	
        if self.entryIsoFilename !="":
            if not self.util.isValidFileName(self.entryIsoFilename):
                mReturn = MessageBox().ShowError((msg.MESSAGE_0024  % ( self.entryIsoFilename)),self.frmCreateCD)
                self.isError = True
        
        if not self.isError:
            self.cmdCreateGo.set_sensitive(False)
            self.cmdCancel.set_sensitive(False)
             
            toMainDir = self.gladeFile.get_widget("fileIsoTo").get_filename()
        
            if self.util.checkAccess(toMainDir):

                self.wProgress = ProgressWindow.AptOnCDProgressDialog(self.frmCreateCD)
                self.wProgress.Title("APTonCD")
                self.wProgress.TaskTitle(msg.MESSAGE_0013)
                self.wProgress.Task(msg.MESSAGE_0002)
                self.wProgress.Description(msg.MESSAGE_0014)
    
                if not self.createAptOnCD():
                    self.isError = True
            else:
                    MessageBox().ShowError(msg.MESSAGE_0015,self.frmCreateCD)
                    self.isError = True
            
        
        self.cmdCreateGo.set_sensitive(True)
        self.cmdCancel.set_sensitive(True)
        
        #return self.isError
        
    def createAptOnCD(self):

        import datetime        
        errorMsg=""
        isos = []
        
        # -- get the user's preferences --
        toMainDir = self.gladeFile.get_widget("fileIsoTo").get_filename()
        
        if not self.util.checkAccess(toMainDir):
            MessageBox().ShowError(msg.MESSAGE_0015,self.frmCreateCD)
            return False

        media = self.cboMediaCreate.get_active_text()       
     
        config.set("cache", "media", media)
                
        config.write(config.CONFIG_FILE)
        
        metaPackActive = self.ckbtnMetaPackage.get_active()
        tmpdir = "/tmp/aptoncd-c/"
        tmpmetapackageDir = tmpdir +"metapackage/"
        tmppackages = tmpdir + "packages/"
        
        self.util.mkdir(tmpdir,True)
        
        if metaPackActive:
            self.util.mkdir(tmpmetapackageDir + 'DEBIAN/',True)
        else:
            self.util.removePath(tmpmetapackageDir )    
        
        self.wProgress.show()
        
        iIndex = 0
        
        # --- Copy the packages ---
        
        # get selected packages in the list
        filesToCopy = [files for files in self.packageList if files[config.C_CHECKED]]
        self.wProgress.TaskLenght(len(filesToCopy)-1)
        
        if media == 'DVD':
            isoFileList = self.CreateIsoList(config.DVD,filesToCopy)
        else:
            isoFileList = self.CreateIsoList(config.CD,filesToCopy)
        
        for cds in isoFileList.keys():
            self.wProgress.Task(msg.MESSAGE_0002)            
            # --- some meta-package configs ---
            controlFile =  tmpmetapackageDir + 'DEBIAN/control'
            self.util.delFile(controlFile)
        
            mPack = metaPackage.MetaPackage(controlFile)
        
            destination = tmppackages+ media +"_" + cds.__str__() + "/"
            pkgdest = destination + 'packages/'
            
            self.util.mkdir(destination,True)
            self.util.mkdir(pkgdest,True)            
            
            for pkg in isoFileList[cds]:
                iIndex +=1
                self.wProgress.update(iIndex)

                mPack.appendPackage(pkg.get_pkg_Name())

                filedestination = pkgdest  + pkg.get_pkg_FileName()
                if self.wProgress.cancel_status:
                    errorMsg = msg.MESSAGE_0016
                    break
                    
                pkg.copyTo(filedestination )
                self.wProgress.Task(msg.MESSAGE_0017 % pkg.get_pkg_FileName())
            
            if self.wProgress.cancel_status or len(errorMsg)>0:
                break
            
            if metaPackActive:
                if not mPack.write():
                    errorMsg = msg.MESSAGE_0018

                result = os.system('dpkg-deb -b ' + tmpmetapackageDir.replace(' ','\ ') + ' ' + pkgdest.replace(' ','\ ')  + mPack.get_mtFileName() + ' > /dev/null 2> /dev/null')
                self.util.delFile(controlFile)
                
            # --- Scan the packages ---
            if self.wProgress.cancel_status:
                errorMsg = msg.MESSAGE_0016
                break
            
            self.wProgress.Task(msg.MESSAGE_0019)
            while gtk.events_pending():    gtk.main_iteration()
            
            curdir = os.getcwd()
            os.chdir(destination)
            PackagesFile = destination.replace(' ','\ ') + 'Packages'      
            os.system('apt-ftparchive packages packages/ > ' + PackagesFile)

            utils.compress(PackagesFile, PackagesFile)
            
            fileObj = gzip.GzipFile(os.path.join(destination +'Packages.gz' ), 'wb');
            fileObj.write(file(os.path.join(destination +'Packages' ), 'rb').read())
            fileObj.close()
            
            os.system('apt-ftparchive release  ./ > ./Release')
                       
      	    os.chdir(curdir)
      	    
            #Write aptoncd.inf
            infoFile = destination + 'aptoncd.info'
            info = mediaInfo.mediaInfo(infoFile)
            info.write()
      	    
      	    #write .disk/info
      	    diskinfodir = os.path.join(destination +'.disk')
      	    self.util.mkdir(diskinfodir,True)
      	    infoDiskFile = os.path.join(diskinfodir,'info')
      	    infoDisk = mediaInfo.aptDiskInfo(infoDiskFile,media + cds.__str__())
      	    infoDisk.write()

	    #write README.diskdefines
      	    infoDiskDefinesFile = os.path.join(destination,'README.diskdefines')
      	    infoDiskDefines = mediaInfo.aptDiskDefines(infoDiskDefinesFile,cds.__str__(),cds.__str__())
      	    infoDiskDefines.write()
    
      	    
            # --- Make the .iso image ---
            if self.wProgress.cancel_status:
                errorMsg = msg.MESSAGE_0016
                break
        
        
            today = datetime.date.today().strftime('%Y%m%d') 

#
            if self.entryIsoFilename == "":
                fileNames = [nFile for nFile in os.listdir(toMainDir) if ( 'aptoncd-' + today +"-" + media + cds.__str__() in nFile  )]
                if len(fileNames) >0:
                    fileDestiny = 'aptoncd-' + today +"-" + media + cds.__str__() +'-'+str(len(fileNames)) +'.iso'
                else:
                    fileDestiny = 'aptoncd-' + today +"-" + media + cds.__str__() +'.iso'
            else:
                fileNames = [nFile for nFile in os.listdir(toMainDir) if ( self.entryIsoFilename + "-" + media + cds.__str__() in  nFile)]
                if len(fileNames) >0:
                    fileDestiny = self.entryIsoFilename + "-" + media + cds.__str__() +'-' +str( len(fileNames)) +'.iso'
                else:
                    fileDestiny = self.entryIsoFilename + "-" + media + cds.__str__() +'.iso'
                
            finalDestiny = os.path.join(toMainDir, fileDestiny)
            isos.append(finalDestiny)
            
            self.wProgress.Task(msg.MESSAGE_0020)
            while gtk.events_pending():    gtk.main_iteration()
            os.system('mkisofs -quiet -iso-level 4 -pad -l -r -J -joliet-long -v -V "APTonCD" -hide-rr-moved -o ' + finalDestiny.replace(' ','\ ') + ' ' + destination.replace(' ','\ ') + ' 2> /dev/null')

            if self.wProgress.cancel_status:
                errorMsg = msg.MESSAGE_0016
                break 
            self.wProgress.Task(msg.MESSAGE_0021)
        
        #clean folders created previously    
        self.util.removePath(tmpdir)        
        self.wProgress.hide()
        if len(errorMsg) > 0 :
            #mReturn = MessageBox().ShowInfo((msg.MESSAGE_0022  % ( finalDestiny,errorMsg)),self.frmCreateCD)
            return False
        else :
            if MessageBox().ShowQuestion((msg.MESSAGE_0023 % finalDestiny),self.frmCreateCD):
                for finalDestiny in isos:
                    os.system('/usr/bin/nautilus-cd-burner --source-iso=' + finalDestiny.replace(' ','\ ') + ' &')   
        
        self.frmCreateCD.destroy()     
        return True            
                                
    def CreateIsoList(self,size,packList = []):
        
        cds = {}
        currentCD = 1
        actualSize = 0
        
        
        for n in packList:
            pkg = n[config.C_PKG]
            if not currentCD in cds: cds[currentCD] = []
            if ( actualSize + pkg.get_pkg_Size()) > size:
                    actualSize = 0
                    currentCD += 1
                    cds[currentCD] = []
            cds[currentCD].append(pkg)
            actualSize += pkg.get_pkg_Size()
                
        return cds