#include "H\General.H"
#include "H\Disco.H"
#include "H\Prog.H"
#include "H\Gastos.H"
#include "H\Efectivo.H"
#include "H\Credito.H"
#include "H\Bancos.H"

#define Inc		10

// Estructura de control
typedef struct DPRO {
	Char        tipo;    		// 1=Fijo  2=Variable
	DPE 		*prx;	 		// Manejo en memoria del control
	MemHandle 	mpr;
	Int16       tpr,cn;
	PROG        pro;			// Apuntador a estructura
	UInt8 		*col;			// Colores
	Boolean     cmb;			// Hubo cambios
	Boolean     edt;			// Está en edición
	Int8        wf,hf;			// De fechas
	Int16       op;				// Opción interna
	OCalc       oc;				// Para calculadora y teclado
	MOVGA       niv;			// Para cuenta de gastos
	ID          idg;
	Char        opg;			// Opcion al llamar gastos 0=Gasto 1=Ingreso
	Boolean     ayu;			// Hay ayuda ?
	Boolean     gas;			// Hay gastos ?
	Fecha       fx;
	Boolean     slc;			// Hay selección de cuentas ?
	Char        tpc;			// Tipo de cuenta
	ID          idl;			// Copia del ID original
	Boolean     didl;           // 
	Char        tppl;           // y del tipo
	double      vt;				// Temporal para calculadora
	double      NumChRef;       // Cheque o referencia
	Boolean     ModChRef;
	Char        str[1][120];	// Para manejo de strings
} PRO;
PRO			*pro;
MemHandle 	mpr;


void 	PntLResPR		(Int16,RectangleType*,char**,ListType*)					ES5;
Boolean AgMemPR			(Int16)      											ES5;
void 	AnaDato			(Char,Int16,Fecha*,ID*)									ES5;
void 	IniVec			(Char,Int16,Fecha*)										ES5;
Int16 	IniciaVector	(Char)      											ES5;
void 	OrdenaLista		(void)      											ES5;
void 	IniFormaPR		(FormType*,Char)      									ES5;
void 	IniFormaCPR		(FormType*)      										ES5;
Boolean EnFecPR			(Int16,Int16)      										ES5;
Boolean	CapConfirma		(FormType*)												ES5;
void    SbListaPR		(void)													ES5;
void    BorListaPR		(void)									    			ES5;
void 	PonerConPR		(Boolean)	    										ES5;
Boolean BajaInfoProg	(MOVGA*,DPE*,double,double,ID*,Char,double) 			ES5;
void 	RegMov		 	(Char,void*,void*,ID*)					    			ES5; // Si se cambia qui se debe cambiar en General.h


