home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 5 / DATAFILE_PDCD5.iso / utilities / p / python / pytexdoc / ext / source / !Python / Modules / c / drawfmodul < prev    next >
Encoding:
Text File  |  1996-02-15  |  15.9 KB  |  595 lines
  1. /* drawf  DrawFile functions */
  2.  
  3. #include "h.os"
  4. #include "h.osfile"
  5. #include "h.drawfile"
  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,int 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)) *pe++=PyInt_AsLong(p);
  203.     else
  204.     { *pe++=PyInt_AsLong(PyTuple_GetItem(p,0));
  205.       *pe++=PyInt_AsLong(PyTuple_GetItem(p,1));
  206.     }
  207.   }
  208.   *pe=draw_END_PATH;
  209.   line_style.join_style=style.flags&3;
  210.   line_style.end_cap_style=(style.flags&3)>>2;
  211.   line_style.start_cap_style=(style.flags&3)>>4;
  212.   line_style.reserved=0;
  213.   line_style.mitre_limit=10;
  214.   line_style.start_cap_width=style.cap_width;
  215.   line_style.end_cap_width=style.cap_width;
  216.   line_style.start_cap_length=style.cap_length;
  217.   line_style.end_cap_length=style.cap_length;
  218.   e=xdraw_process_path(thepath,0x70000000,0,0,width,&line_style,dash_pattern,
  219.   (draw_output_path)((char*)box+0x80000000),0);
  220.   if(e) return drawf_oserror();
  221.   extend(&(diag->bbox),box);
  222.   Py_INCREF(Py_None);return Py_None;
  223. }
  224.  
  225. static PyObject *DrawF_Text(PyDrawFObject *self,PyObject *arg)
  226. { os_colour fill,bg_hint;
  227.   drawfile_text_style style;
  228.   int xsize,ysize,x,y;
  229.   int size,len;
  230.   char *text;
  231.   drawfile_diagram *diag;
  232.   drawfile_object *dobj;
  233.   drawfile_text *dtext;
  234.   os_box *box;
  235.   if(!PyArg_ParseTuple(arg,"(ii)s(iiiii)",&x,&y,&text,
  236.      (int*)&fill,(int*)&bg_hint,(int*)&style,&xsize,&ysize)) return NULL;
  237.   len=strlen(text);
  238.   size=((len+4)&(~3))+52;
  239.   diag=realloc(self->drawf,self->size+size);
  240.   if(!diag) return PyErr_NoMemory();
  241.   self->drawf=diag;
  242.   dobj=(drawfile_object*)((char*)diag+self->size);
  243.   dobj->type=drawfile_TYPE_TEXT;
  244.   dobj->size=size;
  245.   dtext=&dobj->data.text;
  246.   self->size+=size;
  247.   self->nobjs++;
  248.   dtext->fill=fill;
  249.   dtext->bg_hint=bg_hint;
  250.   dtext->style=style;
  251.   dtext->xsize=xsize;
  252.   dtext->ysize=ysize;
  253.   dtext->base.x=x;
  254.   dtext->base.y=y;
  255.   memset(dtext->text,0,(len+4)&(~3));
  256.   sprintf(dtext->text,"%s",text);
  257.   box=&(dtext->bbox);
  258.   box->x0=x;box->y0=y;box->x1=x+len*xsize;box->y1=y+ysize;
  259.   extend(&(diag->bbox),box);
  260.   Py_INCREF(Py_None);return Py_None;
  261. }
  262.  
  263. static PyObject *DrawF_FontTable(PyDrawFObject *self,PyObject *arg)
  264. { int size=8,n=0;
  265.   PyObject *d,*key,*value;
  266.   drawfile_diagram *diag;
  267.   drawfile_object *dobj;
  268.   char *dtable;
  269.   if(!PyArg_ParseTuple(arg,"O!",&PyDict_Type,&d)) return NULL;
  270.   while(PyDict_Next(d,&n,&key,&value))
  271.   { int m=PyString_Size(value);
  272.     if(m<0||!PyInt_Check(key)) return NULL;
  273.     size+=m+2;
  274.   }
  275.   size=(size+3)&(~3);
  276.   diag=realloc(self->drawf,self->size+size);
  277.   if(!diag) return PyErr_NoMemory();
  278.   self->drawf=diag;
  279.   dobj=(drawfile_object*)((char*)diag+self->size);
  280.   dobj->type=drawfile_TYPE_FONT_TABLE;
  281.   dobj->size=size;
  282.   dtable=(char*)(&dobj->data.font_table);
  283.   self->size+=size;
  284.   self->nobjs++;
  285.   memset(dtable,0,size-8);
  286.   n=0;
  287.   while(PyDict_Next(d,&n,&key,&value))
  288.   { int m=PyString_Size(value);
  289.     *dtable=(char)PyInt_AsLong(key);
  290.     strcpy(dtable+1,PyString_AsString(value));
  291.     dtable+=m+2;
  292.   }
  293.   Py_INCREF(Py_None);return Py_None;
  294. }
  295.  
  296. static PyObject *DrawF_Group(PyDrawFObject *self,PyObject *arg)
  297. { int size,n;
  298.   PyDrawFObject *g;
  299.   char *name="";
  300.   drawfile_diagram *diag;
  301.   drawfile_object *dobj;
  302.   drawfile_group *dgroup;
  303.   if(!PyArg_ParseTuple(arg,"O!|s",&PyDrawFType,(PyObject*)&g,&name))
  304.        return NULL;
  305.   size=g->size-4;
  306.   diag=realloc(self->drawf,self->size+size);
  307.   if(!diag) return PyErr_NoMemory();
  308.   self->drawf=diag;
  309.   self->nobjs++;
  310.   dobj=(drawfile_object*)((char*)diag+self->size);
  311.   self->size+=size;
  312.   dobj->type=drawfile_TYPE_GROUP;
  313.   dobj->size=g->size-4;
  314.   dgroup=&dobj->data.group;
  315.   dgroup->bbox=g->drawf->bbox;
  316.   memset(dgroup->name,' ',12);
  317.   n=strlen(name);
  318.   if(n>12) n=12;
  319.   memcpy(dgroup->name,name,n);
  320.   memcpy((char*)dgroup->objects,(char*)g->drawf+40,g->size-40);
  321.   extend(&(diag->bbox),&(dgroup->bbox));
  322.   Py_INCREF(Py_None);return Py_None;
  323. }
  324.  
  325. static PyObject *DrawF_Find(PyDrawFObject *self,PyObject *arg)
  326. { int x,y,n=0;
  327.   int r=-1;
  328.   drawfile_object *d;
  329.   if(!PyArg_ParseTuple(arg,"ii|i",&x,&y,&n)) return NULL;
  330.   if(n<self->nobjs&&n>=0)
  331.   { d=findobj(self,n);
  332.     while(n<self->nobjs)
  333.     { if(x>=d->data.text.bbox.x0&&x<=d->data.text.bbox.x1&&
  334.          y>=d->data.text.bbox.y0&&y<=d->data.text.bbox.y1) { r=n;break;}
  335.       n++;
  336.       d=NEXT(d);
  337.     }
  338.   }
  339.   return PyInt_FromLong(r);
  340. }
  341.  
  342.  
  343. static PyObject *DrawF_Box(PyDrawFObject *self,PyObject *arg)
  344. { int n=-1;
  345.   os_box *box;
  346.   if(!PyArg_ParseTuple(arg,"|i",&n)) return NULL;
  347.   if(n>=self->nobjs|n<0) box=&(self->drawf->bbox);
  348.   else box=&(findobj(self,n)->data.text.bbox);
  349.   return Py_BuildValue("iiii",box->x0,box->y0,box->x1,box->y1);
  350. }
  351.  
  352. static void SetBlock(drawfile_object *d,int size,int type,int offset,int value)
  353. { char *end=(char*)d+size;
  354.   printf("s%d t%d o%d v%d\n",size,type,offset,value);
  355.   for(;(char*)d<end;d=NEXT(d))
  356.     if(d->type==type) ((int*)(d))[offset]=value;
  357.     else if(d->type==drawfile_TYPE_GROUP)
  358.            SetBlock((drawfile_object*)&d->data.group.objects,
  359.                     d->size,type,offset,value);
  360.   printf("SetBlock Done\n");
  361. }
  362.  
  363. static PyObject *SetWord(PyDrawFObject *self,PyObject *arg,int type,int offset)
  364. { int n=PyTuple_Size(arg);
  365.   int m,value,q;
  366.   PyObject *par;
  367.   drawfile_object *e,*d=self->drawf->objects;
  368.   if(n==0) return  drawf_error("Value Required");
  369.   par=PyTuple_GetItem(arg,0);
  370.   if(!PyInt_Check(par))
  371.   { PyErr_SetString(PyExc_TypeError,"Int Required");
  372.     return 0;
  373.   }
  374.   value=(int)PyInt_AsLong(par);
  375.   if(n==1) SetBlock(d,self->size-HDRSIZE,type,offset,value);
  376.   else
  377.   { for(m=1;m<n;m++)
  378.     { par=PyTuple_GetItem(arg,m);
  379.       if(!PyInt_Check(par))
  380.       { PyErr_SetString(PyExc_TypeError,"Int Required");
  381.         return 0;
  382.       }
  383.       q=(int)PyInt_AsLong(par);
  384.       if(q<0||q>=self->nobjs)
  385.       { PyErr_SetString(PyExc_ValueError,"Object out of range");
  386.         return 0;
  387.       }
  388.       e=d;
  389.       for(;q>0;q--) e=NEXT(e);
  390.       if(e->type==type)
  391.       { ((int*)(e))[offset]=value;
  392.       }
  393.       else if(e->type==drawfile_TYPE_GROUP)
  394.              SetBlock((drawfile_object*)&e->data.group.objects,
  395.                       e->size-GRPHDRSIZE,type,offset,value);
  396.     }
  397.   }
  398.   Py_INCREF(Py_None);return Py_None;
  399. }
  400.  
  401. static PyObject *DrawF_PathFill(PyDrawFObject *self,PyObject *arg)
  402. { return SetWord(self,arg,drawfile_TYPE_PATH,6);
  403. }
  404.  
  405. static PyObject *DrawF_PathColour(PyDrawFObject *self,PyObject *arg)
  406. { return SetWord(self,arg,drawfile_TYPE_PATH,7);
  407. }
  408.  
  409. static PyObject *DrawF_TextColour(PyDrawFObject *self,PyObject *arg)
  410. { return SetWord(self,arg,drawfile_TYPE_TEXT,6);
  411. }
  412.  
  413. static PyObject *DrawF_TextBackground(PyDrawFObject *self,PyObject *arg)
  414. { return SetWord(self,arg,drawfile_TYPE_TEXT,7);
  415. }
  416.  
  417. static struct PyMethodDef PyDrawF_Methods[]=
  418. {
  419.   { "render",(PyCFunction)DrawF_Render,1},
  420.   { "save",(PyCFunction)DrawF_Save,1},
  421.   { "path",(PyCFunction)DrawF_Path,1},
  422.   { "text",(PyCFunction)DrawF_Text,1},
  423.   { "fonttable",(PyCFunction)DrawF_FontTable,1},
  424.   { "group",(PyCFunction)DrawF_Group,1},
  425.   { "find",(PyCFunction)DrawF_Find,1},
  426.   { "box",(PyCFunction)DrawF_Box,1},
  427.   { "pathfill",(PyCFunction)DrawF_PathFill,1},
  428.   { "pathcolour",(PyCFunction)DrawF_PathColour,1},
  429.   { "textcolour",(PyCFunction)DrawF_TextColour,1},
  430.   { "textbackground",(PyCFunction)DrawF_TextBackground,1},
  431.   { NULL,NULL}        /* sentinel */
  432. };
  433.  
  434. static int drawf_len(PyDrawFObject *b)
  435. { return b->nobjs;
  436. }
  437.  
  438. static PyObject *drawf_concat(PyDrawFObject *b,PyDrawFObject *c)
  439. { int size=b->size+c->size-2*HDRSIZE;
  440.   PyDrawFObject *p=new(size);
  441.   drawfile_diagram *dd;
  442.   drawfile_object *d;
  443.   int n;
  444.   if(!p) return NULL;
  445.   dd=p->drawf;
  446.   d=(drawfile_object*)((char*)dd+b->size);
  447.   memcpy((char*)dd,(char*)(b->drawf),b->size);
  448.   memcpy(d,(char*)(c->drawf)+HDRSIZE,c->size-HDRSIZE);
  449.   p->nobjs=b->nobjs+c->nobjs;
  450.   for(n=c->nobjs;n>0;n--)
  451.   { extend(&(dd->bbox),&(d->data.path.bbox));
  452.     d=NEXT(d);
  453.   }
  454.   return (PyObject*)p;
  455. }
  456.  
  457. static PyObject *drawf_repeat(PyDrawFObject *b,int i)
  458. { PyErr_SetString(PyExc_IndexError,"drawf repetition not implemented");
  459.   return NULL;
  460. }
  461.  
  462. static PyObject *drawf_item(PyDrawFObject *b,int i)
  463. { PyDrawFObject *c;
  464.   int size;
  465.   drawfile_diagram *dd;
  466.   drawfile_object *d;
  467.   if(i<0||i>=b->nobjs)
  468.   { PyErr_SetString(PyExc_IndexError,"drawf index out of range");
  469.     return NULL;
  470.   }
  471.   d=findobj(b,i);
  472.   size=(char*)findobj(b,i+1)-(char*)d;
  473.   c=new(size);
  474.   if(!c) return NULL;
  475.   dd=c->drawf;
  476.   *((dheader*)dd)=header;
  477.   memcpy(dd->objects,d,size);
  478.   c->nobjs=1;
  479.   extend(&(dd->bbox),&(d->data.path.bbox));
  480.   return (PyObject*)c;
  481. }
  482.  
  483. static PyObject *drawf_slice(PyDrawFObject *b,int i,int j)
  484. { PyDrawFObject *c;
  485.   int size,n;
  486.   drawfile_diagram *dd;
  487.   drawfile_object *d;
  488.   if(i<0||j>b->nobjs)
  489.   { PyErr_SetString(PyExc_IndexError,"drawf index out of range");
  490.     return NULL;
  491.   }
  492.   d=findobj(b,i);
  493.   size=(char*)findobj(b,j)-(char*)d;
  494.   c=new(size);
  495.   if(!c) return NULL;
  496.   dd=c->drawf;
  497.   *((dheader*)dd)=header;
  498.   memcpy(dd->objects,d,size);
  499.   c->nobjs=j-i;
  500.   for(n=j-i;n>0;n--)
  501.   { extend(&(dd->bbox),&(d->data.path.bbox));
  502.     d=NEXT(d);
  503.   }
  504.   return (PyObject*)c;
  505. }
  506.  
  507. static int drawf_ass_item(PyDrawFObject *b,int i,PyObject *v)
  508. { PyErr_SetString(PyExc_IndexError,"drawf ass not implemented");
  509.   return NULL;
  510. }
  511. /*{ if(i<0||4*i>=b->length)
  512.   { PyErr_SetString(PyExc_IndexError,"drawf index out of range");
  513.     return -1;
  514.   }
  515.   if(!PyInt_Check(v))
  516.   { PyErr_SetString(PyExc_TypeError,"drawf item must be integer");
  517.     return -1;
  518.   }
  519.   ((long*)(b->drawf))[i]=PyInt_AsLong(v);
  520.   return 0;
  521. }
  522. */
  523.  
  524. static int drawf_ass_slice(PyDrawFObject *b,int i,int j,PyObject *v)
  525. { PyErr_SetString(PyExc_IndexError,"drawf ass_slice not implemented");
  526.   return NULL;
  527. }
  528.  
  529. static PySequenceMethods drawf_as_sequence=
  530. { (inquiry)drawf_len,
  531.   (binaryfunc)drawf_concat,
  532.   (intargfunc)drawf_repeat,
  533.   (intargfunc)drawf_item,
  534.   (intintargfunc)drawf_slice,
  535.   (intobjargproc)drawf_ass_item,
  536.   (intintobjargproc)drawf_ass_slice,
  537. };
  538.  
  539. static PyObject *PyDrawF_GetAttr(PyDrawFObject *s,char *name)
  540. {
  541.   if (!strcmp(name, "size")) return PyInt_FromLong((long)s->size);
  542.   if (!strcmp(name, "start")) return PyInt_FromLong((long)s->drawf);
  543.   if (!strcmp(name, "__members__"))
  544.   { PyObject *list = PyList_New(2);
  545.     if (list)
  546.     { PyList_SetItem(list, 0, PyString_FromString("size"));
  547.       PyList_SetItem(list, 1, PyString_FromString("start"));
  548.       if (PyErr_Occurred()) { Py_DECREF(list);list = NULL;}
  549.     }
  550.     return list;
  551.   }
  552.   return Py_FindMethod(PyDrawF_Methods, (PyObject*) s,name);
  553. }
  554.  
  555. static void PyDrawF_Dealloc(PyDrawFObject *b)
  556. { PyMem_XDEL(b->drawf);
  557.   PyMem_DEL(b);
  558. }
  559.  
  560. static PyTypeObject PyDrawFType=
  561. { PyObject_HEAD_INIT(&PyType_Type)
  562.   0,                /*ob_size*/
  563.   "drawf",            /*tp_name*/
  564.   sizeof(PyDrawFObject),    /*tp_size*/
  565.   0,                /*tp_itemsize*/
  566.     /* methods */
  567.   (destructor)PyDrawF_Dealloc,    /*tp_dealloc*/
  568.   0,                /*tp_print*/
  569.   (getattrfunc)PyDrawF_GetAttr,    /*tp_getattr*/
  570.   0,                /*tp_setattr*/
  571.   0,                /*tp_compare*/
  572.   0,                /*tp_repr*/
  573.   0,                /*tp_as_number*/
  574.   &drawf_as_sequence,        /*tp_as_sequence*/
  575.   0,                /*tp_as_mapping*/
  576.   0,                            /*tp_hash*/
  577. };
  578.  
  579.  
  580.  
  581. static PyMethodDef DrawFMethods[]=
  582. {
  583.   { "load",DrawF_Load,1},
  584.   { "new",DrawF_New,1},
  585.   { NULL,NULL}         /* Sentinel */
  586. };
  587.  
  588. void initdrawf()
  589. { PyObject *m, *d;
  590.   m = Py_InitModule("drawf", DrawFMethods);
  591.   d = PyModule_GetDict(m);
  592.   DrawFError=PyString_FromString("drawf.error");
  593.   PyDict_SetItemString(d,"error",DrawFError);
  594. }
  595.