b78b7b242e1fe2070941099995aeb1b6c9e0dded
[dragonfly.git] / sys / dev / misc / syscons / scmouse.c
1 /*-
2  * Copyright (c) 1999 Kazutaka YOKOTA <yokota@zodiac.mech.utsunomiya-u.ac.jp>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer as
10  *    the first lines of this file unmodified.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/dev/syscons/scmouse.c,v 1.12.2.3 2001/07/28 12:51:47 yokota Exp $
27  * $DragonFly: src/sys/dev/misc/syscons/scmouse.c,v 1.14 2008/08/10 19:47:31 swildner Exp $
28  */
29
30 #include "opt_syscons.h"
31
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/conf.h>
35 #include <sys/signalvar.h>
36 #include <sys/proc.h>
37 #include <sys/tty.h>
38 #include <sys/thread2.h>
39
40 #include <machine/console.h>
41 #include <sys/mouse.h>
42
43 #include "syscons.h"
44
45 #ifdef SC_TWOBUTTON_MOUSE
46 #define SC_MOUSE_PASTEBUTTON    MOUSE_BUTTON3DOWN       /* right button */
47 #define SC_MOUSE_EXTENDBUTTON   MOUSE_BUTTON2DOWN       /* not really used */
48 #else
49 #define SC_MOUSE_PASTEBUTTON    MOUSE_BUTTON2DOWN       /* middle button */
50 #define SC_MOUSE_EXTENDBUTTON   MOUSE_BUTTON3DOWN       /* right button */
51 #endif /* SC_TWOBUTTON_MOUSE */
52
53 #define SC_WAKEUP_DELTA         20
54
55 #ifndef SC_NO_SYSMOUSE
56
57 /* local variables */
58 static int              cut_buffer_size;
59 static u_char           *cut_buffer;
60
61 /* local functions */
62 static void set_mouse_pos(scr_stat *scp);
63 #ifndef SC_NO_CUTPASTE
64 static int skip_spc_right(scr_stat *scp, int p);
65 static int skip_spc_left(scr_stat *scp, int p);
66 static void mouse_cut(scr_stat *scp);
67 static void mouse_cut_start(scr_stat *scp);
68 static void mouse_cut_end(scr_stat *scp);
69 static void mouse_cut_word(scr_stat *scp);
70 static void mouse_cut_line(scr_stat *scp);
71 static void mouse_cut_extend(scr_stat *scp);
72 static void mouse_paste(scr_stat *scp);
73 #endif /* SC_NO_CUTPASTE */
74
75 #ifndef SC_NO_CUTPASTE
76 /* allocate a cut buffer */
77 void
78 sc_alloc_cut_buffer(scr_stat *scp, int wait)
79 {
80     u_char *p;
81
82     if ((cut_buffer == NULL)
83         || (cut_buffer_size < scp->xsize * scp->ysize + 1)) {
84         p = cut_buffer;
85         cut_buffer = NULL;
86         if (p != NULL)
87             kfree(p, M_SYSCONS);
88         cut_buffer_size = scp->xsize * scp->ysize + 1;
89         p = kmalloc(cut_buffer_size, M_SYSCONS, (wait) ? M_WAITOK : M_NOWAIT);
90         if (p != NULL)
91             p[0] = '\0';
92         cut_buffer = p;
93     }
94 }
95 #endif /* SC_NO_CUTPASTE */
96
97 /* move mouse */
98 void
99 sc_mouse_move(scr_stat *scp, int x, int y)
100 {
101     crit_enter();
102     scp->mouse_xpos = scp->mouse_oldxpos = x;
103     scp->mouse_ypos = scp->mouse_oldypos = y;
104     if (scp->font_size <= 0)
105         scp->mouse_pos = scp->mouse_oldpos = 0;
106     else
107         scp->mouse_pos = scp->mouse_oldpos = 
108             (y/scp->font_size - scp->yoff)*scp->xsize + x/8 - scp->xoff;
109     scp->status |= MOUSE_MOVED;
110     crit_exit();
111 }
112
113 /* adjust mouse position */
114 static void
115 set_mouse_pos(scr_stat *scp)
116 {
117     if (scp->mouse_xpos < scp->xoff*8)
118         scp->mouse_xpos = scp->xoff*8;
119     if (scp->mouse_ypos < scp->yoff*scp->font_size)
120         scp->mouse_ypos = scp->yoff*scp->font_size;
121     if (ISGRAPHSC(scp)) {
122         if (scp->mouse_xpos > scp->xpixel-1)
123             scp->mouse_xpos = scp->xpixel-1;
124         if (scp->mouse_ypos > scp->ypixel-1)
125             scp->mouse_ypos = scp->ypixel-1;
126         return;
127     } else {
128         if (scp->mouse_xpos > (scp->xsize + scp->xoff)*8 - 1)
129             scp->mouse_xpos = (scp->xsize + scp->xoff)*8 - 1;
130         if (scp->mouse_ypos > (scp->ysize + scp->yoff)*scp->font_size - 1)
131             scp->mouse_ypos = (scp->ysize + scp->yoff)*scp->font_size - 1;
132     }
133
134     if (scp->mouse_xpos != scp->mouse_oldxpos || scp->mouse_ypos != scp->mouse_oldypos) {
135         scp->status |= MOUSE_MOVED;
136         scp->mouse_pos =
137             (scp->mouse_ypos/scp->font_size - scp->yoff)*scp->xsize 
138                 + scp->mouse_xpos/8 - scp->xoff;
139 #ifndef SC_NO_CUTPASTE
140         if ((scp->status & MOUSE_VISIBLE) && (scp->status & MOUSE_CUTTING))
141             mouse_cut(scp);
142 #endif
143     }
144 }
145
146 #ifndef SC_NO_CUTPASTE
147
148 void
149 sc_draw_mouse_image(scr_stat *scp)
150 {
151     if (ISGRAPHSC(scp))
152         return;
153
154     ++scp->sc->videoio_in_progress;
155     (*scp->rndr->draw_mouse)(scp, scp->mouse_xpos, scp->mouse_ypos, TRUE);
156     scp->mouse_oldpos = scp->mouse_pos;
157     scp->mouse_oldxpos = scp->mouse_xpos;
158     scp->mouse_oldypos = scp->mouse_ypos;
159     scp->status |= MOUSE_VISIBLE;
160     --scp->sc->videoio_in_progress;
161 }
162
163 void
164 sc_remove_mouse_image(scr_stat *scp)
165 {
166     int size;
167     int i;
168
169     if (ISGRAPHSC(scp))
170         return;
171
172     ++scp->sc->videoio_in_progress;
173     (*scp->rndr->draw_mouse)(scp,
174                              (scp->mouse_oldpos%scp->xsize + scp->xoff)*8,
175                              (scp->mouse_oldpos/scp->xsize + scp->yoff)
176                                  * scp->font_size,
177                              FALSE);
178     size = scp->xsize*scp->ysize;
179     i = scp->mouse_oldpos;
180     mark_for_update(scp, i);
181     mark_for_update(scp, i);
182     if (i + scp->xsize + 1 < size) {
183         mark_for_update(scp, i + scp->xsize + 1);
184     } else if (i + scp->xsize < size) {
185         mark_for_update(scp, i + scp->xsize);
186     } else if (i + 1 < size) {
187         mark_for_update(scp, i + 1);
188     }
189     scp->status &= ~MOUSE_VISIBLE;
190     --scp->sc->videoio_in_progress;
191 }
192
193 int
194 sc_inside_cutmark(scr_stat *scp, int pos)
195 {
196     int start;
197     int end;
198
199     if (scp->mouse_cut_end < 0)
200         return FALSE;
201     if (scp->mouse_cut_start <= scp->mouse_cut_end) {
202         start = scp->mouse_cut_start;
203         end = scp->mouse_cut_end;
204     } else {
205         start = scp->mouse_cut_end;
206         end = scp->mouse_cut_start - 1;
207     }
208     return ((start <= pos) && (pos <= end));
209 }
210
211 void
212 sc_remove_cutmarking(scr_stat *scp)
213 {
214     crit_enter();
215     if (scp->mouse_cut_end >= 0) {
216         mark_for_update(scp, scp->mouse_cut_start);
217         mark_for_update(scp, scp->mouse_cut_end);
218     }
219     scp->mouse_cut_start = scp->xsize*scp->ysize;
220     scp->mouse_cut_end = -1;
221     crit_exit();
222     scp->status &= ~MOUSE_CUTTING;
223 }
224
225 void
226 sc_remove_all_cutmarkings(sc_softc_t *sc)
227 {
228     scr_stat *scp;
229     int i;
230
231     /* delete cut markings in all vtys */
232     for (i = 0; i < sc->vtys; ++i) {
233         scp = SC_STAT(sc->dev[i]);
234         if (scp == NULL)
235             continue;
236         sc_remove_cutmarking(scp);
237     }
238 }
239
240 void
241 sc_remove_all_mouse(sc_softc_t *sc)
242 {
243     scr_stat *scp;
244     int i;
245
246     for (i = 0; i < sc->vtys; ++i) {
247         scp = SC_STAT(sc->dev[i]);
248         if (scp == NULL)
249             continue;
250         if (scp->status & MOUSE_VISIBLE) {
251             scp->status &= ~MOUSE_VISIBLE;
252             mark_all(scp);
253         }
254     }
255 }
256
257 #define IS_SPACE_CHAR(c)        (((c) & 0xff) == ' ')
258
259 /* skip spaces to right */
260 static int
261 skip_spc_right(scr_stat *scp, int p)
262 {
263     int c;
264     int i;
265
266     for (i = p % scp->xsize; i < scp->xsize; ++i) {
267         c = sc_vtb_getc(&scp->vtb, p);
268         if (!IS_SPACE_CHAR(c))
269             break;
270         ++p;
271     }
272     return i;
273 }
274
275 /* skip spaces to left */
276 static int
277 skip_spc_left(scr_stat *scp, int p)
278 {
279     int c;
280     int i;
281
282     for (i = p-- % scp->xsize - 1; i >= 0; --i) {
283         c = sc_vtb_getc(&scp->vtb, p);
284         if (!IS_SPACE_CHAR(c))
285             break;
286         --p;
287     }
288     return i;
289 }
290
291 /* copy marked region to the cut buffer */
292 static void
293 mouse_cut(scr_stat *scp)
294 {
295     int start;
296     int end;
297     int from;
298     int to;
299     int blank;
300     int c;
301     int p;
302     int i;
303
304     start = scp->mouse_cut_start;
305     if (scp->mouse_pos >= start) {
306         from = start;
307         to = end = scp->mouse_pos;
308     } else {
309         from = end = scp->mouse_pos;
310         to = start - 1;
311     }
312     for (p = from, i = blank = 0; p <= to; ++p) {
313         cut_buffer[i] = sc_vtb_getc(&scp->vtb, p);
314         /* remember the position of the last non-space char */
315         if (!IS_SPACE_CHAR(cut_buffer[i++]))
316             blank = i;          /* the first space after the last non-space */
317         /* trim trailing blank when crossing lines */
318         if ((p % scp->xsize) == (scp->xsize - 1)) {
319             cut_buffer[blank] = '\r';
320             i = blank + 1;
321         }
322     }
323     cut_buffer[i] = '\0';
324
325     /* scan towards the end of the last line */
326     --p;
327     for (i = p % scp->xsize; i < scp->xsize; ++i) {
328         c = sc_vtb_getc(&scp->vtb, p);
329         if (!IS_SPACE_CHAR(c))
330             break;
331         ++p;
332     }
333     /* if there is nothing but blank chars, trim them, but mark towards eol */
334     if (i >= scp->xsize) {
335         if (end >= start)
336             to = end = p - 1;
337         else
338             to = start = p;
339         cut_buffer[blank++] = '\r';
340         cut_buffer[blank] = '\0';
341     }
342
343     /* remove the current marking */
344     crit_enter();
345     if (scp->mouse_cut_start <= scp->mouse_cut_end) {
346         mark_for_update(scp, scp->mouse_cut_start);
347         mark_for_update(scp, scp->mouse_cut_end);
348     } else if (scp->mouse_cut_end >= 0) {
349         mark_for_update(scp, scp->mouse_cut_end);
350         mark_for_update(scp, scp->mouse_cut_start);
351     }
352
353     /* mark the new region */
354     scp->mouse_cut_start = start;
355     scp->mouse_cut_end = end;
356     mark_for_update(scp, from);
357     mark_for_update(scp, to);
358     crit_exit();
359 }
360
361 /* a mouse button is pressed, start cut operation */
362 static void
363 mouse_cut_start(scr_stat *scp) 
364 {
365     int i;
366     int j;
367
368     if (scp->status & MOUSE_VISIBLE) {
369         i = scp->mouse_cut_start;
370         j = scp->mouse_cut_end;
371         sc_remove_all_cutmarkings(scp->sc);
372         if (scp->mouse_pos == i && i == j) {
373             cut_buffer[0] = '\0';
374         } else if (skip_spc_right(scp, scp->mouse_pos) >= scp->xsize) {
375             /* if the pointer is on trailing blank chars, mark towards eol */
376             i = skip_spc_left(scp, scp->mouse_pos) + 1;
377             crit_enter();
378             scp->mouse_cut_start =
379                 (scp->mouse_pos / scp->xsize) * scp->xsize + i;
380             scp->mouse_cut_end =
381                 (scp->mouse_pos / scp->xsize + 1) * scp->xsize - 1;
382             crit_exit();
383             cut_buffer[0] = '\r';
384             cut_buffer[1] = '\0';
385             scp->status |= MOUSE_CUTTING;
386         } else {
387             crit_enter();
388             scp->mouse_cut_start = scp->mouse_pos;
389             scp->mouse_cut_end = scp->mouse_cut_start;
390             crit_exit();
391             cut_buffer[0] = sc_vtb_getc(&scp->vtb, scp->mouse_cut_start);
392             cut_buffer[1] = '\0';
393             scp->status |= MOUSE_CUTTING;
394         }
395         mark_all(scp);  /* this is probably overkill XXX */
396     }
397 }
398
399 /* end of cut operation */
400 static void
401 mouse_cut_end(scr_stat *scp) 
402 {
403     if (scp->status & MOUSE_VISIBLE)
404         scp->status &= ~MOUSE_CUTTING;
405 }
406
407 /* copy a word under the mouse pointer */
408 static void
409 mouse_cut_word(scr_stat *scp)
410 {
411     int start;
412     int end;
413     int sol;
414     int eol;
415     int c;
416     int i;
417     int j;
418
419     /*
420      * Because we don't have locale information in the kernel,
421      * we only distinguish space char and non-space chars.  Punctuation
422      * chars, symbols and other regular chars are all treated alike.
423      */
424     if (scp->status & MOUSE_VISIBLE) {
425         /* remove the current cut mark */
426         crit_enter();
427         if (scp->mouse_cut_start <= scp->mouse_cut_end) {
428             mark_for_update(scp, scp->mouse_cut_start);
429             mark_for_update(scp, scp->mouse_cut_end);
430         } else if (scp->mouse_cut_end >= 0) {
431             mark_for_update(scp, scp->mouse_cut_end);
432             mark_for_update(scp, scp->mouse_cut_start);
433         }
434         scp->mouse_cut_start = scp->xsize*scp->ysize;
435         scp->mouse_cut_end = -1;
436         crit_exit();
437
438         sol = (scp->mouse_pos / scp->xsize) * scp->xsize;
439         eol = sol + scp->xsize;
440         c = sc_vtb_getc(&scp->vtb, scp->mouse_pos);
441         if (IS_SPACE_CHAR(c)) {
442             /* blank space */
443             for (j = scp->mouse_pos; j >= sol; --j) {
444                 c = sc_vtb_getc(&scp->vtb, j);
445                 if (!IS_SPACE_CHAR(c))
446                     break;
447             }
448             start = ++j;
449             for (j = scp->mouse_pos; j < eol; ++j) {
450                 c = sc_vtb_getc(&scp->vtb, j);
451                 if (!IS_SPACE_CHAR(c))
452                     break;
453             }
454             end = j - 1;
455         } else {
456             /* non-space word */
457             for (j = scp->mouse_pos; j >= sol; --j) {
458                 c = sc_vtb_getc(&scp->vtb, j);
459                 if (IS_SPACE_CHAR(c))
460                     break;
461             }
462             start = ++j;
463             for (j = scp->mouse_pos; j < eol; ++j) {
464                 c = sc_vtb_getc(&scp->vtb, j);
465                 if (IS_SPACE_CHAR(c))
466                     break;
467             }
468             end = j - 1;
469         }
470
471         /* copy the found word */
472         for (i = 0, j = start; j <= end; ++j)
473             cut_buffer[i++] = sc_vtb_getc(&scp->vtb, j);
474         cut_buffer[i] = '\0';
475         scp->status |= MOUSE_CUTTING;
476
477         /* mark the region */
478         crit_enter();
479         scp->mouse_cut_start = start;
480         scp->mouse_cut_end = end;
481         mark_for_update(scp, start);
482         mark_for_update(scp, end);
483         crit_exit();
484     }
485 }
486
487 /* copy a line under the mouse pointer */
488 static void
489 mouse_cut_line(scr_stat *scp)
490 {
491     int i;
492     int j;
493
494     if (scp->status & MOUSE_VISIBLE) {
495         /* remove the current cut mark */
496         crit_enter();
497         if (scp->mouse_cut_start <= scp->mouse_cut_end) {
498             mark_for_update(scp, scp->mouse_cut_start);
499             mark_for_update(scp, scp->mouse_cut_end);
500         } else if (scp->mouse_cut_end >= 0) {
501             mark_for_update(scp, scp->mouse_cut_end);
502             mark_for_update(scp, scp->mouse_cut_start);
503         }
504
505         /* mark the entire line */
506         scp->mouse_cut_start =
507             (scp->mouse_pos / scp->xsize) * scp->xsize;
508         scp->mouse_cut_end = scp->mouse_cut_start + scp->xsize - 1;
509         mark_for_update(scp, scp->mouse_cut_start);
510         mark_for_update(scp, scp->mouse_cut_end);
511         crit_exit();
512
513         /* copy the line into the cut buffer */
514         for (i = 0, j = scp->mouse_cut_start; j <= scp->mouse_cut_end; ++j)
515             cut_buffer[i++] = sc_vtb_getc(&scp->vtb, j);
516         cut_buffer[i++] = '\r';
517         cut_buffer[i] = '\0';
518         scp->status |= MOUSE_CUTTING;
519     }
520 }
521
522 /* extend the marked region to the mouse pointer position */
523 static void
524 mouse_cut_extend(scr_stat *scp) 
525 {
526     int start;
527     int end;
528
529     if ((scp->status & MOUSE_VISIBLE) && !(scp->status & MOUSE_CUTTING)
530         && (scp->mouse_cut_end >= 0)) {
531         if (scp->mouse_cut_start <= scp->mouse_cut_end) {
532             start = scp->mouse_cut_start;
533             end = scp->mouse_cut_end;
534         } else {
535             start = scp->mouse_cut_end;
536             end = scp->mouse_cut_start - 1;
537         }
538         crit_enter();
539         if (scp->mouse_pos > end) {
540             scp->mouse_cut_start = start;
541             scp->mouse_cut_end = end;
542         } else if (scp->mouse_pos < start) {
543             scp->mouse_cut_start = end + 1;
544             scp->mouse_cut_end = start;
545         } else {
546             if (scp->mouse_pos - start > end + 1 - scp->mouse_pos) {
547                 scp->mouse_cut_start = start;
548                 scp->mouse_cut_end = end;
549             } else {
550                 scp->mouse_cut_start = end + 1;
551                 scp->mouse_cut_end = start;
552             }
553         }
554         crit_exit();
555         mouse_cut(scp);
556         scp->status |= MOUSE_CUTTING;
557     }
558 }
559
560 /* paste cut buffer contents into the current vty */
561 static void
562 mouse_paste(scr_stat *scp) 
563 {
564     if (scp->status & MOUSE_VISIBLE)
565         sc_paste(scp, cut_buffer, strlen(cut_buffer));
566 }
567
568 #endif /* SC_NO_CUTPASTE */
569
570 int
571 sc_mouse_ioctl(struct tty *tp, u_long cmd, caddr_t data, int flag)
572 {
573     mouse_info_t *mouse;
574     scr_stat *cur_scp;
575     scr_stat *scp;
576     struct proc *oproc;
577     int f;
578
579     scp = SC_STAT(tp->t_dev);
580
581     switch (cmd) {
582
583     case CONS_MOUSECTL:         /* control mouse arrow */
584         mouse = (mouse_info_t*)data;
585         cur_scp = scp->sc->cur_scp;
586
587         switch (mouse->operation) {
588         case MOUSE_MODE:
589             if (ISSIGVALID(mouse->u.mode.signal)) {
590                 oproc = scp->mouse_proc;
591                 scp->mouse_signal = mouse->u.mode.signal;
592                 scp->mouse_proc = curproc;
593                 scp->mouse_pid = curproc->p_pid;
594                 PHOLD(curproc);
595             } else {
596                 oproc = scp->mouse_proc;
597                 scp->mouse_signal = 0;
598                 scp->mouse_proc = NULL;
599                 scp->mouse_pid = 0;
600             }
601             if (oproc) {
602                     PRELE(oproc);
603                     oproc = NULL;
604             }
605             return 0;
606
607         case MOUSE_SHOW:
608             crit_enter();
609             if (!(scp->sc->flags & SC_MOUSE_ENABLED)) {
610                 scp->sc->flags |= SC_MOUSE_ENABLED;
611                 cur_scp->status &= ~MOUSE_HIDDEN;
612                 if (!ISGRAPHSC(cur_scp))
613                     mark_all(cur_scp);
614                 crit_exit();
615                 return 0;
616             } else {
617                 crit_exit();
618                 return EINVAL;
619             }
620             break;
621
622         case MOUSE_HIDE:
623             crit_enter();
624             if (scp->sc->flags & SC_MOUSE_ENABLED) {
625                 scp->sc->flags &= ~SC_MOUSE_ENABLED;
626                 sc_remove_all_mouse(scp->sc);
627                 crit_exit();
628                 return 0;
629             } else {
630                 crit_exit();
631                 return EINVAL;
632             }
633             break;
634
635         case MOUSE_MOVEABS:
636             crit_enter();
637             scp->mouse_xpos = mouse->u.data.x;
638             scp->mouse_ypos = mouse->u.data.y;
639             set_mouse_pos(scp);
640             crit_exit();
641             break;
642
643         case MOUSE_MOVEREL:
644             crit_enter();
645             scp->mouse_xpos += mouse->u.data.x;
646             scp->mouse_ypos += mouse->u.data.y;
647             set_mouse_pos(scp);
648             crit_exit();
649             break;
650
651         case MOUSE_GETINFO:
652             mouse->u.data.x = scp->mouse_xpos;
653             mouse->u.data.y = scp->mouse_ypos;
654             mouse->u.data.z = 0;
655             mouse->u.data.buttons = scp->mouse_buttons;
656             return 0;
657
658         case MOUSE_ACTION:
659         case MOUSE_MOTION_EVENT:
660             /* send out mouse event on /dev/sysmouse */
661 #if 0
662             /* this should maybe only be settable from /dev/consolectl SOS */
663             if (SC_VTY(tp->t_dev) != SC_CONSOLECTL)
664                 return ENOTTY;
665 #endif
666             crit_enter();
667             if (mouse->u.data.x != 0 || mouse->u.data.y != 0) {
668                 cur_scp->mouse_xpos += mouse->u.data.x;
669                 cur_scp->mouse_ypos += mouse->u.data.y;
670                 set_mouse_pos(cur_scp);
671             }
672             f = 0;
673             if (mouse->operation == MOUSE_ACTION) {
674                 f = cur_scp->mouse_buttons ^ mouse->u.data.buttons;
675                 cur_scp->mouse_buttons = mouse->u.data.buttons;
676             }
677             crit_exit();
678
679             if (sysmouse_event(mouse) == 0)
680                 return 0;
681
682             /* 
683              * If any buttons are down or the mouse has moved a lot, 
684              * stop the screen saver.
685              */
686             if (((mouse->operation == MOUSE_ACTION) && mouse->u.data.buttons)
687                 || (mouse->u.data.x*mouse->u.data.x
688                         + mouse->u.data.y*mouse->u.data.y
689                         >= SC_WAKEUP_DELTA*SC_WAKEUP_DELTA)) {
690                 sc_touch_scrn_saver();
691             }
692
693             cur_scp->status &= ~MOUSE_HIDDEN;
694
695             if (cur_scp->mouse_signal) {
696                 /* has controlling process died? */
697                 if (cur_scp->mouse_proc && 
698                     (cur_scp->mouse_proc != pfindn(cur_scp->mouse_pid))){
699                         oproc = cur_scp->mouse_proc;
700                         cur_scp->mouse_signal = 0;
701                         cur_scp->mouse_proc = NULL;
702                         cur_scp->mouse_pid = 0;
703                         if (oproc)
704                                 PRELE(oproc);
705                 } else {
706                     ksignal(cur_scp->mouse_proc, cur_scp->mouse_signal);
707                     break;
708                 }
709             }
710
711             if (ISGRAPHSC(cur_scp) || (cut_buffer == NULL))
712                 break;
713
714 #ifndef SC_NO_CUTPASTE
715             if ((mouse->operation == MOUSE_ACTION) && f) {
716                 /* process button presses */
717                 if (cur_scp->mouse_buttons & MOUSE_BUTTON1DOWN)
718                     mouse_cut_start(cur_scp);
719                 else
720                     mouse_cut_end(cur_scp);
721                 if (cur_scp->mouse_buttons & MOUSE_BUTTON2DOWN ||
722                     cur_scp->mouse_buttons & MOUSE_BUTTON3DOWN)
723                     mouse_paste(cur_scp);
724             }
725 #endif /* SC_NO_CUTPASTE */
726             break;
727
728         case MOUSE_BUTTON_EVENT:
729             if ((mouse->u.event.id & MOUSE_BUTTONS) == 0)
730                 return EINVAL;
731             if (mouse->u.event.value < 0)
732                 return EINVAL;
733 #if 0
734             /* this should maybe only be settable from /dev/consolectl SOS */
735             if (SC_VTY(tp->t_dev) != SC_CONSOLECTL)
736                 return ENOTTY;
737 #endif
738             if (mouse->u.event.value > 0)
739                 cur_scp->mouse_buttons |= mouse->u.event.id;
740             else
741                 cur_scp->mouse_buttons &= ~mouse->u.event.id;
742
743             if (sysmouse_event(mouse) == 0)
744                 return 0;
745
746             /* if a button is held down, stop the screen saver */
747             if (mouse->u.event.value > 0)
748                 sc_touch_scrn_saver();
749
750             cur_scp->status &= ~MOUSE_HIDDEN;
751
752             if (cur_scp->mouse_signal) {
753                 if (cur_scp->mouse_proc && 
754                     (cur_scp->mouse_proc != pfindn(cur_scp->mouse_pid))){
755                         oproc = cur_scp->mouse_proc;
756                         cur_scp->mouse_signal = 0;
757                         cur_scp->mouse_proc = NULL;
758                         cur_scp->mouse_pid = 0;
759                         if (oproc)
760                                 PRELE(oproc);
761                 } else {
762                     ksignal(cur_scp->mouse_proc, cur_scp->mouse_signal);
763                     break;
764                 }
765             }
766
767             if (ISGRAPHSC(cur_scp) || (cut_buffer == NULL))
768                 break;
769
770 #ifndef SC_NO_CUTPASTE
771             switch (mouse->u.event.id) {
772             case MOUSE_BUTTON1DOWN:
773                 switch (mouse->u.event.value % 4) {
774                 case 0: /* up */
775                     mouse_cut_end(cur_scp);
776                     break;
777                 case 1: /* single click: start cut operation */
778                     mouse_cut_start(cur_scp);
779                     break;
780                 case 2: /* double click: cut a word */
781                     mouse_cut_word(cur_scp);
782                     mouse_cut_end(cur_scp);
783                     break;
784                 case 3: /* triple click: cut a line */
785                     mouse_cut_line(cur_scp);
786                     mouse_cut_end(cur_scp);
787                     break;
788                 }
789                 break;
790             case SC_MOUSE_PASTEBUTTON:
791                 switch (mouse->u.event.value) {
792                 case 0: /* up */
793                     break;
794                 default:
795                     mouse_paste(cur_scp);
796                     break;
797                 }
798                 break;
799             case SC_MOUSE_EXTENDBUTTON:
800                 switch (mouse->u.event.value) {
801                 case 0: /* up */
802                     if (!(cur_scp->mouse_buttons & MOUSE_BUTTON1DOWN))
803                         mouse_cut_end(cur_scp);
804                     break;
805                 default:
806                     mouse_cut_extend(cur_scp);
807                     break;
808                 }
809                 break;
810             }
811 #endif /* SC_NO_CUTPASTE */
812             break;
813
814         case MOUSE_MOUSECHAR:
815             if (mouse->u.mouse_char < 0) {
816                 mouse->u.mouse_char = scp->sc->mouse_char;
817             } else {
818                 if (mouse->u.mouse_char >= (unsigned char)-1 - 4)
819                     return EINVAL;
820                 crit_enter();
821                 sc_remove_all_mouse(scp->sc);
822 #ifndef SC_NO_FONT_LOADING
823                 if (ISTEXTSC(cur_scp) && (cur_scp->font != NULL))
824                     sc_load_font(cur_scp, 0, cur_scp->font_size, cur_scp->font,
825                                  cur_scp->sc->mouse_char, 4);
826 #endif
827                 scp->sc->mouse_char = mouse->u.mouse_char;
828                 crit_exit();
829             }
830             break;
831
832         default:
833             return EINVAL;
834         }
835
836         return 0;
837     }
838
839     return ENOIOCTL;
840 }
841
842 #endif /* SC_NO_SYSMOUSE */