// **********************************************************************
//
// Disco
//
// **********************************************************************
// Inicio de los registros
void  IniciaRegPR () {
PROG   *ApI;
        ApI = SacarApRM();
        ApI->TipoReg=6;
        ApI->sfi=0;
        ApI->sfe=0;
        ApI->svi=0;
        ApI->sve=0;
        InsReg((INF*)ApI);
        return;
}
// Afectar la cuenta de programados
Boolean CG_PR(Int8 op, void *cta) {
	UInt16  NReg;
	switch(op) {
      case 0: // Cargar
              if(!SacarNReg (6,0,&NReg)) return false;
              if(!LeerReg(cta,NReg)) return false;
		break;
	case 1: // Guardar
              if(!SacarNReg (6,0,&NReg)) return false;
              if(ModReg(cta,NReg)) return false;
	          break;
	}
	return true;
}
// **********************************************************************
//
// Inicio, termino, pintar formas y control borrar y home
//
// **********************************************************************
// Inicio y término
Boolean FinalizaPR() {
Boolean cmb;
	if (pro->ayu) FinAyuda();
	if (pro->gas) FinalizaGA();
	if (pro->slc) FinalizaCuentas();
	MemHandleUnlock(pro->mpr); MemHandleFree(pro->mpr);
	cmb=pro->cmb;
	MemHandleUnlock(mpr); MemHandleFree(mpr); pro=NULL;
	return cmb;
}
Char IniciaPR(Char tipo, UInt8 *c) { 
	mpr=MemHandleNew(sizeof(PRO));
	pro=(PRO *)MemHandleLock(mpr);
	pro->tpr=Inc;
	pro->mpr=MemHandleNew(sizeof(DPE)*pro->tpr);
	pro->prx=MemHandleLock(pro->mpr);
	pro->cn=0;
	pro->col=c;	
	pro->slc=false;
	pro->edt=false;	pro->cmb=false; pro->ayu=false; pro->gas=false;
	pro->tipo=tipo;
	pro->NumChRef=0;pro->ModChRef=false;
	FrmPopupForm(FResumenPR);
	return 4; 
}
// **********************************************************************
//
// Manejo de la estrucura de control
//
// **********************************************************************
// Subir una pos. la lista
void SbListaPR() {
Int16 i;
	pro->cn--;
	for (i=pro->op;i<pro->cn;i++) 
		MemMove(&(pro->prx[i]),&(pro->prx[i+1]),sizeof(DPE));
	for (i=pro->op;i<pro->cn;i++)
		{ if (pro->prx[i].n>0) pro->prx[i].n--; else break; }
}
// Incrementar la lista
Boolean AgMemPR(Int16 t) {
	if (pro->tpr-pro->cn<t) {
		do pro->tpr+=Inc; while (pro->tpr-pro->cn<t);
		MemHandleUnlock(pro->mpr);
		MemHandleResize(pro->mpr,sizeof(DPE)*pro->tpr);
		pro->prx=MemHandleLock(pro->mpr);
	} 
	return true;
}
// Ordenar vector por fechas
void OrdenaLista() {
DPE 	p;
Int16 	i;
Boolean c;
    do { c=false;
	     for (i=0;i<pro->cn-1;i++) if (Comp2Fec(&(pro->prx[i].f),&(pro->prx[i+1].f))==1) {
	     	MemMove(&p,&(pro->prx[i]),sizeof(DPE));
	     	MemMove(&(pro->prx[i]),&(pro->prx[i+1]),sizeof(DPE));
	     	MemMove(&(pro->prx[i+1]),&p,sizeof(DPE));
	     	c=true;
	     } 
    } while (c==true);
}
// Iniciar el vector, sacar cuentas de gastos e ingresos programados
// Agregar uno nuevo al vector en caso de botón NUEVO
void AnaDato(Char tp, Int16 id, Fecha *h, ID *idg) {
MOVGA niv;
Int16 d=0;
Int8  n;
Fecha p,q;
ID    idt;
	if (idg==NULL) CBG_GA(tp,0,id,&niv,&d);
	else LeerConID(idg,(void*)&niv,false);
    if (niv.Per.op==pro->tipo) {
    	if (idg==NULL) SacarID(&idt); else MemMove(&idt,idg,sizeof(ID));
    	CopFec(&q,&(niv.Per.f)); n=0;
    	do { CopFec(&p,&q);	ProxFPPer(&p,&(niv.Per),2);
    		 if (Comp2Fec(h,&p)==1) {
    		 	AgMemPR(1); MemMove(&(pro->prx[pro->cn].id),&idt,sizeof(ID));
    		 	CopFec(&(pro->prx[pro->cn].f),&p);
    		 	pro->prx[pro->cn].n=n; pro->prx[pro->cn].tipo=tp; 
    		 	(pro->cn)++;
    		 	ProxFPPer(&q,&(niv.Per),3); n++;
    		 } else break;
    	} while(1==1);
    }
}
void IniVec(Char tp, Int16 id, Fecha *h) {
Int16 t,i,r;
	t=TotGA(tp,id);
	for (i=0;i<t;i++) {
		r=IdGA(tp,id,i); AnaDato(tp,r,h,NULL); IniVec(tp,r,h);
	}
}
// Si agregar = true -> se oprimió botón NUEVO si se debe agregar el 
// nuevo dato, calro, analizándolo antes.
Int16 IniciaVector(Char op) { 
Fecha h;
Int16 i;
	FecHoy(&h); h.d=1; SumarMeses(1,&h);
	if (op==2) pro->cn=0;
	if (op==1) AnaDato(pro->opg,0,&h,&(pro->idg));
	else { IniVec(0,0,&h); IniVec(1,0,&h); }
	if (pro->cn>0) OrdenaLista();
	if (op!=0) {
		for (i=0;i<pro->cn;i++) 
		if (pro->prx[i].id.m==pro->idg.m && pro->prx[i].id.r==pro->idg.r) return i;
	}
	return 0;
}	
// **********************************************************************
//
// Control de fechas
//
// **********************************************************************
Boolean EnFecPR(Int16 x, Int16 y) {
	return (x>=57 && x<=57+pro->wf && y>=35 && y<=35+pro->hf);
}
// **********************************************************************
//
// Confirmar movimiento
//
// **********************************************************************

