PageRenderTime 526ms CodeModel.GetById 141ms app.highlight 256ms RepoModel.GetById 120ms app.codeStats 1ms

/RISCOS/Modules/drawfmodule.c

http://unladen-swallow.googlecode.com/
C | 664 lines | 595 code | 50 blank | 19 comment | 78 complexity | 4d744e4b7ee614767bf4ab432c05654f MD5 | raw file
  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
 16typedef struct
 17{ PyObject_HEAD
 18  drawfile_diagram *drawf;
 19  int size; /*length in bytes*/
 20  int nobjs;  /* no of objects */
 21} PyDrawFObject;
 22
 23typedef 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
 31static PyObject *DrawFError; /* Exception drawf.error */
 32static os_error *e;
 33static PyTypeObject PyDrawFType;
 34
 35static 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
 42static PyObject *drawf_oserror(void)
 43{ PyErr_SetString(DrawFError,e->errmess);
 44  return 0;
 45}
 46
 47static PyObject *drawf_error(char *s)
 48{ PyErr_SetString(DrawFError,s);
 49  return 0;
 50}
 51
 52/* DrawFile commands */
 53
 54static 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
 69static 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
 76static 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
 89static 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
 96static 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
106static 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
130static 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
139static 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
148static 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
241static 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
279static 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
328static 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
361static 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
390static 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
408static 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
417static 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
428static 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
466static PyObject *DrawF_PathFill(PyDrawFObject *self,PyObject *arg)
467{ return SetWord(self,arg,drawfile_TYPE_PATH,6);
468}
469
470static PyObject *DrawF_PathColour(PyDrawFObject *self,PyObject *arg)
471{ return SetWord(self,arg,drawfile_TYPE_PATH,7);
472}
473
474static PyObject *DrawF_TextColour(PyDrawFObject *self,PyObject *arg)
475{ return SetWord(self,arg,drawfile_TYPE_TEXT,6);
476}
477
478static PyObject *DrawF_TextBackground(PyDrawFObject *self,PyObject *arg)
479{ return SetWord(self,arg,drawfile_TYPE_TEXT,7);
480}
481
482static 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
500static int drawf_len(PyDrawFObject *b)
501{ return b->nobjs;
502}
503
504static 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
523static PyObject *drawf_repeat(PyDrawFObject *b,Py_ssize_t i)
524{ PyErr_SetString(PyExc_IndexError,"drawf repetition not implemented");
525  return NULL;
526}
527
528static 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
549static 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
573static 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
590static 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
595static 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
605static 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
621static void PyDrawF_Dealloc(PyDrawFObject *b)
622{
623    if (b->drawf)
624        ;
625    else
626        PyMem_DEL(b->drawf);
627  PyMem_DEL(b);
628}
629
630static 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
651static PyMethodDef DrawFMethods[]=
652{
653  { "load",DrawF_Load,1},
654  { "new",DrawF_New,1},
655  { NULL,NULL}		 /* Sentinel */
656};
657
658void 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}