#include <stdio.h>
#include <stdlib.h>
#include "image.h"
#include "canal.h"




Canal CreeCanal(Image image,Type type,Broche broche,Zone zone)
/************************************************************/

{
Canal canal;

if (image==NULL) return(NULL);
if ( (canal=(Canal)malloc(sizeof(*canal)))==NULL) return(NULL);

canal->ptr=(Valeur *)image->donnee.octet;
canal->timage=image->type;
canal->tvaleur=type;

switch(canal->timage)
	{
	case T_OCTET:
		canal->dp=sizeof(Octet);
		break;

	case T_ENTIER:
		canal->dp=sizeof(Entier);
		break;

	case T_ENTIERL:
		canal->dp=sizeof(EntierL);
		break;

	case T_REEL:
		canal->dp=sizeof(Reel);
		break;

	case T_REELL:
		canal->dp=sizeof(ReelL);
		break;

	case T_COMPLEXE:
		canal->dp=sizeof(Complexe);
		break;

	case T_COMPLEXEL:
		canal->dp=sizeof(ComplexeL);
		break;

	case T_COULEUR:
		canal->dp=sizeof(Couleur);
		break;
	case T_VECTEUR2D:
		canal->dp=sizeof(Vecteur2D);
		break;
	}

if (zone==Z_IMAGE)
	{
	canal->orgi=0;
	canal->orgj=0;
	canal->imax=image->taille.y;
	canal->jmax=image->taille.x;
	}
else if (zone==Z_FENETRE)
	{
	canal->orgi=(size_t) image->fenetre.origine.y;
	canal->orgj=(size_t) image->fenetre.origine.x*canal->dp;
	canal->imax=image->fenetre.taille.y;
	canal->jmax=image->fenetre.taille.x;
	}
if (broche==B_POINT) canal->jbroche=1;
else if (broche==B_LIGNE) canal->jbroche=canal->jmax;

canal->ptri=canal->ptr+canal->orgi;
canal->ptrj.octet=((canal->ptri++)->octet) + canal->orgj;
canal->i=0;
canal->j=0;

return(canal);
}




 void LibereCanal(Canal canal)
/****************************/

{
free(canal);
}

int PoseCanal(Canal canal,int x,int y)
/*************************************/

{

if((x>=canal->jmax)||(y>=canal->imax) || (x<0) || (y<0)) return(1);
canal->i=y;
if (canal->jbroche==1) canal->j=x;
else canal->j=0;

canal->ptri=canal->ptr+canal->orgi+canal->i;
canal->ptrj.octet=((canal->ptri++)->octet) + canal->orgj + canal->j*canal->dp;

return(0);
}

void RepereCanal(Canal canal,int *x,int *y)
/*****************************************/
{
*x=canal->j;
*y=canal->i;
}


int LitCanal(Canal canal,void *valeur)
/*************************************/