//     Realizar los cambios por un confirmar

//     En *id* esta el ID seleccionado en esta ventana
//     En *tpp* esta tambien el tipo

Boolean BajaInfoProg(MOVGA *niv, DPE *pe, double v, double vt, ID *id,Char tpp, double NumChRef) {
double d;
PROG   pr;
Fecha  h,p,q;
MOVEF  *mefe;
MOVC   *mcre;
CRE    *cre;
EFE    *efe;

	FecHoy(&h); if (MemCmp(&(pe->f),&h,sizeof(Fecha))!=0) 
	switch(FrmAlert(2502)) {
		case 0: break;
		case 1: MemMove(&(pe->f),&h,sizeof(Fecha)); break;
		case 2: return false;
	}
	d=v-vt;
	// Afectar cuenta destino
	if (v!=0) {
		CGB_ID(id,5); 
		switch(SacarTpApRM()) {
		case 1: cre=SacarApRM(); mcre=SacarApMM(); 
				switch(cre->tp) {
				case 0: case 1: case 2: case 3: 
				case 4: mcre->didg=true;
	            		MemMove(&(mcre->idg),&(pe->id),sizeof(ID)); 
		        		switch(pe->tipo) {
		        		case 0: mcre->tp=2; mcre->ct=tpp; break;
			    		case 1: mcre->tp=1; mcre->ct=0; break;
		        		}
	            		mcre->v=v; MemMove(&(mcre->f),&(pe->f),sizeof(Fecha));
	            		StrCopy(mcre->ds,niv->Nom);
	            		RegMov(1,cre,mcre,id);
	            		break;
				} break;
		case 2: efe=SacarApRM(); mefe=SacarApMM(); mefe->didg=true; 
				MemMove(&(mefe->idg),&(pe->id),sizeof(ID)); 
		        switch(pe->tipo) {
		        case 0: mefe->tp=1; mefe->tp1=0; break;
			    case 1: mefe->tp=3; mefe->tp1=0; break;
		        }
	            mefe->v=v;
	            MemMove(&(mefe->f),&(pe->f),sizeof(Fecha));
	            StrCopy(mefe->dsc,niv->Nom);
	            RegMov(2,efe,mefe,NULL);
	            break;
         case 7:FormaMovBA(2,(pe->tipo==0)?2:1,v,&pe->f,tpp,niv->Nom,&pe->id,NumChRef);	            
 	            break;
		}	
        CGB_ID(id,3);
	}
	
//        Afectar periodo

	if (niv->tpc==1) {
		 MemMove(&(niv->id),id,sizeof(ID));
		 niv->tpp=tpp;
	}
	if (v!=0) {
		niv->Per.v=v;
   		FecHoy(&h); h.d=1; SumarMeses(1,&h);
    	CopFec(&q,&(niv->Per.f)); v=0;
    	do { CopFec(&p,&q); ProxFPPer(&p,&(niv->Per),2);
    	 	 if (Comp2Fec(&h,&p)==1) 
    	 	 { v+=d; ProxFPPer(&q,&(niv->Per),3); } else break;
    	} while(1==1);
	}
	ProxFPPer(&(niv->Per.f),&(niv->Per),3);	
	GuardarConID(&(pe->id),(void*)niv);
	
//   Actualiza total de programados	
	
    CG_PR(0,(void*)&pr);
    switch(pe->tipo) {
    case 0: switch(niv->Per.op) { case 1: pr.sfe+=v-niv->Per.v; break;
	   	       			          case 2: pr.sve+=v-niv->Per.v; break;  } break;
	case 1: switch(niv->Per.op) { case 1: pr.sfi+=v-niv->Per.v; break;
	   	       				      case 2: pr.svi+=v-niv->Per.v; break;  } break;
    }
    CG_PR(1,(void*)&pr); 
    return true;
}

