sys/src/libcontrol/scribble.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <draw.h>
   4 #include <thread.h>
   5 #include <mouse.h>
   6 #include <keyboard.h>
   7 #include <control.h>
   8 #include <scribble.h>
   9
  10 typedef struct Scrib Scrib;
  11
  12 struct Scrib
  13 {
  14         Control;
  15         int             border;
  16         CImage  *image;
  17         CImage  *color;
  18         CImage  *bordercolor;
  19         CFont   *font;
  20         int             align;
  21         int             lastbut;
  22         char            lastchar[8];
  23         Scribble        *scrib;
  24 };
  25
  26 enum{
  27         EAlign,
  28         EBorder,
  29         EBordercolor,
  30         EFocus,
  31         EFont,
  32         EHide,
  33         EImage,
  34         ELinecolor,
  35         ERect,
  36         EReveal,
  37         EShow,
  38         ESize,
  39 };
  40
  41 static char *cmds[] = {
  42         [EAlign] =              "align",
  43         [EBorder] =     "border",
  44         [EBordercolor] ="bordercolor",
  45         [EFocus] =      "focus",
  46         [EFont] =               "font",
  47         [EHide] =               "hide",
  48         [EImage] =      "image",
  49         [ELinecolor] =  "linecolor",
  50         [ERect] =               "rect",
  51         [EReveal] =     "reveal",
  52         [EShow] =               "show",
  53         [ESize] =               "size",
  54         nil
  55 };
  56
  57 static void     scribshow(Scrib*);
  58 static void scribchar(Scrib*, Rune);
  59
  60 static void     resetstroke(Scrib *w);
  61 static void     displaylast(Scrib *w);
  62 static void     addpoint(Scrib *w, Point p);
  63
  64 static void
  65 scribmouse(Control *c, Mouse *m)
  66 {
  67         Scrib *b;
  68         Rune r;
  69
  70         b = (Scrib*)c;
  71         if (m->buttons & 0x1) {
  72                 if ((b->lastbut & 0x1) == 0) {
  73                         /* mouse went down */
  74                         resetstroke(b);
  75                 }
  76                 /* mouse is down */
  77                 if (ptinrect(m->xy,b->rect))
  78                         addpoint(b, m->xy);
  79         } else if (b->lastbut & 0x1) {
  80                 /* mouse went up */
  81                 if (ptinrect(m->xy,b->rect)) {
  82                         r = recognize(b->scrib);
  83                         scribchar(b, r);
  84                         scribshow(b);
  85                         if (r) chanprint(b->event, b->format, b->name, r);
  86                 }
  87         }
  88         b->lastbut = m->buttons;
  89 }
  90
  91 static void
  92 scribfree(Control *c)
  93 {
  94         Scrib *b;
  95
  96         b = (Scrib*)c;
  97         _putctlimage(b->image);
  98         _putctlimage(b->color);
  99         _putctlimage(b->bordercolor);
 100         _putctlfont(b->font);
 101 //      scribblefree(b->scrib);
 102 }
 103
 104 static void
 105 scribchar(Scrib *b, Rune r)
 106 {
 107         if(r == 0)
 108                 b->lastchar[0] = '\0';
 109         else if(r == ' ')
 110                 strcpy(b->lastchar, "' '");
 111         else if(r < ' ')
 112                 sprint(b->lastchar, "ctl-%c", r+'@');
 113         else
 114                 sprint(b->lastchar, "%C", r);
 115 }
 116
 117
 118 static void
 119 scribshow(Scrib *b)
 120 {
 121         Image *i;
 122         Rectangle r;
 123         char *mode;
 124         Scribble *s = b->scrib;
 125         char buf[32];
 126
 127         if (b->hidden)
 128                 return;
 129         if(b->border > 0){
 130                 r = insetrect(b->rect, b->border);
 131                 border(b->screen, b->rect, b->border, b->bordercolor->image, ZP);
 132         }else
 133                 r = b->rect;
 134
 135         i = b->image->image;
 136         draw(b->screen, r, i, nil, i->r.min);
 137
 138         if (s->ctrlShift)
 139                 mode = " ^C";
 140         else if (s->puncShift)
 141                 mode = " #&^";
 142         else if (s->curCharSet == CS_DIGITS)
 143                 mode = " 123";
 144         else if (s->capsLock)
 145                 mode = " ABC";
 146         else if (s->tmpShift)
 147                 mode = " Abc";
 148         else
 149                 mode = " abc";
 150
 151         snprint(buf, sizeof buf, "%s %s", mode, b->lastchar);
 152
 153         string(b->screen, r.min, b->color->image, ZP, b->font->font, buf);
 154         flushimage(display, 1);
 155 }
 156
 157 static void
 158 scribctl(Control *c, CParse *cp)
 159 {
 160         int cmd;
 161         Rectangle r;
 162         Scrib *b;
 163
 164         b = (Scrib*)c;
 165         cmd = _ctllookup(cp->args[0], cmds, nelem(cmds));
 166         switch(cmd){
 167         default:
 168                 abort();
 169                 ctlerror("%q: unrecognized message '%s'", b->name, cp->str);
 170                 break;
 171         case EAlign:
 172                 _ctlargcount(b, cp, 2);
 173                 b->align = _ctlalignment(cp->args[1]);
 174                 break;
 175         case EBorder:
 176                 _ctlargcount(b, cp, 2);
 177                 if(cp->iargs[1] < 0)
 178                         ctlerror("%q: bad border: %c", b->name, cp->str);
 179                 b->border = cp->iargs[1];
 180                 break;
 181         case EBordercolor:
 182                 _ctlargcount(b, cp, 2);
 183                 _setctlimage(b, &b->bordercolor, cp->args[1]);
 184                 break;
 185         case EFocus:
 186                 break;
 187         case EImage:
 188                 _ctlargcount(b, cp, 2);
 189                 _setctlimage(b, &b->image, cp->args[1]);
 190                 break;
 191         case ELinecolor:
 192                 _ctlargcount(b, cp, 2);
 193                 _setctlimage(b, &b->bordercolor, cp->args[1]);
 194                 break;
 195         case ERect:
 196                 _ctlargcount(b, cp, 5);
 197                 r.min.x = cp->iargs[1];
 198                 r.min.y = cp->iargs[2];
 199                 r.max.x = cp->iargs[3];
 200                 r.max.y = cp->iargs[4];
 201                 if(Dx(r)<0 || Dy(r)<0)
 202                         ctlerror("%q: bad rectangle: %s", b->name, cp->str);
 203                 b->rect = r;
 204                 break;
 205         case EReveal:
 206                 _ctlargcount(b, cp, 1);
 207                 b->hidden = 0;
 208                 scribshow(b);
 209                 break;
 210         case EShow:
 211                 _ctlargcount(b, cp, 1);
 212                 scribshow(b);
 213                 break;
 214         case EFont:
 215                 _ctlargcount(b, cp, 2);
 216                 _setctlfont(b, &b->font, cp->args[1]);
 217                 break;
 218         case EHide:
 219                 _ctlargcount(b, cp, 1);
 220                 b->hidden = 1;
 221                 break;
 222         case ESize:
 223                 if (cp->nargs == 3)
 224                         r.max = Pt(0x7fffffff, 0x7fffffff);
 225                 else{
 226                         _ctlargcount(b, cp, 5);
 227                         r.max.x = cp->iargs[3];
 228                         r.max.y = cp->iargs[4];
 229                 }
 230                 r.min.x = cp->iargs[1];
 231                 r.min.y = cp->iargs[2];
 232                 if(r.min.x<=0 || r.min.y<=0 || r.max.x<=0 || r.max.y<=0 || r.max.x < r.min.x || r.max.y < r.min.y)
 233                         ctlerror("%q: bad sizes: %s", b->name, cp->str);
 234                 b->size.min = r.min;
 235                 b->size.max = r.max;
 236                 break;
 237         }
 238 }
 239
 240 static void
 241 resetstroke(Scrib *w)
 242 {
 243         Scribble *s = w->scrib;
 244
 245         s->ps.npts = 0;
 246         scribshow(w);
 247 }
 248
 249 static void
 250 displaylast(Scrib *w)
 251 {
 252         int         npt;
 253         Scribble *s = w->scrib;
 254
 255         npt = s->ps.npts;
 256         if (npt > 2)
 257                 npt = 2;
 258         poly(w->screen, s->pt + (s->ps.npts - npt), npt, Endsquare, Endsquare,
 259                 0, w->color->image, ZP);
 260         flushimage(display, 1);
 261 }
 262
 263 static void
 264 addpoint(Scrib *w, Point p)
 265 {
 266         pen_point       *ppa;
 267         Point   *pt;
 268         int             ppasize;
 269         Scribble        *s = w->scrib;
 270
 271         if (s->ps.npts == s->ppasize) {
 272                 ppasize = s->ppasize + 100;
 273                 ppa = malloc ((sizeof (pen_point) + sizeof (Point)) * ppasize);
 274                 if (!ppa)
 275                         return;
 276                 pt = (Point *) (ppa + ppasize);
 277                 memmove(ppa, s->ps.pts, s->ppasize * sizeof (pen_point));
 278                 memmove(pt, s->pt, s->ppasize * sizeof (Point));
 279                 free (s->ps.pts);
 280                 s->ps.pts = ppa;
 281                 s->pt = pt;
 282                 s->ppasize = ppasize;
 283         }
 284         ppa = &s->ps.pts[s->ps.npts];
 285         ppa->Point = p;
 286
 287         pt = &s->pt[s->ps.npts];
 288         *pt = p;
 289
 290         s->ps.npts++;
 291
 292         displaylast(w);
 293 }
 294
 295 Control*
 296 createscribble(Controlset *cs, char *name)
 297 {
 298         Scrib *b;
 299
 300         b = (Scrib*)_createctl(cs, "scribble", sizeof(Scrib), name);
 301         b->image = _getctlimage("white");
 302         b->color = _getctlimage("black");
 303         b->bordercolor = _getctlimage("black");
 304         b->align = Aupperleft;
 305         b->format = ctlstrdup("%q: value 0x%x");
 306         b->font = _getctlfont("font");
 307         b->scrib = scribblealloc();
 308         b->lastbut = 0;
 309         b->bordercolor = _getctlimage("black");
 310         b->border = 0;
 311         b->ctl = scribctl;
 312         b->mouse = scribmouse;
 313         b->exit = scribfree;
 314         return (Control*)b;
 315 }