#include <draw3.h>
#include <stdio.h>
#include <stdlib.h>

/*************************************************************/
/* Renvoi le numero de type qui correspond a un object draw3 */
uint32 draw3_type(void)
{ static uint32 draw3_type_num = 0;

  if(draw3_type_num == 0)
  {
    draw3_type_num = object_num_new;
  }
  return(draw3_type_num);
}
/*************************************************************/

void draw3_fun1(obj_ofs *this)
{
  /* on utilise aucun attributs, methodes de l'objet => pas de recherche. */
  printf("fun1 surcharge dans draw3\n");
}

void draw3_fun3(obj_ofs *this)
{
  /* on utilise aucun attributs, methodes de l'objet => pas de recherche. */
  printf("fun3\n");
}

void call_draw3_fun3(obj_ofs *this)
{ int i;
  draw3 *vdraw3;

  /* si on veut acceder a un champ de draw3 */
  for(i=0;(this[i].obj_type != 0) && (this[i].obj_type != draw3_type());i++);

  /* on peut meme faire une petite verification dynamique de l'objet      */
  /* pour verifier si cet objet peut bien etre considere comme un "draw3" */
  if(this[i].obj_type == 0)
  {
    fprintf(stderr,"call_draw3_fun3 (draw3.c) : invalide draw3\n");
    exit(2);
  }
  vdraw3 = (draw3 *)this[i].ofs;
  /* on appele la fonction correspondante */
  vdraw3->fun3(this);
}

/* ce que l'on peut voir comme le constructeur de l'objet */
void draw3_init(obj_ofs *this)
{ int i;
  draw1 *vdraw1;
  draw3 *vdraw3;
  
  /* on appele les constructeurs des parents. */
  /* l'ordre est tres important.              */
  object_init(this);
  draw_init(this);
  draw2_init(this); /* la fonction display de draw est surcharge dans draw1  */
                    /* et draw2. Si on initialise draw1 en dernier, c'est la */
                    /* surcharge de draw1 qui gagne. C'est la resolution des */
                    /* conflits par priorite (draw1 prioritaire sur draw2)   */
  draw1_init(this);

  /* si on veut acceder a un champ de draw1 */
  for(i=0;(this[i].obj_type != 0) && (this[i].obj_type != draw1_type());i++);

  /* on peut meme faire une petite verification dynamique de l'objet      */
  /* pour verifier si cet objet peut bien etre considere comme un "draw1" */
  if(this[i].obj_type == 0)
  {
    fprintf(stderr,"draw3_init (draw3.c) : invalide draw1\n");
    exit(2);
  }
  vdraw1 = (draw1 *)this[i].ofs;

  /* si on veut acceder a un champ de draw3 */
  for(i=0;(this[i].obj_type != 0) && (this[i].obj_type != draw3_type());i++);

  /* on peut meme faire une petite verification dynamique de l'objet      */
  /* pour verifier si cet objet peut bien etre considere comme un "draw3" */
  if(this[i].obj_type == 0)
  {
    fprintf(stderr,"draw3_init (draw3.c) : invalide draw3\n");
    exit(2);
  }
  vdraw3 = (draw3 *)this[i].ofs;

  /* on initialise les attributs et les methodes */
  vdraw1->fun1 = draw3_fun1; /* on fait notre surcharge */

  vdraw3->draw3_att = 55;
  vdraw3->fun3 = draw3_fun3;
}

/* la fonction qui permet de creer un nouvel objet draw3 */
obj_ofs *draw3_new(void)
{ obj_ofs *vobj_table;
  pointer mem;

  /* allocation de la memoire pour l'objet */
  if((mem = (pointer)malloc(sizeof(obj_ofs)*6+sizeof(object)+sizeof(draw)+
                            sizeof(draw1)+sizeof(draw2)+sizeof(draw3))) == NULL)
  { perror("malloc failed "); exit(1); }

  /* table des objets */
  vobj_table = (obj_ofs *)mem;

  /* pour la partie uniquement object */
  vobj_table[0].obj_type = object_type();
  vobj_table[0].ofs      = mem + sizeof(obj_ofs)*6;

  /* pour la partie draw "seulement" de l'objet draw3 */
  vobj_table[1].obj_type = draw_type();
  vobj_table[1].ofs      = mem + sizeof(obj_ofs)*6 + sizeof(object);

  /* pour la partie draw1 "seulement" de l'objet draw3 */
  vobj_table[2].obj_type = draw1_type();
  vobj_table[2].ofs      = mem + sizeof(obj_ofs)*6 + sizeof(object) + 
                           sizeof(draw);

  /* pour la partie draw2 "seulement" de l'objet draw3 */
  vobj_table[3].obj_type = draw2_type();
  vobj_table[3].ofs      = mem + sizeof(obj_ofs)*6 + sizeof(object) +
                           sizeof(draw) + sizeof(draw1);

  /* pour la partie draw3 "seulement" de l'objet draw3 */
  vobj_table[4].obj_type = draw3_type();
  vobj_table[4].ofs      = mem + sizeof(obj_ofs)*6 + sizeof(object) +
                           sizeof(draw) + sizeof(draw1) + sizeof(draw2);

  /* le dernier sert a delimiter la table des objets                */
  /* aucun objet n'est identifie par la clee 0 donc pas d'ambiguite */
  vobj_table[5].obj_type = 0;

  /* on fait appel au constructeur de l'objet draw1 */
  draw3_init(vobj_table);

  /* et voila un nouvel objet */
  return(vobj_table);
}