/*
void IniCuentaCPR() {
FormType *f;	
INF   *inf;
REGBA  *rb;
    f=FrmGetActiveForm();
	if (pro->didl) {
		inf=SacarApRM(); LeerConID(&(pro->idl),inf,true);
		pro->tpc=inf->TReg;
		switch(pro->tpc) {
		case 1: FrmHideObject(f,FrmGetObjectIndex(f,116));
				FrmShowObject(f,FrmGetObjectIndex(f,115));
				FrmShowObject(f,FrmGetObjectIndex(f,205));
				if(pro->tppl < 0 || pro->tppl > 1 ) pro->tppl=0;
				break;
		case 2: FrmHideObject(f,FrmGetObjectIndex(f,115));
				FrmHideObject(f,FrmGetObjectIndex(f,116));
				FrmHideObject(f,FrmGetObjectIndex(f,205));
				break;
    	case 7: pro->NumChRef=0;  pro->ModChRef=false;
   				if(pro->tppl < 0 || pro->tppl > 2 ) pro->tppl=0;			    
			    if(pro->prx[pro->op].tipo==0) {
			        rb=SacarApRM();
		            if(rb->TipoCDI==1 && pro->tppl==0 ) pro->NumChRef=rb->UNumCh+1;
		            FrmShowObject(f,FrmGetObjectIndex(f,116));
			    } else FrmHideObject(f,FrmGetObjectIndex(f,116));
		        FrmShowObject(f,FrmGetObjectIndex(f,115));
				FrmShowObject(f,FrmGetObjectIndex(f,205));
				break;  
		}
	}
	else {
		FrmHideObject(f,FrmGetObjectIndex(f,116));
		FrmHideObject(f,FrmGetObjectIndex(f,115));
		FrmHideObject(f,FrmGetObjectIndex(f,205));
	}
}
*/

//      Inicia forma de confirmar programado

void IniFormaCPR(FormType *f) {
Int8  aa;
Char  s[120],t[20];
	LeerConID(&(pro->prx[pro->op].id),(void*)&(pro->niv),false);
	MemMove(&(pro->idl),&(pro->niv.id),sizeof(ID));
    if(pro->niv.tpc==0) pro->didl=false; else	pro->didl=pro->niv.did;
    pro->tppl=pro->niv.tpp;
	switch(pro->prx[pro->op].tipo) {
	case 0: SacaTexto(s,2500,4,120); FrmCopyTitle(f,s);
			SacaTexto(s,2300,10,120); FrmCopyLabel(f,204,s);
			break;
	case 1: SacaTexto(s,2500,5,120); FrmCopyTitle(f,s);
			SacaTexto(s,2300,11,120); FrmCopyLabel(f,204,s);
			break;
	}
	FrmDrawForm(f);
	StrCopy(s,pro->niv.Nom); 
    if (pro->prx[pro->op].n>0) { 
    	StrIToA(t,pro->prx[pro->op].n); StrCat(s," ("); 
    	StrCat(s,t); StrCat(s,")");
    }
	PonTexto(s,80,15,B,C,156,false,-1,-1,&aa);
	CopFec(&(pro->fx),&(pro->prx[pro->op].f)); ProxFPPer(&(pro->fx),&(pro->niv.Per),2);
	if (pro->prx[pro->op].n>0) {
		FrmHideObject(f,FrmGetObjectIndex(f,1000)); 
		FrmHideObject(f,FrmGetObjectIndex(f,1002)); 
		FrmHideObject(f,FrmGetObjectIndex(f,1025)); 
	}
	FrmSetFocus(f,FrmGetObjectIndex(f,113)); 
	PonBotonCT(&(pro->oc),1,113,&(pro->niv.Per.v),NULL,f,0,2500,0);
	IniCuenta(FrmGetActiveForm(),pro->didl,&(pro->idl),&(pro->tppl),(pro->prx[pro->op].tipo==0),&(pro->NumChRef),&(pro->ModChRef));
	PonerConPR(true);
}

