def rellenar_cobros(self):
     model = self.wids['tv_cobros'].get_model()
     model.clear()
     if self.objeto.cobros != []:
         utils.combo_set_from_db(self.wids['cbe_cliente'], 
                                 self.objeto.cobros[0].cliente.id)
     for c in self.objeto.cobros:
         if c.facturaVentaID != None:
             importe_factura = c.facturaVenta.importeTotal
             vencimientos = "(%d) " % len(c.facturaVenta.vencimientosCobro)
             vencimientos += "; ".join(
                 ["%s: %s €" % (utils.str_fecha(v.fecha), 
                  utils.float2str(v.importe)) 
                  for v in c.facturaVenta.vencimientosCobro])
         elif c.prefacturaID != None:
             importe_factura = c.prefactura.importeTotal
             vencimientos = "(%d) " % (len(c.prefactura.vencimientosCobro))
             vencimientos += "; ".join(
                 ["%s: %s €" % (utils.str_fecha(v.fecha), 
                                utils.float2str(v.importe)) 
                  for v in c.prefactura.vencimientosCobro])
         model.append((c.numfactura, 
                       "%s €" % (utils.float2str(c.importe)), 
                       utils.str_fecha(c.fecha), 
                       "%s €" % (utils.float2str(importe_factura)),
                       vencimientos,  
                       c.id))

 def rellenar_pies(self, 
                   total, pendiente, cobrado, 
                   total_pagares, pendiente_pagares, cobrado_pagares, 
                   total_otros, pendiente_otros, cobrado_otros, 
                   total_vencimientos, cobrado_strict):
     """
     Rellena los entries del pie del formulario con los totales recibidos.
     CWT: Al pendiente de cobro hay que restarle lo negociado en pagaré, 
     aunque no hayan vencido o estén marcados como pendiente.
     Por tanto, el 
     pendiente = total (facturado) - total_pagares - cobrado_otros
     y (lo mismo pero jugando con las incóginitas) el 
     cobrado = total_pagares + cobrado_otros = total - pendiente
     """
     self.wids['e_total'].set_text("%s €" % utils.float2str(total))
     # self.wids['e_pendiente'].set_text("%s €" % utils.float2str(pendiente))
     self.wids['e_pendiente'].set_text("%s €" % utils.float2str(total_vencimientos - total_pagares - cobrado_otros))
     self.wids['e_cobrado_strict'].set_text("%s €" % utils.float2str(cobrado_strict))
     # self.wids['e_cobrado'].set_text("%s €" % utils.float2str(cobrado))
     self.wids['e_cobrado'].set_text("%s €" % utils.float2str(total_pagares + cobrado_otros))
     self.wids['e_total_pagares'].set_text("%s €" % utils.float2str(total_pagares))
     self.wids['e_pendiente_pagares'].set_text("%s €" % utils.float2str(pendiente_pagares))
     self.wids['e_cobrado_pagares'].set_text("%s €" % utils.float2str(cobrado_pagares))
     self.wids['e_total_otros'].set_text("%s €" % utils.float2str(total_otros))
     self.wids['e_pendiente_otros'].set_text("%s €" % utils.float2str(pendiente_otros))
     self.wids['e_cobrado_otros'].set_text("%s €" % utils.float2str(cobrado_otros))

 def imprimir(self,boton):
     """
     Prepara la vista preliminar para la impresión del informe
     """
     import informes
     datos = []
     total = 0
     self.resultados.sort(self.por_fecha_ldc)
     for ldc in self.resultados:
         subtotal = ldc.cantidad * ldc.precio
         datos.append((ldc.nombre_proveedor,
                       ldc.albaranEntrada.numalbaran,
                       utils.str_fecha(ldc.albaranEntrada.fecha),
                       ldc.descripcion_productoCompra,
                       utils.float2str(ldc.cantidad),
                       utils.float2str(ldc.precio),
                       utils.float2str(subtotal)
                     ))
         total += subtotal
     if len(self.resultados) > 0:
         datos.append(("", "", "", "", "", "", "-"*20))
         datos.append(("", "", "", "", "", "", utils.float2str(total)))
     if (self.inicio) == None:            
         fechaInforme = 'Hasta '+utils.str_fecha(self.fin)
     else:
         fechaInforme = utils.str_fecha(self.inicio)+' - '+utils.str_fecha(self.fin)
     if datos != []:
         informes.abrir_pdf(geninformes.entradasAlmacen(datos,fechaInforme, cols_a_derecha=(4, 5, 6)))

