|
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 } |