//      Procesar aceptar de confirmar programado

Boolean CapConfirma(FormType *f) {
	if (!(pro->didl)&&pro->niv.Per.v!=0) { FrmAlert(2501); return false; }
//	if (FrmAlert(2500)==1) return false;
	if (!BajaInfoProg(&(pro->niv),&(pro->prx[pro->op]),pro->niv.Per.v,pro->vt,&(pro->idl),pro->tppl,pro->NumChRef)) return false;
    SbListaPR();
    return true;
}

//   Poner y sacar info de forma en confirmar programado 

void PonerConPR(Boolean poner) {
FormType *f;	
Int8  aa;
Char   s[120],t[20];
    f=FrmGetActiveForm();
//                          Nombre, valor, ...    
    if(poner) {
 	     StrCopy(s,pro->niv.Nom); 
         if (pro->prx[pro->op].n>0) { 
    	     StrIToA(t,pro->prx[pro->op].n); StrCat(s," ("); 
    	     StrCat(s,t); StrCat(s,")");
         }
	     PonTexto(s,80,15,B,C,156,false,-1,-1,&aa);
	     AstrX(pro->niv.Per.v,s,false,false); Texto(s,GetObjPtr(f,113),true);
	     pro->hf=PonFecCamp(57,35,&(pro->fx),-1,-1,true,&pro->wf);
    } else {
	    Texto(s,GetObjPtr(f,113),false); pro->niv.Per.v=AdblX(s);
        Texto(s,GetObjPtr(f,116),false); pro->NumChRef=AdblX(s);	
    }
    
//                          Si hay cuenta, nombre, tipo    
	if (pro->didl && poner) {
		PonValorCuenta(f,114,&(pro->idl),pro->didl,pro->str[0]);		
		switch(pro->tpc) {
		case 1: Lista(GetObjPtr(f,115),GetObjPtr(f,210),pro->tppl,true,0,NULL);
				break;
		case 2: break;
		case 7: AstrX(pro->NumChRef,s,false,false); Texto(s,GetObjPtr(f,116),true);		
				Lista(GetObjPtr(f,115),GetObjPtr(f,211),pro->tppl,true,0,NULL);
				break;  
		}
	}
		
}

//     Procesar mensajes de confirmar programado