def valorar_a_precio_valoracion(tv):
    """
    Valora todos los productos de compra con existencias distintas a cero 
    (OJO: Incluye existencias negativas) según el precio de valoración 
    definido (precio por defecto, precio medio ponderado, etc.).
    """
    pcs = pclases.ProductoCompra.select(pclases.AND(
            pclases.ProductoCompra.q.controlExistencias == True, 
            pclases.ProductoCompra.q.existencias != 0))
    model = tv.get_model()
    tv.freeze_child_notify()
    tv.set_model(None)
    model.clear()
    suma = 0.0
    for pc in pcs:
        precio_valoracion = pc.get_precio_valoracion()
        valoracion = precio_valoracion * pc.existencias
        model.append((pc.codigo, 
                      pc.descripcion, 
                      utils.float2str(pc.existencias,precision=2,autodec=True),
                      utils.float2str(precio_valoracion, precision = 2), 
                      utils.float2str(valoracion, precision = 2), 
                      pc.id))
        suma += valoracion
    tv.set_model(model)
    tv.thaw_child_notify()
    return suma

 def rellenar_widgets(self):
     """
     Introduce la información del producto actual
     en los widgets.
     No se chequea que sea != None, así que
     hay que tener cuidado de no llamar a 
     esta función en ese caso.
     """
     producto = self.objeto
     self.wids['i_barcode'].set_from_file(EanBarCode().getImage(producto.codigo))
     self.wids['e_codigo'].set_text(producto.codigo)
     self.wids['e_descripcion'].set_text(producto.descripcion)
     self.wids['e_nombre'].set_text(producto.nombre)
     self.wids['e_precio'].set_text(str(producto.preciopordefecto))
     self.wids['e_minimo'].set_text(str(producto.minimo))
     self.wids['e_arancel'].set_text(str(producto.arancel))
     self.wids['e_prodestandar'].set_text(utils.float2str(producto.prodestandar))
     campos = producto.camposEspecificosEspecial
     self.wids['e_stock'].set_text(utils.float2str(campos.stock))
     self.wids['e_existencias'].set_text(str(campos.existencias))
     try:
         pesobulto = utils.float2str(producto.calcular_razon_bultos())
     except (ValueError, TypeError):
         pesobulto = "N/A"
     self.wids['e_razon'].set_text(pesobulto)
     self.wids['e_unidad'].set_text(campos.unidad)
     self.wids['e_observaciones'].set_text(campos.observaciones)
     # Datos no modificables:
     self.wids['e_idproducto'].set_text(`producto.id`)
     self.mostrar_especificos()
     self.rellenar_tabla_tarifas()
     self.rellenar_existencias_almacen(producto)
     self.objeto.make_swap()
     self.objeto.camposEspecificosEspecial.make_swap()

    def GET(self, id=None):
        #if id is None, email every active user with his balance
        if id is not None:
            users = [get_object_or_404(User, id=id)]
        else:
            users = User.filter(active=True)

        default_tpl = settings.MAIL_DEFAULT_TEMPLATE
        try:
            f = open(settings.MAIL_FILE_TEMPLATE, 'rb')
            tpl = pickle.load(f)
            f.close()
        except (IOError, pickle.PickleError):
            tpl = default_tpl

        userside = web.input(u=0).u != 0 # used to check if the mail is coming from a QR scan
        for u in users:
            utpl = default_tpl
            if u.balance < 0 and not userside:
                utpl = tpl
            
            body = utpl.format(apayer = float2str(-u.balance if u.balance <0 else 0), 
                               solde = float2str(u.balance), 
                               prenom = u.firstname, 
                               nom = u.lastname)

            web.sendmail(settings.MAIL_ADDRESS, u.email, 'Your INGI cafetaria balance', body)

        if userside:
            return render_no_layout.consume('BALANCE', u)

        raise web.seeother('/')

