def __actualizar_reg_interfazdatos(self, row, col, valor):
     """actualiza un dato en interfazdatos,recogiendo la excepcion en caso de error """
     LOG.debug("Actualizando datos de la interfaz:" + str(row) + "," + str(col))
     try:
         self.__idu[row][col] = valor
     except ValueError:
         QMessageBox.warning(self, 'Atención', u'El dato no es válido')

 def setSource(self, url):
     #action, key, filename = split_url(url)
     action, name = split_url(url)
     filehandler = self.app.game_fileshandler
     if action == 'cleanup':
         filehandler.cleanup_game(name)
     elif action == 'prepare':
         filehandler.prepare_game(name)
     elif action == 'edit':
         dlg = EditGameDataDialog(self, name)
         dlg.show()
     elif action == 'set_title_screenshot':
         self.select_title_screenshot(name)
     elif action == 'open_weblink':
         # get gamedata from doc object
         # to keep from excessive xml parsing
         gamedata = self.doc.gamedata
         cmd = self.app.myconfig.get('externalactions', 'launch_weblink')
         # for these url's, the name is the site
         weblink_url = gamedata['weblinks'][name]
         if '%s' in cmd:
             os.system(cmd % weblink_url)
         else:
             os.system("%s '%s'" % (cmd, weblink_url))
         # now we reset the name variable to reset the page properly
         name = gamedata['name']
     else:
         QMessageBox.information(self, '%s is unimplemented.' % action)
     # refresh the page
     self.set_game_info(name)
     # need to emit signal here for mainwin to pick up
     # this method is ugly
     if action in ['cleanup', 'prepare', 'edit']:
         mainwin = self.parent().parent()
         mainwin.refreshListView()

 def accept(self):
     """Función de aceptación del dialogo. 
     Avisa al usuario si los datos han sido introducidos incorrectamente, y genera"""
     if self.lineEdit1.text():
         from Driza.excepciones import VariableExisteException
         sobreescritura = self.checkBox1.isChecked()
         solofiltrado = False
         if sobreescritura:
             if self.checkBox2.isChecked():
                 solofiltrado = True
         try:
             self.__idu.ana_var_expresion(self.lineEdit1.text().latin1(), self.comboBox1.currentText().latin1(), \
                     "NA", self.lineEdit2.text(),self.textEdit1.text().latin1(), \
                     permitirsobreescritura=sobreescritura, solofiltrados=solofiltrado)
         except (SyntaxError,NameError):
             #La expresión no es correcta, mostramos un mensaje de error
             LOG.exception("Excepción al añadir la variable con la expresión")
             QErrorMessage(self, "error").message(u"La expresión no es correcta")
             self.__idu.borrar_var(self.lineEdit1.text().latin1()) #Borrar la variable que está a medias
         except (ZeroDivisionError,OverflowError):
             QErrorMessage(self, "error").message(u"La expresión genera un desbordamiento")
         except VariableExisteException:
             QMessageBox.warning(self, u"atención", u"La variable ya existe")
         except TypeError:
             QErrorMessage(self, "error").message(u"El tipo de variable no coincide con el existente")
             LOG.exception("Excepción al añadir la variable con la expresión")
         else:
             DialogoCrevar.accept(self)
             self.parent().grid.myUpdate()
     else:
         returncode = QMessageBox.warning(self, 'Atencion', \
                 'No has rellenado todos los campos', \
                 'Volver al dialogo', 'Salir', '', 0, 1 )
         if returncode == 1:
             self.reject()

 def __guardar_como(self):
     """Abre un diálogo pidiendo el nombre de archivo y guarda en dicho archivo"""
     filtro = ""
     for fmt in SL.extensiones_fichero:
         filtro = filtro+ "%s files (*.%s);;" % (fmt, fmt.lower())
     filename = QFileDialog.getSaveFileName(QString.null, filtro, self)
     filename = str(filename)
     if filename:
         from Driza.excepciones import FicheroExisteException, FicheroTipoDesconocidoException
         import re
         extension = re.compile('.*\..*')
         if not extension.match(filename):
             filename += ".driza"
         try:
             self.__gestorproyectos.guardar(filename)
         except FicheroExisteException, fichero:
             returncode = QMessageBox.information(self, 'Atencion:', 'El fichero' + fichero.fichero + ' ya existe' , 'Sobreescribir', 'Otro nombre', 'Cancelar', 0, 1)
             if returncode == 0:
                 self.__gestorproyectos.guardar(filename, True)
                 self.__idu.establecer_original()
                 self.__myUpdate()
             elif returncode == 1:
                 self.__guardarcomo()
         except FicheroTipoDesconocidoException:
             QMessageBox.warning(self, u'Atención', u'La extensión del fichero es incorrecta.\nPruebe con otra extensión')
             self.__gestorproyectos.fichero = None

 def __insertar_registro(self):
     """Inserta un registro, devolviendo un mensaje si ha habido un error"""
     try:
         self.grid.insertar_reg()
     except AssertionError:
         QMessageBox.warning(self, u'Atención', u'Error en la inserción')
         LOG.exception("excepcion capturada al insertar")

    def __modificacion_t_var(self, fila, columna):
        """Funcion a que conecta con la introduccion de nuevos datos en la tabla de variables"""
        if columna == 1 and (self.table2.text(fila, columna).latin1() == self.__idu.var(fila).tipo):
            return # Se ha solicitado un cambio de tipo al propio tipo
        self.__portero.guardar_estado()
        if fila >= self.__idu.n_var(): #Es una nueva variable
            #Variables intermedias (creadas con los valores por defecto)
            for valorintermedio in range (self.__idu.n_var(), fila):
                self.__insertar_variable()
                self.__mostrar_var(valorintermedio)
            self.__insertar_variable()
        #Variable modificada
        variable = self.__idu.var(fila)
        if columna == 1:   # El usuario quiere cambiar el tipo
            textoencuestion = self.table2.text(fila, columna).latin1() 
            #preguntar el tipo de conversion
            metododeseado = self.__preguntar_conversion(variable, textoencuestion)
            if metododeseado:
                variable, columna = self.__agenteconversion(variable, textoencuestion, metododeseado) #Pareja variable-list
                self.__idu.establecer_var(fila, variable, columna)
                self.__mostrar_t_reg()  
        else: #Restos de campos (Texto)
            from Driza.excepciones import VariableExisteException
            try:
                self.__idu.modificar_var(variable, columna, str(self.table2.text(fila, columna).latin1()))
            except VariableExisteException:
                QMessageBox.warning(self, u'Atención', u'El nombre de variable ya existe')
            except NameError:
                QMessageBox.warning(self, u'Atención', u'Nombre de variable Erróneo')

        self.__mostrar_var(fila)
        #En todos los casos, actualizamos el titulo de la tabla de datos
        self.__mostrar_titulo_t_reg()

    def slotAcceptData(self):
        tabForm=self.tabs[0][0]
        rec = self.tabs[0][1]
        for field, fieldDef in tabForm.fieldList:
            if fieldDef.readonly:
                continue
            elif fieldDef.relation <> None: #combobox
                if field == "usernr":
                    rec.updateUser()
                else:
                    rec.setFieldValue(rec.getDescriptorColumnName(field),
                                      tabForm.getFieldText(field))
                    fieldDef.default = tabForm.getFieldValue(field)
                    rec.setFieldValue(field, tabForm.getFieldValue(field))
            else:
                rec.setFieldValue(field, tabForm.getFieldValue(field))
            #print "Type ", type(getattr(rec, field))
        if self.mode == constants.INSERT:
            try:
                rec.insert()
                self.mode = constants.UPDATE
            except dbexceptions.dbError, dberr:
                QMessageBox.information(self, "Kura Error while inserting"
                                        , dberr.errorMessage)
                return False
            self.emit(PYSIGNAL("sigAcceptNewData"), (rec,))

            self.mode = constants.UPDATE

 def __buscar(self):
     """ Funcion busca la cadena de texto introducida por el usuario en la tabla que este activa, seleccionando el primer registro válido que encuentre"""
     if not self.lineEdit1.text().latin1():
         return
     if self.parent().grid.currentPageIndex() == 0: 
         tablaactual = self.parent().grid.table1
     else: 
         tablaactual = self.parent().grid.table2
     fila = tablaactual.currentRow()
     columna = tablaactual.currentColumn()
     textoabuscar = self.lineEdit1.text().latin1()
     LOG.debug("Busqueda de " + textoabuscar)
     resultado = self.__buscarinterno(tablaactual, textoabuscar, fila, columna)
     if resultado:
         LOG.debug("Resultado encontrado en la primera columna")
         tablaactual.clearSelection()
         tablaactual.setCurrentCell(resultado[0], resultado[1])
         self.accept()
         return
     codigoretorno = QMessageBox.warning(self, 'Atencion', 'No he encontrado nada', '¿Continuar desde el principio?', 'Salir', '', 0, 1)
     if codigoretorno == 1:
         self.reject()
         return
     resultado = self.__buscarinterno(tablaactual, textoabuscar)
     if resultado:
         tablaactual.clearSelection()
         tablaactual.setCurrentCell(resultado[0], resultado[1])
         self.accept()
         return
     codigoretorno = QMessageBox.warning(self, 'Atencion', 'No he encontrado nada', 'Otra busqueda', 'Salir', '', 0, 1)
     if codigoretorno == 1:
         self.reject()
     else:
         self.lineEdit1.clear()
     return

