RISCOS/Modules/drawfmodule.c

   1 /* drawf  DrawFile functions */
   2
   3 #include "oslib/os.h"
   4 #include "oslib/osfile.h"
   5 #include "oslib/drawfile.h"
   6 #include "Python.h"
   7
   8 #include <limits.h>
   9
  10 #define PyDrawF_Check(op) ((op)->ob_type == &PyDrawFType)
  11 #define HDRSIZE 40
  12 #define GRPHDRSIZE 36
  13 #define DRAWTYPE 0xaff
  14 #define NEXT(d) ((drawfile_object*)((char*)(d)+(d)->size))
  15
  16 typedef struct
  17 { PyObject_HEAD
  18   drawfile_diagram *drawf;
  19   int size; /*length in bytes*/
  20   int nobjs;  /* no of objects */
  21 } PyDrawFObject;
  22
  23 typedef struct dheader
  24 {  char tag [4];
  25    int major_version;
  26    int minor_version;
  27    char source [12];
  28    os_box bbox;
  29 } dheader;
  30
  31 static PyObject *DrawFError; /* Exception drawf.error */
  32 static os_error *e;
  33 static PyTypeObject PyDrawFType;
  34
  35 static dheader header=
  36 { {'D','r','a','w'},
  37   201,0,
  38   {'P','y','t','h','o','n',' ',' ',' ',' ',' ',' '},
  39   {INT_MAX,INT_MAX,INT_MIN,INT_MIN}
  40 };
  41
  42 static PyObject *drawf_oserror(void)
  43 { PyErr_SetString(DrawFError,e->errmess);
  44   return 0;
  45 }
  46
  47 static PyObject *drawf_error(char *s)
  48 { PyErr_SetString(DrawFError,s);
  49   return 0;
  50 }
  51
  52 /* DrawFile commands */
  53
  54 static void countobjs(PyDrawFObject *pd)
  55 { int k=0,q;
  56   drawfile_diagram *dd=pd->drawf;
  57   drawfile_object *d=dd->objects;
  58   char *end=(char*)dd+pd->size;
  59   pd->nobjs=-1;
  60   while((char*)d<end)
  61   { k++;
  62     q=d->size;
  63     if(q<=0||q&3) return ;
  64     d=NEXT(d);
  65   }
  66   if ((char*)d==end) pd->nobjs=k;
  67 }
  68
  69 static drawfile_object *findobj(PyDrawFObject *pd,Py_ssize_t n)
  70 { drawfile_diagram *dd=pd->drawf;
  71   drawfile_object *d=dd->objects;
  72   for(;n>0;n--) d=NEXT(d);
  73   return d;
  74 }
  75
  76 static PyDrawFObject* new(int size)
  77 { PyDrawFObject *b=PyObject_NEW(PyDrawFObject,&PyDrawFType);
  78   if(!b) return NULL;
  79   size+=HDRSIZE;
  80   b->drawf=malloc(size);
  81   if(!b->drawf)
  82   { Py_DECREF(b);
  83     return (PyDrawFObject*)PyErr_NoMemory();
  84   }
  85   b->size=size;
  86   return b;
  87 }
  88
  89 static void extend(os_box *b,os_box *c)
  90 { if(b->x0>c->x0) b->x0=c->x0;
  91   if(b->y0>c->y0) b->y0=c->y0;
  92   if(b->x1<c->x1) b->x1=c->x1;
  93   if(b->y1<c->y1) b->y1=c->y1;
  94 }
  95
  96 static PyObject *DrawF_New(PyObject *self,PyObject *args)
  97 { PyDrawFObject *b;
  98   if(!PyArg_ParseTuple(args,"")) return NULL;
  99   b=new(0);
 100   if(!b) return NULL;
 101   *((dheader*)b->drawf)=header;
 102   b->nobjs=0;
 103   return (PyObject *)b;
 104 }
 105
 106 static PyObject *DrawF_Load(PyObject *self,PyObject *args)
 107 { int size;
 108   char *fname;
 109   PyDrawFObject *b;
 110   fileswitch_object_type ot;
 111   if(!PyArg_ParseTuple(args,"s",&fname)) return NULL;
 112   e=xosfile_read_no_path(fname,&ot,0,0,&size,0);
 113   if(e) return drawf_oserror();
 114   size-=HDRSIZE;
 115   if(ot!=osfile_IS_FILE||size<0||size&3) return drawf_error("Bad draw file");
 116   b=new(size);
 117   if(!b) return NULL;
 118   e=xosfile_load_stamped_no_path(fname,(byte*)(b->drawf),0,0,0,0,0);
 119   if(e)
 120   { Py_DECREF(b);
 121     return drawf_oserror();
 122   }
 123   countobjs(b);
 124   if(b->nobjs>=0) return (PyObject *)b;
 125   Py_DECREF(b);
 126   return drawf_error("Corrupt draw file");
 127 }
 128
 129
 130 static PyObject *DrawF_Save(PyDrawFObject *self,PyObject *arg)
 131 { char *fname;
 132   if(!PyArg_ParseTuple(arg,"s",&fname)) return NULL;
 133   e=xosfile_save_stamped(fname,DRAWTYPE,
 134   (byte*)(self->drawf),(byte*)(self->drawf)+self->size);
 135   if (e) return drawf_oserror();
 136   Py_INCREF(Py_None);return Py_None;
 137 }
 138
 139 static PyObject *DrawF_Render(PyDrawFObject *self,PyObject *arg)
 140 { int flags,trans,clip,flat;
 141   if(!PyArg_ParseTuple(arg,"iiii",&flags,&trans,&clip,&flat)) return NULL;
 142   e=xdrawfile_render((drawfile_render_flags)flags,self->drawf,self->size,
 143   (os_trfm*)trans,(os_box*)clip,flat);
 144   if(e) return drawf_oserror();
 145   Py_INCREF(Py_None);return Py_None;
 146 }
 147
 148 static PyObject *DrawF_Path(PyDrawFObject *self,PyObject *arg)
 149 { PyObject *pl;
 150   PyObject *dp=0;
 151   os_colour fill;
 152   os_colour outline;
 153   int width,start=0;
 154   drawfile_path_style style;
 155   int size=40;
 156   int n,i,element_count;
 157   drawfile_diagram *diag;
 158   drawfile_object *dobj;
 159   drawfile_path *dpath;
 160   draw_path *thepath;
 161   draw_line_style line_style;
 162   draw_dash_pattern *dash_pattern=0;
 163   os_box *box;
 164   long *pe;
 165   if(!PyArg_ParseTuple(arg,"O!(iiii)|O!i",&PyList_Type,&pl,(int*)&fill,
 166      (int*)&outline,&width,(int*)&style,&PyTuple_Type,&dp,&start)) return NULL;
 167   if(dp)
 168   { element_count=PyTuple_Size(dp);
 169     size+=4*element_count+8;
 170     style.flags|=drawfile_PATH_DASHED;
 171   }
 172   else style.flags&=~drawfile_PATH_DASHED;
 173   n=PyList_Size(pl);
 174   size+=4*n+8;
 175   for(i=0;i<n;i++) if(!PyInt_Check(PyList_GetItem(pl,i))) size+=4;
 176   diag=realloc(self->drawf,self->size+size);
 177   if(!diag) return PyErr_NoMemory();
 178   self->drawf=diag;
 179   dobj=(drawfile_object*)((char*)diag+self->size);
 180   dobj->type=drawfile_TYPE_PATH;
 181   dobj->size=size;
 182   dpath=&dobj->data.path;
 183   self->size+=size;
 184   self->nobjs++;
 185   box=&dpath->bbox;
 186   dpath->fill=fill;dpath->outline=outline;
 187   dpath->width=width;dpath->style=style;
 188   pe=(long*)&(dpath->path);
 189   if(dp)
 190   { dash_pattern=&(((drawfile_path_with_pattern*)dpath)->pattern);
 191     dash_pattern->start=start;
 192     dash_pattern->element_count=element_count;
 193     for(i=0;i<element_count;i++)
 194     { dash_pattern->elements[i]=(int)PyInt_AsLong(PyTuple_GetItem(dp,i));
 195     }
 196     pe+=element_count+2;
 197   }
 198   thepath=(draw_path*)pe;
 199   *pe++=draw_MOVE_TO;
 200   for(i=0;i<n;i++)
 201   { PyObject *p=PyList_GetItem(pl,i);
 202     if(PyInt_Check(p))
 203       *pe++=PyInt_AsLong(p);
 204     else
 205     {
 206       *pe++=PyInt_AsLong(PyTuple_GetItem(p,0));
 207       *pe++=PyInt_AsLong(PyTuple_GetItem(p,1));
 208     }
 209   }
 210   *pe=draw_END_PATH;
 211   line_style.join_style=style.flags&3;
 212   line_style.end_cap_style=(style.flags&3)>>2;
 213   line_style.start_cap_style=(style.flags&3)>>4;
 214   line_style.reserved=0;
 215   line_style.mitre_limit=10;
 216   line_style.start_cap_width=style.cap_width;
 217   line_style.end_cap_width=style.cap_width;
 218   line_style.start_cap_length=style.cap_length;
 219   line_style.end_cap_length=style.cap_length;
 220   e=xdraw_process_path(thepath,0x70000000,0,0,width,&line_style,dash_pattern,
 221   (draw_output_path)((char*)box+0x80000000),0);
 222   if(e) return drawf_oserror();
 223
 224   /* draw_process_path seems to have a bug:
 225      If the bounding box size is zero, it returns 0x7FFFFFFF, ..., 0x80000000 instead of the
 226      correct size. */
 227   if (box->x0==0x7FFFFFFF)
 228   {
 229       /* path has zero extension, so forget it; it would be invisible anyway */
 230       self->size-=size;
 231       self->nobjs--;
 232       diag=realloc(self->drawf,self->size);
 233       if(!diag) return PyErr_NoMemory();
 234       self->drawf=diag;
 235   }
 236   else
 237       extend(&(diag->bbox),box);
 238   Py_INCREF(Py_None);return Py_None;
 239 }
 240
 241 static PyObject *DrawF_Text(PyDrawFObject *self,PyObject *arg)
 242 { os_colour fill,bg_hint;
 243   drawfile_text_style style;
 244   int xsize,ysize,x,y;
 245   int size,len;
 246   char *text;
 247   drawfile_diagram *diag;
 248   drawfile_object *dobj;
 249   drawfile_text *dtext;
 250   os_box *box;
 251   if(!PyArg_ParseTuple(arg,"(ii)s(iiiii)",&x,&y,&text,
 252      (int*)&fill,(int*)&bg_hint,(int*)&style,&xsize,&ysize)) return NULL;
 253   len=strlen(text);
 254   size=((len+4)&(~3))+52;
 255   diag=realloc(self->drawf,self->size+size);
 256   if(!diag) return PyErr_NoMemory();
 257   self->drawf=diag;
 258   dobj=(drawfile_object*)((char*)diag+self->size);
 259   dobj->type=drawfile_TYPE_TEXT;
 260   dobj->size=size;
 261   dtext=&dobj->data.text;
 262   self->size+=size;
 263   self->nobjs++;
 264   dtext->fill=fill;
 265   dtext->bg_hint=bg_hint;
 266   dtext->style=style;
 267   dtext->xsize=xsize;
 268   dtext->ysize=ysize;
 269   dtext->base.x=x;
 270   dtext->base.y=y;
 271   memset(dtext->text,0,(len+4)&(~3));
 272   sprintf(dtext->text,"%s",text);
 273   box=&(dtext->bbox);
 274   box->x0=x;box->y0=y;box->x1=x+len*xsize;box->y1=y+ysize;
 275   extend(&(diag->bbox),box);
 276   Py_INCREF(Py_None);return Py_None;
 277 }
 278
 279 static PyObject *DrawF_TText(PyDrawFObject *self,PyObject *arg)
 280 { os_colour fill,bg_hint;
 281   drawfile_text_style style;
 282   int xsize,ysize,x,y;
 283   int t1,t2,t3,t4,t5,t6;
 284   int size,len;
 285   char *text;
 286   drawfile_diagram *diag;
 287   drawfile_object *dobj;
 288   drawfile_trfm_text *dtext;
 289   os_box *box;
 290   t1=1<<16;t2=0;
 291   t3=0;t4=1<<16;
 292   t5=t6=0;
 293   if(!PyArg_ParseTuple(arg,"(ii)s(iiiii)|(iiiiii)",&x,&y,&text,
 294      (int*)&fill,(int*)&bg_hint,(int*)&style,&xsize,&ysize,&t1,&t2,&t3,&t4,&t5,&t6)) return NULL;
 295   len=strlen(text);
 296   size=((len+4)&(~3))+52+28;
 297   diag=realloc(self->drawf,self->size+size);
 298   if(!diag) return PyErr_NoMemory();
 299   self->drawf=diag;
 300   dobj=(drawfile_object*)((char*)diag+self->size);
 301   dobj->type=drawfile_TYPE_TRFM_TEXT;
 302   dobj->size=size;
 303   dtext=&dobj->data.trfm_text;
 304   self->size+=size;
 305   self->nobjs++;
 306   dtext->trfm.entries[0][0]=t1;
 307   dtext->trfm.entries[0][1]=t2;
 308   dtext->trfm.entries[1][0]=t3;
 309   dtext->trfm.entries[1][1]=t4;
 310   dtext->trfm.entries[2][0]=t5;
 311   dtext->trfm.entries[2][1]=t6;
 312   dtext->flags=0;
 313   dtext->fill=fill;
 314   dtext->bg_hint=bg_hint;
 315   dtext->style=style;
 316   dtext->xsize=xsize;
 317   dtext->ysize=ysize;
 318   dtext->base.x=x;
 319   dtext->base.y=y;
 320   memset(dtext->text,0,(len+4)&(~3));
 321   sprintf(dtext->text,"%s",text);
 322   box=&(dtext->bbox);
 323   box->x0=x;box->y0=y;box->x1=x+len*xsize;box->y1=y+ysize;
 324   extend(&(diag->bbox),box);
 325   Py_INCREF(Py_None);return Py_None;
 326 }
 327
 328 static PyObject *DrawF_FontTable(PyDrawFObject *self,PyObject *arg)
 329 { int size=8,n=0;
 330   PyObject *d,*key,*value;
 331   drawfile_diagram *diag;
 332   drawfile_object *dobj;
 333   char *dtable;
 334   if(!PyArg_ParseTuple(arg,"O!",&PyDict_Type,&d)) return NULL;
 335   while(PyDict_Next(d,&n,&key,&value))
 336   { int m=PyString_Size(value);
 337     if(m<0||!PyInt_Check(key)) return NULL;
 338     size+=m+2;
 339   }
 340   size=(size+3)&(~3);
 341   diag=realloc(self->drawf,self->size+size);
 342   if(!diag) return PyErr_NoMemory();
 343   self->drawf=diag;
 344   dobj=(drawfile_object*)((char*)diag+self->size);
 345   dobj->type=drawfile_TYPE_FONT_TABLE;
 346   dobj->size=size;
 347   dtable=(char*)(&dobj->data.font_table);
 348   self->size+=size;
 349   self->nobjs++;
 350   memset(dtable,0,size-8);
 351   n=0;
 352   while(PyDict_Next(d,&n,&key,&value))
 353   { int m=PyString_Size(value);
 354     *dtable=(char)PyInt_AsLong(key);
 355     strcpy(dtable+1,PyString_AsString(value));
 356     dtable+=m+2;
 357   }
 358   Py_INCREF(Py_None);return Py_None;
 359 }
 360
 361 static PyObject *DrawF_Group(PyDrawFObject *self,PyObject *arg)
 362 { int size,n;
 363   PyDrawFObject *g;
 364   char *name="";
 365   drawfile_diagram *diag;
 366   drawfile_object *dobj;
 367   drawfile_group *dgroup;
 368   if(!PyArg_ParseTuple(arg,"O!|s",&PyDrawFType,(PyObject*)&g,&name))
 369        return NULL;
 370   size=g->size-4;
 371   diag=realloc(self->drawf,self->size+size);
 372   if(!diag) return PyErr_NoMemory();
 373   self->drawf=diag;
 374   self->nobjs++;
 375   dobj=(drawfile_object*)((char*)diag+self->size);
 376   self->size+=size;
 377   dobj->type=drawfile_TYPE_GROUP;
 378   dobj->size=g->size-4;
 379   dgroup=&dobj->data.group;
 380   dgroup->bbox=g->drawf->bbox;
 381   memset(dgroup->name,' ',12);
 382   n=strlen(name);
 383   if(n>12) n=12;
 384   memcpy(dgroup->name,name,n);
 385   memcpy((char*)dgroup->objects,(char*)g->drawf+40,g->size-40);
 386   extend(&(diag->bbox),&(dgroup->bbox));
 387   Py_INCREF(Py_None);return Py_None;
 388 }
 389
 390 static PyObject *DrawF_Find(PyDrawFObject *self,PyObject *arg)
 391 { int x,y,n=0;
 392   int r=-1;
 393   drawfile_object *d;
 394   if(!PyArg_ParseTuple(arg,"ii|i",&x,&y,&n)) return NULL;
 395   if(n<self->nobjs&&n>=0)
 396   { d=findobj(self,n);
 397     while(n<self->nobjs)
 398     { if(x>=d->data.text.bbox.x0&&x<=d->data.text.bbox.x1&&
 399          y>=d->data.text.bbox.y0&&y<=d->data.text.bbox.y1) { r=n;break;}
 400       n++;
 401       d=NEXT(d);
 402     }
 403   }
 404   return PyInt_FromLong(r);
 405 }
 406
 407
 408 static PyObject *DrawF_Box(PyDrawFObject *self,PyObject *arg)
 409 { int n=-1;
 410   os_box *box;
 411   if(!PyArg_ParseTuple(arg,"|i",&n)) return NULL;
 412   if(n>=self->nobjs|n<0) box=&(self->drawf->bbox);
 413   else box=&(findobj(self,n)->data.text.bbox);
 414   return Py_BuildValue("iiii",box->x0,box->y0,box->x1,box->y1);
 415 }
 416
 417 static void SetBlock(drawfile_object *d,int size,int type,int offset,int value)
 418 { char *end=(char*)d+size;
 419   printf("s%d t%d o%d v%d\n",size,type,offset,value);
 420   for(;(char*)d<end;d=NEXT(d))
 421     if(d->type==type) ((int*)(d))[offset]=value;
 422     else if(d->type==drawfile_TYPE_GROUP)
 423            SetBlock((drawfile_object*)&d->data.group.objects,
 424                     d->size,type,offset,value);
 425   printf("SetBlock Done\n");
 426 }
 427
 428 static PyObject *SetWord(PyDrawFObject *self,PyObject *arg,int type,int offset)
 429 { int n=PyTuple_Size(arg);
 430   int m,value,q;
 431   PyObject *par;
 432   drawfile_object *e,*d=self->drawf->objects;
 433   if(n==0) return  drawf_error("Value Required");
 434   par=PyTuple_GetItem(arg,0);
 435   if(!PyInt_Check(par))
 436   { PyErr_SetString(PyExc_TypeError,"Int Required");
 437     return 0;
 438   }
 439   value=(int)PyInt_AsLong(par);
 440   if(n==1) SetBlock(d,self->size-HDRSIZE,type,offset,value);
 441   else
 442   { for(m=1;m<n;m++)
 443     { par=PyTuple_GetItem(arg,m);
 444       if(!PyInt_Check(par))
 445       { PyErr_SetString(PyExc_TypeError,"Int Required");
 446         return 0;
 447       }
 448       q=(int)PyInt_AsLong(par);
 449       if(q<0||q>=self->nobjs)
 450       { PyErr_SetString(PyExc_ValueError,"Object out of range");
 451         return 0;
 452       }
 453       e=d;
 454       for(;q>0;q--) e=NEXT(e);
 455       if(e->type==type)
 456       { ((int*)(e))[offset]=value;
 457       }
 458       else if(e->type==drawfile_TYPE_GROUP)
 459              SetBlock((drawfile_object*)&e->data.group.objects,
 460                       e->size-GRPHDRSIZE,type,offset,value);
 461     }
 462   }
 463   Py_INCREF(Py_None);return Py_None;
 464 }
 465
 466 static PyObject *DrawF_PathFill(PyDrawFObject *self,PyObject *arg)
 467 { return SetWord(self,arg,drawfile_TYPE_PATH,6);
 468 }
 469
 470 static PyObject *DrawF_PathColour(PyDrawFObject *self,PyObject *arg)
 471 { return SetWord(self,arg,drawfile_TYPE_PATH,7);
 472 }
 473
 474 static PyObject *DrawF_TextColour(PyDrawFObject *self,PyObject *arg)
 475 { return SetWord(self,arg,drawfile_TYPE_TEXT,6);
 476 }
 477
 478 static PyObject *DrawF_TextBackground(PyDrawFObject *self,PyObject *arg)
 479 { return SetWord(self,arg,drawfile_TYPE_TEXT,7);
 480 }
 481
 482 static struct PyMethodDef PyDrawF_Methods[]=
 483 {
 484   { "render",(PyCFunction)DrawF_Render,1},
 485   { "save",(PyCFunction)DrawF_Save,1},
 486   { "path",(PyCFunction)DrawF_Path,1},
 487   { "text",(PyCFunction)DrawF_Text,1},
 488   { "ttext",(PyCFunction)DrawF_TText,1},
 489   { "fonttable",(PyCFunction)DrawF_FontTable,1},
 490   { "group",(PyCFunction)DrawF_Group,1},
 491   { "find",(PyCFunction)DrawF_Find,1},
 492   { "box",(PyCFunction)DrawF_Box,1},
 493   { "pathfill",(PyCFunction)DrawF_PathFill,1},
 494   { "pathcolour",(PyCFunction)DrawF_PathColour,1},
 495   { "textcolour",(PyCFunction)DrawF_TextColour,1},
 496   { "textbackground",(PyCFunction)DrawF_TextBackground,1},
 497   { NULL,NULL}          /* sentinel */
 498 };
 499
 500 static int drawf_len(PyDrawFObject *b)
 501 { return b->nobjs;
 502 }
 503
 504 static PyObject *drawf_concat(PyDrawFObject *b,PyDrawFObject *c)
 505 { int size=b->size+c->size-2*HDRSIZE;
 506   PyDrawFObject *p=new(size);
 507   drawfile_diagram *dd;
 508   drawfile_object *d;
 509   int n;
 510   if(!p) return NULL;
 511   dd=p->drawf;
 512   d=(drawfile_object*)((char*)dd+b->size);
 513   memcpy((char*)dd,(char*)(b->drawf),b->size);
 514   memcpy(d,(char*)(c->drawf)+HDRSIZE,c->size-HDRSIZE);
 515   p->nobjs=b->nobjs+c->nobjs;
 516   for(n=c->nobjs;n>0;n--)
 517   { extend(&(dd->bbox),&(d->data.path.bbox));
 518     d=NEXT(d);
 519   }
 520   return (PyObject*)p;
 521 }
 522
 523 static PyObject *drawf_repeat(PyDrawFObject *b,Py_ssize_t i)
 524 { PyErr_SetString(PyExc_IndexError,"drawf repetition not implemented");
 525   return NULL;
 526 }
 527
 528 static PyObject *drawf_item(PyDrawFObject *b,Py_ssize_t i)
 529 { PyDrawFObject *c;
 530   Py_ssize_t size;
 531   drawfile_diagram *dd;
 532   drawfile_object *d;
 533   if(i<0||i>=b->nobjs)
 534   { PyErr_SetString(PyExc_IndexError,"drawf index out of range");
 535     return NULL;
 536   }
 537   d=findobj(b,i);
 538   size=(char*)findobj(b,i+1)-(char*)d;
 539   c=new(size);
 540   if(!c) return NULL;
 541   dd=c->drawf;
 542   *((dheader*)dd)=header;
 543   memcpy(dd->objects,d,size);
 544   c->nobjs=1;
 545   extend(&(dd->bbox),&(d->data.path.bbox));
 546   return (PyObject*)c;
 547 }
 548
 549 static PyObject *drawf_slice(PyDrawFObject *b,Py_ssize_t i,Py_ssize_t j)
 550 { PyDrawFObject *c;
 551   Py_ssize_t size,n;
 552   drawfile_diagram *dd;
 553   drawfile_object *d;
 554   if(i<0||j>b->nobjs)
 555   { PyErr_SetString(PyExc_IndexError,"drawf index out of range");
 556     return NULL;
 557   }
 558   d=findobj(b,i);
 559   size=(char*)findobj(b,j)-(char*)d;
 560   c=new(size);
 561   if(!c) return NULL;
 562   dd=c->drawf;
 563   *((dheader*)dd)=header;
 564   memcpy(dd->objects,d,size);
 565   c->nobjs=j-i;
 566   for(n=j-i;n>0;n--)
 567   { extend(&(dd->bbox),&(d->data.path.bbox));
 568     d=NEXT(d);
 569   }
 570   return (PyObject*)c;
 571 }
 572
 573 static int drawf_ass_item(PyDrawFObject *b,Py_ssize_t i,PyObject *v)
 574 { PyErr_SetString(PyExc_IndexError,"drawf ass not implemented");
 575   return NULL;
 576 }
 577 /*{ if(i<0||4*i>=b->length)
 578   { PyErr_SetString(PyExc_IndexError,"drawf index out of range");
 579     return -1;
 580   }
 581   if(!PyInt_Check(v))
 582   { PyErr_SetString(PyExc_TypeError,"drawf item must be integer");
 583     return -1;
 584   }
 585   ((long*)(b->drawf))[i]=PyInt_AsLong(v);
 586   return 0;
 587 }
 588 */
 589
 590 static int drawf_ass_slice(PyDrawFObject *b,Py_ssize_t i,Py_ssize_t j,PyObject *v)
 591 { PyErr_SetString(PyExc_IndexError,"drawf ass_slice not implemented");
 592   return NULL;
 593 }
 594
 595 static PySequenceMethods drawf_as_sequence=
 596 { (inquiry)drawf_len,
 597   (binaryfunc)drawf_concat,
 598   (ssizeargfunc)drawf_repeat,
 599   (ssizeargfunc)drawf_item,
 600   (ssizessizeargfunc)drawf_slice,
 601   (ssizeobjargproc)drawf_ass_item,
 602   (ssizessizeobjargproc)drawf_ass_slice,
 603 };
 604
 605 static PyObject *PyDrawF_GetAttr(PyDrawFObject *s,char *name)
 606 {
 607   if (!strcmp(name, "size")) return PyInt_FromLong((long)s->size);
 608   if (!strcmp(name, "start")) return PyInt_FromLong((long)s->drawf);
 609   if (!strcmp(name, "__members__"))
 610   { PyObject *list = PyList_New(2);
 611     if (list)
 612     { PyList_SetItem(list, 0, PyString_FromString("size"));
 613       PyList_SetItem(list, 1, PyString_FromString("start"));
 614       if (PyErr_Occurred()) { Py_DECREF(list);list = NULL;}
 615     }
 616     return list;
 617   }
 618   return Py_FindMethod(PyDrawF_Methods, (PyObject*) s,name);
 619 }
 620
 621 static void PyDrawF_Dealloc(PyDrawFObject *b)
 622 {
 623     if (b->drawf)
 624         ;
 625     else
 626         PyMem_DEL(b->drawf);
 627   PyMem_DEL(b);
 628 }
 629
 630 static PyTypeObject PyDrawFType=
 631 { PyObject_HEAD_INIT(&PyType_Type)
 632   0,                            /*ob_size*/
 633   "drawf",                      /*tp_name*/
 634   sizeof(PyDrawFObject),        /*tp_size*/
 635   0,                            /*tp_itemsize*/
 636         /* methods */
 637   (destructor)PyDrawF_Dealloc,  /*tp_dealloc*/
 638   0,                            /*tp_print*/
 639   (getattrfunc)PyDrawF_GetAttr, /*tp_getattr*/
 640   0,                            /*tp_setattr*/
 641   0,                            /*tp_compare*/
 642   0,                            /*tp_repr*/
 643   0,                            /*tp_as_number*/
 644   &drawf_as_sequence,           /*tp_as_sequence*/
 645   0,                            /*tp_as_mapping*/
 646   0,                            /*tp_hash*/
 647 };
 648
 649
 650
 651 static PyMethodDef DrawFMethods[]=
 652 {
 653   { "load",DrawF_Load,1},
 654   { "new",DrawF_New,1},
 655   { NULL,NULL}           /* Sentinel */
 656 };
 657
 658 void initdrawf()
 659 { PyObject *m, *d;
 660   m = Py_InitModule("drawf", DrawFMethods);
 661   d = PyModule_GetDict(m);
 662   DrawFError=PyString_FromString("drawf.error");
 663   PyDict_SetItemString(d,"error",DrawFError);
 664 }