def setter_textview(objeto, col, w):
    """
    Muestra el valor del atributo "col" del objeto
    "objeto" en el textview "w".
    """
    valor = getattr(objeto, col.name)
    if isinstance(col, sqlobject.col.SODateCol):
        valor = str_fecha(valor)
    elif isinstance(col, sqlobject.col.SODateTimeCol):
        valor = str_fechahoralarga(valor)
    elif isinstance(col, sqlobject.col.SOTimeCol):
        valor = str_hora(valor)
    elif isinstance(col, sqlobject.col.SOFloatCol):
        # XXX
        # HACK: Workaround. Los valores que son porcentaje (descuentos e IVA) 
        # se deben mostrar con el símbolo "%", pero la única manera de 
        # distinguir esas columnas es mirar el nombre.
        if col.name in NOMBRES_COLUMNAS_PORCENTAJE:
            valor = "%s %%" % float2str(valor * 100, 
                                        precision = 5, 
                                        autodec = True)
        # XXX
        else:
            valor = float2str(valor, autodec = False)
            # Si autodec=True y es número redondo > 1000 escribe 1.000 y el 
            # getter lo interpreta como flotante.
    if not isinstance(valor, str):
        valor = str(valor)
    buf = w.get_buffer()
    buf.set_text(valor)

 def imprimir(self,boton):
     """
     Prepara la vista preliminar para la impresión del informe
     """
     import informes
     datos = []
     model = self.wids['tv_datos'].get_model()
     for i in model:
         datos.append((i[0],
                       i[1],
                       i[2]))
     if self.balas != 0:
         datos.append(("", "", ""))
         datos.append(("", "-" * 30 , "-" * 30))
         datos.append(("", "", ""))
         datos.append((" " * 50 + "TOTAL:", "%s m²" % (utils.float2str(self.kilos)), self.balas))
     if self.rollos != 0:
         datos.append(("", "", ""))
         datos.append(("", "-" * 30 , "-" * 30))
         datos.append(("", "", ""))
         datos.append((" " * 50 + "TOTAL:", "%s m²" % (utils.float2str(self.metros)), self.rollos))
     if (self.inicio) == None:            
         fechaInforme = 'Hasta '+utils.str_fecha(time.strptime(self.fin,"%Y/%m/%d"))
     else:
         fechaInforme = utils.str_fecha(time.strptime(self.inicio,"%Y/%m/%d"))+' - '+utils.str_fecha(time.strptime(self.fin,"%Y/%m/%d"))
     if datos != []:
         informes.abrir_pdf(geninformes.producido_produccion(datos, fechaInforme, self.grafico))

 def rellenar_tabla(self, tabla):
     """
     Rellena el model con las ldc existentes
     """
     albaran = self.objeto
     if albaran != None:
         lineas = albaran.lineasDeCompra
         try:
             lineas.sort(lambda l1, l2: l1.id - l2.id)
         except:
             pass
         model = self.wids['tv_ldvs'].get_model()
         model.clear()
         for l in lineas:
             model.append((l.productoCompra.codigo,
                           l.productoCompra.descripcion,
                           utils.float2str(l.cantidad, 2),
                           utils.float2str(l.precio, 4, autodec = True),
                           "%s %%" % (utils.float2str(l.iva * 100, 0)),
                           "%s %%" % (utils.float2str(l.descuento * 100, 0)),
                           utils.float2str(l.get_subtotal(iva = True)),
                           #l.silo and l.silo.nombre or "", 
                           l.pedidoCompra 
                             and l.pedidoCompra.numpedido or "", 
                           l.pedidoCompra 
                             and utils.str_fecha(l.pedidoCompra.fecha) 
                             or "", 
                           l.id))

 def mostrar_totales(self, devengado, soportado, base_devengado):
     """
     Muestra los totales, la diferencia de ambos y colorea los Entries.
     """
     # Base imponible de las facturas de venta. (Si trabajara con más IVAs debería haber una línea por cada tipo de IVA)
     self.wids['e_base_devengado'].set_text("%s €" % (utils.float2str(base_devengado, 2)))
     # Devengado
     self.wids['e_devengado'].set_text("%s €" % utils.float2str(devengado, 2))
     self.wids['e_devengado'].set_tooltip_text(str(devengado))
     self.wids['e_devengado'].modify_text(gtk.STATE_NORMAL, 
         self.wids['e_devengado'].get_colormap().alloc_color("red"))
     # Soportado
     self.wids['e_soportado'].set_text(
         "%s €" % utils.float2str(soportado, 2))
     self.wids['e_soportado'].set_tooltip_text(str(soportado))
     self.wids['e_soportado'].modify_text(gtk.STATE_NORMAL, 
         self.wids['e_soportado'].get_colormap().alloc_color("blue"))
     # Diferencia
     diferencia = devengado - soportado
     self.wids['e_diferencia'].set_text(
         "%s €" % utils.float2str(diferencia, 2))
     self.wids['e_diferencia'].set_tooltip_text(str(diferencia))
     if diferencia > 0:
         self.wids['e_diferencia'].modify_text(gtk.STATE_NORMAL, 
             self.wids['e_diferencia'].get_colormap().alloc_color("red"))
     else:
         self.wids['e_diferencia'].modify_text(gtk.STATE_NORMAL, 
             self.wids['e_diferencia'].get_colormap().alloc_color("blue"))

 def imprimir(self, boton):
     """
     Imprime la tarifa en pantalla.
     """
     import informes
     datos = []
     model = self.wids['tabla_productos'].get_model()
     for iter in model: 
         datos.append((iter[0], 
                       iter[1], 
                       "%s €" % (utils.float2str(iter[2], 3)), 
                       "%s €" % (utils.float2str(iter[3], 3))
                     ))
     def cmp_func(x, y):
         """
         Para ordenar por nombre de producto.
         """
         if x[1] < y[1]:
             return -1
         if x[1] > y[1]:
             return 1
         return 0
     datos.sort(cmp_func)
     if datos != []:
         nombre_tarifa = self.wids['cb_nombre_tarifa'].child.get_text()
         informes.abrir_pdf(geninformes.imprimir_tarifa(datos, nombre_tarifa, utils.str_fecha(mx.DateTime.localtime())))