{
Valeur val;
int n=0;
int jb;

val.octet=(Octet *) valeur;
jb=canal->j+canal->jbroche;

if (canal->i==canal->imax) return(0);

switch(canal->tvaleur)
	{
	case T_OCTET :
		switch(canal->timage)
			{
			case T_OCTET :
				while(canal->j++<jb)
				{
				n++;
				*val.octet++=(Octet)*canal->ptrj.octet++;
				}
			break;

			case T_ENTIER :
				while(canal->j++<jb)
				{
				n++;
				*val.octet++=(Octet)*canal->ptrj.entier++;
				}
			break;

			case T_ENTIERL :
				while(canal->j++<jb)
				{
				n++;
				*val.octet++=(Octet)*canal->ptrj.entierL++;
				}
			break;
			case T_REEL :
				while(canal->j++<jb)
				{
				n++;
				*val.octet++=(Octet)*canal->ptrj.reel++;
				}
			break;
			case T_REELL :
				while(canal->j++<jb)
				{
				n++;
				*val.octet++=(Octet)*canal->ptrj.reelL++;
				}
			break;
			case T_COMPLEXE :
				while(canal->j++<jb)
				{
				n++;
				*val.octet++=(Octet)(canal->ptrj.complexe++)->x;
				}
			break;
			case T_COMPLEXEL :
				while(canal->j++<jb)
				{
				n++;
				*val.octet++=(Octet)(canal->ptrj.complexeL++)->x;
				}
			break;
			case T_COULEUR :
				while(canal->j++<jb)
				{
				n++;
				*val.octet++=(Octet)(canal->ptrj.couleur++)->c1;
				}
			break;

			}
	break;

	case T_ENTIER :
		switch(canal->timage)
			{
			case T_OCTET :
				while(canal->j++<jb)
				{
				n++;
				*val.entier++=(Entier)*canal->ptrj.octet++;
				}
			break;

			case T_ENTIER :
				while(canal->j++<jb)
				{
				n++;
				*val.entier++=(Entier)*canal->ptrj.entier++;
				}
			break;

			case T_ENTIERL :
				while(canal->j++<jb)
				{
				n++;
				*val.entier++=(Entier)*canal->ptrj.entierL++;
				}
			break;
			case T_REEL :
				while(canal->j++<jb)
				{
				n++;
				*val.entier++=(Entier)*canal->ptrj.reel++;
				}
			break;
			case T_REELL :
				while(canal->j++<jb)
				{
				n++;
				*val.entier++=(Entier)*canal->ptrj.reelL++;
				}
			break;
			case T_COMPLEXE :
				while(canal->j++<jb)
				{
				n++;
				*val.entier++=(Entier)(canal->ptrj.complexe++)->x;
				}
			break;
			case T_COMPLEXEL :
				while(canal->j++<jb)
				{
				n++;
				*val.entier++=(Entier)(canal->ptrj.complexeL++)->x;
				}
			break;
			case T_COULEUR :
				while(canal->j++<jb)
				{
				n++;
				*val.entier++=(Entier)(canal->ptrj.couleur++)->c1;
				}
			break;

			}
	break;

	case T_ENTIERL :
		switch(canal->timage)
			{
			case T_OCTET :
				while(canal->j++<jb)
				{
				n++;
				*val.entierL++=(EntierL)*canal->ptrj.octet++;
				}
			break;

			case T_ENTIER :
				while(canal->j++<jb)
				{
				n++;
				*val.entierL++=(EntierL)*canal->ptrj.entier++;
				}
			break;

			case T_ENTIERL :
				while(canal->j++<jb)
				{
				n++;
				*val.entierL++=(EntierL)*canal->ptrj.entierL++;
				}
			break;
			case T_REEL :
				while(canal->j++<jb)
				{
				n++;
				*val.entierL++=(EntierL)*canal->ptrj.reel++;
				}
			break;
			case T_REELL :
				while(canal->j++<jb)
				{
				n++;
				*val.entierL++=(EntierL)*canal->ptrj.reelL++;
				}
			break;
			case T_COMPLEXE :
				while(canal->j++<jb)
				{
				n++;
				*val.entierL++=(EntierL)(canal->ptrj.complexe++)->x;
				}
			break;
			case T_COMPLEXEL :
				while(canal->j++<jb)
				{
				n++;
				*val.entierL++=(EntierL)(canal->ptrj.complexeL++)->x;
				}
			break;
			case T_COULEUR :
				while(canal->j++<jb)
				{
				n++;
				*val.entierL++=(EntierL)(canal->ptrj.couleur++)->c1;
				}
			break;

			}
	break;

	case T_REEL :
		switch(canal->timage)
			{
			case T_OCTET :
				while(canal->j++<jb)
				{
				n++;
				*val.reel++=(Reel)*canal->ptrj.octet++;
				}
			break;

			case T_ENTIER :
				while(canal->j++<jb)
				{
				n++;
				*val.reel++=(Reel)*canal->ptrj.entier++;
				}
			break;

			case T_ENTIERL :
				while(canal->j++<jb)
				{
				n++;
				*val.reel++=(Reel)*canal->ptrj.entierL++;
				}
			break;
			case T_REEL :
				while(canal->j++<jb)
				{
				n++;
				*val.reel++=(Reel)*canal->ptrj.reel++;
				}
			break;
			case T_REELL :
				while(canal->j++<jb)
				{
				n++;
				*val.reel++=(Reel)*canal->ptrj.reelL++;
				}
			break;
			case T_COMPLEXE :
				while(canal->j++<jb)
				{
				n++;
				*val.reel++=(Reel)(canal->ptrj.complexe++)->x;
				}
			break;
			case T_COMPLEXEL :
				while(canal->j++<jb)
				{
				n++;
				*val.reel++=(Reel)(canal->ptrj.complexeL++)->x;
				}
			break;
			case T_COULEUR :
				while(canal->j++<jb)
				{
				n++;
				*val.reel++=(Reel)(canal->ptrj.couleur++)->c1;
				}
			break;

			}
	break;

	case T_REELL :
		switch(canal->timage)
			{
			case T_OCTET :
				while(canal->j++<jb)
				{
				n++;
				*val.reelL++=(ReelL)*canal->ptrj.octet++;
				}
			break;

			case T_ENTIER :
				while(canal->j++<jb)
				{
				n++;
				*val.reelL++=(ReelL)*canal->ptrj.entier++;
				}
			break;

			case T_ENTIERL :
				while(canal->j++<jb)
				{
				n++;
				*val.reelL++=(ReelL)*canal->ptrj.entierL++;
				}
			break;
			case T_REEL :
				while(canal->j++<jb)
				{
				n++;
				*val.reelL++=(ReelL)*canal->ptrj.reel++;
				}
			break;
			case T_REELL :
				while(canal->j++<jb)
				{
				n++;
				*val.reelL++=(ReelL)*canal->ptrj.reelL++;
				}
			break;
			case T_COMPLEXE :
				while(canal->j++<jb)
				{
				n++;
				*val.reelL++=(ReelL)(canal->ptrj.complexe++)->x;
				}
			break;
			case T_COMPLEXEL :
				while(canal->j++<jb)
				{
				n++;
				*val.reelL++=(ReelL)(canal->ptrj.complexeL++)->x;
				}
			break;
			case T_COULEUR :
				while(canal->j++<jb)
				{
				n++;
				*val.reelL++=(ReelL)(canal->ptrj.couleur++)->c1;
				}
			break;

			}
	break;

	case T_COMPLEXE:
		switch(canal->timage)
			{
			case T_OCTET :
				while(canal->j++<jb)
				{
				n++;
				(val.complexe)->x=(Reel)*canal->ptrj.octet++;
				(val.complexe++)->y=0;
				}
			break;

			case T_ENTIER :
				while(canal->j++<jb)
				{
				n++;
				(val.complexe)->x=(Reel)*canal->ptrj.entier++;
				(val.complexe++)->y=0;
				}
			break;

			case T_ENTIERL :
				while(canal->j++<jb)
				{
				n++;
				(val.complexe)->x=(Reel)*canal->ptrj.entierL++;
				(val.complexe++)->y=0;
				}
			break;
			case T_REEL :
				while(canal->j++<jb)
				{
				n++;
				(val.complexe)->x=(Reel)*canal->ptrj.reel++;
				(val.complexe++)->y=0;
				}
			break;
			case T_REELL :
				while(canal->j++<jb)
				{
				n++;
				(val.complexe)->x=(Reel)*canal->ptrj.reelL++;
				(val.complexe++)->y=0;
				}
			break;
			case T_COMPLEXE :
				while(canal->j++<jb)
				{
				n++;
				*(val.complexe++)=*(canal->ptrj.complexe++);
				}
			break;
			case T_COMPLEXEL :
				while(canal->j++<jb)
				{
				n++;
				(val.complexe)->x=(Reel)(canal->ptrj.complexeL)->x;
				(val.complexe++)->y=(Reel)(canal->ptrj.complexeL++)->y;
				}
			break;
			case T_COULEUR :
				while(canal->j++<jb)
				{
				n++;
				(val.complexe)->x=(Reel)(canal->ptrj.couleur)->c1;
				(val.complexe++)->y=(Reel)(canal->ptrj.couleur++)->c2;
				}
			break;
			case T_VECTEUR2D :
				while(canal->j++<jb)
				{
				n++;
				(val.complexe)->x=(canal->ptrj.vecteur2D)->u;
				(val.complexe++)->y=(canal->ptrj.vecteur2D++)->v;
				}
			break;
			}
	break;

	case T_COMPLEXEL:
		switch(canal->timage)
			{
			case T_OCTET :
				while(canal->j++<jb)
				{
				n++;
				(val.complexeL)->x=(ReelL)*canal->ptrj.octet++;
				(val.complexeL++)->y=0;
				}
			break;

			case T_ENTIER :
				while(canal->j++<jb)
				{
				n++;
				(val.complexeL)->x=(ReelL)*canal->ptrj.entier++;
				(val.complexeL++)->y=0;
				}
			break;

			case T_ENTIERL :
				while(canal->j++<jb)
				{
				n++;
				(val.complexeL)->x=(ReelL)*canal->ptrj.entierL++;
				(val.complexeL++)->y=0;
				}
			break;
			case T_REEL :
				while(canal->j++<jb)
				{
				n++;
				(val.complexeL)->x=(ReelL)*canal->ptrj.reel++;
				(val.complexeL++)->y=0;
				}
			break;
			case T_REELL :
				while(canal->j++<jb)
				{
				n++;
				(val.complexeL)->x=(ReelL)*canal->ptrj.reelL++;
				(val.complexeL++)->y=0;
				}
			break;
			case T_COMPLEXE :
				while(canal->j++<jb)
				{
				n++;
				(val.complexeL)->x=(ReelL)(canal->ptrj.complexe)->x;
				(val.complexeL++)->y=(ReelL)(canal->ptrj.complexe++)->y;
				}
			break;
			case T_COMPLEXEL :
				while(canal->j++<jb)
				{
				n++;
				*(val.complexeL++)=*(canal->ptrj.complexeL++);
				}
			break;
			case T_COULEUR :
				while(canal->j++<jb)
				{
				n++;
				(val.complexeL)->x=(ReelL)(canal->ptrj.couleur)->c1;
				(val.complexeL++)->y=(ReelL)(canal->ptrj.couleur++)->c2;
				}
			break;
			case T_VECTEUR2D :
				while(canal->j++<jb)
				{
				n++;
				(val.complexe)->x=(ReelL)(canal->ptrj.vecteur2D)->u;
				(val.complexe++)->y=(ReelL)(canal->ptrj.vecteur2D++)->v;
				}
			break;

			}
	break;

	case T_COULEUR :
		switch(canal->timage)
			{
			case T_OCTET :
				while(canal->j++<jb)
				{
				n++;
				(val.couleur)->c1=(Octet)*canal->ptrj.octet++;
				(val.couleur)->c2=0;
				(val.couleur++)->c3=0;
				}
			break;

			case T_ENTIER :
				while(canal->j++<jb)
				{
				n++;
				(val.couleur)->c1=(Octet)*canal->ptrj.entier++;
				(val.couleur)->c2=0;
				(val.couleur++)->c3=0;
				}
			break;

			case T_ENTIERL :
				while(canal->j++<jb)
				{
				n++;
				(val.couleur)->c1=(Octet)*canal->ptrj.entierL++;
				(val.couleur)->c2=0;
				(val.couleur++)->c3=0;
				}
			break;
			case T_REEL :
				while(canal->j++<jb)
				{
				n++;
				(val.couleur)->c1=(Octet)*canal->ptrj.reel++;
				(val.couleur)->c2=0;
				(val.couleur++)->c3=0;
				}
			break;
			case T_REELL :
				while(canal->j++<jb)
				{
				n++;
				(val.couleur)->c1=(Octet)*canal->ptrj.reelL++;
				(val.couleur)->c2=0;
				(val.couleur++)->c3=0;
				}
			break;
			case T_COMPLEXE :
				while(canal->j++<jb)
				{
				n++;
				(val.couleur)->c1=(Octet)(canal->ptrj.complexe)->x;
				(val.couleur)->c2=(Octet)(canal->ptrj.complexe++)->y;
				(val.couleur++)->c3=0;
				}
			break;
			case T_COMPLEXEL :
				while(canal->j++<jb)
				{
				n++;
				(val.couleur)->c1=(Octet)(canal->ptrj.complexeL)->x;
				(val.couleur)->c2=(Octet)(canal->ptrj.complexeL++)->y; ;
				(val.couleur++)->c3=0;
				}
			break;
			case T_COULEUR :
				while(canal->j++<jb)
				{
				n++;
				*(val.couleur++)=*(canal->ptrj.couleur++);
				}
			break;

			}
	break;
	}

if(--canal->j==canal->jmax)
	{
	canal->j=0;
	if (++canal->i<canal->imax)
	   canal->ptrj.octet=(canal->ptri++)->octet + canal->orgj;
	}

return(n);
}