def main():
    if not os.path.exists(os.path.expanduser("~/.pyqlogger")):
        os.mkdir(os.path.expanduser("~/.pyqlogger"))    
    settings = Settings.Settings.load()
    UI.prepareModule(settings)
    app =  UI.API.KQApplication(sys.argv, None)
    stat = UI.API.prepareCommandLine()    
    pic = QPixmap ( 150, 50)
    pic.fill()
    loginsplash = QSplashScreen( pic )
    pixmap = QPixmap( "splash.png" )
    splash = QSplashScreen( pixmap )
    splash.show()
    splash.message( "Loading forms...",alignflag )
    qApp.processEvents()
    load_forms(splash,app,settings)
    splash.message( "Loading plugins...",alignflag )
    qApp.processEvents()
    manager = Manager.load(__FORMS__["Main"]["Impl"])
    del splash
    acc = None
    pwd = None
    if settings.AutoLogin: # check if we have auto login info
        acc = settings.accountByName(settings.AutoLogin)
        pwd = acc.Password

    while True:
        if not acc:
            wnd = __FORMS__["Login"]
            if wnd["Impl"].init(settings,__FORMS__,manager):
                if wnd["Class"].exec_loop() == QDialog.Accepted:
                    acc = wnd["Impl"].acc
                    pwd = str(wnd["Impl"].edtPassword.text())
        if not acc or not pwd:
            break
        else:
            (acc.Password,oldpwd) = (pwd,acc.Password)            
            acc.init()
            loginsplash.show()
            loginsplash.message( "Logging in...",Qt.AlignCenter)            
            logres = acc.login()
            loginsplash.hide()
            acc.Password = oldpwd
            if not logres:
                QMessageBox.warning(None,"Failed!","""Cannot login!""")
                acc = None
            else:
                wnd = __FORMS__["Main"]
                acc.init()
                wnd["Impl"].init(settings,__FORMS__, acc, pwd,\
                                 manager)
                app.setMainWidget(wnd["Class"])
                wnd["Class"].show()
                #splash.finish(wnd["Class"])
                app.exec_loop()
                if wnd["Impl"].reload:
                    acc = None
                else:
                    break

 def __copiar(self):
     """Funcion que copia y borra la seleccion"""
     try:
         self.__copiar_privado()
     except AssertionError:
         QMessageBox.warning(self, u'Atención', 'Las operaciones de copiado, cortado y pegado no han sido implementadas')
     else:
         self.grid.borrar_seleccion() 

 def btnFetchUrl_clicked(self):
     bc = BloggerClient(str(self.editHost.text()), str(self.editLogin.text()), str(self.editPassword.text()))
     try:
         url = bc.getHomepage(self.blogs[unicode(self.comboBlogs.currentText())]['id'])
         if url:
             self.editURL.setText(url)
     except Exception, inst:
         print "btnFetchUrl_clicked: %s" % inst
         QMessageBox.critical(self, "Error", "Couldn't fetch blog's URL!")

 def __dacerca_de(self):
     """Mensaje acerca de"""
     from Driza import VERSION
     separador = "\n----------------------------------\n"
     betatesters = u"Carlos Mestre Gonzalez\n Luis de Bethencourt Guimerá"
     iconos = "Iconos del Tango Desktop Project: http://tango.freedesktop.org/"
     ristra = u"Driza %s es una interfaz estadística\n (C) Néstor Arocha Rodríguez - Tutorizado por Inmaculada luengo Merino\n Distribuido bajo licencia GPL" +\
             separador + "Betatesters:\n" + betatesters + separador +\
             u" Mantenedor del paquete .deb:\n Luis de Bethencourt Guimerá"+ separador + iconos
     QMessageBox.about(self, "Acerca de Driza", ristra % (VERSION))

 def __init__(self, swappers):
     QMessageBox.__init__(self)
     decorateWindow(self, m18n("Swap Seats"))
     self.setText(
         m18n("By the rules, %1 and %2 should now exchange their seats. ",
              swappers[0].name, swappers[1].name))
     self.yesAnswer = QPushButton(m18n("&Exchange"))
     self.addButton(self.yesAnswer, QMessageBox.YesRole)
     self.noAnswer = QPushButton(m18n("&Keep seat"))
     self.addButton(self.noAnswer, QMessageBox.NoRole)

    def removeChildDataTypesSlot(self):
        """ Removes the selected data type from the list of parent data types. """

        if self._relationTypeView.mySelectedChildDataTypeList == []:
            QMessageBox.information(self._parentFrame, self._parentFrame.tr("DataFinder: No Selection"),
                                          "Please select a Data Type to remove!",
                                          self._parentFrame.tr("OK"), "", "",
                                          0, -1)
        else:
            self._relationTypeModel.removeChildDataTypes(self._relationTypeView.mySelectedChildDataTypeList)
            self._relationTypeView.setButtonsState(True)

    def addChildDataTypesSlot(self):
        """ Adds the selected data types from the list of available data types to the list of child data types. """

        if self._relationTypeView.mySelectedAvailableDataTypeList == []:
            QMessageBox.information(self._parentFrame, self._parentFrame.tr("DataFinder: No Selection"),
                                          "Please select a Data Type to add!",
                                          self._parentFrame.tr("OK"), "", "",
                                          0, -1)
        else:
            self._relationTypeModel.addChildDataTypes(self._relationTypeView.mySelectedAvailableDataTypeList)
            self._relationTypeView.setButtonsState(True)

    def removeAttributeSlot(self):
        """ Removes selected rows/attributes. """

        if self._dataTypeView.propertyTable.currentSelection() == -1:
            QMessageBox.information(self._parentFrame, self._parentFrame.tr("DataFinder: No Selection"),
                                          "Please select a row to remove!",
                                          self._parentFrame.tr("OK"), "", "",
                                          0, -1)
        else:
            for index in self._dataTypeView.mySelectedRowList:
                self._dataTypeView.propertyTable.removeRow(index)
            self._dataTypeModel.myPropertyList = self._dataTypeView.myPropertyList
            self._dataTypeView.setButtonsState(True)

 def btnRefresh_clicked(self):
     if str(self.editUrl.text()):
         try:
             img = urllib2.urlopen(str(self.editUrl.text())).read()
             pic = QPixmap()
             pic.loadFromData(img)
             if not str(self.editWidth.text()):
                 self.editWidth.setText(str(pic.width()))
             if not str(self.editHeight.text()):
                 self.editHeight.setText(str(pic.height()))
             self.previewImage.setPixmap(pic)
         except:
             QMessageBox.warning(self, "Warning", "Cannot open the image url!")

 def select_title_screenshot(self, name):
     if self.select_title_screenshot_dlg is None:
         file_filter = "*.png|PNG Images\n*|All Files"
         path = self.app.dosbox.get_capture_path(name)
         dlg = QFileDialog(path, file_filter, self, 'select_title_screenshot_dlg', True)
         dlg.connect(dlg, SIGNAL('okClicked()'), self.title_screenshot_selected)
         dlg.connect(dlg, SIGNAL('cancelClicked()'), self.destroy_select_title_screenshot_dlg)
         dlg.connect(dlg, SIGNAL('closeClicked()'), self.destroy_select_title_screenshot_dlg)
         dlg.game_name = name
         dlg.show()
         self.select_title_screenshot_dlg = dlg
     else:
         # we shouldn't need this with a modal dialog
         QMessageBox.information(self, opendlg_errormsg)

 def __cortar(self):
     """Copia, borra la seleccion y su contenido"""
     from Driza.excepciones import SeleccionIncorrectaException
     try:
         self.grid.verificar_seleccion_registros()
         self.__portero.guardar_estado()
         self.__copiar_privado()
     except SeleccionIncorrectaException:
         QMessageBox.warning(self, u'Atención', 'Solo se permite cortar registros')
     except AssertionError:
         QMessageBox.warning(self, u'Atención', 'Las operaciones de copiado, cortado y pegado no han sido implementadas')
     else:
         self.grid.borrar_seleccion(borrardatos=True)
         self.grid.myUpdate()

    def _set_name(self, newname):
        name = self.name
        if newname == name:
            return
        if not re.match('^[a-zA-Z]\w*$', newname):
            QMessageBox.information(None, "grafit", 
                        "<b>Illegal column name</b><p>Column names must start with a letter and consist "
                        "of letters, numbers and underscore (_)<p>")
            return
        if newname in self.worksheet.column_names and name != newname:
            QMessageBox.information(None, "grafit", 
                        "<b>A column with this name already exists</b><p>Please choose another name<p>")
            return

        self.rename___(self.worksheet.name, self.name, newname).do().register()