def build_tabla_contenido(data):
    """
    Construye la tabla del contenido del albaranSalida.
    Los datos deben venir en listas. Cada línea de la tabla, una tupla o lista 
    con el código, descripción, cantidad, precio unitario (con dto. si lo 
    lleva e IVA) y número de pedido.
    El precio y cantidad deben ser flotantes para poder calcular el subtotal.
    """
    estilo_cabecera_tabla = ParagraphStyle("Cabecera tabla", 
                                           parent=estilos["Heading3"])
    estilo_cabecera_tabla.fontName = "Times-Bold"
    estilo_cabecera_tabla.alignment = enums.TA_CENTER
    estilo_numeros_tabla = ParagraphStyle("Números tabla", 
                                           parent=estilos["Normal"])
    estilo_numeros_tabla.alignment = enums.TA_RIGHT
    datos = [(Paragraph(escribe("Código"), estilo_cabecera_tabla), 
              Paragraph(escribe("Descripción"), estilo_cabecera_tabla), 
              Paragraph("Cantidad", estilo_cabecera_tabla), 
              Paragraph("Precio/U", estilo_cabecera_tabla), 
              #Paragraph("Total c/IVA", estilo_cabecera_tabla), 
              # CWT: Prefiere la carta de portes sin IVA.
              Paragraph("Total", estilo_cabecera_tabla), 
              Paragraph(escribe("Nº Pedido"), estilo_cabecera_tabla))
            ]
    for d in data:
        fila = (escribe(d[0]), 
                Paragraph(escribe(d[1]),estilos["Normal"]), 
                Paragraph(escribe(utils.float2str(d[2])),estilo_numeros_tabla),
                Paragraph(escribe(utils.float2str(d[3])),estilo_numeros_tabla),
                Paragraph(escribe(utils.float2str(d[2] * d[3])), 
                    estilo_numeros_tabla),
                escribe(d[4])
               )
        datos.append(fila)
    tabla = Table(datos, 
                  colWidths = (PAGE_WIDTH * 0.13, 
                               PAGE_WIDTH * 0.35, 
                               PAGE_WIDTH * 0.09, 
                               PAGE_WIDTH * 0.09, 
                               PAGE_WIDTH * 0.13, 
                               PAGE_WIDTH * 0.11), 
                  repeatRows = 1)
    tabla.setStyle(TableStyle([
        ("BACKGROUND", (0, 0), (-1, 0), colors.lightgrey), 
        ("LINEBEFORE", (0, 0), (-1, -1), 0.25, colors.black),
        ("LINEBELOW", (0, 0), (-1, 0), 1.0, colors.black), 
        ("LINEBELOW", (0, "splitlast"), (-1, "splitlast"), 1.0, colors.black), 
        ("BOX", (0, 0), (-1, -1), 1.0, colors.black),
        ("INNERGRID", (0, 0), (-1, -1), 0.25, colors.black), 
        ("VALIGN", (0, 0), (-1, 0), "CENTER"), 
        ("VALIGN", (0, 0), (0, -1), "TOP"), 
        ("ALIGN", (0, 0), (-1, 0), "CENTER"), 
        ("ALIGN", (-3, 1), (-1, -1), "RIGHT"), 
        #("ALIGN", (0, 1), (0, -1), "DECIMAL"), <- No puedo cambiar 
        #                               el pivotChar de "." a ",". No me vale.
        ("ALIGN", (-1, 1), (-1, -1), "CENTER"), 
        ("ALIGN", (0, 1), (0, -1), "CENTER"), 
        #("RIGHTPADDING", (0, 1), (0, -1), 0.75 * cm), 
        ]))
    return tabla

 def rellenar_tabla(self, facturas):
     """
     Rellena el model con los items de la consulta
     """        
     model = self.wids['tv_datos'].get_model()
     model.clear()
     self.wids['tv_datos'].freeze_child_notify()
     self.wids['tv_datos'].set_model(None)
     for cliente in facturas:
         padre = model.append(None, (cliente and cliente.nombre 
                                         or "Sin cliente", 
                                     "0.00", 
                                     "", 
                                     "0.00", 
                                     cliente and cliente.get_puid() or ""))
         for factura in facturas[cliente]:
             formapago = factura.get_forma_de_pago()
             importe = factura.calcular_total()
             pdte = factura.calcular_pendiente_de_documento_de_pago()
             model[padre][1] = utils.float2str(utils._float(model[padre][1])
                 + importe)
             model[padre][3] = utils.float2str(utils._float(model[padre][3])
                 + pdte)
             model.append(padre, (factura.numfactura, 
                                  utils.float2str(importe), 
                                  utils.str_fecha(factura.fecha), 
                                  utils.float2str(pdte), 
                                  factura.get_puid()))
     self.wids['tv_datos'].set_model(model)
     self.wids['tv_datos'].thaw_child_notify()

 def rellenar_tabla(self, items):
     """
     Rellena el model con los items de la consulta
     """
     vpro = VentanaProgreso(padre = self.wids['ventana'])
     vpro.mostrar()
     vpro.set_valor(0.0, "Contando existencias...")
     act = 0.0
     tot = len(items) * len(self.tvs)
     try:
         fecha = utils.parse_fecha(self.wids['e_fecha'].get_text())
     except (TypeError, ValueError, AttributeError):
         fecha = mx.DateTime.today()
         self.wids['e_fecha'].set_text(utils.str_fecha(fecha))
     # XXX: Optimización (cosas de cómo están hechas las funciones de get_*
     #      por dentro en pclases):
     if fecha >= mx.DateTime.today():
         fecha = None
     for tv, kg, bultos, a in self.tvs:
         model = tv.get_model()
         model.clear()
         totalkgs = 0.0
         totalbultos = 0
         for pv in items:
             vpro.set_valor(act/tot, 
                            "Contando existencias...\t[%s]" % pv.get_puid())
             stock = pv.get_stock(hasta = fecha, almacen = a)
             totalkgs += stock
             existencias = pv.get_existencias(hasta=fecha, almacen = a)
             totalbultos += existencias
             stock_A = pv.get_stock_A(hasta = fecha, almacen = a)
             existencias_A = pv.get_existencias_A(hasta=fecha, almacen = a)
             stock_B = pv.get_stock_B(hasta = fecha, almacen = a)
             existencias_B = pv.get_existencias_B(hasta=fecha, almacen = a)
             stock_C = pv.get_stock_C(hasta = fecha, almacen = a)
             existencias_C = pv.get_existencias_C(hasta=fecha, almacen = a)
             model.append((pv.codigo,
                           pv.descripcion,
                           utils.float2str(stock),
                           utils.float2str(existencias, autodec = True),
                           utils.float2str(stock_A!=None and stock_A or 0),
                           utils.float2str(existencias_A != None and 
                                           existencias_A or 0, 
                                           autodec = True),
                           utils.float2str(stock_B!=None and stock_B or 0),
                           utils.float2str(existencias_B != None and 
                                           existencias_B or 0, 
                                           autodec = True),
                           utils.float2str(stock_C!=None and stock_C or 0),
                           utils.float2str(existencias_C != None and 
                                           existencias_C or 0, 
                                           autodec = True),
                           pv.get_puid()))
             act += 1
         kg.set_text(utils.float2str(totalkgs))
         bultos.set_text(utils.float2str(totalbultos, autodec = True))
     vpro.ocultar()

 def buscar(self, boton):
     """
     Busca todos los productos e introduce en los TreeViews las existencias 
     de los mismos. En total y por almacén.
     El total no lo calcula, se obtiene del total global (que debería 
     coincidir con el sumatorio de...).
     """
     fechaini = self.wids['e_fechaini'].get_text().strip()
     if fechaini:
         try:
             fechaini = utils.parse_fecha(fechaini)
         except (ValueError, TypeError):
             utils.dialogo_info(titulo = "ERROR EN FECHA INICIAL", 
              texto = "El texto «%s» no es una fecha correcta." % fechaini,
              padre = self.wids['ventana'])
             fechaini = None
     fechafin = self.wids['e_fechafin'].get_text().strip()
     if fechafin:
         try:
             fechafin = utils.parse_fecha(fechafin)
         except (ValueError, TypeError):
             utils.dialogo_info(titulo = "ERROR EN FECHA FINAL", 
              texto = "El texto «%s» no es una fecha correcta." % fechafin,
              padre = self.wids['ventana'])
             fechafin = None
     if fechafin:
         FV = pclases.FacturaVenta
         if fechaini:
             facturas = FV.select(pclases.AND(
                                     FV.q.fecha >= fechaini, 
                                     FV.q.fecha <= fechafin))
         else:
             facturas = FV.select(FV.q.fecha <= fechafin)
         from ventana_progreso import VentanaProgreso
         vpro = VentanaProgreso(padre = self.wids['ventana'])
         vpro.mostrar()
         txtvpro = "Buscando facturas..."
         total = 0.0
         i = 0.0
         vpro.set_valor(i, txtvpro)
         model = self.wids['tv_datos'].get_model()
         model.clear()
         for f in facturas:
             i += 1
             vpro.set_valor(i/facturas.count(), 
                            txtvpro)
             model.append((f.numfactura, 
                         utils.str_fecha(f.fecha), 
                         f.cliente and f.cliente.cif or "¡Sin cliente!", 
                         f.cliente and f.cliente.nombre or "¡Sin cliente!", 
                         utils.float2str(f.calcular_base_imponible()), 
                         utils.float2str(f.calcular_total_iva()), 
                         utils.float2str(f.calcular_importe_total()), 
                         f.get_puid()))
             total += f.calcular_importe_total()
         vpro.ocultar()
         self.wids['e_total'].set_text(utils.float2str(total))

 def rellenar_tabla(self, items):
 	"""
     Rellena el model con los items de la consulta
     """        
 	model = self.wids['tv_datos'].get_model()
 	model.clear()
     total = 0
     vencido = 0
     hoy = datetime.date.today()
     por_fecha = {}
 	for i in items:
         if not i[2]:  # i[2] = False cuando es vencimiento normal de la BD
             total += i[1].importe 
             importe = i[1].importe
             anno = i[1].fecha.year
             mes = i[1].fecha.month
             if i[1].fecha < hoy:
                 vencido += i[1].importe
             fra = i[1].facturaVenta or i[1].prefactura
             model.append((fra.numfactura,
                           utils.str_fecha(i[1].fecha),
                           utils.float2str(importe),
                           i[1].observaciones,
                           fra.cliente.nombre,
                           "V:" + `i[1].id`))
         else:   # i[2] = True. Es un vencimiento rescatado de LogicMovimientos.
             importe = i[1]['importe']
             anno = i[1]['fecha'].year
             mes = i[1]['fecha'].month
             total += i[1]['importe']
             if i[1]['fecha'] < hoy:
                 vencido += i[1]['importe']
             model.append(("LOGIC",      # Esto me va a valer para diferenciar un vto. de la BD de uno de Logic.
                           utils.str_fecha(i[1]['fecha']),
                           utils.float2str(i[1]['importe']),
                           i[1]['comentario'],
                           i[1]['cuenta'],
                           "L:" + i[1]['id']))
         if anno not in por_fecha:
             por_fecha[anno] = {}
         if mes not in por_fecha[anno]:
             por_fecha[anno][mes] = 0.0
         por_fecha[anno][mes] += importe
     self.wids['e_total'].set_text("%s €" % utils.float2str(total))
     self.wids['e_vencido'].set_text("%s €" % utils.float2str(vencido))
     # Relleno el model de totales.
     annos = por_fecha.keys()
     annos.sort()
     model = self.wids['tv_totales'].get_model()
     model.clear()
     for anno in annos:
         total_anno = sum([por_fecha[anno][mes] for mes in por_fecha[anno]])
         anno_padre = model.append(None, (`anno`, 
                                          utils.float2str(total_anno), 
                                          ""))
         meses = por_fecha[anno].keys()

 def rellenar_tabla_XXX(self):
     model = self.wids['XXXtv_treeview'].get_model()
     model.clear()
     total = 0.0
     for p in self.objeto.XXXunoamuchos:
         total += p.XXXcampoacumulable
         model.append((p.XXXcampo1, 
                       utils.float2str(p.XXXcampoacumulable), 
                       p.id))
     self.wids['XXXe_total_si_lo_hay'].set_text(utils.float2str(total))

 def rellenar_totales(self, totf, tots, totb):
     """
     Introduce los totales en los "entries".
     """
     self.wids['e_total'].set_text(utils.float2str(totf))
     self.wids['e_siniva'].set_text(utils.float2str(tots))
     try:
         beneficio = totb * 100.0 / tots
     except ZeroDivisionError:
         beneficio = 0
     self.wids['e_beneficio'].set_text("%s (%s %%)" % (utils.float2str(totb), utils.float2str(beneficio, 4, autodec = True)))

 def rellenar_facturas(self):
 	"""
     Rellena el model con las facturas no bloqueadas.
     """        
 	model = self.wids['tv_facturas'].get_model()
 	model.clear()
     self.wids['tv_facturas'].freeze_child_notify()
     self.wids['tv_facturas'].set_model(None)
     vpro = ventana_progreso.VentanaProgreso(padre = self.wids['ventana'])
     vpro.mostrar()
     i = 0.0
     facturas = pclases.FacturaVenta.select(pclases.FacturaVenta.q.bloqueada == False, orderBy = "id")
     prefacturas = pclases.Prefactura.select(pclases.Prefactura.q.bloqueada == False, orderBy = "id")
     tot = facturas.count() + prefacturas.count()
     for factura in facturas:
         vpro.set_valor(i/tot, 'Recuperando factura %s...' % (factura.numfactura))
         i += 1
         if factura.vencimientosCobro == []:
             motivo = "Sin vencimientos."
         elif factura.cliente.cif == None or factura.cliente.cif.strip() == "":
             motivo = "Cliente sin CIF."
         else:
             motivo = "Factura no bloqueada."
         model.append((factura.numfactura,
                       utils.str_fecha(factura.fecha),
                       factura.cliente and factura.cliente.nombre or "-",
                       "%s €" % (utils.float2str(factura.calcular_total())), 
                       ", ".join([a.numalbaran for a in factura.get_albaranes()]),
                       factura.bloqueada,
                       motivo,
                       factura.id))
     for factura in prefacturas:
         vpro.set_valor(i/tot, 'Recuperando factura %s...' % (factura.numfactura))
         i += 1
         if factura.vencimientosCobro == []:
             motivo = "Sin vencimientos."
         elif factura.cliente.cif == None or factura.cliente.cif.strip() == "":
             motivo = "Cliente sin CIF."
         else:
             motivo = "Factura no bloqueada."
         model.append((factura.numfactura,
                       utils.str_fecha(factura.fecha),
                       factura.cliente and factura.cliente.nombre or "-",
                       "%s €" % (utils.float2str(factura.calcular_total())), 
                       ", ".join([a.numalbaran for a in factura.get_albaranes()]),
                       factura.bloqueada,
                       motivo,
                       factura.id))
     self.wids['tv_facturas'].set_model(model)
     self.wids['tv_facturas'].thaw_child_notify()
     vpro.ocultar()

 def imprimir(self,boton):
     """
     Prepara la vista preliminar para la impresión del informe
     """
     import informes
     datos = []
     for i in self.resultado:
         if not i[2]:    # i[2] = False cuando es vencimiento normal de la BD
             if isinstance(i[1], pclases.FacturaDeAbono):
                 importe = i[1].calcular_importe_total()
                 datos.append((i[1].numfactura,
                               utils.str_fecha(i[1].fecha),
                               utils.float2str(importe),
                               "",
                               i[1].cliente and i[1].cliente.nombre or ""))
             else:
                 fra = i[1].facturaVenta or i[1].prefactura
                 datos.append((fra.numfactura,
                               utils.str_fecha(i[1].fecha),
                               utils.float2str(i[1].importe),
                               i[1].observaciones,
                               fra.cliente.nombre))
         else:   # i[2] = True. Es un vencimiento rescatado de LogicMovimientos.
             datos.append(("LOGIC",      # Esto me va a valer para diferenciar un vto. de la BD de uno de Logic.
                           utils.str_fecha(i[1]['fecha']),
                           utils.float2str(i[1]['importe']),
                           i[1]['comentario'],
                           i[1]['cuenta']))
     if (self.inicio) == None:            
         fechaInforme = 'Hasta %s' % (utils.str_fecha(self.fin))
     else:
         fechaInforme = utils.str_fecha(self.inicio)+' - '+utils.str_fecha(self.fin)
     if datos != []:
         model = self.wids['tv_totales'].get_model()
         datos.append(("---", )*5)
         datos.append(("TOTALES POR MES Y AÑO", ">->", ">->", ">->", ">->"))
         for fila in model:
             datos.append((fila[0], "", fila[1], "", ""))
             iter_filames = model.iter_children(fila.iter)
             while iter_filames:
                 filames = model[iter_filames]
                 datos.append(("", filames[0], filames[1], "", ""))
                 iter_filames = model.iter_next(iter_filames)
         datos.append(("---", )*5)
         datos.append(("", 
                       "Total", 
                       self.wids['e_total'].get_text(), 
                       "Vencido a la fecha", 
                       self.wids['e_vencido'].get_text()))
         informes.abrir_pdf(geninformes.vencimientosCobro(datos,fechaInforme))