/RISCOS/Modules/drawfmodule.c

http://unladen-swallow.googlecode.com/ · C · 664 lines · 595 code · 50 blank · 19 comment · 82 complexity · 4d744e4b7ee614767bf4ab432c05654f MD5 · raw file

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