symbian-qemu-0.9.1-12/python-2.6.1/RISCOS/Modules/drawfmodule.c
changeset 1 2fb8b9db1c86
equal deleted inserted replaced
0:ffa851df0825 1:2fb8b9db1c86
       
     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 }