int EcritCanal(Canal canal,void *valeur)
/***************************************/

{
Valeur val;
int n=0;
int jb;

val.octet=(Octet *)valeur;
jb=canal->j+canal->jbroche;

if (canal->i==canal->imax) return(0);

switch(canal->tvaleur)
	{
	case T_OCTET :
		switch(canal->timage)
			{
			case T_OCTET :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.octet++=(Octet)*val.octet++;
				}
			break;

			case T_ENTIER :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.entier++=(Entier)*val.octet++;
				}
			break;

			case T_ENTIERL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.entierL++=(EntierL)*val.octet++;
				}
			break;
			case T_REEL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.reel++=(Reel)*val.octet++;
				}
			break;
			case T_REELL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.reelL++=(ReelL)*val.octet++;
				}
			break;
			case T_COMPLEXE :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.complexe)->x=(Reel)*val.octet++;
				(canal->ptrj.complexe++)->y=0;
				}
			break;
			case T_COMPLEXEL :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.complexeL)->x=(ReelL)*val.octet++;
				(canal->ptrj.complexeL++)->y=0;
				}
			break;
			case T_COULEUR :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.couleur)->c1=(Octet)*val.octet++;
				(canal->ptrj.couleur)->c2=0;
				(canal->ptrj.couleur++)->c3=0;
				}
			break;

			}
	break;

	case T_ENTIER :
		switch(canal->timage)
			{
			case T_OCTET :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.octet++=(Octet)*val.entier++;
				}
			break;

			case T_ENTIER :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.entier++=(Entier)*val.entier++;
				}
			break;

			case T_ENTIERL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.entierL++=(EntierL)*val.entier++;
				}
			break;
			case T_REEL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.reel++=(Reel)*val.entier++;
				}
			break;
			case T_REELL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.reelL++=(ReelL)*val.entier++;
				}
			break;
			case T_COMPLEXE :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.complexe)->x=(Reel)*val.entier++;
				(canal->ptrj.complexe++)->y=0;
				}
			break;
			case T_COMPLEXEL :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.complexeL)->x=(ReelL)*val.entier++;
				(canal->ptrj.complexeL++)->y=0;
				}
			break;
			case T_COULEUR :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.couleur)->c1=(Octet)*val.entier++;
				(canal->ptrj.couleur)->c2=0;
				(canal->ptrj.couleur++)->c3=0;
				}
			break;

			}
	break;

	case T_ENTIERL :
		switch(canal->timage)
			{
			case T_OCTET :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.octet++=(Octet)*val.entierL++;
				}
			break;

			case T_ENTIER :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.entier++=(Entier)*val.entierL++;
				}
			break;

			case T_ENTIERL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.entierL++=(EntierL)*val.entierL++;
				}
			break;
			case T_REEL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.reel++=(Reel)*val.entierL++;
				}
			break;
			case T_REELL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.reelL++=(ReelL)*val.entierL++;
				}
			break;
			case T_COMPLEXE :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.complexe)->x=(Reel)*val.entierL++;
				(canal->ptrj.complexe++)->y=0;
				}
			break;
			case T_COMPLEXEL :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.complexeL)->x=(ReelL)*val.entierL++;
				(canal->ptrj.complexeL++)->y=0;
				}
			break;
			case T_COULEUR :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.couleur)->c1=(Octet)*val.entierL++;
				(canal->ptrj.couleur)->c2=0;
				(canal->ptrj.couleur++)->c3=0;
				}
			break;

			}
	break;

	case T_REEL :
		switch(canal->timage)
			{
			case T_OCTET :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.octet++=(Octet)*val.reel++;
				}
			break;

			case T_ENTIER :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.entier++=(Entier)*val.reel++;
				}
			break;

			case T_ENTIERL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.entierL++=(EntierL)*val.reel++;
				}
			break;
			case T_REEL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.reel++=(Reel)*val.reel++;
				}
			break;
			case T_REELL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.reelL++=(ReelL)*val.reel++;
				}
			break;
			case T_COMPLEXE :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.complexe)->x=(Reel)*val.reel++;
				(canal->ptrj.complexe++)->y=0;
				}
			break;
			case T_COMPLEXEL :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.complexeL)->x=(ReelL)*val.reel++;
				(canal->ptrj.complexeL++)->y=0;
				}
			break;
			case T_COULEUR :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.couleur)->c1=(Octet)*val.reel++;
				(canal->ptrj.couleur)->c2=0;
				(canal->ptrj.couleur++)->c3=0;
				}
			break;

			}
	break;

	case T_REELL :
		switch(canal->timage)
			{
			case T_OCTET :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.octet++=(Octet)*val.reelL++;
				}
			break;

			case T_ENTIER :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.entier++=(Entier)*val.reelL++;
				}
			break;

			case T_ENTIERL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.entierL++=(EntierL)*val.reelL++;
				}
			break;
			case T_REEL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.reel++=(Reel)*val.reelL++;
				}
			break;
			case T_REELL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.reelL++=(ReelL)*val.reelL++;
				}
			break;
			case T_COMPLEXE :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.complexe)->x=(Reel)*val.reelL++;
				(canal->ptrj.complexe++)->y=0;
				}
			break;
			case T_COMPLEXEL :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.complexeL)->x=(ReelL)*val.reelL++;
				(canal->ptrj.complexeL++)->y=0;
				}
			break;
			case T_COULEUR :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.couleur)->c1=(Octet)*val.reelL++;
				(canal->ptrj.couleur)->c2=0;
				(canal->ptrj.couleur++)->c3=0;
				}
			break;

			}
	break;

	case T_COMPLEXE:
		switch(canal->timage)
			{
			case T_OCTET :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.octet++=(Octet)(val.complexe++)->x;
				}
			break;

			case T_ENTIER :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.entier++=(Entier)(val.complexe++)->x;
				}
			break;

			case T_ENTIERL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.entierL++=(EntierL)(val.complexe++)->x;
				}
			break;
			case T_REEL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.reel++=(Reel)(val.complexe++)->x;
				}
			break;
			case T_REELL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.reelL++=(ReelL)(val.complexe++)->x;
				}
			break;
			case T_COMPLEXE :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.complexe++=*val.complexe++;
				}
			break;
			case T_COMPLEXEL :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.complexeL)->x=(ReelL)(val.complexe)->x;
				(canal->ptrj.complexeL++)->y=(ReelL)(val.complexe++)->y;
				}
			break;
			case T_COULEUR :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.couleur)->c1=(Octet)(val.complexe)->x;
				(canal->ptrj.couleur)->c2=(Octet)(val.complexe++)->y;
				(canal->ptrj.couleur++)->c3=0;
				}
			break;
			case T_VECTEUR2D :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.vecteur2D)->u=(val.complexe)->x;
				(canal->ptrj.vecteur2D++)->v=(val.complexe++)->y;
				}
			break;

			}
	break;

	case T_COMPLEXEL:
		switch(canal->timage)
			{
			case T_OCTET :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.octet++=(Octet)(val.complexeL++)->x;
				}
			break;

			case T_ENTIER :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.entier++=(Entier)(val.complexeL++)->x;
				}
			break;

			case T_ENTIERL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.entierL++=(EntierL)(val.complexeL++)->x;
				}
			break;
			case T_REEL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.reel++=(Reel)(val.complexeL++)->x;
				}
			break;
			case T_REELL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.reelL++=(ReelL)(val.complexeL++)->x;
				}
			break;
			case T_COMPLEXE :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.complexe)->x=(Reel)(val.complexeL)->x;
				(canal->ptrj.complexe++)->y=(Reel)(val.complexeL++)->y;
				}
			break;
			case T_COMPLEXEL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.complexeL++=*val.complexeL++;
				}
			break;
			case T_COULEUR :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.couleur)->c1=(Octet)(val.complexeL)->x;
				(canal->ptrj.couleur)->c2=(Octet)(val.complexeL++)->y;
				(canal->ptrj.couleur++)->c3=0;
				}
			break;
			case T_VECTEUR2D :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.vecteur2D)->u=(Reel)(val.complexe)->x;
				(canal->ptrj.vecteur2D++)->v=(Reel)(val.complexe++)->y;
				}
			break;

			}
	break;

	case T_COULEUR :
		switch(canal->timage)
			{
			case T_OCTET :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.octet++=(Octet)(val.couleur++)->c1;
				}
			break;

			case T_ENTIER :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.entier++=(Entier)(val.couleur++)->c1;
				}
			break;

			case T_ENTIERL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.entierL++=(EntierL)(val.couleur++)->c1;
				}
			break;
			case T_REEL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.reel++=(Reel)(val.couleur++)->c1;
				}
			break;
			case T_REELL :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.reelL++=(ReelL)(val.couleur++)->c1;
				}
			break;
			case T_COMPLEXE :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.complexe)->x=(Reel)(val.couleur)->c1;
				(canal->ptrj.complexe++)->y=(Reel)(val.couleur++)->c2;
				}
			break;
			case T_COMPLEXEL :
				while(canal->j++<jb)
				{
				n++;
				(canal->ptrj.complexeL)->x=(ReelL)(val.couleur)->c1;
				(canal->ptrj.complexeL++)->y=(ReelL)(val.couleur++)->c2;
				}
			break;
			case T_COULEUR :
				while(canal->j++<jb)
				{
				n++;
				*canal->ptrj.couleur++=*(val.couleur++);
				}
			break;

			}
	break;
	}

if(--canal->j==canal->jmax)
	{
	canal->j=0;
	if(++canal->i<canal->imax) canal->ptrj.octet=(canal->ptri++)->octet + canal->orgj;
	}

return(n);
}

