init.c 9.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468
  1. #include <u.h>
  2. #include <libc.h>
  3. #include <draw.h>
  4. Display *display;
  5. Font *font;
  6. Image *screen;
  7. int _drawdebug = 0;
  8. static char deffontname[] = "*default*";
  9. Screen *_screen;
  10. int debuglockdisplay = 0;
  11. static void _closedisplay(Display*, int);
  12. /* note handler */
  13. static void
  14. drawshutdown(void)
  15. {
  16. Display *d;
  17. d = display;
  18. if(d){
  19. display = nil;
  20. _closedisplay(d, 1);
  21. }
  22. }
  23. int
  24. geninitdraw(char *devdir, void(*error)(Display*, char*), char *fontname, char *label, char *windir, int ref)
  25. {
  26. int fd, n;
  27. Subfont *df;
  28. char buf[128];
  29. display = initdisplay(devdir, windir, error);
  30. if(display == nil)
  31. return -1;
  32. /*
  33. * Set up default font
  34. */
  35. df = getdefont(display);
  36. display->defaultsubfont = df;
  37. if(df == nil){
  38. fprint(2, "imageinit: can't open default subfont: %r\n");
  39. Error:
  40. closedisplay(display);
  41. display = nil;
  42. return -1;
  43. }
  44. if(fontname == nil){
  45. fd = open("/env/font", OREAD);
  46. if(fd >= 0){
  47. n = read(fd, buf, sizeof(buf));
  48. if(n>0 && n<sizeof buf-1){
  49. buf[n] = 0;
  50. fontname = buf;
  51. }
  52. close(fd);
  53. }
  54. }
  55. /*
  56. * Build fonts with caches==depth of screen, for speed.
  57. * If conversion were faster, we'd use 0 and save memory.
  58. */
  59. if(fontname == nil){
  60. snprint(buf, sizeof buf, "%d %d\n0 %d\t%s\n", df->height, df->ascent,
  61. df->n-1, deffontname);
  62. //BUG: Need something better for this installsubfont("*default*", df);
  63. font = buildfont(display, buf, deffontname);
  64. if(font == nil){
  65. fprint(2, "imageinit: can't open default font: %r\n");
  66. goto Error;
  67. }
  68. }else{
  69. font = openfont(display, fontname); /* BUG: grey fonts */
  70. if(font == nil){
  71. fprint(2, "imageinit: can't open font %s: %r\n", fontname);
  72. goto Error;
  73. }
  74. }
  75. display->defaultfont = font;
  76. /*
  77. * Write label; ignore errors (we might not be running under rio)
  78. */
  79. if(label){
  80. snprint(buf, sizeof buf, "%s/label", display->windir);
  81. fd = open(buf, OREAD);
  82. if(fd >= 0){
  83. read(fd, display->oldlabel, (sizeof display->oldlabel)-1);
  84. close(fd);
  85. fd = create(buf, OWRITE, 0666);
  86. if(fd >= 0){
  87. write(fd, label, strlen(label));
  88. close(fd);
  89. }
  90. }
  91. }
  92. snprint(buf, sizeof buf, "%s/winname", display->windir);
  93. if(gengetwindow(display, buf, &screen, &_screen, ref) < 0)
  94. goto Error;
  95. atexit(drawshutdown);
  96. return 1;
  97. }
  98. int
  99. initdraw(void(*error)(Display*, char*), char *fontname , char *label)
  100. {
  101. char *dev = "/dev";
  102. if(access("/dev/draw/new", AEXIST)<0 && bind("#i", "/dev", MAFTER)<0){
  103. fprint(2, "imageinit: can't bind /dev/draw: %r\n");
  104. return -1;
  105. }
  106. return geninitdraw(dev, error, fontname, label, dev, Refnone);
  107. }
  108. /*
  109. * Attach, or possibly reattach, to window.
  110. * If reattaching, maintain value of screen pointer.
  111. */
  112. int
  113. gengetwindow(Display *d, char *winname, Image **winp, Screen **scrp, int ref)
  114. {
  115. int n, fd;
  116. char buf[64+1];
  117. Image *image;
  118. Rectangle r;
  119. fd = open(winname, OREAD);
  120. if(fd<0 || (n=read(fd, buf, sizeof buf-1))<=0){
  121. if((image=d->image) == nil){
  122. fprint(2, "gengetwindow: %r\n");
  123. *winp = nil;
  124. d->screenimage = nil;
  125. return -1;
  126. }
  127. strcpy(buf, "noborder");
  128. }else{
  129. close(fd);
  130. buf[n] = '\0';
  131. if(*winp != nil){
  132. _freeimage1(*winp);
  133. freeimage((*scrp)->image);
  134. freescreen(*scrp);
  135. *scrp = nil;
  136. }
  137. image = namedimage(d, buf);
  138. if(image == 0){
  139. fprint(2, "namedimage %s failed: %r\n", buf);
  140. *winp = nil;
  141. d->screenimage = nil;
  142. return -1;
  143. }
  144. assert(image->chan != 0);
  145. }
  146. d->screenimage = image;
  147. *scrp = allocscreen(image, d->white, 0);
  148. if(*scrp == nil){
  149. freeimage(d->screenimage);
  150. *winp = nil;
  151. d->screenimage = nil;
  152. return -1;
  153. }
  154. r = image->r;
  155. if(strncmp(buf, "noborder", 8) != 0)
  156. r = insetrect(image->r, Borderwidth);
  157. *winp = _allocwindow(*winp, *scrp, r, ref, DWhite);
  158. if(*winp == nil){
  159. freescreen(*scrp);
  160. *scrp = nil;
  161. freeimage(image);
  162. d->screenimage = nil;
  163. return -1;
  164. }
  165. d->screenimage = *winp;
  166. assert((*winp)->chan != 0);
  167. return 1;
  168. }
  169. int
  170. getwindow(Display *d, int ref)
  171. {
  172. char winname[128];
  173. snprint(winname, sizeof winname, "%s/winname", d->windir);
  174. return gengetwindow(d, winname, &screen, &_screen, ref);
  175. }
  176. #define NINFO 12*12
  177. Display*
  178. initdisplay(char *dev, char *win, void(*error)(Display*, char*))
  179. {
  180. char buf[NINFO+1], info[NINFO+1], *t, isnew;
  181. int n, datafd, ctlfd, reffd;
  182. Display *disp;
  183. Dir *dir;
  184. Image *image;
  185. fmtinstall('P', Pfmt);
  186. fmtinstall('R', Rfmt);
  187. if(dev == 0)
  188. dev = "/dev";
  189. if(win == 0)
  190. win = "/dev";
  191. if(strlen(dev)>sizeof buf-25 || strlen(win)>sizeof buf-25){
  192. werrstr("initdisplay: directory name too long");
  193. return nil;
  194. }
  195. t = strdup(win);
  196. if(t == nil)
  197. return nil;
  198. sprint(buf, "%s/draw/new", dev);
  199. ctlfd = open(buf, ORDWR|OCEXEC);
  200. if(ctlfd < 0){
  201. if(bind("#i", dev, MAFTER) < 0){
  202. Error1:
  203. free(t);
  204. werrstr("initdisplay: %s: %r", buf);
  205. return 0;
  206. }
  207. ctlfd = open(buf, ORDWR|OCEXEC);
  208. }
  209. if(ctlfd < 0)
  210. goto Error1;
  211. if((n=read(ctlfd, info, sizeof info)) < 12){
  212. Error2:
  213. close(ctlfd);
  214. goto Error1;
  215. }
  216. if(n==NINFO+1)
  217. n = NINFO;
  218. buf[n] = '\0';
  219. isnew = 0;
  220. if(n < NINFO) /* this will do for now, we need something better here */
  221. isnew = 1;
  222. sprint(buf, "%s/draw/%d/data", dev, atoi(info+0*12));
  223. datafd = open(buf, ORDWR|OCEXEC);
  224. if(datafd < 0)
  225. goto Error2;
  226. sprint(buf, "%s/draw/%d/refresh", dev, atoi(info+0*12));
  227. reffd = open(buf, OREAD|OCEXEC);
  228. if(reffd < 0){
  229. Error3:
  230. close(datafd);
  231. goto Error2;
  232. }
  233. disp = mallocz(sizeof(Display), 1);
  234. if(disp == 0){
  235. Error4:
  236. close(reffd);
  237. goto Error3;
  238. }
  239. image = nil;
  240. if(0){
  241. Error5:
  242. free(image);
  243. free(disp);
  244. goto Error4;
  245. }
  246. if(n >= NINFO){
  247. image = mallocz(sizeof(Image), 1);
  248. if(image == nil)
  249. goto Error5;
  250. image->display = disp;
  251. image->id = 0;
  252. image->chan = strtochan(info+2*12);
  253. image->depth = chantodepth(image->chan);
  254. image->repl = atoi(info+3*12);
  255. image->r.min.x = atoi(info+4*12);
  256. image->r.min.y = atoi(info+5*12);
  257. image->r.max.x = atoi(info+6*12);
  258. image->r.max.y = atoi(info+7*12);
  259. image->clipr.min.x = atoi(info+8*12);
  260. image->clipr.min.y = atoi(info+9*12);
  261. image->clipr.max.x = atoi(info+10*12);
  262. image->clipr.max.y = atoi(info+11*12);
  263. }
  264. disp->_isnewdisplay = isnew;
  265. disp->bufsize = iounit(datafd);
  266. if(disp->bufsize <= 0)
  267. disp->bufsize = 8000;
  268. if(disp->bufsize < 512){
  269. werrstr("iounit %d too small", disp->bufsize);
  270. goto Error5;
  271. }
  272. disp->buf = malloc(disp->bufsize+5); /* +5 for flush message */
  273. if(disp->buf == nil)
  274. goto Error5;
  275. disp->image = image;
  276. disp->dirno = atoi(info+0*12);
  277. disp->fd = datafd;
  278. disp->ctlfd = ctlfd;
  279. disp->reffd = reffd;
  280. disp->bufp = disp->buf;
  281. disp->error = error;
  282. disp->windir = t;
  283. disp->devdir = strdup(dev);
  284. qlock(&disp->qlock);
  285. disp->white = allocimage(disp, Rect(0, 0, 1, 1), GREY1, 1, DWhite);
  286. disp->black = allocimage(disp, Rect(0, 0, 1, 1), GREY1, 1, DBlack);
  287. if(disp->white == nil || disp->black == nil){
  288. free(disp->devdir);
  289. free(disp->white);
  290. free(disp->black);
  291. goto Error5;
  292. }
  293. disp->opaque = disp->white;
  294. disp->transparent = disp->black;
  295. dir = dirfstat(ctlfd);
  296. if(dir!=nil && dir->type=='i'){
  297. disp->local = 1;
  298. disp->dataqid = dir->qid.path;
  299. }
  300. if(dir!=nil && dir->qid.vers==1) /* other way to tell */
  301. disp->_isnewdisplay = 1;
  302. free(dir);
  303. return disp;
  304. }
  305. /*
  306. * Call with d unlocked.
  307. * Note that disp->defaultfont and defaultsubfont are not freed here.
  308. */
  309. void
  310. closedisplay(Display *disp)
  311. {
  312. _closedisplay(disp, 0);
  313. }
  314. static void
  315. _closedisplay(Display *disp, int isshutdown)
  316. {
  317. int fd;
  318. char buf[128];
  319. if(disp == nil)
  320. return;
  321. if(disp == display)
  322. display = nil;
  323. if(disp->oldlabel[0]){
  324. snprint(buf, sizeof buf, "%s/label", disp->windir);
  325. fd = open(buf, OWRITE);
  326. if(fd >= 0){
  327. write(fd, disp->oldlabel, strlen(disp->oldlabel));
  328. close(fd);
  329. }
  330. }
  331. /*
  332. * if we're shutting down, don't free all the resources.
  333. * if other procs are getting shot down by notes too,
  334. * one might get shot down while holding the malloc lock.
  335. * just let the kernel clean things up when we exit.
  336. */
  337. if(isshutdown)
  338. return;
  339. free(disp->devdir);
  340. free(disp->windir);
  341. freeimage(disp->white);
  342. freeimage(disp->black);
  343. close(disp->fd);
  344. close(disp->ctlfd);
  345. /* should cause refresh slave to shut down */
  346. close(disp->reffd);
  347. qunlock(&disp->qlock);
  348. free(disp);
  349. }
  350. void
  351. lockdisplay(Display *disp)
  352. {
  353. if(debuglockdisplay){
  354. /* avoid busy looping; it's rare we collide anyway */
  355. while(!canqlock(&disp->qlock)){
  356. fprint(1, "proc %d waiting for display lock...\n", getpid());
  357. sleep(1000);
  358. }
  359. }else
  360. qlock(&disp->qlock);
  361. }
  362. void
  363. unlockdisplay(Display *disp)
  364. {
  365. qunlock(&disp->qlock);
  366. }
  367. void
  368. drawerror(Display *d, char *s)
  369. {
  370. char err[ERRMAX];
  371. if(d && d->error)
  372. d->error(d, s);
  373. else{
  374. errstr(err, sizeof err);
  375. fprint(2, "draw: %s: %s\n", s, err);
  376. exits(s);
  377. }
  378. }
  379. static
  380. int
  381. doflush(Display *d)
  382. {
  383. int n, nn;
  384. n = d->bufp-d->buf;
  385. if(n <= 0)
  386. return 1;
  387. if((nn=write(d->fd, d->buf, n)) != n){
  388. if(_drawdebug)
  389. fprint(2, "flushimage fail: d=%p: n=%d nn=%d %r\n", d, n, nn); /**/
  390. d->bufp = d->buf; /* might as well; chance of continuing */
  391. return -1;
  392. }
  393. d->bufp = d->buf;
  394. return 1;
  395. }
  396. int
  397. flushimage(Display *d, int visible)
  398. {
  399. if(d == nil)
  400. return 0;
  401. if(visible){
  402. *d->bufp++ = 'v'; /* five bytes always reserved for this */
  403. if(d->_isnewdisplay){
  404. BPLONG(d->bufp, d->screenimage->id);
  405. d->bufp += 4;
  406. }
  407. }
  408. return doflush(d);
  409. }
  410. uchar*
  411. bufimage(Display *d, int n)
  412. {
  413. uchar *p;
  414. if(n<0 || n>d->bufsize){
  415. werrstr("bad count in bufimage");
  416. return 0;
  417. }
  418. if(d->bufp+n > d->buf+d->bufsize)
  419. if(doflush(d) < 0)
  420. return 0;
  421. p = d->bufp;
  422. d->bufp += n;
  423. return p;
  424. }