Boolean ConfirmarPR(EventType* pEvent) {
Char  s[50];
Int16 v;
	switch (pEvent->eType) {
		case frmUpdateEvent:
			switch(pEvent->data.frmUpdate.updateCode) {
			  case 70: break;
			  case 90: pro->ayu=false; break;
			  case 92: pro->slc=false; break;
			  case 93: pro->slc=false; 
				   	   pro->didl=true;
				   	   pro->tppl=0;
					   IniCuenta(FrmGetActiveForm(),pro->didl,&(pro->idl),&(pro->tppl),(pro->prx[pro->op].tipo==0),&(pro->NumChRef),&(pro->ModChRef));
				       break;
			  case 99: pro->gas=false; FrmUpdateForm(FGastos,96); FrmReturnToForm(0); return true;
			default: return false;
			}
			PonerConPR(true);
			return true;
		case frmOpenEvent:
			IniFormaCPR(FrmGetActiveForm());
			pro->vt=pro->niv.Per.v;
			return true;
		case ctlSelectEvent:
		    switch(pEvent->data.ctlSelect.controlID) {
	    	case BAyu: PonerConPR(false);
	    	           pro->ayu=Ayuda(2504,1,pro->col,FConfirmarPR); 
	    	           return true;
		    case BCal: PonerConPR(false);
	    	           OpBotonCT(&(pro->oc)); 
	    	           return true;
		   	case BAce: PonerConPR(false);
		   	           if (!CapConfirma(FrmGetActiveForm())) return true;
		   	           FrmUpdateForm(FResumenPR,99);
		   	case BCan: FrmReturnToForm(0); 
		   	           return true;
		   	case BEdi: PonerConPR(false);
	    	           pro->gas=true;
		   	           IniciaGastos(pro->prx[pro->op].tipo,3,FConfirmarPR,&(pro->prx[pro->op].id),false,pro->col,pro->tipo);
		   	           break;
		    }
		    break;
        case ctlEnterEvent:
            switch(pEvent->data.ctlEnter.controlID) {
            case  114: PonerConPR(false);
                       pro->slc=IniciaCuentas(FConfirmarPR,NULL,&(pro->idl),pro->didl,pro->col); 
                       return true;
        	case  115: PonerConPR(false);
        	           switch(pro->tpc) {
        			   case 1: v=LstPopupList(GetObjPtr(FrmGetActiveForm(),210)); 
        			           if (v==-1) return true;
        			           break;
        			   case 2: return true;
		   			   case 7: v=LstPopupList(GetObjPtr(FrmGetActiveForm(),211)); 
        			           if (v==-1) return true;
        	                   if(v!=0 && !pro->ModChRef) pro->NumChRef=0;
        			           break;
        			   }
        	           pro->tppl=(Char)v;
        	           PonerConPR(true);
        	           return true;
            }
            break;
	    case fldEnterEvent:
            switch(pEvent->data.fldEnter.fieldID) {
   		    case  113: PonBotonCT(&(pro->oc),1,113,&(pro->niv.Per.v),NULL,FrmGetActiveForm(),0,2500,0); return false;
  		    case  116: PonBotonCT(&(pro->oc),1,116,&(pro->NumChRef),NULL,FrmGetActiveForm(),0,2500,0); pro->ModChRef=true;return false;   		    
           	default  : PonBotonCT(&(pro->oc),0,0,NULL,NULL,FrmGetActiveForm(),0,2500,0); return false;
            }
		    break;
        case penDownEvent:
            if (EnFecPR(pEvent->screenX,pEvent->screenY)) {
            	PonerConPR(false);
		        if (SelFecha(s,&(pro->fx),false))PonerConPR(true);
            	return true;
            }
		default: break;
	}
	return false;
}
// **********************************************************************
//
// Movimientos programados
//
// **********************************************************************
// Iniciar y pintar forma
// Pintar lista resumen (desde SO)
void PntLResPR(Int16 it, RectangleType *r,char **u, ListType *p) {
MOVGA 			niv;
Int16    		bc,x,y;
Int8            a;
RectangleType   e;
Boolean  		pn;
double          v;
Char            s[120],t[20];
	pn=SelecLst(pro->col[0]);
    if (pn) {
    	e.topLeft.x=r->topLeft.x; e.topLeft.y=r->topLeft.y; 
    	e.extent.y=r->extent.y;   e.extent.x=150;
		bc=WinSetBackColor((((it&0x01)>0)?pro->col[6]:pro->col[2])); 
		WinEraseRectangle(&e,0);
    }
    x=r->topLeft.x; y=r->topLeft.y;
    LeerConID(&(pro->prx[it].id),(void*)&niv,false);
    ForFec(s,1,&(pro->prx[it].f)); PonTexto(s,x,y,N,I,26,false,-1,-1,&a); x+=28;
    StrCopy(s,niv.Nom); 
    if (pro->prx[it].n>0) { 
    	StrIToA(t,pro->prx[it].n); StrCat(s," ("); 
    	StrCat(s,t); StrCat(s,")");
    }
    PonTexto(s,x,y,N,I,70,false,-1,-1,&a);
    v=niv.Per.v; if (niv.Per.tpv==0) v*=(double)(-1);
	AstrX(v,s,false,true);
    PonTexto(s,150,y,N,D,50,false,(pn)?(v<0)?pro->col[5]:-1:-1,-1,&a);
	if (pn) WinSetBackColor(bc);
}
// op 0=inicio 1=Agregar 2=Repaint
void IniFormaPR(FormType *f, Char op) {
Int16 		x,y,w,h;
Char     	t[120]; 
Int8        aa;
	switch(op) {
		case 0: SacaTexto(t,2500,((pro->tipo==1)?0:1),120); FrmCopyTitle(f,t);
			    FrmDrawForm(f); IniciaVector(0); pro->op=0; break;
		case 1: pro->op=IniciaVector(1); break;
		case 2: pro->op=IniciaVector(2); break;
	}
	CG_PR(0,(void*)&(pro->pro));
    x=1; y=16; w=158; h=FntCharHeight(); 
    EliminaMarco(f,100,(ListDrawDataFuncPtr)PntLResPR,pro->cn,(op==0),pro->op);
    PintaB(255,x,y,w,8+(h*2),8,9,1,2,true,pro->col); y+=2;
    switch(pro->tipo) {
   	case  1: SacaTexto(t,2500,2,120); PonTexto(t,5,y,B,I,100,false,-1,pro->col[8],&aa);
		 	 AstrX(pro->pro.sfi,t,true,true); 
		 	 PonTexto(t,155,y,B,D,100,false,(pro->pro.sfi<0)?pro->col[5]:-1,pro->col[8],&aa);
		 	 y+=(h+2);
		 	 SacaTexto(t,2500,3,120); PonTexto(t,5,y,B,I,100,false,-1,pro->col[8],&aa);
		 	 AstrX(pro->pro.sfe*(-1),t,true,true); 
		 	 PonTexto(t,155,y,B,D,100,false,(pro->pro.sfe>0)?pro->col[5]:-1,pro->col[8],&aa);
			 break;
    case  2: SacaTexto(t,2500,2,120); PonTexto(t,5,y,B,I,100,false,-1,pro->col[8],&aa);
		 	 AstrX(pro->pro.svi,t,true,true); 
		 	 PonTexto(t,155,y,B,D,100,false,(pro->pro.svi<0)?pro->col[5]:-1,pro->col[8],&aa);
		 	 y+=(h+2);
  			 SacaTexto(t,2500,3,120); PonTexto(t,5,y,B,I,100,false,-1,pro->col[8],&aa);
		 	 AstrX(pro->pro.sve*(-1),t,true,true); 
		 	 PonTexto(t,155,y,B,D,100,false,(pro->pro.sfe>0)?pro->col[5]:-1,pro->col[8],&aa);
	    	 break;
    }	
}
// Principal
Boolean ResumenPR(EventType* pEvent) {
Int16 v;	
	switch (pEvent->eType) {
		case frmUpdateEvent:
			switch(pEvent->data.frmUpdate.updateCode) {
			case 90: pro->ayu=false; return true;
			case 94: pro->gas=false; return true;
			case 95: pro->cmb=true; pro->gas=false; IniFormaPR(FrmGetActiveForm(),1); return true;
			case 96: pro->cmb=true; IniFormaPR(FrmGetActiveForm(),2); return true;
			case 99: IniFormaPR(FrmGetActiveForm(),2); return true;
			default: return false;
			}
		case frmOpenEvent:
			IniFormaPR(FrmGetActiveForm(),0);
			return true;
		case ctlSelectEvent:
		    switch(pEvent->data.ctlSelect.controlID) {
	    	case BAyu: pro->ayu=Ayuda((pro->tipo==1)?2500:2502,1,pro->col,FResumenPR); return true;
		   	case BAce: if (FinalizaPR()) FrmUpdateForm(FPrincipal,99);
		   			   else FrmUpdateForm(FPrincipal,98);
		   	           FrmReturnToForm(0); 
		   	           return true;
		   	case BNue: v=LstPopupList((ListType*)GetObjPtr(FrmGetActiveForm(),101));
		   			   switch(v) {
		   			   case 0: pro->gas=true; pro->opg=0;
        	           	       IniciaGastos(1,4,FResumenPR,&(pro->idg),false,pro->col,pro->tipo);
        	           	       break;
		   			   case 1: pro->gas=true; pro->opg=1;
        	           	       IniciaGastos(0,4,FResumenPR,&(pro->idg),false,pro->col,pro->tipo);
        	           	       break;
		   			   }
		   			   return true;		   	
		    }
		    break;
        case lstSelectEvent:
		    pro->op=pEvent->data.lstSelect.selection;
		    if (pro->op==noListSelection) return true;
		    FrmPopupForm(FConfirmarPR);
            return true;
		default: break;
	}
	return false;
}
